Testing is a crucial part of software development, ensuring that applications behave as expected. When working with Fastify, a fast and low-overhead web framework for Node.js, developers often need to mock or stub external dependencies to create reliable and isolated tests. Implementing mocking and stubbing correctly can improve test accuracy and reduce flakiness.

Understanding Mocking and Stubbing

Mocking and stubbing are techniques used to simulate parts of a system during testing. They help isolate the unit of code under test from external systems such as databases, APIs, or other services.

What is Mocking?

Mocking involves creating a fake version of an object or function that mimics the behavior of the real one. Mocks can verify whether specific methods were called, how many times, and with what arguments.

What is Stubbing?

Stubbing replaces a function or method with a predefined response. Unlike mocks, stubs typically do not verify interactions but provide controlled outputs for testing.

Implementing Mocks and Stubs in Fastify Tests

Fastify tests are often written using testing frameworks like Jest or Mocha. To implement mocking and stubbing, you can use libraries such as Sinon.js, which provides powerful tools for creating spies, stubs, and mocks.

Setting Up Sinon.js

First, install Sinon.js in your project:

npm install sinon --save-dev

Creating Mocks and Stubs in Tests

Here's an example of how to stub an external API call within a Fastify route test:

const sinon = require('sinon');
const fastify = require('fastify')();
const axios = require('axios');

describe('Fastify API Tests', () => {
  let axiosGetStub;

  beforeEach(() => {
    axiosGetStub = sinon.stub(axios, 'get');
  });

  afterEach(() => {
    axiosGetStub.restore();
  });

  it('should return data from external API', async () => {
    const mockData = { data: { message: 'Hello World' } };
    axiosGetStub.resolves(mockData);

    fastify.get('/greet', async (request, reply) => {
      const response = await axios.get('https://api.example.com/message');
      return response.data;
    });

    const response = await fastify.inject({
      method: 'GET',
      url: '/greet'
    });

    expect(response.statusCode).toBe(200);
    expect(JSON.parse(response.payload)).toEqual({ message: 'Hello World' });
    sinon.assert.calledOnceWithExactly(axiosGetStub, 'https://api.example.com/message');
  });
});

Best Practices for Reliable Tests

  • Always restore your stubs and mocks after each test to prevent cross-test interference.
  • Use descriptive names for your mocks and stubs to improve test readability.
  • Prefer specific stubs over general ones to keep tests precise and predictable.
  • Combine mocking with assertions to verify interactions when necessary.
  • Keep tests isolated; avoid sharing mocks across multiple tests unless explicitly intended.

Implementing effective mocking and stubbing strategies in Fastify tests enhances reliability and confidence in your codebase. Proper setup and teardown, combined with clear test cases, ensure that tests remain deterministic and maintainable.