assert.strictEqual() Function in Node.js

In Node.js, the assert module is an essential tool for writing effective tests. One of the core assertion methods is assert.strictEqual(), which helps in verifying that two values are strictly equal to each other. This function is widely used to ensure that values in your code match expected results. In this blog post, we will dive into what assert.strictEqual() is, its syntax, and how it can be used in testing scenarios.

What is assert.strictEqual()?

The assert.strictEqual() method checks whether two values are strictly equal. In JavaScript, "strict equality" means that the values must be of the same type and have the same value. Unlike regular equality (`==`), which performs type coercion, strict equality (`===`) does not convert types and will only return true if the values are identical in both value and type.

Syntax of assert.strictEqual()

The syntax of the assert.strictEqual() function is as follows:

assert.strictEqual(actual, expected, [message]);

• actual: The actual value that your code returns or produces.
• expected: The value you expect actual to be equal to.
• message (optional): A custom error message that will be displayed if the assertion fails.

How Does assert.strictEqual() Work?

When you use assert.strictEqual(), it compares the two values provided as arguments. If the values are strictly equal (both in type and value), the test passes. If they are not strictly equal, the test fails, and an error is thrown.

For example, the function will distinguish between a number `1` and a string `'1'`, treating them as different because their types differ, even though they might look similar.

Example Usage of assert.strictEqual()

Let's look at a simple example where we compare two values using assert.strictEqual():

const assert = require('assert');

let actual = 5;
let expected = 5;

assert.strictEqual(actual, expected, 'Values are not strictly equal');
    

In this example, since both the actual and expected values are of type number and have the same value (`5`), the assertion passes without any issues.

Testing Strict Equality with Different Data Types

One of the key features of assert.strictEqual() is its ability to detect differences in data types. Consider the following example:

let actual = '5';
let expected = 5;

assert.strictEqual(actual, expected, 'Values should be strictly equal');
    

Here, even though both values look the same in value (`'5'` and `5`), the test will fail because one is a string and the other is a number. The strict equality check will fail due to the type mismatch.

When to Use assert.strictEqual()

Use assert.strictEqual() when you need to ensure that two values are not only equal in value but also identical in type. This is particularly useful when you want to avoid the issues that arise from JavaScript's automatic type coercion, which happens when using the regular equality operator (`==`). It is ideal for situations where precise type matching is important, such as when testing APIs, functions that return specific types, or any scenario where data integrity is crucial.

Conclusion

The assert.strictEqual() function in Node.js is an essential tool for ensuring that two values are strictly equal, both in type and value. By using this method, developers can write more reliable tests and catch potential bugs that might arise from unexpected type coercion. It’s a powerful function to have in your testing toolkit, especially when you need precise and accurate comparisons between values in your application.