{ "source": "doc/api/assert.md", "modules": [ { "textRaw": "Assert", "name": "assert", "introduced_in": "v0.10.0", "stability": 2, "stabilityText": "Stable", "desc": "
The assert
module provides a simple set of assertion tests that can be used to\ntest invariants.
An alias of assert.ok()
.
Tests for deep equality between the actual
and expected
parameters.\nPrimitive values are compared with the Abstract Equality Comparison\n( ==
).
Only enumerable "own" properties are considered. The\nassert.deepEqual()
implementation does not test the\n[[Prototype]]
of objects, attached symbols, or\nnon-enumerable properties — for such checks, consider using\nassert.deepStrictEqual()
instead. This can lead to some\npotentially surprising results. For example, the following example does not\nthrow an AssertionError
because the properties on the RegExp
object are\nnot enumerable:
// WARNING: This does not throw an AssertionError!\nassert.deepEqual(/a/gi, new Date());\n
\nAn exception is made for Map
and Set
. Maps and Sets have their\ncontained items compared too, as expected.
"Deep" equality means that the enumerable "own" properties of child objects\nare evaluated also:
\nconst assert = require('assert');\n\nconst obj1 = {\n a: {\n b: 1\n }\n};\nconst obj2 = {\n a: {\n b: 2\n }\n};\nconst obj3 = {\n a: {\n b: 1\n }\n};\nconst obj4 = Object.create(obj1);\n\nassert.deepEqual(obj1, obj1);\n// OK, object is equal to itself\n\nassert.deepEqual(obj1, obj2);\n// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }\n// values of b are different\n\nassert.deepEqual(obj1, obj3);\n// OK, objects are equal\n\nassert.deepEqual(obj1, obj4);\n// AssertionError: { a: { b: 1 } } deepEqual {}\n// Prototypes are ignored\n
\nIf the values are not equal, an AssertionError
is thrown with a message
\nproperty set equal to the value of the message
parameter. If the message
\nparameter is undefined, a default error message is assigned.
Generally identical to assert.deepEqual()
with a few exceptions:
===
). Set values and Map keys are compared using the SameValueZero\ncomparison. (Which means they are free of the caveats).[[Prototype]]
of objects are compared using\nthe Strict Equality Comparison too.const assert = require('assert');\n\nassert.deepEqual({ a: 1 }, { a: '1' });\n// OK, because 1 == '1'\n\nassert.deepStrictEqual({ a: 1 }, { a: '1' });\n// AssertionError: { a: 1 } deepStrictEqual { a: '1' }\n// because 1 !== '1' using strict equality\n\n// The following objects don't have own properties\nconst date = new Date();\nconst object = {};\nconst fakeDate = {};\n\nObject.setPrototypeOf(fakeDate, Date.prototype);\n\nassert.deepEqual(object, fakeDate);\n// OK, doesn't check [[Prototype]]\nassert.deepStrictEqual(object, fakeDate);\n// AssertionError: {} deepStrictEqual Date {}\n// Different [[Prototype]]\n\nassert.deepEqual(date, fakeDate);\n// OK, doesn't check type tags\nassert.deepStrictEqual(date, fakeDate);\n// AssertionError: 2017-03-11T14:25:31.849Z deepStrictEqual Date {}\n// Different type tags\n\nassert.deepStrictEqual(new Number(1), new Number(2));\n// Fails because the wrapped number is unwrapped and compared as well.\nassert.deepStrictEqual(new String('foo'), Object('foo'));\n// OK because the object and the string are identical when unwrapped.\n
\nIf the values are not equal, an AssertionError
is thrown with a message
\nproperty set equal to the value of the message
parameter. If the message
\nparameter is undefined, a default error message is assigned.
Asserts that the function block
does not throw an error. See\nassert.throws()
for more details.
When assert.doesNotThrow()
is called, it will immediately call the block
\nfunction.
If an error is thrown and it is the same type as that specified by the error
\nparameter, then an AssertionError
is thrown. If the error is of a different\ntype, or if the error
parameter is undefined, the error is propagated back\nto the caller.
The following, for instance, will throw the TypeError
because there is no\nmatching error type in the assertion:
assert.doesNotThrow(\n () => {\n throw new TypeError('Wrong value');\n },\n SyntaxError\n);\n
\nHowever, the following will result in an AssertionError
with the message\n'Got unwanted exception (TypeError)..':
assert.doesNotThrow(\n () => {\n throw new TypeError('Wrong value');\n },\n TypeError\n);\n
\nIf an AssertionError
is thrown and a value is provided for the message
\nparameter, the value of message
will be appended to the AssertionError
\nmessage:
assert.doesNotThrow(\n () => {\n throw new TypeError('Wrong value');\n },\n TypeError,\n 'Whoops'\n);\n// Throws: AssertionError: Got unwanted exception (TypeError). Whoops\n
\n"
},
{
"textRaw": "assert.equal(actual, expected[, message])",
"type": "method",
"name": "equal",
"meta": {
"added": [
"v0.1.21"
],
"changes": []
},
"signatures": [
{
"params": [
{
"textRaw": "`actual` {any} ",
"name": "actual",
"type": "any"
},
{
"textRaw": "`expected` {any} ",
"name": "expected",
"type": "any"
},
{
"textRaw": "`message` {any} ",
"name": "message",
"type": "any",
"optional": true
}
]
},
{
"params": [
{
"name": "actual"
},
{
"name": "expected"
},
{
"name": "message",
"optional": true
}
]
}
],
"desc": "Tests shallow, coercive equality between the actual
and expected
parameters\nusing the Abstract Equality Comparison ( ==
).
const assert = require('assert');\n\nassert.equal(1, 1);\n// OK, 1 == 1\nassert.equal(1, '1');\n// OK, 1 == '1'\n\nassert.equal(1, 2);\n// AssertionError: 1 == 2\nassert.equal({ a: { b: 1 } }, { a: { b: 1 } });\n//AssertionError: { a: { b: 1 } } == { a: { b: 1 } }\n
\nIf the values are not equal, an AssertionError
is thrown with a message
\nproperty set equal to the value of the message
parameter. If the message
\nparameter is undefined, a default error message is assigned.
Throws an AssertionError
. If message
is falsy, the error message is set as\nthe values of actual
and expected
separated by the provided operator
.\nIf just the two actual
and expected
arguments are provided, operator
will\ndefault to '!='
. If message
is provided only it will be used as the error\nmessage, the other arguments will be stored as properties on the thrown object.\nIf stackStartFunction
is provided, all stack frames above that function will\nbe removed from stacktrace (see Error.captureStackTrace
).
const assert = require('assert');\n\nassert.fail(1, 2, undefined, '>');\n// AssertionError [ERR_ASSERTION]: 1 > 2\n\nassert.fail(1, 2, 'fail');\n// AssertionError [ERR_ASSERTION]: fail\n\nassert.fail(1, 2, 'whoops', '>');\n// AssertionError [ERR_ASSERTION]: whoops\n
\nNote: In the last two cases actual
, expected
, and operator
have no\ninfluence on the error message.
assert.fail();\n// AssertionError [ERR_ASSERTION]: Failed\n\nassert.fail('boom');\n// AssertionError [ERR_ASSERTION]: boom\n\nassert.fail('a', 'b');\n// AssertionError [ERR_ASSERTION]: 'a' != 'b'\n
\nExample use of stackStartFunction
for truncating the exception's stacktrace:
function suppressFrame() {\n assert.fail('a', 'b', undefined, '!==', suppressFrame);\n}\nsuppressFrame();\n// AssertionError [ERR_ASSERTION]: 'a' !== 'b'\n// at repl:1:1\n// at ContextifyScript.Script.runInThisContext (vm.js:44:33)\n// ...\n
\n"
},
{
"textRaw": "assert.fail(actual, expected[, message[, operator[, stackStartFunction]]])",
"type": "method",
"name": "fail",
"meta": {
"added": [
"v0.1.21"
],
"changes": []
},
"signatures": [
{
"params": [
{
"textRaw": "`actual` {any} ",
"name": "actual",
"type": "any"
},
{
"textRaw": "`expected` {any} ",
"name": "expected",
"type": "any"
},
{
"textRaw": "`message` {any} ",
"name": "message",
"type": "any",
"optional": true
},
{
"textRaw": "`operator` {string} **Default:** '!=' ",
"name": "operator",
"type": "string",
"desc": "**Default:** '!='",
"optional": true
},
{
"textRaw": "`stackStartFunction` {Function} **Default:** `assert.fail` ",
"name": "stackStartFunction",
"type": "Function",
"desc": "**Default:** `assert.fail`",
"optional": true
}
]
},
{
"params": [
{
"name": "actual"
},
{
"name": "expected"
},
{
"name": "message",
"optional": true
},
{
"name": "operator",
"optional": true
},
{
"name": "stackStartFunction",
"optional": true
}
]
}
],
"desc": "Throws an AssertionError
. If message
is falsy, the error message is set as\nthe values of actual
and expected
separated by the provided operator
.\nIf just the two actual
and expected
arguments are provided, operator
will\ndefault to '!='
. If message
is provided only it will be used as the error\nmessage, the other arguments will be stored as properties on the thrown object.\nIf stackStartFunction
is provided, all stack frames above that function will\nbe removed from stacktrace (see Error.captureStackTrace
).
const assert = require('assert');\n\nassert.fail(1, 2, undefined, '>');\n// AssertionError [ERR_ASSERTION]: 1 > 2\n\nassert.fail(1, 2, 'fail');\n// AssertionError [ERR_ASSERTION]: fail\n\nassert.fail(1, 2, 'whoops', '>');\n// AssertionError [ERR_ASSERTION]: whoops\n
\nNote: In the last two cases actual
, expected
, and operator
have no\ninfluence on the error message.
assert.fail();\n// AssertionError [ERR_ASSERTION]: Failed\n\nassert.fail('boom');\n// AssertionError [ERR_ASSERTION]: boom\n\nassert.fail('a', 'b');\n// AssertionError [ERR_ASSERTION]: 'a' != 'b'\n
\nExample use of stackStartFunction
for truncating the exception's stacktrace:
function suppressFrame() {\n assert.fail('a', 'b', undefined, '!==', suppressFrame);\n}\nsuppressFrame();\n// AssertionError [ERR_ASSERTION]: 'a' !== 'b'\n// at repl:1:1\n// at ContextifyScript.Script.runInThisContext (vm.js:44:33)\n// ...\n
\n"
},
{
"textRaw": "assert.ifError(value)",
"type": "method",
"name": "ifError",
"meta": {
"added": [
"v0.1.97"
],
"changes": []
},
"signatures": [
{
"params": [
{
"textRaw": "`value` {any} ",
"name": "value",
"type": "any"
}
]
},
{
"params": [
{
"name": "value"
}
]
}
],
"desc": "Throws value
if value
is truthy. This is useful when testing the error
\nargument in callbacks.
const assert = require('assert');\n\nassert.ifError(null);\n// OK\nassert.ifError(0);\n// OK\nassert.ifError(1);\n// Throws 1\nassert.ifError('error');\n// Throws 'error'\nassert.ifError(new Error());\n// Throws Error\n
\n"
},
{
"textRaw": "assert.notDeepEqual(actual, expected[, message])",
"type": "method",
"name": "notDeepEqual",
"meta": {
"added": [
"v0.1.21"
],
"changes": []
},
"signatures": [
{
"params": [
{
"textRaw": "`actual` {any} ",
"name": "actual",
"type": "any"
},
{
"textRaw": "`expected` {any} ",
"name": "expected",
"type": "any"
},
{
"textRaw": "`message` {any} ",
"name": "message",
"type": "any",
"optional": true
}
]
},
{
"params": [
{
"name": "actual"
},
{
"name": "expected"
},
{
"name": "message",
"optional": true
}
]
}
],
"desc": "Tests for any deep inequality. Opposite of assert.deepEqual()
.
const assert = require('assert');\n\nconst obj1 = {\n a: {\n b: 1\n }\n};\nconst obj2 = {\n a: {\n b: 2\n }\n};\nconst obj3 = {\n a: {\n b: 1\n }\n};\nconst obj4 = Object.create(obj1);\n\nassert.notDeepEqual(obj1, obj1);\n// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }\n\nassert.notDeepEqual(obj1, obj2);\n// OK: obj1 and obj2 are not deeply equal\n\nassert.notDeepEqual(obj1, obj3);\n// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }\n\nassert.notDeepEqual(obj1, obj4);\n// OK: obj1 and obj4 are not deeply equal\n
\nIf the values are deeply equal, an AssertionError
is thrown with a message
\nproperty set equal to the value of the message
parameter. If the message
\nparameter is undefined, a default error message is assigned.
Tests for deep strict inequality. Opposite of assert.deepStrictEqual()
.
const assert = require('assert');\n\nassert.notDeepEqual({ a: 1 }, { a: '1' });\n// AssertionError: { a: 1 } notDeepEqual { a: '1' }\n\nassert.notDeepStrictEqual({ a: 1 }, { a: '1' });\n// OK\n
\nIf the values are deeply and strictly equal, an AssertionError
is thrown\nwith a message
property set equal to the value of the message
parameter. If\nthe message
parameter is undefined, a default error message is assigned.
Tests shallow, coercive inequality with the Abstract Equality Comparison\n( !=
).
const assert = require('assert');\n\nassert.notEqual(1, 2);\n// OK\n\nassert.notEqual(1, 1);\n// AssertionError: 1 != 1\n\nassert.notEqual(1, '1');\n// AssertionError: 1 != '1'\n
\nIf the values are equal, an AssertionError
is thrown with a message
\nproperty set equal to the value of the message
parameter. If the message
\nparameter is undefined, a default error message is assigned.
Tests strict inequality as determined by the Strict Equality Comparison\n( !==
).
const assert = require('assert');\n\nassert.notStrictEqual(1, 2);\n// OK\n\nassert.notStrictEqual(1, 1);\n// AssertionError: 1 !== 1\n\nassert.notStrictEqual(1, '1');\n// OK\n
\nIf the values are strictly equal, an AssertionError
is thrown with a\nmessage
property set equal to the value of the message
parameter. If the\nmessage
parameter is undefined, a default error message is assigned.
Tests if value
is truthy. It is equivalent to\nassert.equal(!!value, true, message)
.
If value
is not truthy, an AssertionError
is thrown with a message
\nproperty set equal to the value of the message
parameter. If the message
\nparameter is undefined
, a default error message is assigned.
const assert = require('assert');\n\nassert.ok(true);\n// OK\nassert.ok(1);\n// OK\nassert.ok(false);\n// throws "AssertionError: false == true"\nassert.ok(0);\n// throws "AssertionError: 0 == true"\nassert.ok(false, 'it\\'s false');\n// throws "AssertionError: it's false"\n
\n"
},
{
"textRaw": "assert.strictEqual(actual, expected[, message])",
"type": "method",
"name": "strictEqual",
"meta": {
"added": [
"v0.1.21"
],
"changes": []
},
"signatures": [
{
"params": [
{
"textRaw": "`actual` {any} ",
"name": "actual",
"type": "any"
},
{
"textRaw": "`expected` {any} ",
"name": "expected",
"type": "any"
},
{
"textRaw": "`message` {any} ",
"name": "message",
"type": "any",
"optional": true
}
]
},
{
"params": [
{
"name": "actual"
},
{
"name": "expected"
},
{
"name": "message",
"optional": true
}
]
}
],
"desc": "Tests strict equality as determined by the Strict Equality Comparison\n( ===
).
const assert = require('assert');\n\nassert.strictEqual(1, 2);\n// AssertionError: 1 === 2\n\nassert.strictEqual(1, 1);\n// OK\n\nassert.strictEqual(1, '1');\n// AssertionError: 1 === '1'\n
\nIf the values are not strictly equal, an AssertionError
is thrown with a\nmessage
property set equal to the value of the message
parameter. If the\nmessage
parameter is undefined, a default error message is assigned.
Expects the function block
to throw an error.
If specified, error
can be a constructor, RegExp
, or validation\nfunction.
If specified, message
will be the message provided by the AssertionError
if\nthe block fails to throw.
Validate instanceof using constructor:
\nassert.throws(\n () => {\n throw new Error('Wrong value');\n },\n Error\n);\n
\nValidate error message using RegExp
:
assert.throws(\n () => {\n throw new Error('Wrong value');\n },\n /value/\n);\n
\nCustom error validation:
\nassert.throws(\n () => {\n throw new Error('Wrong value');\n },\n function(err) {\n if ((err instanceof Error) && /value/.test(err)) {\n return true;\n }\n },\n 'unexpected error'\n);\n
\nNote that error
can not be a string. If a string is provided as the second\nargument, then error
is assumed to be omitted and the string will be used for\nmessage
instead. This can lead to easy-to-miss mistakes:
// THIS IS A MISTAKE! DO NOT DO THIS!\nassert.throws(myFunction, 'missing foo', 'did not throw with expected message');\n\n// Do this instead.\nassert.throws(myFunction, /missing foo/, 'did not throw with expected message');\n
\n"
}
],
"modules": [
{
"textRaw": "Caveats",
"name": "caveats",
"desc": "For the following cases, consider using ES2015 Object.is()
,\nwhich uses the SameValueZero comparison.
const a = 0;\nconst b = -a;\nassert.notStrictEqual(a, b);\n// AssertionError: 0 !== -0\n// Strict Equality Comparison doesn't distinguish between -0 and +0...\nassert(!Object.is(a, b));\n// but Object.is() does!\n\nconst str1 = 'foo';\nconst str2 = 'foo';\nassert.strictEqual(str1 / 1, str2 / 1);\n// AssertionError: NaN === NaN\n// Strict Equality Comparison can't be used to check NaN...\nassert(Object.is(str1 / 1, str2 / 1));\n// but Object.is() can!\n
\nFor more information, see\nMDN's guide on equality comparisons and sameness.
\n", "type": "module", "displayName": "Caveats" } ], "type": "module", "displayName": "Assert" } ] }