Guia Completo de Mocking no Node.js

O que é mocking e por que utilizá-lo?

Mocking é uma técnica usada em testes para simular funções, objetos ou módulos. Ao usar mocking, você pode substituir partes do código que interagem com recursos externos, como bancos de dados, APIs ou arquivos, por versões simuladas. Isso facilita a criação de testes unitários e de integração, pois você pode testar a lógica de funções isoladas sem depender de outros sistemas.

No Node.js, mocking é muito útil para simular interações com componentes que não são diretamente controláveis durante os testes, como interações com o banco de dados ou chamadas para APIs externas. Neste guia, veremos como fazer mocking em funções e módulos no Node.js utilizando as bibliotecas Sinon e Jest.

1. Como usar o Sinon para fazer mocking no Node.js

O Sinon é uma das bibliotecas mais populares para mocking no Node.js. Ele permite que você substitua funções reais por funções falsas e verifique se elas foram chamadas corretamente durante a execução do teste.

Passo 1: Instalando o Sinon

Para instalar o Sinon em seu projeto, basta rodar o seguinte comando:

npm install sinon --save-dev

Passo 2: Usando o Sinon para mockar funções

Aqui está um exemplo de como usar o Sinon para fazer mocking de uma função que interage com o banco de dados:

const sinon = require('sinon');
const expect = require('chai').expect;
const db = require('./db');  // Supondo que db.js seja o arquivo de funções do banco de dados

describe('Mocking de Função do Banco de Dados', () => {
    it('deve simular uma função de consulta ao banco', () => {
        const queryMock = sinon.stub(db, 'query').returns(Promise.resolve({ id: 1, name: 'Test User' }));
        db.query('SELECT * FROM users').then(result => {
            expect(result).to.deep.equal({ id: 1, name: 'Test User' });
            expect(queryMock.calledOnce).to.be.true;
        });
    });
});

Neste exemplo, usamos o sinon.stub() para substituir a função query do módulo db por uma versão falsa que retorna uma Promise resolvida com dados simulados. O test case verifica se o mock foi chamado e se a resposta está correta.

2. Usando o Jest para mocking no Node.js

O Jest é uma alternativa popular ao Sinon e oferece funcionalidades de mocking embutidas, o que o torna uma opção atraente para projetos que já utilizam Jest para testes. O Jest permite simular tanto funções quanto módulos inteiros, além de verificar como as funções são chamadas e os valores que retornam.

Passo 1: Instalando o Jest

Se você ainda não tiver o Jest instalado, execute o seguinte comando:

npm install jest --save-dev

Passo 2: Usando o Jest para mocking de funções

Aqui está um exemplo simples de como mockar uma função com o Jest:

const { getUser } = require('./user');

describe('Mocking com Jest', () => {
    it('deve retornar dados simulados do usuário', () => {
        const getUserMock = jest.fn().mockReturnValue({ id: 1, name: 'Test User' });
        expect(getUserMock()).toEqual({ id: 1, name: 'Test User' });
        expect(getUserMock).toHaveBeenCalledTimes(1);
    });
});

No exemplo acima, estamos utilizando o jest.fn() para criar um mock da função getUser(). A função mockada retorna dados simulados, e o Jest verifica se ela foi chamada corretamente. A função mockReturnValue() é usada para definir o valor de retorno da função mockada.

3. Mocking de módulos inteiros com Jest

Além de funções, o Jest permite que você faça mocking de módulos inteiros. Isso é útil quando você quer simular a interação de sua aplicação com módulos externos, como um módulo de banco de dados ou APIs.

Aqui está um exemplo de como mockar um módulo inteiro usando o Jest:

jest.mock('./db'); // Mock do módulo db.js
const db = require('./db');

describe('Mocking de Módulo com Jest', () => {
    it('deve simular a função de consulta ao banco de dados', async () => {
        db.query.mockResolvedValue({ id: 1, name: 'Test User' });
        const result = await db.query('SELECT * FROM users');
        expect(result).toEqual({ id: 1, name: 'Test User' });
    });
});

Neste exemplo, estamos mockando o módulo db inteiro e simulando o comportamento da função query para retornar dados falsos. O Jest fornece o método mockResolvedValue() para simular o retorno de uma Promise resolvida.

4. Usando Mocking para simular falhas

O mocking também é útil para testar como a aplicação lida com falhas ou exceções. Você pode simular um erro nas funções mockadas e verificar como sua aplicação reage.

Exemplo de simulação de erro com Jest:

jest.mock('./db');
const db = require('./db');

describe('Mocking de erro de banco de dados', () => {
    it('deve capturar erro de conexão', async () => {
        db.query.mockRejectedValue(new Error('Database connection failed'));
        try {
            await db.query('SELECT * FROM users');
        } catch (err) {
            expect(err.message).toBe('Database connection failed');
        }
    });
});

Neste exemplo, estamos simulando um erro na função query e verificando se ele é capturado corretamente pela aplicação.

5. Conclusão

O mocking é uma técnica poderosa e essencial para realizar testes isolados em funções e módulos do Node.js. Ele permite simular comportamentos de funções e objetos sem a necessidade de interagir com bancos de dados, APIs ou arquivos reais. Com o uso de Sinon e Jest, você pode testar a lógica da sua aplicação de forma eficaz, sem depender de recursos externos, garantindo que sua aplicação se comporte corretamente em diferentes cenários.

Além disso, o mocking também é útil para testar falhas e erros de forma controlada, ajudando a melhorar a confiabilidade e a robustez do seu código.

A importância do Mocking para testes de alta qualidade no Node.js

Mocking é uma técnica que permite simular o comportamento de funções, módulos ou objetos durante os testes. Isso ajuda a testar componentes de uma aplicação de maneira isolada, sem depender de recursos externos, como bancos de dados ou APIs. No Node.js, o mocking é frequentemente utilizado para testar o código que interage com esses recursos sem realmente chamar os serviços externos.

Ao usar Sinon ou Jest, você pode simular funções e módulos de forma flexível e eficaz, permitindo testar diferentes fluxos e cenários. O mocking não só melhora a cobertura de testes, mas também facilita o teste de erros e falhas que podem ocorrer quando interagimos com sistemas externos.

Algumas aplicações:

• Testar funções assíncronas sem depender de recursos externos
• Simular falhas em conexões com banco de dados para garantir o tratamento de erros
• Testar interações com APIs externas de forma isolada
• Mockar o sistema de autenticação para testar a autorização em endpoints protegidos
• Realizar testes de unidade sem precisar de uma infraestrutura externa complexa

Dicas para quem está começando

• Use jest.mock() para mockar módulos inteiros em testes.
• Teste funções assíncronas simulando as respostas com mockResolvedValue() ou mockRejectedValue() no Jest.
• Evite depender de bancos de dados reais durante o desenvolvimento, use mocking para simular interações.
• Quando usar o Sinon, use sinon.stub() para mockar funções específicas de módulos.
• Realize testes de falhas usando mocking para garantir que a aplicação lide com erros corretamente.

Compartilhe este tutorial