Latest
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758import { assert, assertEquals} from 'https://deno.land/std@0.97.0/testing/asserts.ts'
import * as mock from './mock.ts'
import { MatchResult, toBe, toBeDefined, toBeFalsy, toBeGreaterThan, toBeInstanceOf, toBeLessThan, toBeLessThanOrEqual, toBeNaN, toBeNull, toBeTruthy, toBeTypeOf, toBeUndefined, toContain, toEqual, toHaveBeenCalled, toHaveBeenCalledTimes, toHaveBeenCalledWith, toHaveBeenLastCalledWith, toHaveBeenNthCalledWith, toHaveLastReturnedWith, toHaveLength, toHaveNthReturnedWith, toHaveProperty, toHaveReturned, toHaveReturnedTimes, toHaveReturnedWith, toMatch, toThrow} from './matchers.ts'
function assertResult(actual: MatchResult, expected: MatchResult) { assertEquals( actual.pass, expected.pass, `expected to be ${ expected.pass ? `pass but received: ${actual.message}` : 'fail' }` ) if (typeof expected.message !== 'undefined') { assert(!!actual.message, 'no message given') const colourless = actual.message.replace( /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '' ) const trim = (x: string) => x.trim().replace(/\s*\n\s+/g, '\n')
assertEquals(trim(colourless), trim(expected.message)) }}
function assertResultPass(result: any) { assertResult(result, { pass: true })}
Deno.test({ name: 'toBePass', fn: () => { assertResultPass(toBe(10, 10)) }})
Deno.test({ name: 'toBeFail', fn: () => { assertResult(toBe(10, 20), { pass: false, message: `expect(actual).toBe(expected) - 10 + 20` })
assertResult(toBe({}, {}), { pass: false, message: `expect(actual).toBe(expected)
{}` }) }})
Deno.test({ name: 'toEqualPass', fn: () => { assertResultPass(toEqual({ a: 1 }, { a: 1 })) assertResultPass(toEqual(1, 1)) assertResultPass(toEqual([1], [1])) }})
Deno.test({ name: 'toEqualFail', fn: () => { assertResult(toEqual(10, 20), { pass: false, message: `expect(actual).toEqual(expected)\n\n- 10\n+ 20` })
assertResult(toEqual({ a: 1 }, { a: 2 }), { pass: false, message: `expect(actual).toEqual(expected) - { a: 1 } + { a: 2 }` }) }})
Deno.test({ name: 'toBeGreaterThanPass', fn: () => { assertResultPass(toBeGreaterThan(2, 1)) }})
Deno.test({ name: 'toBeGreaterThanFail', fn: () => { assertResult(toBeGreaterThan(1, 2), { pass: false, message: `expect(actual).toBeGreaterThan(expected)
1 is not greater than 2` }) }})
Deno.test({ name: 'toBeLessThanPass', fn: () => { assertResultPass(toBeLessThan(1, 2)) }})
Deno.test({ name: 'toBeLessThanFail', fn: () => { assertResult(toBeLessThan(2, 1), { pass: false, message: `expect(actual).toBeLessThan(expected)
2 is not less than 1` }) }})
Deno.test({ name: 'toBeLessThanOrEqualPass', fn: () => { assertResultPass(toBeLessThanOrEqual(1, 2)) }})
Deno.test({ name: 'toBeLessThanOrEqualFail', fn: () => { assertResult(toBeLessThanOrEqual(2, 1), { pass: false, message: `expect(actual).toBeLessThanOrEqual(expected)
2 is not less than or equal to 1` }) }})
Deno.test({ name: 'toBeTruthyPass', fn: () => { assertResultPass(toBeTruthy(1)) assertResultPass(toBeTruthy(true)) assertResultPass(toBeTruthy([])) }})
Deno.test({ name: 'toBeTruthyFail', fn: () => { assertResult(toBeTruthy(false), { pass: false, message: `expect(actual).toBeTruthy()
false is not truthy` }) }})
Deno.test({ name: "toBeTypeOfPass", fn: () => { assertResultPass(toBeTypeOf(BigInt(123), "bigint")); assertResultPass(toBeTypeOf(true, "boolean")); assertResultPass(toBeTypeOf(() => false, "function")); assertResultPass(toBeTypeOf(123, "number")); assertResultPass(toBeTypeOf(123.123, "number")); assertResultPass(toBeTypeOf(new Object(), 'object')); assertResultPass(toBeTypeOf("stringstring", 'string')); assertResultPass(toBeTypeOf(Symbol("testSymbol"), 'symbol')); assertResultPass(toBeTypeOf(undefined, 'undefined')); },});
Deno.test({ name: "toBeTypeOfFail", fn: () => { assertResult(toBeTypeOf(123, "bigint"),{ pass: false, message: `expect(actual).toBeTypeOf(expected) 123 is not a bigint` }); },});
Deno.test({ name: 'toBeFalsyPass', fn: () => { assertResultPass(toBeFalsy(0)) assertResultPass(toBeFalsy(false)) assertResultPass(toBeFalsy(null)) }})
Deno.test({ name: 'toBeFalsyFail', fn: () => { assertResult(toBeFalsy(true), { pass: false, message: `expect(actual).toBeFalsy()
true is not falsy` }) }})
Deno.test({ name: 'toBeDefinedPass', fn: () => { assertResultPass(toBeDefined(1)) assertResultPass(toBeDefined({})) }})
Deno.test({ name: 'toBeDefinedFail', fn: () => { assertResult(toBeDefined(undefined), { pass: false, message: `expect(actual).toBeDefined()
undefined is not defined` }) }})
Deno.test({ name: 'toBeUndefinedPass', fn: () => { assertResultPass(toBeUndefined(undefined)) }})
Deno.test({ name: 'toBeUndefinedFail', fn: () => { assertResult(toBeUndefined(null), { pass: false, message: `expect(actual).toBeUndefined()
null is defined but should be undefined` }) }})
Deno.test({ name: 'toBeNullPass', fn: () => { assertResultPass(toBeNull(null)) }})
Deno.test({ name: 'toBeNullFail', fn: () => { assertResult(toBeNull(10), { pass: false, message: `expect(actual).toBeNull()
10 should be null` }) }})
Deno.test({ name: 'toBeNaNPass', fn: () => { assertResultPass(toBeNaN(NaN)) }})
Deno.test({ name: 'toBeNaNFail', fn: () => { assertResult(toBeNaN(10), { pass: false, message: `expect(actual).toBeNaN()
10 should be NaN` }) }})
Deno.test({ name: 'toBeInstanceOfPass', fn: () => { class A {} const a = new A() assertResultPass(toBeInstanceOf(a, A)) }})
Deno.test({ name: 'toBeInstanceOfFail', fn: () => { class A {} class B {}
const a = new A()
assertResult(toBeInstanceOf(a, B), { pass: false, message: `expect(actual).toBeInstanceOf(expected)
expected B but received A {}` }) }})
Deno.test({ name: 'toBeMatchPass', fn: () => { assertResultPass(toMatch('hello', 'hell')) assertResultPass(toMatch('hello', /^hell/)) }})
Deno.test({ name: 'toBeMatchFail', fn: () => { assertResult(toMatch('yo', 'hell'), { pass: false, message: `expect(actual).toMatch(expected)
expected "yo" to contain "hell"` })
assertResult(toMatch('yo', /^hell/), { pass: false, message: `expect(actual).toMatch(expected)
"yo" did not match regex /^hell/` }) }})
Deno.test({ name: 'toBeHavePropertyPass', fn: () => { assertResultPass(toHaveProperty({ a: 1 }, 'a')) }})
Deno.test({ name: 'toBeHavePropertyFail', fn: () => { assertResult(toHaveProperty({ a: 1 }, 'b'), { pass: false, message: `expect(actual).toHaveProperty(expected)
{ a: 1 } did not contain property "b"` }) }})
Deno.test({ name: 'toHaveLengthPass', fn: () => { assertResultPass(toHaveLength([], 0)) assertResultPass(toHaveLength([1, 2], 2)) assertResultPass(toHaveLength({ length: 2 }, 2)) }})
Deno.test({ name: 'toBeHaveLengthFail', fn: () => { assertResult(toHaveLength([], 1), { pass: false, message: `expect(actual).toHaveLength(expected)
expected array to have length 1 but was 0` }) }})
Deno.test({ name: 'toContainPass', fn: () => { assertResultPass(toContain([1, 2], 2)) assertResultPass(toContain('Hello', 'Hell')) }})
Deno.test({ name: 'toContainFail', fn: () => { assertResult(toContain([2, 3], 1), { pass: false, message: `expect(actual).toContain(expected)
[ 2, 3 ] did not contain 1` }) assertResult(toContain('Hello', 'Good'), { pass: false, message: `expect(actual).toContain(expected)
"Hello" did not contain "Good"` }) assertResult(toContain(false, 1), { pass: false, message: `expect(actual).toContain(expected)
expected false to have an includes method but it is 1` }) }})
Deno.test({ name: 'toThrowPass', fn: () => { assertResultPass( toThrow(() => { throw new Error('TEST') }, 'TEST') ) assertResultPass( toThrow(() => { throw new Error('TEST') }, /^TEST/) ) }})
Deno.test({ name: 'toThrowFail', fn: () => { assertResult( toThrow(() => {}, 'TEST'), { pass: false, message: `expect(actual).toThrow(expected) expected [Function (anonymous)] to throw but it did not` } )
assertResult( toThrow(() => { throw new Error('BLAH') }, 'TEST'), { pass: false, message: `expect(actual).toThrow(expected)
expected [Function (anonymous)] to throw error matching "TEST" but it threw Error: BLAH` } )
assertResult( toThrow(() => { throw new Error('BLAH') }, /^TEST/), { pass: false, message: `expect(actual).toThrow(expected)
expected [Function (anonymous)] to throw error matching /^TEST/ but it threw Error: BLAH` } ) }})
Deno.test({ name: 'toHaveBeenCalledPass', fn: () => { const m = mock.fn() m(10) assertResultPass(toHaveBeenCalled(m)) }})
Deno.test({ name: 'toHaveBeenCalledFail', fn: () => { const m = mock.fn() assertResult(toHaveBeenCalled(m), { pass: false, message: `expect(actual).toHaveBeenCalled()
[Function: f] was not called` }) }})
Deno.test({ name: 'toHaveBeenCalledTimesPass', fn: () => { const m = mock.fn() m(10) m(12) assertResultPass(toHaveBeenCalledTimes(m, 2)) }})
Deno.test({ name: 'toHaveBeenCalledTimesFail', fn: () => { const m = mock.fn() m(10) assertResult(toHaveBeenCalledTimes(m, 2), { pass: false, message: `expect(actual).toHaveBeenCalledTimes(expected)
expected 2 calls but was called: 1` }) }})
Deno.test({ name: 'toHaveBeenCalledWithPass', fn: () => { const m = mock.fn() m(1, 'a') assertResultPass(toHaveBeenCalledWith(m, 1, 'a')) }})
Deno.test({ name: 'toHaveBeenCalledWithFail', fn: () => { const m = mock.fn() m(1, 'a') assertResult(toHaveBeenCalledWith(m, 2, 'b'), { pass: false, message: `expect(actual).toHaveBeenCalledWith(expected)
function was not called with: [ 2, "b" ]` }) }})
Deno.test({ name: 'toHaveBeenLastCalledWithPass', fn: () => { const m = mock.fn() m(1, 'a') m(2, 'b') m(3, 'c') assertResultPass(toHaveBeenLastCalledWith(m, 3, 'c')) }})
Deno.test({ name: 'toHaveBeenLastCalledWithPass', fn: () => { const m = mock.fn() assertResult(toHaveBeenLastCalledWith(m, 2, 'b'), { pass: false, message: `expect(actual).toHaveBeenLastCalledWith(...expected)
expect last call args to be 2,b but was not called` }) m(1, 'a') m(2, 'b') m(3, 'c') assertResult(toHaveBeenLastCalledWith(m, 2, 'b'), { pass: false, message: `expect(actual).toHaveBeenLastCalledWith(...expected)
expect last call args to be 2,b but was: 3,c` }) }})
Deno.test({ name: 'toHaveBeenNthCalledWithPass', fn: () => { const m = mock.fn() m(1, 'a') m(2, 'b') m(3, 'c') const nthCall = 2 assertResultPass(toHaveBeenNthCalledWith(m, nthCall, 2, 'b')) }})
Deno.test({ name: 'toHaveBeenNthCalledWithFail', fn: () => { const m = mock.fn() const nthCall = 3 assertResult(toHaveBeenNthCalledWith(m, nthCall, 2, 'b'), { pass: false, message: `expect(actual).toHaveBeenNthCalledWith(expected)
3th call was not made.` }) m(1, 'a') m(2, 'b') m(3, 'c') assertResult(toHaveBeenNthCalledWith(m, nthCall, 2, 'b'), { pass: false, message: `expect(actual).toHaveBeenNthCalledWith(expected)
expect 3th call args to be 2,b but was: 3,c` }) }})
Deno.test({ name: 'toHaveReturnedWithPass', fn: () => { const m = mock.fn(() => true) m() assertResultPass(toHaveReturnedWith(m, true)) }})
Deno.test({ name: 'toHaveReturnedWithFail', fn: () => { const m = mock.fn(() => true) m() assertResult(toHaveReturnedWith(m, false), { pass: false, message: `expect(actual).toHaveReturnedWith(expected)
function did not return: false` }) }})
Deno.test({ name: 'toHaveReturnedPass', fn: () => { const m = mock.fn(() => true) m() assertResultPass(toHaveReturned(m)) }})
Deno.test({ name: 'toHaveReturnedFail', fn: () => { const m = mock.fn(() => true) assertResult(toHaveReturned(m), { pass: false, message: `expected function to return but it never did` }) }})
Deno.test({ name: 'toHaveLastReturnedWithPass', fn: () => { const m = mock.fn((arg: boolean) => arg) m(false) m(true) assertResultPass(toHaveLastReturnedWith(m, true)) }})
Deno.test({ name: 'toHaveLastReturnedWithFail', fn: () => { const m = mock.fn((arg: boolean) => arg) assertResult(toHaveLastReturnedWith(m, true), { pass: false, message: `no calls made to function` }) m(true) m(false) assertResult(toHaveLastReturnedWith(m, true), { pass: false, message: `expected last call to return true but returned: false` }) }})
Deno.test({ name: 'toHaveReturnedTimesPass', fn: () => { const m = mock.fn(() => true) m() m() m() assertResultPass(toHaveReturnedTimes(m, 3)) }})
Deno.test({ name: 'toHaveReturnedTimesFail', fn: () => { const m = mock.fn(() => true) m() assertResult(toHaveReturnedTimes(m, 3), { pass: false, message: `expected 3 returned times but returned 1 times` }) }})
Deno.test({ name: 'toHaveNthReturnedWithPass', fn: () => { const m = mock.fn((n: number) => n) m(1) m(2) m(3) const nthCall = 2 assertResultPass(toHaveNthReturnedWith(m, nthCall, 2)) }})
Deno.test({ name: 'toHaveNthReturnedWithFail', fn: () => { const m = mock.fn((n: number) => n) m(1) m(2) m(3) assertResult(toHaveNthReturnedWith(m, 2, 1), { pass: false, message: `expected 2th call to return 1 but returned: 2` }) assertResult(toHaveNthReturnedWith(m, 9, 1), { pass: false, message: `9 calls were now made` }) }})