Skip to content

Latest commit

 

History

History
2384 lines (1860 loc) · 45.5 KB

README.md

File metadata and controls

2384 lines (1860 loc) · 45.5 KB
Raw

matcher

Unitest provide various matchers. It is fully configurable and can be customised by selecting the matcher you want to use.

preset

Unitest offers a range of presets for different matchers.

module preset
jest jestMatcherMap
jest-extended jestExtendedMatcherMap

We also offer other original matchers.

  • toBeAnything
  • toBeError
import {
  defineExpect,
  jestExtendedMatcherMap,
  jestMatcherMap,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const { toBeString } = jestExtendedMatcherMap;

const expect = defineExpect({
  matcherMap: {
    ...jestMatcherMap,
    toBeString,
    toBeFoo: (actual: unknown) => {
      return {
        pass: actual === "foo",
        expected: "foo",
      };
    },
  },
});

jest-extended difference

Some matchers have been renamed or are no implementation. Matchers that differ from jest-extended are as follows:

matcher diff
toBeArrayOfSize use toHaveLength instead
toBeNaN use jest toBeNaN
toBeHexadecimal rename to toBeHexColor
toContainKey use toHaveProperty instead
toResolve no implementation because not pure
toReject no implementation because not pure
toThrowWithMessage use jest toThrow instead

where snapshot matcher?

We decided not to implement snapshot test in expect().matcher() because of its side effects. see snapshot for more information.

toBeAfterOrEqualTo

preset: jestExtendedMatcherMap

Use .toBeAfterOrEqualTo when checking if a date equals to or occurs after date.

import {
  defineExpect,
  not,
  test,
  toBeAfterOrEqualTo,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeAfterOrEqualTo,
  },
  modifierMap: {
    not,
  },
});

test("passes when input is equal to or after date", () => {
  expect(new Date("01/01/2019")).toBeAfterOrEqualTo(new Date("01/01/2018"));
  expect(new Date("01/01/2019")).toBeAfterOrEqualTo(new Date("01/01/2019"));
  expect(new Date("01/01/2019")).not.toBeAfterOrEqualTo(new Date("01/01/2020"));
});

toBeAfter

preset: jestExtendedMatcherMap

Use .toBeAfter when checking if a date occurs after date.

import {
  defineExpect,
  not,
  test,
  toBeAfter,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeAfter,
  },
  modifierMap: {
    not,
  },
});

test("passes when input is after date", () => {
  expect(new Date("01/01/2019")).toBeAfter(new Date("01/01/2018"));
  expect(new Date("01/01/2018")).not.toBeAfter(new Date("01/01/2019"));
});

toBeArray

preset: jestExtendedMatcherMap

Use .toBeArray when checking if a value is an Array.

import {
  defineExpect,
  not,
  test,
  toBeArray,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeArray,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is an array", () => {
  expect([]).toBeArray();
  expect([1]).toBeArray();
  expect(true).not.toBeArray();
});

toBeAnything

Use .toBeAnything when checking if a value is not null and undefined.

import {
  defineExpect,
  not,
  test,
  toBeAnything,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeAnything,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is not null", () => {
  expect(0).toBeAnything();
  expect(null).not.toBeAnything();
  expect(undefined).not.toBeAnything();
});

toBeBeforeOrEqualTo

preset: jestExtendedMatcherMap

Use .toBeBeforeOrEqualTo when checking if a date equals to or occurs before date.

import {
  defineExpect,
  not,
  test,
  toBeBeforeOrEqualTo,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeBeforeOrEqualTo,
  },
  modifierMap: {
    not,
  },
});

test("passes when input is equal to or before date", () => {
  expect(new Date("01/01/2018")).toBeBeforeOrEqualTo(new Date("01/01/2019"));
  expect(new Date("01/01/2018")).toBeBeforeOrEqualTo(new Date("01/01/2018"));
  expect(new Date("01/01/2019")).not.toBeBeforeOrEqualTo(
    new Date("01/01/2018"),
  );
});

toBeBefore(date)

preset: jestExtendedMatcherMap

Use .toBeBefore when checking if a date occurs before date.

import {
  defineExpect,
  not,
  test,
  toBeBefore,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeBefore,
  },
  modifierMap: {
    not,
  },
});

test("passes when input is before date", () => {
  expect(new Date("01/01/2018")).toBeBefore(new Date("01/01/2019"));
  expect(new Date("01/01/2019")).not.toBeBefore(new Date("01/01/2018"));
});

toBeBetween

preset: jestExtendedMatcherMap

Use .toBeBetween when checking if a date equals or occurs after startDate and equals or occurs before endDate.

import {
  defineExpect,
  not,
  test,
  toBeBetween,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeBetween,
  },
  modifierMap: {
    not,
  },
});

