import { AssertionError, equal,} from "https://deno.land/std@0.50.0/testing/asserts.ts";
import diff, { DiffResult, DiffType,} from "https://deno.land/std@0.50.0/testing/diff.ts";import { bold, gray, green, red, white,} from "https://deno.land/std@0.50.0/fmt/colors.ts";
import * as mock from "./mock.ts";
type MatcherState = { isNot: boolean;};
export type Matcher = (value: any, ...args: any[]) => MatchResult;
export type Matchers = { [key: string]: Matcher;};export type MatchResult = { pass: boolean; message?: string;};
const ACTUAL = red(bold("actual"));const EXPECTED = green(bold("expected"));
const CAN_NOT_DISPLAY = "[Cannot display]";
function createStr(v: unknown): string { try { return Deno.inspect(v); } catch (e) { return red(CAN_NOT_DISPLAY); }}
function createColor(diffType: DiffType): (s: string) => string { switch (diffType) { case DiffType.added: return (s: string) => green(bold(s)); case DiffType.removed: return (s: string) => red(bold(s)); default: return white; }}
function createSign(diffType: DiffType): string { switch (diffType) { case DiffType.added: return "+ "; case DiffType.removed: return "- "; default: return " "; }}
function buildMessage(diffResult: ReadonlyArray<DiffResult<string>>): string { return diffResult .map((result: DiffResult<string>) => { const c = createColor(result.type); return c(`${createSign(result.type)}${result.value}`); }) .join("\n");}
function buildDiffMessage(actual: unknown, expected: unknown) { const actualString = createStr(actual); const expectedString = createStr(expected);
let message; try { const diffResult = diff( actualString.split("\n"), expectedString.split("\n"), );
return buildMessage(diffResult); } catch (e) { return `\n${red(CAN_NOT_DISPLAY)} + \n\n`; }}
function buildFail(message: string) { return { pass: false, message, };}
export function toBe(actual: any, expected: any): MatchResult { if (actual === expected) return { pass: true };
return buildFail( `expect(${ACTUAL}).toBe(${EXPECTED})\n\n${ buildDiffMessage( actual, expected, ) }`, );}
export function toEqual(actual: any, expected: any): MatchResult { if (equal(actual, expected)) return { pass: true };
return buildFail( `expect(${ACTUAL}).toEqual(${EXPECTED})\n\n${ buildDiffMessage( actual, expected, ) }`, );}
export function toBeGreaterThan(actual: any, comparison: number): MatchResult { if (actual > comparison) return { pass: true };
const actualString = createStr(actual); const comparisonString = createStr(comparison);
return buildFail( `expect(${ACTUAL}).toBeGreaterThan(${EXPECTED})\n\n ${ red( actualString, ) } is not greater than ${green(comparisonString)}`, );}
export function toBeLessThan(actual: any, comparison: number): MatchResult { if (actual < comparison) return { pass: true };
const actualString = createStr(actual); const comparisonString = createStr(comparison);
return buildFail( `expect(${ACTUAL}).toBeLessThan(${EXPECTED})\n\n ${ red( actualString, ) } is not less than ${green(comparisonString)}`, );}
export function toBeGreaterThanOrEqual( actual: any, comparison: number,): MatchResult { if (actual >= comparison) return { pass: true };
const actualString = createStr(actual); const comparisonString = createStr(comparison);
return buildFail( `expect(${ACTUAL}).toBeGreaterThanOrEqual(${EXPECTED})\n\n ${ red( actualString, ) } is not greater than or equal to ${green(comparisonString)}`, );}
export function toBeLessThanOrEqual( actual: any, comparison: number,): MatchResult { if (actual <= comparison) return { pass: true };
const actualString = createStr(actual); const comparisonString = createStr(comparison);
return buildFail( `expect(${ACTUAL}).toBeLessThanOrEqual(${EXPECTED})\n\n ${ red( actualString, ) } is not less than or equal to ${green(comparisonString)}`, );}
export function toBeTruthy(value: any): MatchResult { if (value) return { pass: true };
const actualString = createStr(value);
return buildFail(`expect(${ACTUAL}).toBeTruthy()
${red(actualString)} is not truthy`);}
export function toBeFalsy(value: any): MatchResult { if (!value) return { pass: true };
const actualString = createStr(value);
return buildFail( `expect(${ACTUAL}).toBeFalsy()\n\n ${red(actualString)} is not falsy`, );}
export function toBeDefined(value: unknown): MatchResult { if (typeof value !== "undefined") return { pass: true };
const actualString = createStr(value);
return buildFail( `expect(${ACTUAL}).toBeDefined()\n\n ${ red(actualString) } is not defined`, );}
export function toBeUndefined(value: unknown): MatchResult { if (typeof value === "undefined") return { pass: true };
const actualString = createStr(value);
return buildFail( `expect(${ACTUAL}).toBeUndefined()\n\n ${ red( actualString, ) } is defined but should be undefined`, );}
export function toBeNull(value: unknown): MatchResult { if (value === null) return { pass: true };
const actualString = createStr(value);
return buildFail( `expect(${ACTUAL}).toBeNull()\n\n ${red(actualString)} should be null`, );}
export function toBeNaN(value: unknown): MatchResult { if (typeof value === "number" && isNaN(value)) return { pass: true };
const actualString = createStr(value);
return buildFail( `expect(${ACTUAL}).toBeNaN()\n\n ${red(actualString)} should be NaN`, );}
export function toBeInstanceOf(value: any, expected: Function): MatchResult { if (value instanceof expected) return { pass: true };
const actualString = createStr(value); const expectedString = createStr(expected);
return buildFail( `expect(${ACTUAL}).toBeInstanceOf(${EXPECTED})\n\n expected ${ green( expected.name, ) } but received ${red(actualString)}`, );}
export function toMatch(value: any, pattern: RegExp | string): MatchResult { const valueStr = value.toString(); if (typeof pattern === "string") { if (valueStr.indexOf(pattern) !== -1) return { pass: true };
const actualString = createStr(value); const patternString = createStr(pattern);
return buildFail( `expect(${ACTUAL}).toMatch(${EXPECTED})\n\n expected ${ red( actualString, ) } to contain ${green(patternString)}`, ); } else if (pattern instanceof RegExp) { if (pattern.exec(valueStr)) return { pass: true };
const actualString = createStr(value); const patternString = createStr(pattern);
return buildFail( `expect(${ACTUAL}).toMatch(${EXPECTED})\n\n ${ red( actualString, ) } did not match regex ${green(patternString)}`, ); } else { return buildFail("Invalid internal state"); }}
export function toHaveProperty(value: any, propName: string): MatchResult { if (typeof value === "object" && typeof value[propName] !== "undefined") { return { pass: true }; }
const actualString = createStr(value); const propNameString = createStr(propName);
return buildFail( `expect(${ACTUAL}).toHaveProperty(${EXPECTED})\n\n ${ red( actualString, ) } did not contain property ${green(propNameString)}`, );}export function toHaveLength(value: any, length: number): MatchResult { if (value?.length === length) return { pass: true };
const actualString = createStr(value.length); const lengthString = createStr(length);
return buildFail( `expect(${ACTUAL}).toHaveLength(${EXPECTED})\n\n expected array to have length ${ green( lengthString, ) } but was ${red(actualString)}`, );}
export function toContain(value: any, item: any): MatchResult { if (Array.isArray(value) && value.includes(item)) return { pass: true };
const actualString = createStr(value); const itemString = createStr(item);
if (Array.isArray(value)) { return buildFail( `expect(${ACTUAL}).toContain(${EXPECTED})\n\n ${ red( actualString, ) } did not contain ${green(itemString)}`, ); } else { return buildFail( `expect(${ACTUAL}).toContain(${EXPECTED})\n\n expected ${ red( actualString, ) } to contain ${green(itemString)} but it is ${red("not")} an array`, ); }}export function toThrow(value: any, error?: RegExp | string): MatchResult { let fn; if (typeof value === "function") { fn = value; try { value = value(); } catch (err) { value = err; } }
const actualString = createStr(fn); const errorString = createStr(error);
if (value instanceof Error) { if (typeof error === "string") { if (!value.message.includes(error)) { return buildFail( `expect(${ACTUAL}).toThrow(${EXPECTED})\n\nexpected ${ red( actualString, ) } to throw error matching ${green(errorString)} but it threw ${ red( value.toString(), ) }`, ); } } else if (error instanceof RegExp) { if (!value.message.match(error)) { return buildFail( `expect(${ACTUAL}).toThrow(${EXPECTED})\n\nexpected ${ red( actualString, ) } to throw error matching ${green(errorString)} but it threw ${ red( value.toString(), ) }`, ); } }
return { pass: true }; } else { return buildFail( `expect(${ACTUAL}).toThrow(${EXPECTED})\n\nexpected ${ red( actualString, ) } to throw but it did not`, ); }}
function extractMockCalls( value: any, name: string,): { error?: string; calls: mock.MockCall[] | null } { if (typeof value !== "function") { return { calls: null, error: `${name} only works on mock functions. received: ${value}`, }; } const calls = mock.calls(value); if (calls === null) { return { calls: null, error: `${name} only works on mock functions` }; }
return { calls };}
export function toHaveBeenCalled(value: any): MatchResult { const { calls, error } = extractMockCalls(value, "toHaveBeenCalled"); if (error) return buildFail(error);
const actualString = createStr(value);
if (calls && calls.length !== 0) return { pass: true };
return buildFail( `expect(${ACTUAL}).toHaveBeenCalled()\n\n ${ red( actualString, ) } was not called`, );}
export function toHaveBeenCalledTimes(value: any, times: number): MatchResult { const { calls, error } = extractMockCalls(value, "toHaveBeenCalledTimes"); if (error) return buildFail(error); if (!calls) return buildFail("Invalid internal state");
if (calls && calls.length === times) return { pass: true };
return buildFail( `expect(${ACTUAL}).toHaveBeenCalledTimes(${EXPECTED})\n\n expected ${times} calls but was called: ${calls.length}`, );}
export function toHaveBeenCalledWith(value: any, ...args: any[]): MatchResult { const { calls, error } = extractMockCalls(value, "toHaveBeenCalledWith"); if (error) return buildFail(error);
const wasCalledWith = calls && calls.some((c) => equal(c.args, args)); if (wasCalledWith) return { pass: true };
const argsString = createStr(args);
return buildFail( `expect(${ACTUAL}).toHaveBeenCalledWith(${EXPECTED})\n\n function was not called with: ${ green( argsString, ) }`, );}
export function toHaveBeenLastCalledWith( value: any, ...args: any[]): MatchResult { const { calls, error } = extractMockCalls(value, "toHaveBeenLastCalledWith"); if (error) return buildFail(error);
if (!calls || !calls.length) { return buildFail( `expect(${ACTUAL}).toHaveBeenLastCalledWith(...${EXPECTED})\n\n expect last call args to be ${args} but was not called`, ); }
const lastCall = calls[calls.length - 1]; if (equal(lastCall.args, args)) return { pass: true };
return buildFail( `expect(${ACTUAL}).toHaveBeenLastCalledWith(...${EXPECTED})\n\n expect last call args to be ${args} but was: ${lastCall.args}`, );}
export function toHaveBeenNthCalledWith( value: any, nth: number, ...args: any[]): MatchResult { const { calls, error } = extractMockCalls(value, "toHaveBeenNthCalledWith"); if (error) return buildFail(error);
const nthCall = calls && calls[nth - 1]; if (nthCall) { if (equal(nthCall.args, args)) return { pass: true }; return buildFail( `expect(${ACTUAL}).toHaveBeenNthCalledWith(${EXPECTED})\n\n expect ${nth}th call args to be ${args} but was: ${nthCall.args}`, ); } else { return buildFail( `expect(${ACTUAL}).toHaveBeenNthCalledWith(${EXPECTED})\n\n ${nth}th call was not made.`, ); }}
export function toHaveReturnedWith(value: any, result: any): MatchResult { const { calls, error } = extractMockCalls(value, "toHaveReturnedWith"); if (error) return buildFail(error);
const wasReturnedWith = calls && calls.some((c) => c.returns && equal(c.returned, result)); if (wasReturnedWith) return { pass: true };
return buildFail( `expect(${ACTUAL}).toHaveReturnedWith(${EXPECTED})\n\n function did not return: ${result}`, );}
export function toHaveReturned(value: any): MatchResult { const { calls, error } = extractMockCalls(value, "toHaveReturned"); if (error) return buildFail(error);
if (calls && calls.some((c) => c.returns)) return { pass: true };
return buildFail(`expected function to return but it never did`);}
export function toHaveLastReturnedWith( value: any, expected: any,): MatchResult { const { calls, error } = extractMockCalls(value, "toHaveLastReturnedWith"); if (error) return buildFail(error);
const lastCall = calls && calls[calls.length - 1]; if (!lastCall) { return buildFail("no calls made to function"); } if (lastCall.throws) { return buildFail(`last call to function threw: ${lastCall.thrown}`); }
if (equal(lastCall.returned, expected)) return { pass: true };
return buildFail( `expected last call to return ${expected} but returned: ${lastCall.returned}`, );}
export function toHaveReturnedTimes(value: any, times: number): MatchResult { const { calls, error } = extractMockCalls(value, "toHaveReturnedTimes"); if (error) return buildFail(error);
const returnCount = calls && calls.filter((c) => c.returns).length; if (returnCount !== times) { return buildFail( `expected ${times} returned times but returned ${returnCount} times`, ); }
return { pass: true };}
export function toHaveNthReturnedWith( value: any, nth: number, expected: any,): MatchResult { const { calls, error } = extractMockCalls(value, "toHaveNthReturnedWith"); if (error) return buildFail(error);
const nthCall = calls && calls[nth - 1]; if (!nthCall) { return buildFail(`${nth} calls were now made`); }
if (nthCall.throws) { return buildFail(`${nth}th call to function threw: ${nthCall.thrown}`); }
if (!equal(nthCall.returned, expected)) { return buildFail( `expected ${nth}th call to return ${expected} but returned: ${nthCall.returned}`, ); }
return { pass: true };}