Guia Completo: Como testar middlewares no Express.js

O que são middlewares no Express.js?

No Express.js, os middlewares são funções que têm acesso ao objeto request (req), ao objeto response (res) e à próxima função no ciclo de requisição-resposta da aplicação. Elas podem modificar a requisição ou a resposta, executar algum código, fazer verificações ou até mesmo finalizar o ciclo de requisição. No entanto, testar esses middlewares é essencial para garantir que eles estejam funcionando como esperado e para prevenir falhas em seu código.

Neste tutorial, vamos aprender a testar middlewares no Express.js usando as bibliotecas Mocha e Chai, que facilitam a criação de testes automatizados e asseguram que o comportamento da sua aplicação esteja correto.

1. Configurando o ambiente para testar middlewares no Express.js

Antes de começar, você precisa garantir que as bibliotecas Mocha, Chai e Supertest (para testar as rotas) estão instaladas. Para isso, basta rodar o seguinte comando:

npm install mocha chai supertest --save-dev

2. Como testar middlewares no Express.js

Testar middlewares é simples. Basicamente, você quer garantir que a função de middleware faça as alterações ou verificações necessárias na requisição e resposta ou execute a lógica corretamente, antes de passar para o próximo middleware ou retornar a resposta ao cliente.

Exemplo de middleware para verificação de autenticação:

function authMiddleware(req, res, next) {
    if (!req.headers['authorization']) {
        return res.status(401).json({ message: 'Unauthorized' });
    }
    next(); // Continua para o próximo middleware ou rota
}

Este é um exemplo simples de um middleware que verifica se o cabeçalho de autorização está presente na requisição. Se não estiver, a requisição é rejeitada com um status 401. Caso contrário, o middleware chama o próximo middleware ou rota com next().

3. Testando middlewares com Mocha e Chai

Agora, vamos testar o comportamento deste middleware usando o Mocha e Chai. O Supertest será útil para simular uma requisição e testar o comportamento da aplicação.

Exemplo de teste para o middleware de autenticação:

const request = require('supertest');
const app = require('../app');  // Suponha que 'app' seja o arquivo principal da sua aplicação

describe('Middleware de autenticação', () => {
    it('deve retornar 401 se o cabeçalho de autorização não estiver presente', async () => {
        const res = await request(app).get('/protected');
        expect(res.status).toBe(401);
        expect(res.body).toHaveProperty('message', 'Unauthorized');
    });

    it('deve permitir o acesso se o cabeçalho de autorização estiver presente', async () => {
        const res = await request(app)
            .get('/protected')
            .set('Authorization', 'Bearer token');
        expect(res.status).toBe(200);
        expect(res.body).toHaveProperty('message', 'Access granted');
    });
});

No primeiro teste, estamos verificando se a requisição sem o cabeçalho de autorização retorna um erro 401 (Unauthorized). No segundo teste, verificamos se a requisição com o cabeçalho de autorização correto permite o acesso com status 200 e uma mensagem de sucesso.

4. Testando middlewares assíncronos

Se o seu middleware faz operações assíncronas, como acessar banco de dados ou APIs externas, você pode usar async/await para garantir que o teste espere a execução completa do middleware.

Aqui está um exemplo de middleware assíncrono que verifica se o usuário existe no banco de dados:

async function checkUserExists(req, res, next) {
    const user = await User.findById(req.params.id);
    if (!user) {
        return res.status(404).json({ message: 'User not found' });
    }
    next();
}

Agora, vamos testar esse middleware assíncrono com Mocha e Chai:

const request = require('supertest');
const app = require('../app');

describe('Middleware checkUserExists', () => {
    it('deve retornar 404 se o usuário não for encontrado', async () => {
        const res = await request(app).get('/user/123');
        expect(res.status).toBe(404);
        expect(res.body).toHaveProperty('message', 'User not found');
    });

    it('deve permitir o acesso se o usuário for encontrado', async () => {
        const res = await request(app)
            .get('/user/1')
            .set('Authorization', 'Bearer token');
        expect(res.status).toBe(200);
        expect(res.body).toHaveProperty('message', 'User found');
    });
});

Neste exemplo, o middleware checkUserExists verifica se o usuário existe no banco de dados antes de permitir o acesso. O primeiro teste verifica se, quando o usuário não é encontrado, a API retorna 404, enquanto o segundo teste verifica se o middleware permite o acesso quando o usuário é encontrado.

5. Conclusão

Os testes de middlewares são uma parte essencial para garantir que sua aplicação Express.js seja confiável e funcione corretamente. Usando Mocha, Chai e Supertest, você pode testar a lógica dos seus middlewares de maneira simples e eficaz, garantindo que sua aplicação esteja funcionando como esperado.

Escrever testes automatizados para middlewares não só melhora a qualidade do código, mas também ajuda a detectar falhas antes que elas se tornem problemas críticos em produção.

Como testar middlewares de forma eficiente no Express.js

Testar middlewares em Express.js é uma das práticas fundamentais para garantir a qualidade e o bom funcionamento da sua aplicação. Muitas vezes, middlewares lidam com lógica crucial como autenticação, validação de dados e manipulação de erros. Ao escrever testes para essas funções, você pode verificar se o comportamento delas está conforme o esperado antes de a aplicação ser colocada em produção.

Além disso, os testes ajudam a detectar rapidamente problemas em requisições e respostas que podem afetar a experiência do usuário. Utilizando ferramentas como Mocha e Chai, você pode facilmente mockar dados e verificar o comportamento de seus middlewares, permitindo que você escreva testes completos e confiáveis.

Algumas aplicações:

• Testar middleware de autenticação em APIs RESTful
• Verificar a validação de entrada em requisições de APIs
• Garantir a manipulação correta de erros em middlewares de captura de exceções
• Testar middleware de logging para monitoramento de eventos
• Verificar a autorização de usuários em sistemas com papéis diferenciados

Dicas para quem está começando

• Escreva testes de middlewares para garantir que sua lógica seja validada corretamente em cada requisição.
• Use o done no Mocha para testar funções assíncronas em middlewares.
• Use Supertest para testar suas rotas e middlewares de forma realista.
• Garanta que todos os fluxos de erro sejam tratados e testados adequadamente.
• Não deixe de testar os casos negativos para garantir que os erros sejam capturados corretamente.

Contribuições de

Cláudia Medeiros

Especialista em segurança de software, desempenho de APIs e gestão de infraestrutura em nuvem.

Mais sobre o autor

Compartilhe este tutorial