Asserter

areEqual(actual, expected, criteriaopt) → {void}

Expects two given objects to be equal according to a default or custom criteria.

Expects two given objects to be equal according to a default or custom criteria. This is a shortcut of the that syntax followed by a isEqualTo assertion.

Source:

core/asserter.js, line 222

Parameters:

Name	Type	Attributes	Description
`actual`	`*`		the object under test.
`expected`	`*`		the object that you are expecting the `actual` to be.
`criteria`	`function`	<optional>	a two-argument function to be used to compare `actual` and `expected`. Optional.

Returns:

Type:: void

Examples

assert.areEqual(3 + 4, 7)

equivalent version
assert.that('3' + '4').isEqualTo('34')

custom criteria
assert.areEqual([2, 3], ['x', 'y'], (a, b) => a.length === b.length)

areIdentical(actual, expected) → {void}

Expects two given objects to be identical, that is, to share the same reference.

Expects two given objects to be identical, that is, to share the same reference. This is a shortcut of the that syntax followed by a isIdenticalTo assertion.

Source:

core/asserter.js, line 268

Parameters:

Name	Type	Description
`actual`	`*`	the object under test.
`expected`	`*`	the object that you are expecting the `actual` to be.

Returns:

Type:: void

Examples

literals
assert.areIdentical(3, 3)

equivalent version
assert.that(3).isIdenticalTo(3)

same reference
const object = { my: "object" }
assert.areIdentical(object, object)

areNotEqual(actual, expected, criteriaopt) → {void}

Expects two given objects to be not equal, according to a default or custom criteria.

Expects two given objects to be not equal, according to a default or custom criteria. This is a shortcut of the that syntax followed by a isNotEqualTo assertion.

Source:

core/asserter.js, line 245

Parameters:

Name	Type	Attributes	Description
`actual`	`*`		the object under test.
`expected`	`*`		the object that you are expecting the `actual` to not be equal.
`criteria`	`function`	<optional>	a two-argument function to be used to compare `actual` and `expected`. Optional.

Returns:

Type:: void

Examples

assert.areNotEqual(3 + 4, 8)

equivalent version
assert.that('3' + '4').isNotEqualTo('7')

custom criteria
assert.areNotEqual([2, 3], ['x'], (a, b) => a.length === b.length)

areNotIdentical(actual, expected) → {void}

Expects two given objects to be not identical, that is, to not share the same reference.

Expects two given objects to be not identical, that is, to not share the same reference. This is a shortcut of the that syntax followed by a isNotIdenticalTo assertion.

Source:

core/asserter.js, line 292

Parameters:

Name	Type	Description
`actual`	`*`	the object under test.
`expected`	`*`	the object that you are expecting the `actual` to not be identical to.

Returns:

Type:: void

Examples

literals
assert.areNotIdentical(3, 3 + 0)

equivalent version
assert.that(3).isNotIdenticalTo(3 + 0)

different references
const object1 = { my: "object" }
const object2 = { my: "object" }
assert.areNotIdentical(object1, object2)

isEmpty(actual) → {void}

Expects a given object to be an empty collection (arrays, strings, sets and maps).

Expects a given object to be an empty collection (arrays, strings, sets and maps). This is a shortcut of the that syntax followed by a isEmpty assertion.

Source:

core/asserter.js, line 313

Parameters:

Name	Type	Description
`actual`	`*`	the collection object you expect to be empty.

Returns:

Type:: void

Examples

assert.isEmpty([])
assert.isEmpty('')
assert.isEmpty(new Set())
assert.isEmpty(new Map())

equivalent version
assert.that('').isEmpty()

isFalse(actual) → {void}

Expects a given object to be strictly equal to false.

Expects a given object to be strictly equal to false. Other "falsey" values, according to Javascript rules, will be considered not false.

This is a shortcut of the Asserter#that syntax followed by a isFalse assertion.

Source:

core/asserter.js, line 131

Parameters:

Name	Type	Description
`actual`	`*`	the object you expect to be `false`.

Returns:

Type:: void

Examples

assert.isFalse(4 < 3)

equivalent version
assert.that(4 < 3).isFalse()

isMatching(actual, regex) → {void}

Expects a given string to match a given regexp.

Expects a given string to match a given regexp. This is a shortcut of the that syntax followed by a matches assertion.

Source:

core/asserter.js, line 353

Parameters:

Name	Type	Description
`actual`	`String`	the string you will check against the regex.
`regex`	`RegExp`	the regexp you will use to parse the actual string.

Returns:

Type:: void

Examples

assert.isMatching('hello', /[a-z]+/)

equivalent version
assert.that('hello').matches(/[a-z]+/)

isNotEmpty(actual) → {void}

Expects a given object to be a non-empty collection (arrays, strings, sets and maps).

Expects a given object to be a non-empty collection (arrays, strings, sets and maps). This is a shortcut of the that syntax followed by a isNotEmpty assertion.

Source:

core/asserter.js, line 334

Parameters:

Name	Type	Description
`actual`	`*`	the collection object you expect to be non-empty.

