foster/denoland-deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-01-21 21:50:00 -05:00
Code Issues Packages 1 Wiki Activity

Move testing module to deno_std (#1451)

Browse source 
Upgrades deno_std submodule.
This commit is contained in:
Ryan Dahl 2019-01-03 14:55:22 -05:00 • committed by GitHub
parent a8d326b431
commit 4f62a56f90
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 12 additions and 250 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
js/deps/https/deno.land/x/std

@ -1 +1 @@
Subproject commit d3193a09deabaf087f2a3f8d3b8f494d1d38e35d
Subproject commit b4906387469eba24f868082b263dd44d89a40db7

7
js/test_util.ts
View file

@ -8,8 +8,11 @@
// See tools/unit_tests.py for more details.
import * as deno from "deno";
import * as testing from "./testing/testing.ts";
export { assert, assertEqual } from "./testing/testing.ts";
import * as testing from "./deps/https/deno.land/x/std/testing/mod.ts";
export {
assert,
assertEqual
} from "./deps/https/deno.land/x/std/testing/mod.ts";
// testing.setFilter must be run before any tests are defined.
testing.setFilter(deno.args[1]);

175
js/testing/testing.ts
View file

@ -1,175 +0,0 @@
/*!
Copyright 2018 Propel http://propel.site/. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Do not add imports in this file in order to be compatible with Node.
export function assertEqual(actual: unknown, expected: unknown, msg?: string) {
if (!equal(actual, expected)) {
let actualString: string;
let expectedString: string;
try {
actualString = String(actual);
} catch (e) {
actualString = "[Cannot display]";
}
try {
expectedString = String(expected);
} catch (e) {
expectedString = "[Cannot display]";
}
console.error(
"assertEqual failed. actual =",
actualString,
"expected =",
expectedString
);
if (!msg) {
msg = `actual: ${actualString} expected: ${expectedString}`;
}
throw new Error(msg);
}
}
export function assert(expr: boolean, msg = "") {
if (!expr) {
throw new Error(msg);
}
}
export function equal(c: unknown, d: unknown): boolean {
const seen = new Map();
return (function compare(a: unknown, b: unknown) {
if (Object.is(a, b)) {
return true;
}
if (a && typeof a === "object" && b && typeof b === "object") {
if (seen.get(a) === b) {
return true;
}
if (Object.keys(a || {}).length !== Object.keys(b || {}).length) {
return false;
}
const merged = { ...a, ...b };
for (const key in merged) {
type Key = keyof typeof merged;
if (!compare(a && a[key as Key], b && b[key as Key])) {
return false;
}
}
seen.set(a, b);
return true;
}
return false;
})(c, d);
}
export type TestFunction = () => void | Promise<void>;
export interface TestDefinition {
fn: TestFunction;
name: string;
}
export const exitOnFail = true;
let filterRegExp: RegExp | null;
const tests: TestDefinition[] = [];
let filtered = 0;
const ignored = 0;
const measured = 0;
// Must be called before any test() that needs to be filtered.
export function setFilter(s: string): void {
filterRegExp = new RegExp(s, "i");
}
export function test(t: TestDefinition | TestFunction): void {
const fn: TestFunction = typeof t === "function" ? t : t.fn;
const name: string = t.name;
if (!name) {
throw new Error("Test function may not be anonymous");
}
if (filter(name)) {
tests.push({ fn, name });
} else {
filtered++;
}
}
function filter(name: string): boolean {
if (filterRegExp) {
return filterRegExp.test(name);
} else {
return true;
}
}
const RESET = "\x1b[0m";
const FG_RED = "\x1b[31m";
const FG_GREEN = "\x1b[32m";
function red_failed() {
return FG_RED + "FAILED" + RESET;
}
function green_ok() {
return FG_GREEN + "ok" + RESET;
}
async function runTests() {
let passed = 0;
let failed = 0;
console.log("running", tests.length, "tests");
for (let i = 0; i < tests.length; i++) {
const { fn, name } = tests[i];
let result = green_ok();
console.log("test", name);
try {
await fn();
passed++;
} catch (e) {
result = red_failed();
console.error((e && e.stack) || e);
failed++;
if (exitOnFail) {
break;
}
}
// TODO Do this on the same line as test name is printed.
console.log("...", result);
}
// Attempting to match the output of Rust's test runner.
const result = failed > 0 ? red_failed() : green_ok();
console.log(
`\ntest result: ${result}. ${passed} passed; ${failed} failed; ` +
`${ignored} ignored; ${measured} measured; ${filtered} filtered out\n`
);
if (failed === 0) {
// All good.
} else {
// Use setTimeout to avoid the error being ignored due to unhandled
// promise rejections being swallowed.
setTimeout(() => {
throw new Error(`There were ${failed} test failures.`);
}, 0);
}
}
setTimeout(runTests, 0);

70
js/testing/testing_test.ts
View file

@ -1,70 +0,0 @@
/*!
Copyright 2018 Propel http://propel.site/. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
import { test, assert, assertEqual, equal } from "./testing.ts";
test(function testingEqual() {
assert(equal("world", "world"));
assert(!equal("hello", "world"));
assert(equal(5, 5));
assert(!equal(5, 6));
assert(equal(NaN, NaN));
assert(equal({ hello: "world" }, { hello: "world" }));
assert(!equal({ world: "hello" }, { hello: "world" }));
assert(
equal(
{ hello: "world", hi: { there: "everyone" } },
{ hello: "world", hi: { there: "everyone" } }
)
);
assert(
!equal(
{ hello: "world", hi: { there: "everyone" } },
{ hello: "world", hi: { there: "everyone else" } }
)
);
});
test(function testingAssertEqual() {
const a = Object.create(null);
a.b = "foo";
assertEqual(a, a);
});
test(function testingAssertEqualActualUncoercable() {
let didThrow = false;
const a = Object.create(null);
try {
assertEqual(a, "bar");
} catch (e) {
didThrow = true;
console.log(e.message);
assert(e.message === "actual: [Cannot display] expected: bar");
}
assert(didThrow);
});
test(function testingAssertEqualExpectedUncoercable() {
let didThrow = false;
const a = Object.create(null);
try {
assertEqual("bar", a);
} catch (e) {
didThrow = true;
console.log(e.message);
assert(e.message === "actual: bar expected: [Cannot display]");
}
assert(didThrow);
});

2
tests/fetch_deps.ts
View file

@ -1,5 +1,5 @@
// Run ./tools/http_server.py too in order for this test to run.
import { assert } from "../js/testing/testing.ts";
import { assert } from "../js/deps/https/deno.land/x/std/testing/mod.ts";
// TODO Top level await https://github.com/denoland/deno/issues/471
async function main() {

6
tools/ts_library_builder/test.ts
View file

@ -3,7 +3,11 @@
// ./node_modules/.bin/ts-node --project tools/ts_library_builder/tsconfig.json tools/ts_library_builder/test.ts
import { Project, ts } from "ts-simple-ast";
import { assert, assertEqual, test } from "../../js/testing/testing";
import {
assert,
assertEqual,
test
} from "../../js/deps/https/deno.land/x/std/testing/mod";
import { flatten, mergeGlobal } from "./build_library";
import { loadDtsFiles } from "./ast_util";