test("passes when input is in given date range", () => {
  expect(new Date("05/01/2019")).toBeBetween(
    new Date("01/01/2019"),
    new Date("10/01/2019"),
  );
  expect(new Date("05/01/2019")).toBeBetween(
    new Date("05/01/2019"),
    new Date("10/01/2019"),
  );
  expect(new Date("01/01/2019")).not.toBeBetween(
    new Date("05/01/2019"),
    new Date("10/01/2019"),
  );
});

toBeBoolean

preset: jestExtendedMatcherMap

Use .toBeBoolean when checking if a value is a boolean.

import {
  defineExpect,
  not,
  test,
  toBeBoolean,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeBoolean,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is a boolean", () => {
  expect(false).toBeBoolean();
  expect(true).toBeBoolean();
  expect(1 === 1).toBeBoolean();
  expect(1).not.toBeBoolean();
});

toBeCloseTo

preset: jestMatcherMap

Use .toBeCloseTo to compare floating point numbers for approximate equality.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("adding works sanely with decimals", () => {
  expect(0.2   0.1).toBeCloseTo(0.3, 5);
});

toBeDateString

preset: jestExtendedMatcherMap

Use .toBeDateString when checking if a value is a valid date string.

import {
  defineExpect,
  not,
  test,
  toBeDateString,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeDateString,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is a valid toBeDateString", () => {
  expect("2019-11-27T14:05:07.520Z").toBeDateString();
  expect("11/12/21").toBeDateString();
  expect("not a date").not.toBeDateString();
});

toBeDate

preset: jestExtendedMatcherMap

Use .toBeDate when checking if a value is a Date.

import {
  defineExpect,
  not,
  test,
  toBeDate,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeDate,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is a date", () => {
  expect(new Date("01/01/2018")).toBeDate();
  expect("01/01/2018").not.toBeDate();
  expect(undefined).not.toBeDate();
});

toBeDefined

preset: jestMatcherMap

Use .toBeDefined to check that a variable is not undefined.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("there is a new flavor idea", () => {
  expect("defined").toBeDefined();
  expect(undefined).not.toBeDefined();
});

toBeEmptyObject

preset: jestExtendedMatcherMap

Use .toBeEmptyObject when checking if a value is an empty Object.

import {
  defineExpect,
  not,
  test,
  toBeEmptyObject,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeEmptyObject,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is an empty object", () => {
  expect({}).toBeEmptyObject();
  expect([]).toBeEmptyObject();
  expect({ a: "hello" }).not.toBeEmptyObject();
});

toBeEmpty

preset: jestExtendedMatcherMap

Use .toBeEmpty when checking if a String '', Array [], Object {}, or Iterable is empty.

import {
  defineExpect,
  test,
  toBeEmpty,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeEmpty,
  },
});

test("passes when given an empty", () => {
  expect("").toBeEmpty();
  expect([]).toBeEmpty();
  expect({}).toBeEmpty();
  expect(new Map()).toBeEmpty();
});

toBeError

Use .toBeError when checking if a value is Error object or Error extended object.

import {
  defineExpect,
  not,
  test,
  toBeError,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeError,
  },
  modifierMap: {
    not,
  },
});

test("passes when given an error", () => {
  expect(Error()).toBeError();
  expect({}).not.toBeError();
  expect(TypeError()).toBeError(TypeError);
  expect(TypeError()).not.toBeError(Error);
  expect(TypeError("test with unitest")).toBeError(TypeError, "unitest");
});

toBeEven

preset: jestExtendedMatcherMap

Use .toBeEven when checking if a value is an even Number.

import {
  defineExpect,
  not,
  test,
  toBeEven,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeEven,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is an even number", () => {
  expect(2).toBeEven();
  expect(1).not.toBeEven();
  expect(NaN).not.toBeEven();
});

toBeExtensible

preset: jestExtendedMatcherMap

Use .toBeExtensible when checking if an object is extensible.

import {
  defineExpect,
  not,
  test,
  toBeExtensible,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeExtensible,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is extensible", () => {
  expect({ a: 1 }).toBeExtensible();
  expect(1).not.toBeExtensible();
});

toBeFalse

preset: jestExtendedMatcherMap

Use .toBeFalse when checking a value is equal (===) to false.

import {
  defineExpect,
  not,
  test,
  toBeFalse,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeFalse,
  },
  modifierMap: {
    not,
  },
});

test("should be false", () => {
  expect(false).toBeFalse();
  expect(true).not.toBeFalse();
});

toBeFalsy

preset: jestMatcherMap

Use .toBeFalsy when you don't care what a value is and you want to ensure a value is false in a boolean context.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("should be falsy", () => {
  expect(false).toBeFalsy();
  expect(0).toBeFalsy();
  expect(1).not.toBeFalsy();
});

toBeFinite

preset: jestExtendedMatcherMap

Use .toBeFinite when checking if a value is a number, not NaN or Infinity.

