Skip to main content
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.

optional
message: string | Error

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.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
                                        Back to top