Hospedar uma API carrega a responsabilidade de garantir que ela funcione. Não há maneira melhor ou mais fácil de fazer isso do que testes automatizados com uma ferramenta como o Mocha.

O desenvolvimento de software moderno faz grande uso de APIs. Eles servem como um link crucial entre aplicativos do lado do cliente e aplicativos de back-end, bem como entre diferentes aplicativos internos ou externos.

As APIs permitem comunicação e troca de dados suaves, permitindo que os componentes de software interajam perfeitamente uns com os outros. Garantir a confiabilidade, funcionalidade e desempenho dessas APIs é de extrema importância para oferecer uma experiência de usuário perfeita e manter a integridade geral do sistema.

Portanto, é importante testar exaustivamente suas APIs para sinalizar e corrigir bugs durante o desenvolvimento para evitar possíveis falhas do sistema em ambientes de produção.

Testando APIs Node.js usando Mocha, Chai e Chai-HTTP

moca é uma estrutura de teste amplamente utilizada que é compatível com vários

instagram viewer
estruturas JavaScript. Um de seus principais recursos é um executor de teste flexível que simplifica o processo de gerenciamento e execução de casos de teste com eficiência.

Ele também oferece suporte a vários estilos de teste, incluindo testes síncronos e assíncronos, permitindo uma ampla variedade de cenários de teste.

Por outro lado, chai e Chai-HTTP são bibliotecas de asserção que você pode usar em conjunto com o Mocha. Chai fornece uma ampla variedade de interfaces de asserção expressivas e legíveis, como should, expect e assert. Já o Chai-HTTP, uma extensão do Chai, fornece uma interface projetada especificamente para testar solicitações HTTP e confirmar suas respostas.

Ao usar Mocha em conjunto com Chai e Chai-HTTP, você pode testar APIs de forma eficaz. O fluxo de trabalho de teste envolve:

  • Fazer solicitações HTTP para os endpoints de API especificados.
  • Definição das respostas esperadas.
  • Validando os dados recebidos da fonte especificada, os códigos de status HTTP e muito mais.

Você também pode simular cenários de teste de erro de API que podem surgir em tais situações e quais ações devem ser acionadas caso ocorram.

Você pode encontrar o código deste projeto em seu Repositório GitHub.

Configurar o projeto Express.js e o banco de dados MongoDB

Para começar, criar um servidor web Expresse instale estes pacotes:

npm instalar cors dotenv mongoose mongodb

Próximo, criar um banco de dados MongoDB ou configurar um cluster MongoDB na nuvem. Em seguida, copie a URL de conexão do banco de dados, crie um .env arquivo no diretório raiz e cole na string de conexão do banco de dados:

CONNECTION_STRING="string de conexão"

Para finalizar o processo de configuração, você precisa configurar a conexão do banco de dados e definir os modelos de dados para seus dados de usuário. Consulte o código no repositório GitHub deste projeto para:

  • Configure a conexão do banco de dados, em utils/db.js.
  • Defina o esquema de dados do usuário em modelos/usuário.model.js.

Defina as funções do manipulador para as rotas da API

As funções do controlador irão gerenciar a adição e recuperação de dados do usuário no banco de dados. Para garantir a funcionalidade dessas funções do manipulador, você testará se elas podem postar e buscar dados do banco de dados com êxito.

No diretório raiz, crie um controllers/userControllers.js arquivo e adicione o seguinte código:

const Usuário = exigir('../models/user.model');
exports.registerUser = assíncrono (req, res) => {
const { nome de usuário, senha } = req.body;


tentar {
aguardam User.create({ nome de usuário, senha});
 res.status(201).enviar({ mensagem: 'Usuário cadastrado com sucesso' });
 } pegar (erro) {
console.log (erro);
 res.status(500).enviar({ mensagem: 'Um erro ocorreu!! ' });
 }
};
exports.getUsers = assíncrono (req, res) => {
tentar {
const usuários = aguardam User.find({});
 res.json (usuários);
 } pegar (erro) {
console.log (erro);
 res.status(500).enviar({ mensagem: 'Um erro ocorreu!!' });
 }
};

Definir as rotas da API

Crie um novo rotas/userRoutes.js arquivo no diretório raiz e adicione o seguinte código.

const expresso = exigir('expressar');
const roteador = expresso. Roteador();
const userControllers = exigir('../controllers/userControllers');
roteador.post('/api/registro', userControllers.registerUser);
router.get('/api/usuários', userControllers.getUsers);
módulo.exports = roteador;

Defina o ponto de entrada do seu servidor

Atualize seu server.js arquivo com o seguinte código.

const expresso = exigir('expressar');
const cors = exigir('cors');
const aplicativo = expresso();
const porta = 5000;
exigir('dotenv').config();
const conectarDB = exigir('./utils/db');
conectarDB();


app.use (express.json());
app.use (express.urlencoded({ estendido: verdadeiro }));
app.use (cors());


const userRoutes = exigir('./routes/userRoutes');
app.use('/', userRoutes);