import {
  defineExpect,
  not,
  test,
  toBeFinite,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeFinite,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is a finite number", () => {
  expect(1).toBeFinite();
  expect(Infinity).not.toBeFinite();
  expect(NaN).not.toBeFinite();
});

toBeFrozen

preset: jestExtendedMatcherMap

Use .toBeFrozen when checking if an object is frozen.

import {
  defineExpect,
  not,
  test,
  toBeFrozen,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeFrozen,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is frozen", () => {
  expect(Object.freeze({})).toBeFrozen();
  expect(1).toBeFrozen();
  expect({}).not.toBeFrozen();
});

toBeFunction

preset: jestExtendedMatcherMap

Use .toBeFunction when checking if a value is a Function.

import {
  defineExpect,
  not,
  test,
  toBeFunction,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeFunction,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is a function", () => {
  expect(() => {}).toBeFunction();
  expect(function () {}).toBeFunction();
  expect(true).not.toBeFunction();
});

toBeGreaterThanOrEqual

preset: jestMatcherMap

Use .toBeGreaterThanOrEqual to compare actual >= expected for number or bigint.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when value greater than or equal to", () => {
  expect(100).toBeGreaterThanOrEqual(99);
  expect(100n).toBeGreaterThanOrEqual(100n);
  expect(0).not.toBeGreaterThanOrEqual(1);
});

toBeGreaterThan

preset: jestMatcherMap

Use .toBeGreaterThan to compare actual > expected for number or bigint.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when value greater than", () => {
  expect(100).toBeGreaterThan(99);
  expect(100n).toBeGreaterThan(99n);
  expect(1).not.toBeGreaterThan(1);
});

toBeHexColor

preset: jestExtendedMatcherMap

Use .toBeHexadecimal when checking if a value is a valid HTML hex color.

import {
  defineExpect,
  not,
  test,
  toBeHexColor,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeHexColor,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is a valid hex color", () => {
  expect("#abc123").toBeHexColor();
  expect("#FFF").toBeHexColor();
  expect("#000000").toBeHexColor();
  expect("#123ffg").not.toBeHexColor();
});

toBeInstanceOf

preset: jestMatcherMap

Use .toBeInstanceOf to check that an object is an instance of a class.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when value is instance of class", () => {
  class A {}
  expect(new A()).toBeInstanceOf(A);
  expect(() => {}).toBeInstanceOf(Function);
  expect(new A()).not.toBeInstanceOf(Function);
});

toBeInteger

preset: jestExtendedMatcherMap

Use .toBeInteger when checking if a number is an integer.

import {
  defineExpect,
  not,
  test,
  toBeInteger,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeInteger,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is an integer", () => {
  expect(1).toBeInteger();
  expect(1.0).toBeInteger();
  expect(1.1).not.toBeInteger();
});

toBeLessThanOrEqual

preset: jestMatcherMap

Use .toBeLessThanOrEqual to compare actual <= expected for number or bigint.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when value less than or equal to", () => {
  expect(99).toBeLessThanOrEqual(100);
  expect(100n).toBeLessThanOrEqual(100n);
  expect(1).not.toBeLessThanOrEqual(0);
});

toBeLessThan

preset: jestMatcherMap

Use .toBeLessThan to compare actual < expected for number or bigint.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when value less than", () => {
  expect(99).toBeLessThan(100);
  expect(99n).toBeLessThan(100n);
  expect(1).not.toBeLessThan(0);
});

toBeNaN

preset: jestMatcherMap

Use .toBeNaN when checking a value is NaN.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when value less than", () => {
  expect(NaN).toBeNaN();
  expect(-NaN).toBeNaN();
  expect(1).not.toBeNaN();
});

toBeNegative

preset: jestExtendedMatcherMap

Use .toBeNegative when checking if a value is a negative number.

import {
  defineExpect,
  not,
  test,
  toBeNegative,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeNegative,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is a negative number", () => {
  expect(-1).toBeNegative();
  expect(-Infinity).not.toBeNegative();
  expect(1).not.toBeNegative();
  expect(NaN).not.toBeNegative();
});

toBeNil

preset: jestExtendedMatcherMap

Use .toBeNil when checking a value is null or undefined.

import {
  defineExpect,
  not,
  test,
  toBeNil,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeNil,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is null or undefined", () => {
  expect(null).toBeNil();
  expect(undefined).toBeNil();
  expect(true).not.toBeNil();
});

toBeNull

preset: jestMatcherMap

Use .toBeNull when checking a value is null.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when value is null", () => {
  expect(null).toBeNull();
  expect(undefined).not.toBeNull();
});

toBeNumber

preset: jestExtendedMatcherMap

Use .toBeNumber when checking if a value is a number.

import {
  defineExpect,
  not,
  test,
  toBeNumber,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeNumber,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is a number", () => {
  expect(1).toBeNumber();
  expect(NaN).toBeNumber();
  expect(Infinity).toBeNumber();
  expect(true).not.toBeNumber();
});

