Module

std/testing/asserts_test.ts

Deno standard library
Go to Latest
File
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.import { assert, assertAlmostEquals, assertArrayIncludes, assertEquals, assertExists, assertFalse, assertInstanceOf, AssertionError, assertIsError, assertMatch, assertNotEquals, assertNotMatch, assertNotStrictEquals, assertObjectMatch, assertRejects, assertStrictEquals, assertStringIncludes, assertThrows, equal, fail, unimplemented, unreachable,} from "./asserts.ts";import { bold, gray, green, red, stripColor, yellow } from "../fmt/colors.ts";
Deno.test("EqualDifferentZero", () => { assert(equal(0, -0)); assert(equal(0, +0)); assert(equal(+0, -0)); assert(equal([0], [-0])); assert(equal(["hello", 12.21, 0], ["hello", 12.21, -0])); assert(equal(["hello", 12.21, 0], ["hello", 12.21, +0])); assert(equal(["hello", 12.21, -0], ["hello", 12.21, +0])); assert(equal({ msg: "hello", case: 0 }, { msg: "hello", case: -0 })); assert(equal({ msg: "hello", array: [0] }, { msg: "hello", array: [-0] }));});
Deno.test("Equal", function (): void { assert(equal("world", "world")); assert(!equal("hello", "world")); assertFalse(equal("hello", "world")); assert(equal(5, 5)); assert(!equal(5, 6)); assertFalse(equal(5, 6)); assert(equal(NaN, NaN)); assert(equal({ hello: "world" }, { hello: "world" })); assert(!equal({ world: "hello" }, { hello: "world" })); assertFalse(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" } }, ), ); assertFalse( equal( { hello: "world", hi: { there: "everyone" } }, { hello: "world", hi: { there: "everyone else" } }, ), ); assert(equal({ [Symbol.for("foo")]: "bar" }, { [Symbol.for("foo")]: "bar" })); assert(!equal({ [Symbol("foo")]: "bar" }, { [Symbol("foo")]: "bar" })); assertFalse(equal({ [Symbol("foo")]: "bar" }, { [Symbol("foo")]: "bar" }));
assert(equal(/deno/, /deno/)); assert(!equal(/deno/, /node/)); assertFalse(equal(/deno/, /node/)); assert(equal(new Date(2019, 0, 3), new Date(2019, 0, 3))); assert(!equal(new Date(2019, 0, 3), new Date(2019, 1, 3))); assertFalse(equal(new Date(2019, 0, 3), new Date(2019, 1, 3))); assert( !equal( new Date(2019, 0, 3, 4, 20, 1, 10), new Date(2019, 0, 3, 4, 20, 1, 20), ), ); assertFalse( equal( new Date(2019, 0, 3, 4, 20, 1, 10), new Date(2019, 0, 3, 4, 20, 1, 20), ), ); assert(equal(new Date("Invalid"), new Date("Invalid"))); assert(!equal(new Date("Invalid"), new Date(2019, 0, 3))); assertFalse(equal(new Date("Invalid"), new Date(2019, 0, 3))); assert(!equal(new Date("Invalid"), new Date(2019, 0, 3, 4, 20, 1, 10))); assertFalse(equal(new Date("Invalid"), new Date(2019, 0, 3, 4, 20, 1, 10))); assert(equal(new Set([1]), new Set([1]))); assert(!equal(new Set([1]), new Set([2]))); assertFalse(equal(new Set([1]), new Set([2]))); assert(equal(new Set([1, 2, 3]), new Set([3, 2, 1]))); assert(equal(new Set([1, new Set([2, 3])]), new Set([new Set([3, 2]), 1]))); assert(!equal(new Set([1, 2]), new Set([3, 2, 1]))); assertFalse(equal(new Set([1, 2]), new Set([3, 2, 1]))); assert(!equal(new Set([1, 2, 3]), new Set([4, 5, 6]))); assertFalse(equal(new Set([1, 2, 3]), new Set([4, 5, 6]))); assert(equal(new Set("denosaurus"), new Set("denosaurussss"))); assert(equal(new Map(), new Map())); assert( equal( new Map([ ["foo", "bar"], ["baz", "baz"], ]), new Map([ ["foo", "bar"], ["baz", "baz"], ]), ), ); assert( equal( new Map([["foo", new Map([["bar", "baz"]])]]), new Map([["foo", new Map([["bar", "baz"]])]]), ), ); assert( equal( new Map([["foo", { bar: "baz" }]]), new Map([["foo", { bar: "baz" }]]), ), ); assert( equal( new Map([ ["foo", "bar"], ["baz", "qux"], ]), new Map([ ["baz", "qux"], ["foo", "bar"], ]), ), ); assert(equal(new Map([["foo", ["bar"]]]), new Map([["foo", ["bar"]]]))); assert(!equal(new Map([["foo", "bar"]]), new Map([["bar", "baz"]]))); assertFalse(equal(new Map([["foo", "bar"]]), new Map([["bar", "baz"]]))); assertFalse(equal(new Map([["foo", "bar"]]), new Map([["bar", "baz"]]))); assert( !equal( new Map([["foo", "bar"]]), new Map([ ["foo", "bar"], ["bar", "baz"], ]), ), ); assertFalse( equal( new Map([["foo", "bar"]]), new Map([ ["foo", "bar"], ["bar", "baz"], ]), ), ); assert( !equal( new Map([["foo", new Map([["bar", "baz"]])]]), new Map([["foo", new Map([["bar", "qux"]])]]), ), ); assert(equal(new Map([[{ x: 1 }, true]]), new Map([[{ x: 1 }, true]]))); assert(!equal(new Map([[{ x: 1 }, true]]), new Map([[{ x: 1 }, false]]))); assertFalse(equal(new Map([[{ x: 1 }, true]]), new Map([[{ x: 1 }, false]]))); assert(!equal(new Map([[{ x: 1 }, true]]), new Map([[{ x: 2 }, true]]))); assertFalse(equal(new Map([[{ x: 1 }, true]]), new Map([[{ x: 2 }, true]]))); assert(equal([1, 2, 3], [1, 2, 3])); assert(equal([1, [2, 3]], [1, [2, 3]])); assert(!equal([1, 2, 3, 4], [1, 2, 3])); assertFalse(equal([1, 2, 3, 4], [1, 2, 3])); assert(!equal([1, 2, 3, 4], [1, 2, 3])); assertFalse(equal([1, 2, 3, 4], [1, 2, 3])); assert(!equal([1, 2, 3, 4], [1, 4, 2, 3])); assertFalse(equal([1, 2, 3, 4], [1, 4, 2, 3])); assert(equal(new Uint8Array([1, 2, 3, 4]), new Uint8Array([1, 2, 3, 4]))); assert(!equal(new Uint8Array([1, 2, 3, 4]), new Uint8Array([2, 1, 4, 3]))); assertFalse( equal(new Uint8Array([1, 2, 3, 4]), new Uint8Array([2, 1, 4, 3])), ); assert( equal(new URL("https://example.test"), new URL("https://example.test")), ); assert( !equal( new URL("https://example.test"), new URL("https://example.test/with-path"), ), ); assertFalse( equal( new URL("https://example.test"), new URL("https://example.test/with-path"), ), ); assert( !equal({ a: undefined, b: undefined }, { a: undefined, c: undefined }), ); assertFalse( equal({ a: undefined, b: undefined }, { a: undefined, c: undefined }), ); assertFalse(equal({ a: undefined, b: undefined }, { a: undefined })); assertThrows(() => equal(new WeakMap(), new WeakMap())); assertThrows(() => equal(new WeakSet(), new WeakSet())); assert(!equal(new WeakMap(), new WeakSet())); assertFalse(equal(new WeakMap(), new WeakSet())); assert( equal(new WeakRef({ hello: "world" }), new WeakRef({ hello: "world" })), ); assert( !equal(new WeakRef({ world: "hello" }), new WeakRef({ hello: "world" })), ); assertFalse( equal(new WeakRef({ world: "hello" }), new WeakRef({ hello: "world" })), ); assert(!equal({ hello: "world" }, new WeakRef({ hello: "world" }))); assertFalse(equal({ hello: "world" }, new WeakRef({ hello: "world" }))); assert( !equal( new WeakRef({ hello: "world" }), // deno-lint-ignore ban-types new (class<T extends object> extends WeakRef<T> {})({ hello: "world" }), ), ); assertFalse( equal( new WeakRef({ hello: "world" }), // deno-lint-ignore ban-types new (class<T extends object> extends WeakRef<T> {})({ hello: "world" }), ), ); assert( !equal( new WeakRef({ hello: "world" }), // deno-lint-ignore ban-types new (class<T extends object> extends WeakRef<T> { foo = "bar"; })({ hello: "world" }), ), ); assertFalse( equal( new WeakRef({ hello: "world" }), // deno-lint-ignore ban-types new (class<T extends object> extends WeakRef<T> { foo = "bar"; })({ hello: "world" }), ), );
assert( !equal( new (class A { #hello = "world"; })(), new (class B { #hello = "world"; })(), ), );
assertFalse( equal( new (class A { #hello = "world"; })(), new (class B { #hello = "world"; })(), ), );});
Deno.test("EqualCircular", () => { const objA: { prop?: unknown } = {}; objA.prop = objA; const objB: { prop?: unknown } = {}; objB.prop = objB; assert(equal(objA, objB));
const mapA = new Map(); mapA.set("prop", mapA); const mapB = new Map(); mapB.set("prop", mapB); assert(equal(mapA, mapB));});
Deno.test("NotEquals", function (): void { const a = { foo: "bar" }; const b = { bar: "foo" }; assertNotEquals<unknown>(a, b); assertNotEquals("Denosaurus", "Tyrannosaurus"); assertNotEquals( new Date(2019, 0, 3, 4, 20, 1, 10), new Date(2019, 0, 3, 4, 20, 1, 20), ); assertNotEquals(new Date("invalid"), new Date(2019, 0, 3, 4, 20, 1, 20)); let didThrow; try { assertNotEquals("Raptor", "Raptor"); didThrow = false; } catch (e) { assert(e instanceof AssertionError); didThrow = true; } assertEquals(didThrow, true);});
Deno.test("AssertExists", function (): void { assertExists("Denosaurus"); assertExists(false); assertExists(0); assertExists(""); assertExists(-0); assertExists(0); assertExists(NaN);
const value = new URLSearchParams({ value: "test" }).get("value"); assertExists(value); assertEquals(value.length, 4);
let didThrow; try { assertExists(undefined); didThrow = false; } catch (e) { assert(e instanceof AssertionError); didThrow = true; } assertEquals(didThrow, true); didThrow = false; try { assertExists(null); didThrow = false; } catch (e) { assert(e instanceof AssertionError); didThrow = true; } assertEquals(didThrow, true);});
Deno.test("AssertStringContains", function (): void { assertStringIncludes("Denosaurus", "saur"); assertStringIncludes("Denosaurus", "Deno"); assertStringIncludes("Denosaurus", "rus"); let didThrow; try { assertStringIncludes("Denosaurus", "Raptor"); didThrow = false; } catch (e) { assert(e instanceof AssertionError); didThrow = true; } assertEquals(didThrow, true);});
Deno.test("ArrayContains", function (): void { const fixture = ["deno", "iz", "luv"]; const fixtureObject = [{ deno: "luv" }, { deno: "Js" }]; assertArrayIncludes(fixture, ["deno"]); assertArrayIncludes(fixtureObject, [{ deno: "luv" }]); assertArrayIncludes( Uint8Array.from([1, 2, 3, 4]), Uint8Array.from([1, 2, 3]), ); assertThrows( (): void => assertArrayIncludes(fixtureObject, [{ deno: "node" }]), AssertionError, `actual: "[ { deno: "luv", }, { deno: "Js", },]" expected to include: "[ { deno: "node", },]"missing: [ { deno: "node", },]`, );});
Deno.test("AssertStringContainsThrow", function (): void { let didThrow = false; try { assertStringIncludes("Denosaurus from Jurassic", "Raptor"); } catch (e) { assert(e instanceof AssertionError); assert( e.message === `actual: "Denosaurus from Jurassic" expected to contain: "Raptor"`, ); didThrow = true; } assert(didThrow);});
Deno.test("AssertStringMatching", function (): void { assertMatch("foobar@deno.com", RegExp(/[a-zA-Z]+@[a-zA-Z]+.com/));});
Deno.test("AssertStringMatchingThrows", function (): void { let didThrow = false; try { assertMatch("Denosaurus from Jurassic", RegExp(/Raptor/)); } catch (e) { assert(e instanceof AssertionError); assert( e.message === `actual: "Denosaurus from Jurassic" expected to match: "/Raptor/"`, ); didThrow = true; } assert(didThrow);});
Deno.test("AssertStringNotMatching", function (): void { assertNotMatch("foobar.deno.com", RegExp(/[a-zA-Z]+@[a-zA-Z]+.com/));});
Deno.test("AssertStringNotMatchingThrows", function (): void { let didThrow = false; try { assertNotMatch("Denosaurus from Jurassic", RegExp(/from/)); } catch (e) { assert(e instanceof AssertionError); assert( e.message === `actual: "Denosaurus from Jurassic" expected to not match: "/from/"`, ); didThrow = true; } assert(didThrow);});
Deno.test("AssertObjectMatching", function (): void { const sym = Symbol("foo"); const a = { foo: true, bar: false }; const b = { ...a, baz: a }; const c = { ...b, qux: b }; const d = { corge: c, grault: c }; const e = { foo: true } as { [key: string]: unknown }; e.bar = e; const f = { [sym]: true, bar: false }; interface r { foo: boolean; bar: boolean; } const g: r = { foo: true, bar: false }; const h = { foo: [1, 2, 3], bar: true }; const i = { foo: [a, e], bar: true }; const j = { foo: [[1, 2, 3]], bar: true }; const k = { foo: [[1, [2, [3]]]], bar: true }; const l = { foo: [[1, [2, [a, e, j, k]]]], bar: true }; const m = { foo: /abc+/i, bar: [/abc/g, /abc/m] }; const n = { foo: new Set(["foo", "bar"]), bar: new Map([ ["foo", 1], ["bar", 2], ]), baz: new Map([ ["a", a], ["b", b], ]), };
// Simple subset assertObjectMatch(a, { foo: true, }); // Subset with another subset assertObjectMatch(b, { foo: true, baz: { bar: false }, }); // Subset with multiple subsets assertObjectMatch(c, { foo: true, baz: { bar: false }, qux: { baz: { foo: true }, }, }); // Subset with same object reference as subset assertObjectMatch(d, { corge: { foo: true, qux: { bar: false }, }, grault: { bar: false, qux: { foo: true }, }, }); // Subset with circular reference assertObjectMatch(e, { foo: true, bar: { bar: { bar: { foo: true, }, }, }, }); // Subset with interface assertObjectMatch(g, { bar: false }); // Subset with same symbol assertObjectMatch(f, { [sym]: true, }); // Subset with array inside assertObjectMatch(h, { foo: [] }); assertObjectMatch(h, { foo: [1, 2] }); assertObjectMatch(h, { foo: [1, 2, 3] }); assertObjectMatch(i, { foo: [{ bar: false }] }); assertObjectMatch(i, { foo: [{ bar: false }, { bar: { bar: { bar: { foo: true } } } }], }); // Subset with nested array inside assertObjectMatch(j, { foo: [[1, 2, 3]] }); assertObjectMatch(k, { foo: [[1, [2, [3]]]] }); assertObjectMatch(l, { foo: [[1, [2, [a, e, j, k]]]] }); // Regexp assertObjectMatch(m, { foo: /abc+/i }); assertObjectMatch(m, { bar: [/abc/g, /abc/m] }); //Built-in data structures assertObjectMatch(n, { foo: new Set(["foo"]) }); assertObjectMatch(n, { bar: new Map([["bar", 2]]) }); assertObjectMatch(n, { baz: new Map([["b", b]]) }); assertObjectMatch(n, { baz: new Map([["b", { foo: true }]]) });
// Missing key { let didThrow; try { assertObjectMatch( { foo: true, }, { foo: true, bar: false, }, ); didThrow = false; } catch (e) { assert(e instanceof AssertionError); didThrow = true; } assertEquals(didThrow, true); } // Simple subset { let didThrow; try { assertObjectMatch(a, { foo: false, }); didThrow = false; } catch (e) { assert(e instanceof AssertionError); didThrow = true; } assertEquals(didThrow, true); } // Subset with another subset { let didThrow; try { assertObjectMatch(b, { foo: true, baz: { bar: true }, }); didThrow = false; } catch (e) { assert(e instanceof AssertionError); didThrow = true; } assertEquals(didThrow, true); } // Subset with multiple subsets { let didThrow; try { assertObjectMatch(c, { foo: true, baz: { bar: false }, qux: { baz: { foo: false }, }, }); didThrow = false; } catch (e) { assert(e instanceof AssertionError); didThrow = true; } assertEquals(didThrow, true); } // Subset with same object reference as subset { let didThrow; try { assertObjectMatch(d, { corge: { foo: true, qux: { bar: true }, }, grault: { bar: false, qux: { foo: false }, }, }); didThrow = false; } catch (e) { assert(e instanceof AssertionError); didThrow = true; } assertEquals(didThrow, true); } // Subset with circular reference { let didThrow; try { assertObjectMatch(e, { foo: true, bar: { bar: { bar: { foo: false, }, }, }, }); didThrow = false; } catch (e) { assert(e instanceof AssertionError); didThrow = true; } assertEquals(didThrow, true); } // Subset with symbol key but with string key subset { let didThrow; try { assertObjectMatch(f, { foo: true, }); didThrow = false; } catch (e) { assert(e instanceof AssertionError); didThrow = true; } assertEquals(didThrow, true); } // Subset with array inside but doesn't match key subset { let didThrow; try { assertObjectMatch(i, { foo: [1, 2, 3, 4], }); didThrow = false; } catch (e) { assert(e instanceof AssertionError); didThrow = true; } assertEquals(didThrow, true); } { let didThrow; try { assertObjectMatch(i, { foo: [{ bar: true }, { foo: false }], }); didThrow = false; } catch (e) { assert(e instanceof AssertionError); didThrow = true; } assertEquals(didThrow, true); } // actual/expected value as instance of class { class A { a: number; constructor(a: number) { this.a = a; } } assertObjectMatch({ test: new A(1) }, { test: { a: 1 } }); assertObjectMatch({ test: { a: 1 } }, { test: { a: 1 } }); assertObjectMatch({ test: { a: 1 } }, { test: new A(1) }); assertObjectMatch({ test: new A(1) }, { test: new A(1) }); } { // actual/expected contains same instance of Map/TypedArray/etc const body = new Uint8Array([0, 1, 2]); assertObjectMatch({ body, foo: "foo" }, { body }); } { // match subsets of arrays assertObjectMatch( { positions: [[1, 2, 3, 4]] }, { positions: [[1, 2, 3]], }, ); } //Regexp assertThrows(() => assertObjectMatch(m, { foo: /abc+/ }), AssertionError); assertThrows(() => assertObjectMatch(m, { foo: /abc*/i }), AssertionError); assertThrows( () => assertObjectMatch(m, { bar: [/abc/m, /abc/g] }), AssertionError, ); //Built-in data structures assertThrows( () => assertObjectMatch(n, { foo: new Set(["baz"]) }), AssertionError, ); assertThrows( () => assertObjectMatch(n, { bar: new Map([["bar", 3]]) }), AssertionError, ); assertThrows( () => assertObjectMatch(n, { baz: new Map([["a", { baz: true }]]) }), AssertionError, );});
Deno.test("AssertsUnimplemented", function (): void { let didThrow = false; try { unimplemented(); } catch (e) { assert(e instanceof AssertionError); assert(e.message === "unimplemented"); didThrow = true; } assert(didThrow);});
Deno.test("AssertsUnreachable", function (): void { let didThrow = false; try { unreachable(); } catch (e) { assert(e instanceof AssertionError); assert(e.message === "unreachable"); didThrow = true; } assert(didThrow);});
Deno.test("AssertFail", function (): void { assertThrows(fail, AssertionError, "Failed assertion."); assertThrows( (): void => { fail("foo"); }, AssertionError, "Failed assertion: foo", );});
Deno.test("assertThrows with wrong error class", () => { assertThrows( (): void => { //This next assertThrows will throw an AssertionError due to the wrong //expected error class assertThrows( (): void => { fail("foo"); }, TypeError, "Failed assertion: foo", ); }, AssertionError, `Expected error to be instance of "TypeError", but was "AssertionError"`, );});
Deno.test("assertThrows with return type", () => { assertThrows(() => { throw new Error(); });});
Deno.test("assertRejects with return type", async () => { await assertRejects(() => { return Promise.reject(new Error()); });});
Deno.test("assertRejects with synchronous function that throws", async () => { await assertRejects(() => assertRejects(() => { throw new Error(); }) ); await assertRejects( () => assertRejects(() => { throw { wrong: "true" }; }), AssertionError, "Function throws when expected to reject.", );});
Deno.test("assertThrows with non-error value thrown and error callback", () => { assertThrows( () => { assertThrows( () => { throw "Panic!"; }, (error: Error) => error, "Panic!", ); }, AssertionError, "A non-Error object was thrown.", );});
Deno.test("assertRejects with non-error value rejected and error callback", async () => { await assertRejects( () => { return assertRejects( () => { return Promise.reject("Panic!"); }, (error: Error) => error, "Panic!", ); }, AssertionError, "A non-Error object was rejected.", );});
Deno.test("assertRejects with PromiseLike", async () => { await assertRejects( () => ({ then() { throw new Error("some error"); }, }), Error, "some error", );});
Deno.test("assertThrows with non-error value thrown and error class", () => { assertThrows( () => { assertThrows( () => { throw "Panic!"; }, Error, "Panic!", ); }, AssertionError, "A non-Error object was thrown.", );});
Deno.test("assertRejects with non-error value rejected and error class", async () => { await assertRejects( () => { return assertRejects( () => { return Promise.reject("Panic!"); }, Error, "Panic!", ); }, AssertionError, "A non-Error object was rejected.", );});
Deno.test("assertThrows with non-error value thrown", () => { assertThrows( () => { throw "Panic!"; }, ); assertThrows( () => { throw null; }, ); assertThrows( () => { throw undefined; }, );});
Deno.test("assertRejects with non-error value rejected", async () => { await assertRejects(() => { return Promise.reject(null); }); await assertRejects(() => { return Promise.reject(undefined); });});
Deno.test("assertThrows with error class", () => { assertThrows( () => { throw new Error("foo"); }, Error, "foo", );});
Deno.test("assertRejects with error class", async () => { await assertRejects( () => { return Promise.reject(new Error("foo")); }, Error, "foo", );});
Deno.test("assertThrows with error callback", () => { assertThrows( () => { throw new AggregateError([new Error("foo"), new Error("bar")], "baz"); }, (error: Error) => { assert(error instanceof AggregateError); assertEquals(error.message, "baz"); assertEquals(error.errors.length, 2); assertStringIncludes(error.errors[0].stack, "Error: foo"); assertStringIncludes(error.errors[1].stack, "Error: bar"); }, );});
Deno.test("assertRejectes with error callback", async () => { await assertRejects( () => { return Promise.reject( new AggregateError([new Error("foo"), new Error("bar")], "baz"), ); }, (error: Error) => { assert(error instanceof AggregateError); assertEquals(error.message, "baz"); assertEquals(error.errors.length, 2); assertStringIncludes(error.errors[0].stack, "Error: foo"); assertStringIncludes(error.errors[1].stack, "Error: bar"); }, );});
Deno.test("assertThrows with thrown error returns caught error", () => { const error = assertThrows( () => { throw new Error("foo"); }, ); assert(error instanceof Error); assertEquals(error.message, "foo");});
Deno.test("assertThrows with thrown non-error returns caught error", () => { const stringError = assertThrows( () => { throw "Panic!"; }, ); assert(typeof stringError === "string"); assertEquals(stringError, "Panic!");
const numberError = assertThrows( () => { throw 1; }, ); assert(typeof numberError === "number"); assertEquals(numberError, 1);
const nullError = assertThrows( () => { throw null; }, ); assert(nullError === null);
const undefinedError = assertThrows( () => { throw undefined; }, ); assert(typeof undefinedError === "undefined"); assertEquals(undefinedError, undefined);});
Deno.test("assertRejectes resolves with caught error", async () => { const error = await assertRejects( () => { return Promise.reject(new Error("foo")); }, ); assert(error instanceof Error); assertEquals(error.message, "foo");});
const createHeader = (): string[] => [ "", "", ` ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${ green( bold("Expected"), ) }`, "", "",];
const added: (s: string) => string = (s: string): string => green(bold(stripColor(s)));const removed: (s: string) => string = (s: string): string => red(bold(stripColor(s)));
Deno.test({ name: "pass case", fn(): void { assertEquals({ a: 10 }, { a: 10 }); assertEquals(true, true); assertEquals(10, 10); assertEquals("abc", "abc"); assertEquals({ a: 10, b: { c: "1" } }, { a: 10, b: { c: "1" } }); assertEquals(new Date("invalid"), new Date("invalid")); },});
Deno.test({ name: "failed with number", fn(): void { assertThrows( (): void => assertEquals(1, 2), AssertionError, [ "Values are not equal:", ...createHeader(), removed(`- ${yellow("1")}`), added(`+ ${yellow("2")}`), "", ].join("\n"), ); },});
Deno.test({ name: "failed with number vs string", fn(): void { assertThrows( (): void => assertEquals<unknown>(1, "1"), AssertionError, [ "Values are not equal:", ...createHeader(), removed(`- ${yellow("1")}`), added(`+ "1"`), ].join("\n"), ); },});
Deno.test({ name: "failed with array", fn(): void { assertThrows( (): void => assertEquals([1, "2", 3], ["1", "2", 3]), AssertionError, ` [- 1,+ "1", "2", 3, ]`, ); },});
Deno.test({ name: "failed with object", fn(): void { assertThrows( (): void => assertEquals({ a: 1, b: "2", c: 3 }, { a: 1, b: 2, c: [3] }), AssertionError, ` { a: 1,+ b: 2,+ c: [+ 3,+ ],- b: "2",- c: 3, }`, ); },});
Deno.test({ name: "failed with date", fn(): void { assertThrows( (): void => assertEquals( new Date(2019, 0, 3, 4, 20, 1, 10), new Date(2019, 0, 3, 4, 20, 1, 20), ), AssertionError, [ "Values are not equal:", ...createHeader(), removed(`- ${new Date(2019, 0, 3, 4, 20, 1, 10).toISOString()}`), added(`+ ${new Date(2019, 0, 3, 4, 20, 1, 20).toISOString()}`), "", ].join("\n"), ); assertThrows( (): void => assertEquals(new Date("invalid"), new Date(2019, 0, 3, 4, 20, 1, 20)), AssertionError, [ "Values are not equal:", ...createHeader(), removed(`- ${new Date("invalid")}`), added(`+ ${new Date(2019, 0, 3, 4, 20, 1, 20).toISOString()}`), "", ].join("\n"), ); },});
Deno.test({ name: "strict types test", fn(): void { const x = { number: 2 };
const y = x as Record<never, never>; const z = x as unknown;
// y.number; // ~~~~~~ // Property 'number' does not exist on type 'Record<never, never>'.deno-ts(2339)
assertStrictEquals(y, x); y.number; // ok
// z.number; // ~ // Object is of type 'unknown'.deno-ts(2571)
assertStrictEquals(z, x); z.number; // ok },});
Deno.test({ name: "strict pass case", fn(): void { assertStrictEquals(true, true); assertStrictEquals(10, 10); assertStrictEquals("abc", "abc"); assertStrictEquals(NaN, NaN);
const xs = [1, false, "foo"]; const ys = xs; assertStrictEquals(xs, ys);
const x = { a: 1 }; const y = x; assertStrictEquals(x, y); },});
Deno.test({ name: "strict failed with structure diff", fn(): void { assertThrows( (): void => assertStrictEquals({ a: 1, b: 2 }, { a: 1, c: [3] }), AssertionError, ` { a: 1,+ c: [+ 3,+ ],- b: 2, }`, ); },});
Deno.test({ name: "strict failed with reference diff", fn(): void { assertThrows( (): void => assertStrictEquals({ a: 1, b: 2 }, { a: 1, b: 2 }), AssertionError, `Values have the same structure but are not reference-equal:
{ a: 1, b: 2, }`, ); },});
Deno.test({ name: "strictly unequal pass case", fn(): void { assertNotStrictEquals(true, false); assertNotStrictEquals(10, 11); assertNotStrictEquals("abc", "xyz"); assertNotStrictEquals<unknown>(1, "1"); assertNotStrictEquals(-0, +0);
const xs = [1, false, "foo"]; const ys = [1, true, "bar"]; assertNotStrictEquals(xs, ys);
const x = { a: 1 }; const y = { a: 2 }; assertNotStrictEquals(x, y); },});
Deno.test({ name: "strictly unequal fail case", fn(): void { assertThrows(() => assertNotStrictEquals(1, 1), AssertionError); assertThrows(() => assertNotStrictEquals(NaN, NaN), AssertionError); },});
Deno.test("assert almost equals number", () => { //Default precision assertAlmostEquals(-0, +0); assertAlmostEquals(Math.PI, Math.PI); assertAlmostEquals(0.1 + 0.2, 0.3); assertAlmostEquals(NaN, NaN); assertAlmostEquals(Number.NaN, Number.NaN); assertThrows(() => assertAlmostEquals(1, 2)); assertThrows(() => assertAlmostEquals(1, 1.1));
//Higher precision assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); assertThrows( () => assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17), AssertionError, `"${ ( 0.1 + 0.2 ).toExponential() }" expected to be close to "${(0.3).toExponential()}"`, );
//Special cases assertAlmostEquals(Infinity, Infinity); assertThrows( () => assertAlmostEquals(0, Infinity), AssertionError, '"0" expected to be close to "Infinity"', ); assertThrows( () => assertAlmostEquals(-Infinity, +Infinity), AssertionError, '"-Infinity" expected to be close to "Infinity"', ); assertThrows( () => assertAlmostEquals(Infinity, NaN), AssertionError, '"Infinity" expected to be close to "NaN"', );});
Deno.test({ name: "assertInstanceOf", fn(): void { class TestClass1 {} class TestClass2 {} class TestClass3 {}
// Regular types assertInstanceOf(new Date(), Date); assertInstanceOf(new Number(), Number); assertInstanceOf(Promise.resolve(), Promise); assertInstanceOf(new TestClass1(), TestClass1);
// Throwing cases assertThrows( () => assertInstanceOf(new Date(), RegExp), AssertionError, `Expected object to be an instance of "RegExp" but was "Date".`, ); assertThrows( () => assertInstanceOf(5, Date), AssertionError, `Expected object to be an instance of "Date" but was "number".`, ); assertThrows( () => assertInstanceOf(new TestClass1(), TestClass2), AssertionError, `Expected object to be an instance of "TestClass2" but was "TestClass1".`, );
// Custom message assertThrows( () => assertInstanceOf(new Date(), RegExp, "Custom message"), AssertionError, "Custom message", );
// Edge cases assertThrows( () => assertInstanceOf(5, Number), AssertionError, `Expected object to be an instance of "Number" but was "number".`, );
let TestClassWithSameName: new () => unknown; { class TestClass3 {} TestClassWithSameName = TestClass3; } // todo(dsherret): this is a bug in swc and below it should only say TestClass3 assertThrows( () => assertInstanceOf(new TestClassWithSameName(), TestClass3), AssertionError, `Expected object to be an instance of "TestClass3" but was "TestClass31".`, );
assertThrows( () => assertInstanceOf(TestClass1, TestClass1), AssertionError, `Expected object to be an instance of "TestClass1" but was not an instanced object.`, ); assertThrows( () => assertInstanceOf(() => {}, TestClass1), AssertionError, `Expected object to be an instance of "TestClass1" but was not an instanced object.`, ); assertThrows( () => assertInstanceOf(null, TestClass1), AssertionError, `Expected object to be an instance of "TestClass1" but was "null".`, ); assertThrows( () => assertInstanceOf(undefined, TestClass1), AssertionError, `Expected object to be an instance of "TestClass1" but was "undefined".`, ); assertThrows( () => assertInstanceOf({}, TestClass1), AssertionError, `Expected object to be an instance of "TestClass1" but was "Object".`, ); assertThrows( () => assertInstanceOf(Object.create(null), TestClass1), AssertionError, `Expected object to be an instance of "TestClass1" but was "Object".`, );
// Test TypeScript types functionality, wrapped in a function that never runs // deno-lint-ignore no-unused-vars function typeScriptTests() { class ClassWithProperty { property = "prop1"; } const testInstance = new ClassWithProperty() as unknown;
// @ts-expect-error: `testInstance` is `unknown` so setting its property before `assertInstanceOf` should give a type error. testInstance.property = "prop2";
assertInstanceOf(testInstance, ClassWithProperty);
// Now `testInstance` should be of type `ClassWithProperty` testInstance.property = "prop3";
let x = 5 as unknown;
// @ts-expect-error: `x` is `unknown` so adding to it shouldn't work x += 5; assertInstanceOf(x, Number);
// @ts-expect-error: `x` is now `Number` rather than `number`, so this should still give a type error. x += 5; } },});
Deno.test({ name: "assert* functions with specified type parameter", fn(): void { assertEquals<string>("hello", "hello"); assertNotEquals<number>(1, 2); assertArrayIncludes<boolean>([true, false], [true]); const value = { x: 1 }; assertStrictEquals<typeof value>(value, value); // deno-lint-ignore ban-types assertNotStrictEquals<object>(value, { x: 1 }); },});
Deno.test( "assertEquals compares objects structurally if one object's constructor is undefined and the other is Object", () => { const a = Object.create(null); a.prop = "test"; const b = { prop: "test", };
assertEquals(a, b); assertEquals(b, a); },);
Deno.test("assertEquals diff for differently ordered objects", () => { assertThrows( () => { assertEquals( { aaaaaaaaaaaaaaaaaaaaaaaa: 0, bbbbbbbbbbbbbbbbbbbbbbbb: 0, ccccccccccccccccccccccc: 0, }, { ccccccccccccccccccccccc: 1, aaaaaaaaaaaaaaaaaaaaaaaa: 0, bbbbbbbbbbbbbbbbbbbbbbbb: 0, }, ); }, AssertionError, ` { aaaaaaaaaaaaaaaaaaaaaaaa: 0, bbbbbbbbbbbbbbbbbbbbbbbb: 0,- ccccccccccccccccccccccc: 0,+ ccccccccccccccccccccccc: 1, }`, );});
Deno.test("Assert Throws Parent Error", () => { assertThrows( () => { throw new AssertionError("Fail!"); }, Error, "Fail!", );});
Deno.test("Assert Throws Async Parent Error", async () => { await assertRejects( () => { return Promise.reject(new AssertionError("Fail!")); }, Error, "Fail!", );});
Deno.test( "Assert Throws Async promise rejected with custom Error", async () => { class CustomError extends Error {} class AnotherCustomError extends Error {} await assertRejects( () => assertRejects( () => Promise.reject(new AnotherCustomError("failed")), CustomError, "fail", ), AssertionError, 'Expected error to be instance of "CustomError", but was "AnotherCustomError".', ); },);
Deno.test("Assert Is Error Non-Error Fail", () => { assertThrows( () => assertIsError("Panic!", undefined, "Panic!"), AssertionError, `Expected "error" to be an Error object.`, );
assertThrows( () => assertIsError(null), AssertionError, `Expected "error" to be an Error object.`, );
assertThrows( () => assertIsError(undefined), AssertionError, `Expected "error" to be an Error object.`, );});
Deno.test("Assert Is Error Parent Error", () => { assertIsError(new AssertionError("Fail!"), Error, "Fail!");});
Deno.test("Assert Is Error with custom Error", () => { class CustomError extends Error {} class AnotherCustomError extends Error {} assertIsError(new CustomError("failed"), CustomError, "fail"); assertThrows( () => assertIsError(new AnotherCustomError("failed"), CustomError, "fail"), AssertionError, 'Expected error to be instance of "CustomError", but was "AnotherCustomError".', );});
Deno.test("Assert False with falsy values", () => { assertFalse(false); assertFalse(0); assertFalse(""); assertFalse(null); assertFalse(undefined);});
Deno.test("Assert False with truthy values", () => { assertThrows(() => assertFalse(true)); assertThrows(() => assertFalse(1)); assertThrows(() => assertFalse("a")); assertThrows(() => assertFalse({})); assertThrows(() => assertFalse([]));});
Deno.test("assertEquals same Set with object keys", () => { const data = [ { id: "_1p7ZED73OF98VbT1SzSkjn", type: { id: "_ETGENUS" }, name: "Thuja", friendlyId: "g-thuja", }, { id: "_567qzghxZmeQ9pw3q09bd3", type: { id: "_ETGENUS" }, name: "Pinus", friendlyId: "g-pinus", }, ]; assertEquals(data, data); assertEquals(new Set(data), new Set(data));});