Unlock the Power of Node.js Assert Module

What Are Invariants?

Invariants are expressions or conditions that must return true at some point in a program. They’re essential for maintaining the integrity of your application. Consider an example where a simple expression returns “true” when run on your terminal or Bash. Now, imagine that the application returns an unexpected result due to a mistake. How would you trace this mistake and ensure it doesn’t happen again? This is where invariants come in.

Types of Assert Methods

Node.js provides various assert methods to test invariants. The choice of method depends on what you’re testing in your application. To get started, install the assert module by running the command npm install assert.

Assert(value[, message])

This method verifies if the value of an invariant is true. It’s an alias of assert.ok(value[, message]) and can be used interchangeably. If the invariant expression returns true, no error is thrown.

const assert = require('assert');

assert(true, 'Expected true but got false');

Assert.deepStrictEqual (actual, expected[, message])

This method uses strict equality comparison, making it ideal for checking equality between actual and expected results. It’s a more reliable alternative to assert.deepEqual.

const assert = require('assert');

assert.deepStrictEqual({ a: 1 }, { a: 1 }, 'Expected objects to be identical');

Assert.fail([message])

This method allows you to add a custom message to your invariant test when it returns false. It’s a simple yet effective debugging technique.

const assert = require('assert');

assert.fail('Expected the expression to be true');

Assert.ifError(value)

This method helps you understand where an error is coming from by testing error callback arguments. It’s essential for identifying and fixing issues in your application.

const assert = require('assert');

assert.ifError(new Error('An error occurred'));

Assert.doesNotMatch(string, regexp[, message])

This experimental method verifies that the actual input string does not match the expected expression. It uses strict mode and is available in Node.js version v13.6.0, v12.16.0.

const assert = require('assert');

assert.doesNotMatch('hello', /world/, 'Expected the string to not match the regex');

Assert.doesNotReject(asyncFn[, error][, message])

This method checks that a promise is not rejected in an asynchronous function. However, it’s not very useful, as catching a rejection just to reject it again doesn’t provide much value.

const assert = require('assert');

async function asyncFn() {
  return Promise.resolve();
}

assert.doesNotReject(asyncFn, undefined, 'Expected the promise to not be rejected');

Assert.rejects()

This method awaits the returned promise in an asynchronous function to verify that it’s rejected. If the promise is not rejected, it throws an error.

const assert = require('assert');

async function asyncFn() {
  return Promise.reject(new Error('An error occurred'));
}

assert.rejects(asyncFn, undefined, 'Expected the promise to be rejected');

Assert in Strict and Legacy Modes

Assert can operate in strict and legacy modes. Strict mode involves using strict equality comparison, while legacy mode uses abstract equality comparison. It’s recommended to use strict mode, as legacy mode may produce unexpected results.

Legacy Mode Comparison Methods

In legacy mode, you can use the following comparison methods:

• Assert.deepEqual(actual, expected[, message]): This method uses abstract equality comparison and is used to check for equality between actual and expected results.
• Assert.notDeepEqual(actual, expected[, message]): This method is used to test for deep inequality and would throw an exception if the actual and expected values are equal.
• Assert.equal(actual, expected[, message]): This method is used to test shallow comparison between actual and expected results using abstract equality comparison.
• Assert.notEqual(actual, expected[, message]): This method is used to check for shallow inequality between actual and expected results.

Best Practices

When working with the assert module, it’s essential to use strict mode to ensure accurate results. Additionally, always add comments next to the specific code path that should not reject and keep error messages expressive.

By mastering the assert module, you can write more robust and reliable Node.js applications. Remember to use strict mode and choose the right assert method for your needs. Happy coding!