toBeObject

preset: jestExtendedMatcherMap

Use .toBeObject when checking if a value is an Object.

import {
  defineExpect,
  not,
  test,
  toBeObject,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeObject,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is an object", () => {
  expect({}).toBeObject();
  expect({ a: "hello" }).toBeObject();
  expect(true).not.toBeObject();
});

toBeOdd

preset: jestExtendedMatcherMap

Use .toBeOdd when checking if a value is an odd number.

import {
  defineExpect,
  not,
  test,
  toBeOdd,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeOdd,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is an odd number", () => {
  expect(1).toBeOdd();
  expect(2).not.toBeOdd();
  expect(NaN).not.toBeOdd();
});

toBeOneOf

preset: jestExtendedMatcherMap

Use .toBeOneOf when checking if a value is a member of a given Array.

import {
  defineExpect,
  not,
  test,
  toBeOneOf,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeOneOf,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is in given array", () => {
  expect(1).toBeOneOf([1, 2, 3]);
  expect(4).not.toBeOneOf([1, 2, 3]);
});

toBePositive

preset: jestExtendedMatcherMap

Use .toBePositive when checking if a value is a positive number.

import {
  defineExpect,
  not,
  test,
  toBePositive,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBePositive,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is a positive number", () => {
  expect(1).toBePositive();
  expect(Infinity).not.toBePositive();
  expect(-1).not.toBePositive();
  expect(NaN).not.toBePositive();
});

toBeSealed

preset: jestExtendedMatcherMap

Use .toBeSealed when checking if an value is sealed.

import {
  defineExpect,
  not,
  test,
  toBeSealed,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeSealed,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is sealed", () => {
  expect(Object.seal({})).toBeSealed();
  expect(1).toBeSealed();
  expect({}).not.toBeSealed();
});

toBeString

preset: jestExtendedMatcherMap

Use .toBeString when checking if a value is a string.

import {
  defineExpect,
  not,
  test,
  toBeString,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeString,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is a string", () => {
  expect("").toBeString();
  expect("hello").toBeString();
  expect(new String("hello")).not.toBeString();
});

toBeSymbol

preset: jestExtendedMatcherMap

Use .toBeSymbol when checking if a value is a symbol.

import {
  defineExpect,
  not,
  test,
  toBeSymbol,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeSymbol,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is a symbol", () => {
  expect(Symbol()).toBeSymbol();
  expect(true).not.toBeSymbol();
});

toBeTrue

preset: jestExtendedMatcherMap

Use .toBeTrue when checking a value is true.

import {
  defineExpect,
  not,
  test,
  toBeTrue,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeTrue,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is true", () => {
  expect(true).toBeTrue();
  expect(false).not.toBeTrue();
});

toBeTruthy

preset: jestMatcherMap

Use .toBeTruthy when you don't care what a value is and you want to ensure a value is true in a boolean context.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("should be truthy", () => {
  expect(true).toBeTruthy();
  expect(1).toBeTruthy();
  expect(0).not.toBeTruthy();
});

toBeUndefined

preset: jestMatcherMap

Use .toBeUndefined to check that a value is undefined.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("should be truthy", () => {
  expect(undefined).toBeUndefined();
  expect(null).not.toBeUndefined();
});

toBeValidDate

preset: jestExtendedMatcherMap

Use .toBeValidDate when check that a Date is valid.

import {
  defineExpect,
  not,
  test,
  toBeValidDate,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeValidDate,
  },
  modifierMap: {
    not,
  },
});

test("passes when Date is valid", () => {
  expect(new Date("01/01/2018")).toBeValidDate();
  expect(new Date("01/90/2018")).not.toBeValidDate();
  expect(new Date("invalid")).not.toBeValidDate();
});

toBeWithin

preset: jestExtendedMatcherMap

Use .toBeWithin when checking if a number is in between the given bounds of: start (inclusive) and end (exclusive).

import {
  defineExpect,
  not,
  test,
  toBeWithin,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toBeWithin,
  },
  modifierMap: {
    not,
  },
});

test("passes when number is within given bounds", () => {
  expect(1).toBeWithin(1, 3);
  expect(2).toBeWithin(1, 3);
  expect(3).not.toBeWithin(1, 3);
});

toBe

preset: jestMatcherMap

Use .toBe to compare primitive values.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("should be", () => {
  expect(0).toBe(0);
  expect(0).not.toBe(-0);
});

toContainAnyEntries

preset: jestExtendedMatcherMap

Use .toContainAnyEntries when checking if an object contains at least one of the provided entries.

import {
  defineExpect,
  not,
  test,
  toContainAnyEntries,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toContainAnyEntries,
  },
  modifierMap: {
    not,
  },
});

