@in/test@0.7.1

Asserts a function to throw an error.

Unlike the epoynmous method from @std/expect, this matcher accepts a second argument that can be either a string or a regular expression when the first argument is a Error class or instance. In this case, the behavior is the same as assertIsError where you can both check the error type and message.

import { expect } from "@in/test"
const throws = () => { throw new Error("Expected error") }
expect(throws).toThrow(Error)
expect(throws).toThrow("Expected error")
expect(throws).toThrow(Error, /Expected/)

Asserts a value matches the given predicate.

import { expect } from "@in/test"
expect("foo").toSatisfy((value:string) => value.length > 1)

Asserts a value is of a given type (using typeof operator). Note that null is not considered of type "object" unless nullable option is set to true.

import { expect } from "@in/test"
expect("foo").toBeType("string")
expect({}).toBeType("object")
expect(null).toBeType("object", { nullable: true })
expect(null).not.toBeType("object")

Asserts a property matches a given descriptor (using Object.getOwnPropertyDescriptor).

import { expect } from "@in/test"
const foo = Object.defineProperties({}, { bar: { value: true, writable: false, enumerable: true } })
expect(foo).toHaveDescribedProperty("bar", { writable: false, enumerable: true })

Asserts a writable property is immutable (i.e. setting its value does not throw but does not change its value either).

Note that it will actually proceed to assign testValue and restore it to original value after test.

import { expect } from "@in/test"
const foo = new (class {
  #bar = true
  get bar() {
    return this.#bar
  }
  set bar(_:unknown) {
    return
  }
})()
expect(foo).toHaveImmutableProperty("bar")

Assert an object is iterable (checking Symbol.iterator presence).

import { expect } from "@in/test"
expect([]).toBeIterable()
expect(new Map()).toBeIterable()
expect(new Set()).toBeIterable()

Assert an object is sealed (using Object.isSealed).

import { expect } from "@in/test"
expect(Object.seal({})).toBeSealed()

Assert an object is frozen (using Object.isFrozen).

import { expect } from "@in/test"
expect(Object.freeze({})).toBeFrozen()

Assert an object is extensible (using Object.isExtensible).

import { expect } from "@in/test"
expect(Object.preventExtensions({})).not.toBeExtensible()

Asserts an object is a shallow copy (i.e. its content is identical but reference is not).

import { expect } from "@in/test"
const foo = { bar: true }
expect({...foo}).toBeShallowCopyOf(foo)

Asserts an iterable is empty.

import { expect } from "@in/test"
expect([]).toBeEmpty()
expect(new Map()).toBeEmpty()
expect(new Set()).toBeEmpty()

Asserts an iterable to be sorted.

import { expect } from "@in/test"
expect([1, 2, 3]).toBeSorted()

Asserts an iterable to be reverse sorted.

import { expect } from "@in/test"
expect([3, 2, 1]).toBeReverseSorted()

Asserts a value is one of expected value.

import { expect } from "@in/test"
expect("foo").toBeOneOf(["foo", "bar"])

Asserts a number is with a given range.

import { expect } from "@in/test"
expect(Math.PI).toBeWithin([3, 4])

Asserts a number to be finite.

import { expect } from "@in/test"
expect(1).toBeFinite()
expect(Infinity).not.toBeFinite()

Asserts a string to be parseable JSON.

import { expect } from "@in/test"
expect('{"foo":"bar"}').toBeParseableJSON()

Asserts a string is a valid base64 string.

import { expect } from "@in/test"
expect(btoa("foo")).toBeBase64()

Asserts a response to have a given status code.

Note that Response.body.cancel() is automatically called to prevent leaks. If you need to perform more assertions on a response, it is advised use separate matchers instead.

import { expect, Status } from "@in/test"
expect(new Response(null, { status: Status.OK })).toRespondWithStatus(Status.OK)
expect(new Response(null, { status: Status.OK })).toRespondWithStatus([Status.OK, Status.Created])
expect(new Response(null, { status: Status.OK })).toRespondWithStatus("2XX")

Asserts a string is hashed by specified algorithm.

Algorithm may be either lowercase or uppercase, and contains dashes or not (e.g. sha256, SHA256 and SHA-256 will all be treated as the same). Will throw if an unknown algorithm is specified.

Please note that it only checks whether it could be a valid output of specified hash algorithm.

import { expect, Status } from "@in/test"
expect("$2a$12$lpGSoVPZ8erLDF93Sqyic.U73v0/w0owPb3dIP9goO7iC5Wp/I8OG").toBeHashed("bcrypt")

Asserts a value is a valid date (using Date).

import { expect, Status } from "@in/test"
expect("2024-07-13T20:30:57.958Z").toBeDate()
expect(new Date()).toBeDate()

Asserts a date is before another date.

import { expect, Status } from "@in/test"
expect(new Date(Date.now() - 5000)).toBePast()

Asserts a date is after another date.

import { expect, Status } from "@in/test"
expect(new Date(Date.now() + 5000)).toBeFuture()

The negation object that allows chaining negated assertions.

The object that allows chaining assertions with async functions that are expected to resolve to a value.

The object that allows chaining assertions with async functions that are expected to throw an error.

Asserts a string is a valid email address (using https://pdw.ex-parrot.com/Mail-RFC822-Address.html).

import { expect } from "@in/test"
expect("foo@example.com").toBeEmail()
expect("foo+bar@example.com").toBeEmail()

Asserts a string is a valid url (using URL).

import { expect } from "@in/test"
expect("https://xr.new").toBeUrl()