A Guide to Test Node.js with Mocha and Chai

Overview

In software development, testing is a critical aspect of ensuring the reliability and correctness of your code. Node.js, a popular runtime for building server-side applications, offers a robust ecosystem for testing. In this blog post, we will test Node.js applications using two powerful libraries, Mocha and Chai. These tools empower developers to write comprehensive and expressive tests to validate their code, catch bugs early, and build more robust applications.

Pioneers in Cloud Consulting & Migration Services

Reduced infrastructural costs
Accelerated application deployment

Get Started

Introduction

While creating an application, it is equally as important as to create an application is to test it before deployment. Many frameworks are available, including Jest, Jasmine, QUnit, Karma, and Cypress. One of the most popular testing frameworks for JavaScript is Mocha. In this blog, we will learn how to test a NodeJS app with Mocha, including writing our test suites and running Mocha Tests.

Mocha

Mocha is a freely available, open-source JavaScript testing framework compatible with Node.js and web browsers.

It offers a user-friendly testing environment that evaluates both synchronous and asynchronous code. Mocha is particularly well-suited for conducting unit and integration tests, making it an excellent choice for Behavior-Driven Development (BDD) adherents.

Mocha’s distinctive feature is its ability to execute tests sequentially, enabling clear identification of failing tests and their respective issues. Additionally, Mocha generates comprehensive reports and accurately associates unhandled exceptions with the corresponding test cases. Mocha automatically resets the software’s state after each test to maintain a clean testing environment, ensuring that tests do not interfere.

While Mocha can be employed with various assertion libraries, it is frequently paired with Chai, a highly regarded assertion library for both Node.js and web-based applications.

Step-by-Step Guide

Step 1 – Running a Mocha test in Node.js

For running Mocha, you need to install it globally or locally as a dev dependency for your project. For that, you need to write the following commands –

npm i --global mocha
OR
npm i --save-dev mocha

npm i --global mocha

npm i --save-dev mocha

To complete your Mocha setup, you’ll have to write a unit test for very simple functionality and configure a script to run the test using Mocha.

Step 2 – Mocha automatically looks for tests inside the ‘test’ directory of your project. Establish this directory at the root of your project:

mkdir test

1	mkdir test

Step 3 – Modify the ‘test’ script in your ‘package.json’ to run tests using Mocha. It should look like the following:

{
  "name": "test",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "mocha"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.18.2"
  }
}

{

"name": "test",

"version": "1.0.0",

"description": "",

"main": "index.js",

"scripts": {

"test": "mocha"

"keywords": [],

"author": "",

"license": "ISC",

"dependencies": {

"express": "^4.18.2"

}

With this setup, you can run the tests in your project using the simple command below:

npm test

npm test

Now we have everything set up but no tests to run. Let’s write the tests for the desired functionalities of our software.

Step 4 – Writing tests with Mocha and Chai

Writing tests often requires using an assertion library. An assertion is a feature used to verify that the result from a programming operation matches the expected result. Mocha does not discriminate, regardless of which assertion library you use.

If you’re working with Mocha in a Node.js environment, you can utilize the built-in assert module as your assertion library. Nevertheless, more comprehensive assertion libraries are available, such as Chai, Expect.js, Should.js, and others.

Throughout this guide, we’ll opt for Chai as our assertion library. Follow these steps to integrate Chai into your project as a development dependency.

npm i --save-dev chai

1	npm i --save-dev chai

Chai provides the assert, expect, and should assertion styles.

Step 5 – Writing a test suite with Mocha

Let’s write our first test suite and run the tests with Mocha. To start, you must implement a sum() function that:

Can accept any number of arguments
Computes and returns the sum of its arguments provided each is a number
Returns 0 if no argument is passed

class MyClass {
    constructor(){
        console.log("Constructor");
    }
    sum(...args) {
        let total = 0;
        args.forEach(arg => {
            total = total + arg;        
        })
        return total;
    }    
}
module.exports = MyClass;

class MyClass {

constructor(){

console.log("Constructor");

}

sum(...args) {

let total = 0;

args.forEach(arg => {

total = total + arg;

})

return total;

}

module.exports = MyClass;

First, define the test suite with tests for the required functionalities. Create a new sum.js file in the test directory of your project and add the following code snippet to it:

const MyClass = require('../src/sum');
var myObj = new MyClass();
var expect = require('chai').expect;


describe('#sum()', function() {
    context('without arguments', function() {
        it('should return 0', function() {
            expect(myobj.sum()).to.equal(0)
        })


    })
    context('with number arguments', function() {
        it('should return sum of arguments', function() {
            expect (myObj. sum(1, 2, 3, 4, 5)).to.equal(15)
        })


        it('should return argument when only one argument is passed',function() {
            expect(myobj. sum(5)).to.equal(5)
        })
    })
})

const MyClass = require('../src/sum');

var myObj = new MyClass();

var expect = require('chai').expect;

describe('#sum()', function() {

context('without arguments', function() {

it('should return 0', function() {

expect(myobj.sum()).to.equal(0)

})

context('with number arguments', function() {

it('should return sum of arguments', function() {

expect (myObj. sum(1, 2, 3, 4, 5)).to.equal(15)

})

it('should return argument when only one argument is passed',function() {

expect(myobj. sum(5)).to.equal(5)

})

Now, you can run the tests in your terminal by running the test script defined earlier:

npm test

npm test

You should get an output that looks like the following:

mocha

Conclusion

Testing is essential to the software development process, and Node.js offers robust tools like Mocha and Chai to streamline this critical aspect. By following the steps outlined in this guide, you can ensure the reliability and functionality of your Node.js applications. Remember that well-tested code leads to more robust and maintainable software, ultimately saving time and effort in the long run.

Drop a query if you have any questions regarding Mocha and Chai in Node.js and we will get back to you quickly.

Making IT Networks Enterprise-ready – Cloud Management Services

Accelerated cloud migration
End-to-end view of the cloud environment

Get Started

About CloudThat

CloudThat is a leading provider of Cloud Training and Consulting services with a global presence in India, the USA, Asia, Europe, and Africa. Specializing in AWS, Microsoft Azure, GCP, VMware, Databricks, and more, the company serves mid-market and enterprise clients, offering comprehensive expertise in Cloud Migration, Data Platforms, DevOps, IoT, AI/ML, and more.

FAQs

1. How do I structure my test suites and organize test files?

ANS: – You can structure your tests in suites and organize test files according to your project’s directory structure. Common approaches include grouping tests by modules or components. Mocha’s describe, and it functions help you create a logical hierarchy for your tests.

2. Can I run specific tests or test suites selectively?

ANS: – Yes, Mocha allows you to run specific tests or suites by specifying the describe or it block names or by using the –grep flag followed by a regular expression pattern matching the test or suite names.

3. How do I handle asynchronous testing in Node.js with Mocha?

ANS: – Node.js often involves asynchronous operations. Mocha handles asynchronous testing through mechanisms like callbacks, Promises, and async/await. You can use the done callback, return a Promise, or mark your test function as async.