test("passes when object contains at least one of the given entries", () => {
  const object = { a: "foo", b: "bar", c: "baz" };
  expect(object).toContainAnyEntries([
    ["a", "qux"],
    ["a", "foo"],
  ]);
  expect(object).toContainAnyEntries([
    ["a", "qux"],
    ["b", "bar"],
  ]);
  expect(object).not.toContainAnyEntries([["d", "qux"]]);
});

toContainAnyKeys

preset: jestExtendedMatcherMap

Use .toContainAnyKeys when checking if an object contains at least one of the provided keys.

import {
  defineExpect,
  not,
  test,
  toContainAnyKeys,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toContainAnyKeys,
  },
  modifierMap: {
    not,
  },
});

test("passes when object contains at least one matching key", () => {
  const object = { a: "hello", b: "world" };
  expect(object).toContainAnyKeys(["a"]);
  expect(object).toContainAnyKeys(["b", "c"]);
  expect(object).not.toContainAnyKeys(["c"]);
});

toContainAnyValues

preset: jestExtendedMatcherMap

Use .toContainAnyValues when checking if an object contains at least one of the provided values.

import {
  defineExpect,
  not,
  test,
  toContainAnyValues,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toContainAnyValues,
  },
  modifierMap: {
    not,
  },
});

test("passes when object contains at least one of the given values", () => {
  const object = { a: "foo", b: "bar", c: "baz" };
  expect(object).toContainAnyValues(["qux", "foo"]);
  expect(object).toContainAnyValues(["qux", "baz"]);
  expect(object).not.toContainAnyValues(["qux"]);
});

toContainEntries

preset: jestExtendedMatcherMap

Use .toContainEntries when checking if an object contains all of the provided entries.

import {
  defineExpect,
  not,
  test,
  toContainEntries,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toContainEntries,
  },
  modifierMap: {
    not,
  },
});

test("passes when object contains all of the given entries", () => {
  const object = { a: "foo", b: "bar", c: "baz" };
  expect(object).toContainEntries([["a", "foo"]]);
  expect(object).toContainEntries([
    ["c", "baz"],
    ["a", "foo"],
  ]);
  expect(object).not.toContainEntries([
    ["b", "qux"],
    ["a", "foo"],
  ]);
});

toContainEntry

preset: jestExtendedMatcherMap

Use .toContainEntry when checking if an object contains the provided entry.

import {
  defineExpect,
  not,
  test,
  toContainEntry,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toContainEntry,
  },
  modifierMap: {
    not,
  },
});

test("passes when object contains given entry", () => {
  const object = { a: "foo", b: "bar", c: "baz" };
  expect(object).toContainEntry(["a", "foo"]);
  expect(object).toContainEntry(["c", "baz"]);
  expect(object).not.toContainEntry(["a", "qux"]);
});

toContainEqual

preset: jestMatcherMap

Use .toContainEqual when you want to check that an item with a specific structure and values is contained in an array.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when array contains given value", () => {
  expect({ a: "foo", b: "bar" }).toContainEqual({ a: "foo" });
  expect({ a: "foo", b: "bar" }).not.toContainEqual({ c: "hoo" });
});

toContainKeys

preset: jestExtendedMatcherMap

Use .toContainKeys when checking if an object has all of the provided keys.

import {
  defineExpect,
  not,
  test,
  toContainKeys,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toContainKeys,
  },
  modifierMap: {
    not,
  },
});

test("passes when object contains all keys", () => {
  const object = { a: "foo", b: "bar", c: "baz" };
  expect(object).toContainKeys(["a", "b"]);
  expect(object).toContainKeys(["b", "c"]);
  expect(object).not.toContainKeys(["d"]);
});

toContainValue

preset: jestExtendedMatcherMap

Use .toContainValue when checking if an object contains the provided value.

import {
  defineExpect,
  not,
  test,
  toContainValue,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toContainValue,
  },
  modifierMap: {
    not,
  },
});

test("passes when object contains given value", () => {
  const object = { a: "foo", b: "bar", c: "baz" };
  expect(object).toContainValue("foo");
  expect(object).toContainValue("bar");
  expect(object).not.toContainValue("qux");
});

toContainValues

preset: jestExtendedMatcherMap

Use .toContainValues when checking if an object contains all of the provided values.

import {
  defineExpect,
  not,
  test,
  toContainValues,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toContainValues,
  },
  modifierMap: {
    not,
  },
});

test("passes when object contains all of the given values", () => {
  const object = { a: "foo", b: "bar", c: "baz" };
  expect(object).toContainValues(["foo"]);
  expect(object).toContainValues(["baz", "bar"]);
  expect(object).not.toContainValues(["qux", "foo"]);
});

toContain

preset: jestMatcherMap

Use .toContain when you want to check that an item is in an array.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when array contains given value", () => {
  expect([1, 2, 3, 4, 5]).toContain(3);
  expect([{}, [], ""]).not.toContain(3);
});

toEndWith

preset: jestExtendedMatcherMap

