Como você pode testar seus aplicativos Node.js com Ava.js

Por que você deseja escrever casos de teste para seus aplicativos, afinal? Bem, é uma questão que vários desenvolvedores tentam evitar, simplesmente porque exige esforço e tempo, e porque o teste manual é muito mais satisfatório. Clique… clique… preencha um formulário… Clique… Presto. Meu aplicativo funciona, minhas APIs são boas, tudo está ótimo.

Avance para quase 30 solicitações pull por dia sendo mescladas em seu branch master. Agora, como você se sente sobre testar 30 recursos manualmente ou refatorar um bloco de código e quebrar o código de outra pessoa sem saber?

Nesse ponto, você normalmente diria: “Gostaria de ter escrito alguns casos de teste para começar”. Então, inspire-se no Facebook: eles compartilharam um artigo muito legal aqui, explicando como a equipe desenvolveu o React 16 com desenvolvimento dirigido por teste.

Os aplicativos de nó por si só são muito fáceis de construir. Há muito apoio da comunidade envolvido, e você normalmente conseguirá o que precisa perguntando por aí. Os aplicativos de nó podem ser um ótimo servidor proxy para vários servidores de API, tornando o teste de endpoint mais crucial.

Neste artigo eu cobri como configurar e escrever casos de teste de unidade básica com relatórios de cobertura para aplicações Node.js .Então, vamos começar.

Ola ava

Ava é um executor de teste de JavaScript. Ele utiliza a natureza de E / S assíncrona do Node e executa testes simultâneos, diminuindo assim enormemente os tempos de teste.

Vamos começar

No seu diretório de trabalho, crie um package.jsonarquivo e adicione os seguintes pacotes:

yarn add ava babel-register

Crie uma pasta de testes . É útil manter seus testes em um só lugar. Você pode manter os módulos / controladores de teste lá também.

Sua atualização package.jsonagora deve ter a seguinte aparência:

{ "name": "ava-test", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "start" : "node server.js", "test": "node_modules/.bin/ava tests/**/*.test.js --verbose", "test:watch": "node_modules/.bin/ava --verbose --watch" }, "dependencies": { "ava": "^0.23.0", "babel-register": "^6.26.0" }, "ava": { "require": [ "babel-register" ] }}

O babel-registercódigo ES6 transpila em tempo de execução no caso de algumas máquinas estarem executando em uma versão antiga do Node que não suporta ES6. O verbosesinalizador nos dará uma saída interessante dependendo se nossos testes falham ou passam. Este sinalizador é muito útil ao depurar seus testes, mas se você escrever centenas de casos de teste, pode querer desligá-lo.

No seu tests/index.test.js, você pode adicionar seu primeiro caso de teste:

A vantagem do Ava é que ele permite que você execute testes assíncronos por meio de funções de espera assíncronas. A sintaxe também é bastante direta. O método de plano nos permite mencionar explicitamente o número de asserções que gostaríamos de ter por teste.

Executar a yarn testpartir de seu console fornece a seguinte saída:

No caso de um de nossos testes falhar, obteríamos:

Essa é a beleza do verbosemodo. Ele fornece uma pilha de erros limpa e nenhum lixo de rastreamento de pilha. No caso de você encontrar um erro de tempo de execução, verá alguns bons realces de sintaxe também.

Você pode realmente explorar a API Ava e usar sua poderosa ferramenta de asserção para escrever casos de teste flexíveis.

Configurando seu servidor Node

Até agora, falamos apenas sobre uma configuração básica para escrever testes - e sejamos francos, é bastante simples. Portanto, nesta seção, explicarei como um servidor Node simples pode ser desmembrado e seus endpoints testados com Ava.

yarn add express body-parser 

Em seu diretório de trabalho, crie um app.jse adicione o seguinte snippet:

O motivo pelo qual exportei o módulo de aplicativo é para que ele possa ser usado com o servidor de API simulado de que Ava precisará para executar seus testes.

Faça um novo arquivo server.jse importe o módulo de app para iniciar o servidor.

A execução de npm start deve iniciar seu servidor e navegar até o ponto final // localhost / status deve fornecer uma resposta 200OK.

Ótimo, então nosso servidor está funcionando.

Uma rápida olhada no código mostra que criamos 3 endpoints: um endpoint de status, um endpoint de saudação e um endpoint de registro. Há alguma validação no ponto final do registro, o que gera um 400 (solicitação incorreta) no caso de os parâmetros do corpo do post estarem ausentes. O método de validação acima é bastante ingênuo, mas serve ao nosso propósito de teste de endpoint - então, vou ficar com ele.

Dica profissional: você sempre pode atribuir tratamento de erros a um middleware e usar next para invocar o tratador de erros.

Vamos escrever mais alguns testes em torno do endpoint. Vou usar o supertestemódulo. É muito semelhante ao superagent: usa as mesmas APIs e tem uma sintaxe semelhante. Então, ganha-ganha.

Importamos o appmódulo exportado anteriormente e o passamos para o superteste. Supertest cria um servidor proxy, que então acessa todos os URLs de endpoint mencionados no teste. Você pode usar o deepEqualmétodo para testar o objeto inteiro ou o ismétodo para testar manualmente cada campo.

Executar o teste de fio resultará no seguinte:

Ótimo. Escrevemos quatro testes e todos eles foram aprovados conforme o esperado. Mas e quanto à cobertura de código?

Ola nyc

Para criar esses lindos relatórios de cobertura, usaremos nyc, que é a interface de linha de comando do Istanbul.js. É muito fácil de usar e tem várias opções configuráveis. Para simplificar, usaremos uma configuração muito simples.

yarn add nyc --save

O comando nyc envolve bem o seu comando de teste e criará uma pasta de cobertura (deve estar em seu gitignore) em seu diretório de trabalho.

Atualize seu package.jsonconforme mostrado abaixo:

{ "name": "ava-test", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "node_modules/.bin/ava tests/**/*.test.js --verbose", "test:watch": "node_modules/.bin/ava --verbose --watch", "cover": "node_modules/.bin/nyc yarn test", }, ... other dependencies "nyc": { "reporter": [ "lcov", "text", "html" ] }}

Os tipos de repórter que você deseja podem ser configurados na seção nyc de seu package.jsonarquivo.

Vamos executar a capa do fio:

Ok, então não temos 100% de cobertura ainda. Vamos consertar isso. Primeiro, você deseja ir para a pasta de cobertura do seu diretório de trabalho e ver qual parte do seu código não foi coberta.

Claramente perdemos um ponto. Vamos adicionar nosso caso de teste final ao tests/index.tests.jsarquivo, que cobrirá todo o app.jsarquivo.

test('Create a new user', async t => { let username = 'some-hase' const password = 'some-hase' const response = await request(app) .post('/register') .send({username, password});
t.is(response.status, 200); t.is(response.body.message, `new user created`);});

E agora….

Presto.

Dica profissional: se você deseja adicionar um limite para casos de teste, você pode adicionar um script em seu arquivo package.json.
"check-coverage": "node_modules/.bin/nyc check-coverage --lines 100 --functions 100 --branches 100 --statements 100"

Este comando pode ser executado como parte de seus sistemas de construção de pipeline travis / gitlab.

Conclusão

Cobrimos uma configuração básica com Ava para casos de teste de unidade de APIs do seu Node. A documentação é bastante extensa e pode ser consultada em caso de dúvida.

PS: Espero que gostem do artigo, corrija-me se estiver errado em algum lugar. Sempre seja bem-vindo uma discussão.