Testes automatizados são fundamentais para garantir a qualidade e a robustez do software. Mas no ecossistema Node.js, Mocha e Chai são duas ferramentas amplamente utilizadas para testes. Mocha é um framework de teste flexível e extensível, enquanto Chai é uma biblioteca de asserções que facilita a escrita de testes. Portanto neste guia, vamos explorar como configurar e utilizar Mocha e Chai para escrever e executar testes automatizados em projetos Node.js.

Pré-requisitos

Antes de começarmos, certifique-se de ter:

• Node.js e npm instalados no seu sistema.
• Conhecimento básico de JavaScript e Node.js.
• Familiaridade com conceitos de testes de software.

Passo 1: Configurando o Ambiente

1. Inicializando o Projeto

Crie um novo diretório para o seu projeto e inicialize um novo projeto Node.js.

mkdir nodejs-testing
cd nodejs-testing
npm init -y

2. Instalando Mocha e Chai

Instale Mocha e Chai como dependências de desenvolvimento.

npm install --save-dev mocha chai

Passo 2: Escrevendo o Primeiro Teste

3. Estrutura do Projeto

Crie a seguinte estrutura de diretórios e arquivos:

nodejs-testing/
├── src/
│   └── calculator.js
└── test/
    └── calculator.test.js

4. Implementando o Módulo

Crie um arquivo calculator.js dentro da pasta src e implemente uma função simples de adição.

// src/calculator.js
function add(a, b) {
  return a + b;
}

module.exports = { add };

5. Escrevendo o Teste

Crie um arquivo calculator.test.js dentro da pasta test e escreva um teste para a função de adição.

// test/calculator.test.js
const { expect } = require('chai');
const { add } = require('../src/calculator');

describe('Calculator', () => {
  describe('add', () => {
    it('should return the sum of two numbers', () => {
      const result = add(2, 3);
      expect(result).to.equal(5);
    });
  });
});

Passo 3: Executando os Testes

6. Adicionando um Script de Teste

Adicione um script de teste no arquivo package.json.

"scripts": {
  "test": "mocha"
}

7. Rodando os Testes

Execute os testes usando o comando npm.

npm test

Testes Avançados

8. Testando Funções Assíncronas

Mocha suporta a execução de testes assíncronos utilizando callbacks ou async/await. Vamos modificar o calculator.js para incluir uma função de adição assíncrona.

// src/calculator.js
function add(a, b) {
  return a + b;
}

function addAsync(a, b) {
  return new Promise((resolve) => {
    setTimeout(() => resolve(a + b), 100);
  });
}

module.exports = { add, addAsync };

Atualize o arquivo de teste para incluir testes assíncronos.

// test/calculator.test.js
const { expect } = require('chai');
const { add, addAsync } = require('../src/calculator');

describe('Calculator', () => {
  describe('add', () => {j
    it('should return the sum of two numbers', () => {
      const result = add(2, 3);
      expect(result).to.equal(5);
    });
  });

  describe('addAsync', () => {
    it('should return the sum of two numbers asynchronously', async () => {
      const result = await addAsync(2, 3);
      expect(result).to.equal(5);
    });
  });
});

9. Testando Erros

Chai também permite que você verifique se uma função lança um erro esperado.

// src/calculator.js
function subtract(a, b) {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new Error('Both arguments must be numbers');
  }
  return a - b;
}

module.exports = { add, addAsync, subtract };

Adicione testes para a função de subtração que lança um erro.

// test/calculator.test.js
const { expect } = require('chai');
const { add, addAsync, subtract } = require('../src/calculator');

describe('Calculator', () => {
  describe('add', () => {
    it('should return the sum of two numbers', () => {
      const result = add(2, 3);
      expect(result).to.equal(5);
    });
  });

  describe('addAsync', () => {
    it('should return the sum of two numbers asynchronously', async () => {
      const result = await addAsync(2, 3);
      expect(result).to.equal(5);
    });
  });

  describe('subtract', () => {
    it('should return the difference of two numbers', () => {
      const result = subtract(5, 3);
      expect(result).to.equal(2);
    });

    it('should throw an error if arguments are not numbers', () => {
      expect(() => subtract(5, 'a')).to.throw('Both arguments must be numbers');
    });
  });
});

Integração Contínua

10. Configurando GitHub Actions

Você pode configurar um fluxo de trabalho de integração contínua (CI) com GitHub Actions para executar seus testes automaticamente a cada commit.

Crie um arquivo .github/workflows/nodejs.yml com a seguinte configuração:

name: Node.js CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [14.x, 16.x]

    steps:
      - name: Checkout repository
        uses: actions/checkout@v2

      - name: Setup Node.js
        uses: actions/setup-node@v2
        with:
          node-version: ${{ matrix.node-version }}

      - name: Install dependencies
        run: npm install

      - name: Run tests
        run: npm test

Conclusão

Testes automatizados são essenciais para a qualidade do software. Em conclusão Mocha e Chai fornecem uma combinação poderosa para escrever e executar testes em Node.js. Portanto neste guia, cobrimos desde a configuração do ambiente até a escrita e execução de testes básicos e avançados. Implementar testes automatizados em seu fluxo de desenvolvimento ajuda a detectar e corrigir erros rapidamente, garantindo que seu software funcione conforme o esperado.

---