Use .toEndWith when checking if a string ends with a given string suffix.

import {
  defineExpect,
  not,
  test,
  toEndWith,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toEndWith,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is ends with given string", () => {
  expect("hello world").toEndWith("world");
  expect("hello world").not.toEndWith("hello");
});

toEqualCaseInsensitive

preset: jestExtendedMatcherMap

Use .toEqualCaseInsensitive when checking if a string is equal to another ignoring the casing of both strings.

import {
  defineExpect,
  not,
  test,
  toEqualCaseInsensitive,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toEqualCaseInsensitive,
  },
  modifierMap: {
    not,
  },
});

test("passes when strings are equal ignoring case", () => {
  expect("hello world").toEqualCaseInsensitive("hello world");
  expect("hello world").toEqualCaseInsensitive("HELLO WORLD");
});

toEqualIgnoringWhitespace

preset: jestExtendedMatcherMap

Use .toEqualIgnoringWhitespace when checking if a string is equal to another string ignoring white-space.

import {
  defineExpect,
  not,
  test,
  toEqualIgnoringWhitespace,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toEqualIgnoringWhitespace,
  },
  modifierMap: {
    not,
  },
});

test("passes if strings are equal ignoring white-space", () => {
  expect("SELECT * FROM TABLE WHERE CONDITION").toEqualIgnoringWhitespace(`
        SELECT * FROM TABLE
        WHERE CONDITION
    `);
  expect(".class { cssRule: value }").not.toEqualIgnoringWhitespace(`
        #id {
            cssRule: value
        }
    `);
});

toEqual

preset: jestMatcherMap

Use .toEqual to compare recursively all properties of object instances.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when array contains given value", () => {
  expect({}).toEqual({});
});

toHaveBeenCalledAfter

preset: jestExtendedMatcherMap

Use .toHaveBeenCalledAfter when checking if a mock object was called after another mock object.

import {
  defineExpect,
  fn,
  test,
  toHaveBeenCalledAfter,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toHaveBeenCalledAfter,
  },
});

test("calls mockObject1 after mockObject2", () => {
  const mockObject1 = fn();
  const mockObject2 = fn();

  mockObject2();
  mockObject1();
  mockObject2();

  expect(mockObject1).toHaveBeenCalledAfter(mockObject2);
});

toHaveBeenCalledBefore

preset: jestExtendedMatcherMap

Use .toHaveBeenCalledBefore when checking if a mock object was called before another mock object.

import {
  defineExpect,
  fn,
  test,
  toHaveBeenCalledBefore,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toHaveBeenCalledBefore,
  },
});

test("calls mockObject1 before mockObject2", () => {
  const mockObject1 = fn();
  const mockObject2 = fn();

  mockObject1();
  mockObject2();
  mockObject1();

  expect(mockObject1).toHaveBeenCalledBefore(mockObject2);
});

toHaveBeenCalledOnce

preset: jestExtendedMatcherMap

Use .toHaveBeenCalledOnce to check if a mock object was called exactly one time.

import {
  defineExpect,
  fn,
  not,
  test,
  toHaveBeenCalledOnce,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toHaveBeenCalledOnce,
  },
  modifierMap: {
    not,
  },
});

test("passes only if mock object was called exactly once", () => {
  const mockObject = fn();

  mockObject();
  expect(mockObject).toHaveBeenCalledOnce();
  mockObject();
  expect(mockObject).not.toHaveBeenCalledOnce();
});

toHaveBeenCalledTimes

preset: jestMatcherMap

Use .toHaveBeenCalledTimes to ensure that a mock object got called exact number of times.

import { expect, fn, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when mock object called 2 times", () => {
  const mockObject = fn();
  mockObject();
  mockObject();
  expect(mockObject).toHaveBeenCalledTimes(2);
});

toHaveBeenCalledWith

preset: jestMatcherMap

Use .toHaveBeenCalledWith to ensure that a mock object was called with specific arguments.

import { expect, fn, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when mock object called with arg", () => {
  const mockObject = fn();
  mockObject(1, 2, 3);
  expect(mockObject).toHaveBeenCalledWith(1, 2, 3);
});

toHaveBeenCalled

preset: jestMatcherMap

Use .toHaveBeenCalled to ensure that a mock object got called.

import { expect, fn, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when mock object called", () => {
  const mockObject = fn();
  expect(mockObject).not.toHaveBeenCalled();
  mockObject();
  expect(mockObject).toHaveBeenCalled();
});

toHaveBeenLastCalledWith

preset: jestMatcherMap

Use .toHaveBeenLastCalledWith to test mock object was last called with.

import { expect, fn, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when mock object of last called with", () => {
  const mockObject = fn();
  mockObject(1, 2, 3);
  mockObject(4, 5, 6);
  expect(mockObject).toHaveBeenLastCalledWith(4, 5, 6);
  expect(mockObject).not.toHaveBeenLastCalledWith(1, 2, 3);
});

