foster/denoland-deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-11-23 15:16:54 -05:00
Code Issues Packages 1 Wiki Activity

Make testing more matainable

Browse source 
Original: 2f0ca2242f
This commit is contained in:
Kitson Kelly 2019-01-22 16:09:51 +10:00 committed by Ryan Dahl
parent 41829f3e2b
commit 8d474a7911
1 changed files with 97 additions and 92 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

189
testing/mod.ts
View file

@ -2,123 +2,128 @@
// 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);
}
}
interface Constructor {
new (...args: any[]): any;
}
interface Assert {
/** Make an assertion, if not true, then throw. */
(expr: boolean, msg?: string): void;
const assertions = {
/** Make an assertion, if not `true`, then throw. */
assert(expr: boolean, msg = ""): void {
if (!expr) {
throw new Error(msg);
}
},
/** Make an assertion that `actual` and `expected` are equal, deeply. If not
* deeply equal, then throw.
*/
equal(actual: unknown, expected: unknown, msg?: string): void;
equal(actual: unknown, expected: unknown, msg?: string): void {
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);
}
},
/** Make an assertion that `actual` and `expected` are strictly equal. If
* not then throw.
*/
strictEqual(actual: unknown, expected: unknown, msg?: string): void;
strictEqual(actual: unknown, expected: unknown, msg = ""): void {
if (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(
"strictEqual failed. actual =",
actualString,
"expected =",
expectedString
);
if (!msg) {
msg = `actual: ${actualString} expected: ${expectedString}`;
}
throw new Error(msg);
}
},
/** Executes a function, expecting it to throw. If it does not, then it
* throws. An error class and a string that should be included in the
* error message can also be asserted.
*/
throws(fn: () => void, errorClass?: Constructor, msgIncludes?: string): void;
}
export const assert = function assert(expr: boolean, msg = "") {
if (!expr) {
throw new Error(msg);
}
} as Assert;
assert.equal = assertEqual;
assert.strictEqual = function strictEqual(actual, expected, msg = "") {
if (actual !== expected) {
let actualString: string;
let expectedString: string;
throws(
fn: () => void,
ErrorClass?: Constructor,
msgIncludes = "",
msg = ""
): void {
let doesThrow = false;
try {
actualString = String(actual);
fn();
} catch (e) {
actualString = "[Cannot display]";
}
try {
expectedString = String(expected);
} catch (e) {
expectedString = "[Cannot display]";
}
console.error(
"strictEqual failed. actual =",
actualString,
"expected =",
expectedString
);
if (!msg) {
msg = `actual: ${actualString} expected: ${expectedString}`;
}
throw new Error(msg);
}
};
assert.throws = function throws(
fn,
ErrorClass: Constructor,
msgIncludes = "",
msg = ""
) {
let doesThrow = false;
try {
fn();
} catch (e) {
if (ErrorClass && !(Object.getPrototypeOf(e) === ErrorClass.prototype)) {
msg = `Expected error to be instance of "${ErrorClass.name}"${
msg ? `: ${msg}` : "."
}`;
throw new Error(msg);
}
if (msgIncludes) {
if (!e.message.includes(msgIncludes)) {
msg = `Expected error message to include "${msgIncludes}", but got "${
e.message
}"${msg ? `: ${msg}` : "."}`;
if (ErrorClass && !(Object.getPrototypeOf(e) === ErrorClass.prototype)) {
msg = `Expected error to be instance of "${ErrorClass.name}"${
msg ? `: ${msg}` : "."
}`;
throw new Error(msg);
}
if (msgIncludes) {
if (!e.message.includes(msgIncludes)) {
msg = `Expected error message to include "${msgIncludes}", but got "${
e.message
}"${msg ? `: ${msg}` : "."}`;
throw new Error(msg);
}
}
doesThrow = true;
}
if (!doesThrow) {
msg = `Expected function to throw${msg ? `: ${msg}` : "."}`;
throw new Error(msg);
}
doesThrow = true;
}
if (!doesThrow) {
msg = `Expected function to throw${msg ? `: ${msg}` : "."}`;
throw new Error(msg);
}
};
type Assert = typeof assertions.assert & typeof assertions;
// Decorate assertions.assert with all the assertions
Object.assign(assertions.assert, assertions);
export const assert = assertions.assert as Assert;
/**
* An alias to assert.equal
* @deprecated
*/
export const assertEqual = assert.equal;
export function equal(c: unknown, d: unknown): boolean {
const seen = new Map();
return (function compare(a: unknown, b: unknown) {