deno.com

function assert

#assert(
value: unknown,
message?: string | Error,
): asserts value

An alias of ok.

Parameters #

#value: unknown

The input that is checked for being truthy.

#message: string | Error
optional

Return Type #

asserts value

namespace assert

Classes #

c
assert.AssertionError

Indicates the failure of an assertion. All errors thrown by the node:assert module will be instances of the AssertionError class.

c
assert.CallTracker

This feature is deprecated and will be removed in a future version. Please consider using alternatives such as the mock helper function.

Functions #

f
assert.deepEqual

Strict assertion mode

    f
    assert.deepStrictEqual

    Tests for deep equality between the actual and expected parameters. "Deep" equality means that the enumerable "own" properties of child objects are recursively evaluated also by the following rules.

      f
      assert.doesNotMatch

      Expects the string input not to match the regular expression.

        f
        assert.doesNotReject

        Awaits the asyncFn promise or, if asyncFn is a function, immediately calls the function and awaits the returned promise to complete. It will then check that the promise is not rejected.

          f
          assert.doesNotThrow

          Asserts that the function fn does not throw an error.

            f
            assert.equal

            Strict assertion mode

              f
              assert.fail

              Throws an AssertionError with the provided error message or a default error message. If the message parameter is an instance of an Error then it will be thrown instead of the AssertionError.

                f
                assert.ifError

                Throws value if value is not undefined or null. This is useful when testing the error argument in callbacks. The stack trace contains all frames from the error passed to ifError() including the potential new frames for ifError() itself.

                  f
                  assert.match

                  Expects the string input to match the regular expression.

                    f
                    assert.notDeepEqual

                    Strict assertion mode

                      f
                      assert.notDeepStrictEqual

                      Tests for deep strict inequality. Opposite of deepStrictEqual.

                        f
                        assert.notEqual

                        Strict assertion mode

                          f
                          assert.notStrictEqual

                          Tests strict inequality between the actual and expected parameters as determined by Object.is().

                            f
                            assert.ok

                            Tests if value is truthy. It is equivalent to assert.equal(!!value, true, message).

                              f
                              assert.partialDeepStrictEqual

                              assert.partialDeepStrictEqual() Asserts the equivalence between the actual and expected parameters through a deep comparison, ensuring that all properties in the expected parameter are present in the actual parameter with equivalent values, not allowing type coercion. The main difference with assert.deepStrictEqual() is that assert.partialDeepStrictEqual() does not require all properties in the actual parameter to be present in the expected parameter. This method should always pass the same test cases as assert.deepStrictEqual(), behaving as a super set of it.

                                f
                                assert.rejects

                                Awaits the asyncFn promise or, if asyncFn is a function, immediately calls the function and awaits the returned promise to complete. It will then check that the promise is rejected.

                                  f
                                  assert.strictEqual

                                  Tests strict equality between the actual and expected parameters as determined by Object.is().

                                    f
                                    assert.throws

                                    Expects the function fn to throw an error.

                                      Interfaces #

                                      Namespaces #

                                      N
                                      v
                                      assert.strict

                                      In strict assertion mode, non-strict methods behave like their corresponding strict methods. For example, deepEqual will behave like deepStrictEqual.

                                        Type Aliases #

                                        T
                                        assert.AssertPredicate
                                        No documentation available