toHaveBeenNthCalledWith

preset: jestMatcherMap

Use .toHaveBeenNthCalledWith to test mock object was nth called with.

import { expect, fn, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when mock object of last called with", () => {
  const mockObject = fn();
  mockObject("tomato");
  mockObject("potato");
  expect(mockObject).toHaveBeenNthCalledWith(1, "tomato");
  expect(mockObject).toHaveBeenNthCalledWith(2, "potato");
});

toHaveLastReturnedWith

preset: jestMatcherMap

Use .toHaveLastReturnedWith to test the specific value that a mock object last returned.

import { expect, fn, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when mock object of last returned with", () => {
  const mockObject = fn((a: number, b: number) => a   b);
  mockObject(1, 2);
  mockObject(3, 4);
  expect(mockObject).toHaveLastReturnedWith(7);
});

toHaveLength

preset: jestMatcherMap

Use .toHaveLength to check that an object has a .length property and it is set to a certain numeric value.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when object of length property equal to", () => {
  expect([1, 2, 3]).toHaveLength(3);
  expect("abc").toHaveLength(3);
  expect("").not.toHaveLength(5);
});

toHaveNthReturnedWith

preset: jestMatcherMap

Use .toHaveNthReturnedWith to test the specific value that a mock object returned for the nth call.

import { expect, fn, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when mock object of last returned with", () => {
  const mockObject = fn((a: number, b: number) => a   b);
  mockObject(1, 2);
  mockObject(3, 4);
  expect(mockObject).toHaveNthReturnedWith(1, 3);
  expect(mockObject).toHaveNthReturnedWith(2, 7);
});

toHaveProperty

preset: jestMatcherMap

Use .toHaveProperty to check if property at provided reference keyPath exists for an object.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when check object property via keyPath", () => {
  expect({ a: "b" }).toHaveProperty("a");
  expect({ a: { b: { c: "d" } } }).toHaveProperty("a.b.c");
  expect({ a: { b: { c: "d" } } }).not.toHaveProperty(["a", "b", "c"], "e");
});

toHaveReturnedTimes

preset: jestMatcherMap

Use .toHaveReturnedTimes to ensure that a mock object returned successfully an exact number of times.

import { expect, fn, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when mock object returned successfully times", () => {
  const mockObject = fn((a: number, b: number) => a   b);
  mockObject(1, 2);
  mockObject(3, 4);

  expect(mockObject).toHaveReturnedTimes(2);
});

toHaveReturnedWith

preset: jestMatcherMap

Use .toHaveReturnedWith to ensure that a mock object returned a specific value.

import { expect, fn, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when mock object returned specific value", () => {
  const mockObject = fn((a: number, b: number) => a   b);
  mockObject(1, 2);
  mockObject(3, 4);

  expect(mockObject).toHaveReturnedWith(7);
  expect(mockObject).toHaveReturnedWith(3);
});

toHaveReturned

preset: jestMatcherMap

Use .toHaveReturned that the mock object successfully returned at least one time.

import { expect, fn, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when mock object returned at least once", () => {
  const mockObject = fn(() => true);
  expect(mockObject).not.toHaveReturned();
  mockObject();
  expect(mockObject).toHaveReturned();
});

toIncludeAllMembers

preset: jestExtendedMatcherMap

Use .toIncludeAllMembers when checking if an array contains all of the same members of a given set.

import {
  defineExpect,
  not,
  test,
  toIncludeAllMembers,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toIncludeAllMembers,
  },
  modifierMap: {
    not,
  },
});

test("passes when given array values match the members of the set", () => {
  expect([1, 2, 3]).toIncludeAllMembers([2, 1, 3]);
  expect([1, 2, 2]).toIncludeAllMembers([2, 1]);
});

toIncludeAnyMembers

preset: jestExtendedMatcherMap

Use .toIncludeAnyMembers when checking if an array contains any of the members of a given set.

import {
  defineExpect,
  not,
  test,
  toIncludeAnyMembers,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toIncludeAnyMembers,
  },
  modifierMap: {
    not,
  },
});

test("passes when given array values match any of the members in the set", () => {
  expect([1, 2, 3]).toIncludeAnyMembers([2, 1, 3]);
  expect([1, 2, 2]).toIncludeAnyMembers([2]);
  expect([1, 2, 2]).not.toIncludeAnyMembers([3]);
});

toIncludeMultiple

preset: jestExtendedMatcherMap

Use .toIncludeMultiple when checking if a string includes all of the given substrings.

import {
  defineExpect,
  not,
  test,
  toIncludeMultiple,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toIncludeMultiple,
  },
  modifierMap: {
    not,
  },
});

test("passes when value includes all substrings", () => {
  expect("hello world").toIncludeMultiple(["world", "hello"]);
  expect("hello world").not.toIncludeMultiple(["world", "hello", "bob"]);
});