app.listen (porta, () => {
console.registro(`Servidor está escutando em http://localhost:${porta}`);
});
módulo.exports = aplicativo;

Escreva e execute os casos de teste com o Mocha

Com a API do usuário instalada, vá em frente e configure o ambiente de teste. Primeiro, instale esses pacotes como dependências de desenvolvimento.

npm instalar mocha chai chai-http --save-dev

Agora, adicione o seguinte script ao seu arquivo package.json.

"scripts": {
"teste": "mocha --timeout 10000"
},

Este comando executará os casos de teste — adicionar a propriedade timeout com um valor apropriado permite que você controle o tempo máximo permitido para a execução de casos de teste individuais.

Isso pode ser útil para evitar que os testes sejam executados indefinidamente ou sejam concluídos muito rapidamente antes que os casos de teste sejam concluídos.

Testar os endpoints da API

No diretório raiz, crie uma nova pasta e nomeie-a teste. Dentro desta pasta, crie um novo usuário.testes.js e adicione o código a seguir para o caso de teste do terminal POST.

const chai = exigir('chai');
const chaiHttp = exigir('chai-http');
const aplicativo = exigir('../servidor'); 
chai.use (chaiHttp);
const esperar = chai.esperar;


descrever('API do usuário', () => {
 descrever('POST /API/registro', () => {
 isto('deve lidar com o registro do usuário', (concluído) => {
 chai.request (aplicativo)
 .publicar('/api/registro')
 .enviar({ nome de usuário: 'testUser', senha: 'senha de teste' })
 .fim((erro, res) => {
se (err) {
 esperar (res).to.have.status(500);
 esperar (res.body).to.have.property('mensagem').isto.é.igual('Um erro ocorreu!!');
 } outro {
 esperar (res).to.have.status(201);
 esperar (res.body).to.have.property('mensagem').igual('Usuário cadastrado com sucesso');
 }
 feito();
 });
 });
 });
});

Este código define um caso de teste usando Chai e Chai HTTP para testar a funcionalidade de registro do usuário da API do usuário.

Ele envia uma solicitação POST para o endpoint especificado e faz asserções sobre a resposta esperada da API, verificando se a funcionalidade de registro do usuário foi bem-sucedida ou se ocorreu um erro.

Aqui está uma análise dos principais componentes do caso de teste:

  • esperar -Este objeto permite que você use os métodos de asserção Chai para fazer asserções sobre a resposta esperada da API.
  • descrever - Descreve casos de teste relacionados em conjunto, neste caso, testes relacionados ao API do usuário. O bloco de descrição aninhada agrupa casos de teste relacionados, neste caso, o POST /api/register. Isso ajuda a organizar os casos de teste especificamente relacionados a uma determinada funcionalidade.
  • isto - Esta função descreve o comportamento esperado do endpoint da API.
  • fim - Esta função envia a solicitação e fornece uma função de retorno de chamada para lidar com a resposta. A função de retorno de chamada executa asserções usando o esperar função para verificar a resposta recebida da API.
  • feito - Esta função é executada para marcar o final do caso de teste.

Por fim, adicione o código para o caso de teste de terminal GET logo após o caso de teste de terminal POST.

descrever('GET /api/usuários', () => {
 isto('deve buscar todos os dados do usuário', (concluído) => {
 chai.request (aplicativo)
 .pegar('/api/usuários')
 .fim((erro, res) => {
se (err) {
 esperar (res).to.have.status(500);
 esperar (res.body).to.have.property('mensagem').isto.é.igual('Ocorreu um erro ao buscar os dados do usuário');
 } outro {
 esperar (res).to.have.status(200);
 esperar (res.body).to.be.an('variedade');
 }
 feito();
 });
 });
});

Vá em frente e execute o script de teste em seu terminal para executar os dois casos de teste.

teste npm

Se a execução dos casos de teste não encontrar nenhum erro, você deverá ver uma saída semelhante indicando que os testes foram bem-sucedidos.

Falhas de teste podem ocorrer devido a vários motivos, como problemas de conectividade de rede durante solicitações HTTP para o banco de dados, falta de dados necessários, erros lógicos e outros problemas.

O Mocha faz um bom trabalho ao identificar e destacar esses erros, fornecendo relatórios de teste claros e detalhados nos logs exibidos na janela do terminal. Isso permite que você identifique e diagnostique facilmente os problemas específicos que causaram as falhas de teste.

Mocha não oferece desculpas para não testar suas APIs

Embora testar manualmente a funcionalidade de suas APIs usando ferramentas como o Postman seja um teste válido abordagem, alavancar o Mocha e outras estruturas de teste para testes automatizados leva para o próximo nível.

Com essas ferramentas de teste, você pode automatizar testes de forma rápida e fácil para cobrir uma ampla variedade de cenários e casos extremos. Isso permite detectar bugs rapidamente e resolvê-los antes de implantar suas APIs, garantindo o envio de software de alta qualidade para produção.