Returns:

Type:: void

Examples

assert.isNotEmpty([42])
assert.isNotEmpty('hello')
assert.isNotEmpty(new Set([42]))
assert.isNotEmpty(new Map([['key', 42]]))

equivalent version
assert.that('hello').isNotEmpty()

isNotNull(actual) → {void}

Expects the actual object to be different from null.

Expects the actual object to be different from null. This is a shortcut of the that syntax followed by a isNotNull assertion.

Source:

core/asserter.js, line 199

Parameters:

Name	Type	Description
`actual`	`*`	the object you expect to be different from `null`.

Returns:

Type:: void

Examples

assert.isNotNull('something')

equivalent version
assert.that('something').isNotNull()

isNotUndefined(actual) → {void}

Expects the actual object to be not strictly equal to undefined.

Expects the actual object to be not strictly equal to undefined. This is a shortcut of the Asserter#that syntax followed by a isNotUndefined assertion.

Source:

core/asserter.js, line 165

Parameters:

Name	Type	Description
`actual`	`*`	the object you expect to be not `undefined`.

Returns:

Type:: void

Examples

assert.isNotUndefined("hello".length)

equivalent version
assert.that("hello".length).isNotUndefined()

isNull(actual) → {void}

Expects the actual object to be strictly equal to null.

Expects the actual object to be strictly equal to null. This is a shortcut of the that syntax followed by a isNull assertion.

Source:

core/asserter.js, line 182

Parameters:

Name	Type	Description
`actual`	`*`	the object you expect to be `null`.

Returns:

Type:: void

Examples

assert.isNull(null)

equivalent version
assert.that(null).isNull()

isTrue(actual) → {void}

Expects a given object to be strictly equal to true.

Expects a given object to be strictly equal to true. Other "truthy" values, according to Javascript rules, will be considered not true.

This is a shortcut of the that syntax followed by a isTrue assertion.

Source:

core/asserter.js, line 112

Parameters:

Name	Type	Description
`actual`	`*`	the object you expect to be `true`.

Returns:

Type:: void

Examples

assert.isTrue(3 < 4)

equivalent version
assert.that(3 < 4).isTrue()

isUndefined(actual) → {void}

Expects the actual object to be strictly equal to undefined.

Expects the actual object to be strictly equal to undefined. This is a shortcut of the Asserter#that syntax followed by a isUndefined assertion.

Source:

core/asserter.js, line 148

Parameters:

Name	Type	Description
`actual`	`*`	the object you expect to be `undefined`.

Returns:

Type:: void

Examples

assert.isUndefined(object.missingProperty)

equivalent version
assert.that(object.missingProperty).isUndefined()

that(actual) → {Assertion}

Starts an assertion.

Starts an assertion. A call to this method needs to be chained with an expectation, otherwise it does not represent a valid assertion.

Source:

core/asserter.js, line 75

Parameters:

Name	Type	Description
`actual`	`*`	the object under test.

Returns:

Type:: Assertion

an object that you can use to build an assertion.

Examples

using the Assertion#isEqualTo assertion
assert.that(3 + 4).isEqualTo(7)

using the Assertion#isEmpty assertion
assert.that("").isEmpty()

using the Assertion#isNearTo assertion
assert.that(0.1 + 0.2).isNearTo(0.3)

withDescription(description) → {DescribedAsserter}

Constructs an assertion overriding the default failure message.

Constructs an assertion overriding the default failure message. This is convenient when the assertion does not provide enough context to understand what is happening.

Source:

core/asserter.js, line 89

Parameters:

Name	Type	Description
`description`	`string`	the text you want to see when the assertion fails.

Returns:

Type:: DescribedAsserter

Example

adding context to Assertion#isTrue assertion
assert.withDescription("Light was not turned on!").isTrue(light.isOn())

Constructor

new Asserter()

Methods

areEqual(actual, expected, criteriaopt) → {void}

Parameters:

Returns:

Examples

areIdentical(actual, expected) → {void}

Parameters:

Returns:

Examples

areNotEqual(actual, expected, criteriaopt) → {void}

Parameters:

Returns:

Examples

areNotIdentical(actual, expected) → {void}

Parameters:

Returns:

Examples

isEmpty(actual) → {void}

Parameters:

Returns:

Examples

isFalse(actual) → {void}

Parameters:

Returns:

Examples

isMatching(actual, regex) → {void}

Parameters:

Returns:

Examples

isNotEmpty(actual) → {void}

Parameters:

Returns:

Examples

isNotNull(actual) → {void}

Parameters:

Returns:

Examples

isNotUndefined(actual) → {void}

Parameters:

Returns:

Examples

isNull(actual) → {void}

Parameters:

Returns:

Examples

isTrue(actual) → {void}

Parameters:

Returns:

Examples

isUndefined(actual) → {void}

Parameters:

Returns:

Examples

that(actual) → {Assertion}

Parameters:

Returns:

Examples

withDescription(description) → {DescribedAsserter}

Parameters:

Returns:

Example