toIncludeRepeated

preset: jestExtendedMatcherMap

Use .toIncludeRepeated when checking if a string includes the given string substring the correct number of times.

import {
  defineExpect,
  not,
  test,
  toIncludeRepeated,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toIncludeRepeated,
  },
  modifierMap: {
    not,
  },
});

test("passes when value includes substring n times", () => {
  expect("hello hello world").toIncludeRepeated("hello", 2);
  expect("hello hello world").not.toIncludeRepeated("hello", 1);
});

toIncludeSameMembers

preset: jestExtendedMatcherMap

Use .toIncludeSameMembers when checking if two arrays contain equal values, in any order.

import {
  defineExpect,
  not,
  test,
  toIncludeSameMembers,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toIncludeSameMembers,
  },
  modifierMap: {
    not,
  },
});

test("passes when arrays match in a different order", () => {
  expect([1, 2, 3]).toIncludeSameMembers([3, 1, 2]);
  expect([{ foo: "bar" }, { baz: "qux" }]).toIncludeSameMembers([
    { baz: "qux" },
    { foo: "bar" },
  ]);
});

toInclude

preset: jestExtendedMatcherMap

Use .toInclude when checking if a string includes the given string substring.

import {
  defineExpect,
  not,
  test,
  toInclude,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toInclude,
  },
  modifierMap: {
    not,
  },
});

test("passes when value includes substring", () => {
  expect("hello world").toInclude("ell");
  expect("hello world").not.toInclude("bob");
});

toMatchObject

preset: jestMatcherMap

Use .toMatchObject to check that a object matches a subset of the properties of an object.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when object is part of subset", () => {
  expect({ foo: "bar", hello: "world" }).toMatchObject({ foo: "bar" });
});

toMatch

preset: jestMatcherMap

Use .toMatch to check that a string matches a regular expression.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when value match string or regExp", () => {
  expect("hello world").toMatch(/^hello/);
});

toSatisfyAll

preset: jestExtendedMatcherMap

Use .toSatisfyAll when you want to use a custom matcher by supplying a predicate function that returns a boolean for all values in an array.

import {
  defineExpect,
  not,
  test,
  toSatisfyAll,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toSatisfyAll,
  },
  modifierMap: {
    not,
  },
});

test("passes when all values in array pass given predicate", () => {
  const isOdd = (el: unknown) => typeof el === "number" && el % 2 === 1;
  expect([1, 3, 5, 7]).toSatisfyAll(isOdd);
  expect([1, 3, 4, 5, 7]).not.toSatisfyAll(isOdd);
});

toSatisfyAny

preset: jestExtendedMatcherMap

Use .toSatisfyAny when you want to use a custom matcher by supplying a predicate function that returns true for any matching value in an array.

import {
  defineExpect,
  not,
  test,
  toSatisfyAny,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toSatisfyAny,
  },
  modifierMap: {
    not,
  },
});

test("passes when any value in array pass given predicate", () => {
  const isOdd = (el: unknown) => typeof el === "number" && el % 2 === 1;
  expect([2, 3, 6, 8]).toSatisfyAny(isOdd);
  expect([2, 4, 8, 12]).not.toSatisfyAny(isOdd);
});

toSatisfy

preset: jestExtendedMatcherMap

Use .toSatisfy when you want to use a custom matcher by supplying a predicate function that returns a boolean.

import {
  defineExpect,
  not,
  test,
  toSatisfy,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toSatisfy,
  },
  modifierMap: {
    not,
  },
});

test("passes when value passes given predicate", () => {
  const greaterThanOneButNotThree = (n: unknown) =>
    typeof n === "number" && n > 1 && n !== 3;
  expect(100).toSatisfy(greaterThanOneButNotThree);
  expect(0).not.toSatisfy(greaterThanOneButNotThree);
  expect(3).not.toSatisfy(greaterThanOneButNotThree);
});

toStartWith

preset: jestExtendedMatcherMap

Use .toStartWith when checking if a String starts with a given String prefix.

import {
  defineExpect,
  not,
  test,
  toStartWith,
} from "https://deno.land/x/unitest@$VERSION/mod.ts";

const expect = defineExpect({
  matcherMap: {
    toStartWith,
  },
  modifierMap: {
    not,
  },
});

test("passes when value is starts with given string", () => {
  expect("hello world").toStartWith("hello");
  expect("hello world").not.toStartWith("world");
});

toThrow

preset: jestMatcherMap

Use .toThrow to test that a function throws when it is called.

import { expect, test } from "https://deno.land/x/unitest@$VERSION/mod.ts";

test("passes when the function throw error", () => {
  expect(() => {
    throw Error("test");
  }).toThrow(/test/);
});

TODO

  • toStrictEqual
  • jest-extended
    • toIncludeAllPartialMembers
    • toContainAllKeys
    • toContainAllValues
    • toContainAllEntries