Setting Up Mocha and Chai

Setting Up Mocha and Chai in Node.js

Mocha and Chai are two powerful tools commonly used together for testing in Node.js applications. Mocha is a test framework that runs on Node.js and provides a base structure for organizing tests, while Chai is an assertion library that provides readable assertions to test your expectations.

1. Why Use Mocha and Chai?

• Mocha: Offers test organization, hooks, and asynchronous testing support.
• Chai: Provides fluent, expressive assertions using expect, should, or assert styles.

2. Project Initialization

Step 1: Create a New Project

mkdir mocha-chai-setup
cd mocha-chai-setup
npm init -y

Step 2: Install Mocha and Chai

npm install --save-dev mocha chai

Step 3: Create Test Folder and File

mkdir test
touch test/sample.test.js

Step 4: Update package.json

Edit the scripts section in your package.json:

"scripts": {
  "test": "mocha"
}

3. Writing Your First Test

Create a simple function and test it.

File: math.js

function add(a, b) {
  return a + b;
}

function subtract(a, b) {
  return a - b;
}

module.exports = { add, subtract };

File: test/sample.test.js

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

const { add, subtract } = require('../math');

describe('Math Functions', () => {
  it('should return 5 when adding 2 and 3', () => {
    expect(add(2, 3)).to.equal(5);
  });

  it('should return 1 when subtracting 3 from 4', () => {
    expect(subtract(4, 3)).to.equal(1);
  });
});

4. Running the Tests

npm test

You should see output like:

  Math Functions
    ✓ should return 5 when adding 2 and 3
    ✓ should return 1 when subtracting 3 from 4

  2 passing

5. Assertion Styles in Chai

Expect Style

expect(value).to.equal(10);
expect(arr).to.have.lengthOf(3);
expect(user).to.have.property('name');

Should Style

const should = chai.should();
value.should.equal(10);
arr.should.have.lengthOf(3);

Assert Style

const assert = chai.assert;
assert.equal(value, 10);
assert.lengthOf(arr, 3);

6. Asynchronous Testing

Example with async/await

async function fetchData() {
  return new Promise((resolve) => {
    setTimeout(() => resolve('data'), 100);
  });
}

describe('Async Test', () => {
  it('should return data', async () => {
    const result = await fetchData();
    expect(result).to.equal('data');
  });
});

7. Using Hooks in Mocha

describe('User Suite', () => {
  before(() => {
    // Run once before all tests
  });

  beforeEach(() => {
    // Run before each test
  });

  afterEach(() => {
    // Run after each test
  });

  after(() => {
    // Run once after all tests
  });
});

8. Structuring Your Test Directory

project/
│
├── math.js
├── package.json
└── test/
    ├── sample.test.js
    └── auth.test.js

You can organize test files by module or feature.

9. Test Coverage (Optional)

To measure code coverage, install and use nyc:

npm install --save-dev nyc

Update package.json

"scripts": {
  "test": "nyc mocha"
}

Mocha and Chai are an excellent combination for writing unit and integration tests in Node.js. Mocha provides structure and flow, while Chai gives you expressive assertions. With this setup, you can build a reliable test suite to ensure your application runs as expected.