O Desenvolvimento Orientado a Comportamento (BDD) mudou fundamentalmente a forma como as equipes pensam sobre a qualidade do software, tornando os testes legíveis para todos! Usar Cucumber para testes BDD é uma habilidade que preenche a lacuna entre os requisitos de negócio e a implementação técnica, criando uma documentação viva que realmente é executada. Se você já teve problemas com casos de teste que se tornaram desatualizados no momento em que foram escritos, este guia mostrará uma maneira melhor.
O que é Cucumber e BDD?
Cucumber é uma ferramenta de código aberto que executa testes automatizados escritos em linguagem simples. Ele implementa o Desenvolvimento Orientado a Comportamento (BDD), uma metodologia onde desenvolvedores, testadores e stakeholders de negócios colaboram para definir o comportamento do software usando exemplos concretos.
BDD foca em responder a uma pergunta: "O que o sistema deve fazer?" em vez de "Como devemos testá-lo?". O resultado é uma linguagem compartilhada que elimina mal-entendidos e cria testes que servem tanto como especificações quanto como validação executável.
Cucumber lê arquivos .feature contendo cenários escritos na sintaxe Gherkin e os executa contra definições de passo—código que realiza a automação real. Essa separação significa que os stakeholders de negócios podem revisar os cenários de teste sem ler código, enquanto os desenvolvedores implementam os detalhes técnicos separadamente.
Instalando Cucumber para JavaScript
Configurar o Cucumber em um projeto Node.js leva apenas alguns comandos:
Pré-requisitos:
- Node.js
- NPM
- Um projeto de API que tenha um recurso de login que testaremos (Este tutorial cobrirá apenas a instalação do Cucumber e testes Gherkin).
# Crie um novo diretório de projeto
mkdir cucumber-bdd-demo && cd cucumber-bdd-demo
# Inicialize o npm
npm init -y
# Instale Cucumber e dependências de teste
npm install --save-dev @cucumber/cucumber chai axios
Seu package.json deve incluir um script de teste:
{
"scripts": {
"test": "cucumber-js"
}
}
Crie esta estrutura de diretórios:
project/
├── features/
│ └── user-management.feature
├── step-definitions/
│ └── user-steps.js
├── package.json
└── cucumber.json
Guia Prático: Escrevendo Seu Primeiro Teste BDD
Vamos construir um teste para uma API de gerenciamento de usuários para demonstrar Como Usar Cucumber para Testes BDD na prática.
Passo 1: Escreva o Arquivo Feature
Crie features/user-management.feature:
Funcionalidade: API de Gerenciamento de Usuários
Como um cliente de API
Eu quero gerenciar usuários
Para que eu possa integrar a funcionalidade de usuário em minha aplicação
Cenário: Criar um novo usuário com sucesso
Dado que eu tenho um payload de usuário válido
Quando eu envio uma requisição POST para "/api/users"
Então o status da resposta deve ser 201
E a resposta deve conter um ID de usuário
Cenário: Tentar criar usuário com e-mail inválido
Dado que eu tenho um payload de usuário com e-mail inválido
Quando eu envio uma requisição POST para "/api/users"
Então o status da resposta deve ser 400
E a resposta deve conter "Formato de e-mail inválido"
Passo 2: Implemente as Definições de Passo
Crie step-definitions/user-steps.js:
const { Given, When, Then } = require('@cucumber/cucumber');
const { expect } = require('chai');
const axios = require('axios');
let requestPayload;
let response;
Given('I have a valid user payload', function() {
requestPayload = {
name: 'Test User',
email: 'test@example.com',
password: 'ValidPass123'
};
});
Given('I have a user payload with invalid email', function() {
requestPayload = {
name: 'Test User',
email: 'invalid-email',
password: 'ValidPass123'
};
});
When('I send a POST request to {string}', async function(endpoint) {
try {
response = await axios.post(`http://localhost:3000${endpoint}`, requestPayload);
} catch (error) {
response = error.response;
}
});
Then('the response status should be {int}', function(statusCode) {
expect(response.status).to.equal(statusCode);
});
Then('the response should contain a user ID', function() {
expect(response.data).to.have.property('userId');
expect(response.data.userId).to.match(/^[0-9a-fA-F]{24}$/);
});
Then('the response should contain {string}', function(message) {
expect(response.data.message).to.include(message);
});
Passo 3: Edite o arquivo cucumber.json
Crie um arquivo "cucumber.json" no diretório raiz do seu projeto e adicione o seguinte código:
{
"default": {
"formatOptions": {
"snippetInterface": "synchronous"
}
}
}Passo 4: Execute os Testes
Execute seus testes com:
npm test
O Cucumber exibirá resultados detalhados mostrando quais passos foram aprovados, estão indefinidos ou falharam.
Regras para Escrever Bons Cenários BDD
Aprender Como Usar Cucumber para Testes BDD de forma eficaz requer seguir estas regras comprovadas:
1. Estrutura Dado-Quando-Então (Given-When-Then)
Todo cenário deve ter estas três partes em ordem:
- Dado: Configura as pré-condições
- Quando: Descreve a ação
- Então: Valida o resultado
2. Escreva Declarativamente, Não Imperativamente
Ruim:
Dado que eu abro o navegador
E eu navego para "/login"
E eu digito "test@example.com" no campo de e-mail
E eu digito "senha" no campo de senha
E eu clico no botão de login
Bom:
Dado que eu estou na página de login
Quando eu faço login com credenciais válidas
Então eu devo ver o painel
Concentre-se no que você está testando, não em como você faz isso.
3. Um Cenário, Um Propósito
Cada cenário deve testar um único comportamento. Cenários combinados escondem falhas e dificultam a depuração.
4. Use Linguagem de Negócios
Escreva cenários que os stakeholders de negócios possam entender. Evite jargões técnicos e detalhes de implementação.
5. Torne os Cenários Independentes
Os cenários não devem depender uns dos outros. Cada um deve configurar seus próprios dados e limpar depois.
Recursos Avançados do Cucumber: Tabelas de Dados e Outlines de Cenários
Tabelas de Dados para Entrada Complexa
Quando você precisa testar com múltiplos pontos de dados, use tabelas:
Cenário: Criar usuários com diferentes papéis
Dado que eu tenho os seguintes dados de usuário:
| nome | email | papel |
| Alice | alice@example.com | admin |
| Bob | bob@example.com | usuário |
Quando eu envio uma requisição POST para "/api/users"
Então todos os usuários devem ser criados com sucesso
Definição de passo:
Given('I have the following user data:', function(dataTable) {
requestPayload = dataTable.hashes();
});
Outlines de Cenários para Testes Orientados a Dados
Quando você deseja executar o mesmo cenário com dados diferentes, use outlines:
Outline de Cenário: Login com várias credenciais
Dado que eu estou na página de login
Quando eu digito "<email>" e "<password>"
Então eu devo ver "<result>"
Exemplos:
| email | password | result |
| test@example.com | validPass | Painel |
| test@example.com | wrongPass | Senha inválida |
| invalid@email.com | validPass | E-mail inválido |
Isso cria automaticamente três cenários de teste separados.
Organizando Testes com Tags
Tags ajudam você a categorizar e filtrar cenários:
@smoke @regression
Cenário: Login de usuário
Dado que eu estou na página de login
Quando eu faço login com credenciais válidas
Então eu devo ver o painel
@api @critical
Cenário: Verificação de saúde da API
Dado que a API está funcionando
Quando eu solicito "/health"
Então o status da resposta deve ser 200
Execute apenas tags específicas:
npm test -- --tags "@smoke"
Como Apidog Ajuda com Testes de API em Fluxos de Trabalho BDD
Enquanto o Cucumber se destaca na definição de comportamento, o Apidog automatiza o trabalho pesado de criação e execução de testes de API, tornando o Cucumber para testes BDD muito mais eficiente.
Geração de Casos de Teste de API Impulsionada por IA
Em vez de escrever manualmente as definições de passo para chamadas de API, o Apidog as gera a partir de sua especificação OpenAPI usando IA:
# Sua especificação de API
paths:
/api/users:
post:
requestBody:
content:
application/json:
schema:
type: object
properties:
name: string
email: string
responses:
'201':
description: Usuário criado
Apidog cria automaticamente cenários prontos para teste:
- Teste positivo: Payload válido → status 201
- Teste negativo: E-mail inválido → status 400
- Teste de limite: Campo obrigatório ausente → status 400
Perguntas Frequentes
P1: Preciso saber programação para escrever testes Cucumber?
Resp: Escrever cenários Gherkin não exige codificação—apenas um pensamento claro sobre o comportamento. No entanto, implementar definições de passo requer conhecimento de JavaScript (ou outra linguagem). Ferramentas como o Apidog reduzem essa carga gerando automaticamente o código das definições de passo.
P2: Como o Cucumber se difere dos frameworks de teste tradicionais?
Resp: Frameworks tradicionais (Jest, Mocha) focam na implementação técnica. O Cucumber foca no comportamento de negócios. O mesmo cenário Cucumber pode impulsionar testes de UI web (Selenium), testes de API (Axios) ou testes móveis (Appium) sem alterar o texto Gherkin.
P3: O Cucumber pode substituir ferramentas de teste de API?
Resp: O Cucumber fornece a estrutura de teste, mas você ainda precisa de ferramentas para executar chamadas de API (Axios, Supertest) e validar respostas. O Apidog complementa o Cucumber ao lidar com a camada de execução da API, enquanto o Cucumber gerencia o fluxo de trabalho BDD.
P4: O que torna um cenário Cucumber bom?
Resp: Bons cenários são independentes, usam linguagem de negócios, seguem a estrutura Dado-Quando-Então e testam um comportamento por vez. Eles devem ser legíveis por stakeholders não técnicos e focar no que o sistema faz, não em como ele faz.
P5: Como o Apidog lida com a autenticação em testes BDD?
Resp: O Apidog gerencia tokens de autenticação automaticamente. Você pode definir passos como "Dado que estou autenticado" que usam o gerenciamento de credenciais do Apidog para recuperar tokens válidos, eliminando o manuseio manual de tokens em suas definições de passo.
Conclusão
Usar Cucumber para testes BDD transforma efetivamente seu processo de desenvolvimento, criando um entendimento compartilhado entre equipes técnicas e de negócios. A sintaxe Gherkin força a clareza, enquanto a separação de cenários e definições de passo mantém os testes fáceis de manter à medida que sua aplicação evolui.
O verdadeiro poder vem da integração do Cucumber com ferramentas de automação modernas. O Apidog elimina o trabalho manual tedioso de escrever código de teste de API, permitindo que você se concentre na definição de comportamentos significativos enquanto ele lida com a execução. Essa combinação oferece o melhor dos dois mundos: especificações legíveis por humanos que servem como documentação viva e testes automatizados robustos que são executados continuamente.
Comece pequeno. Escolha um endpoint de API. Escreva três cenários: sucesso, falha e caso de limite. Implemente as definições de passo. Execute-os. Mostre os resultados ao seu product owner. Uma vez que eles vejam os requisitos de negócio executados como testes, você terá o apoio para expandir o BDD para todo o seu projeto. É então que usar Cucumber para testes BDD deixa de ser uma prática técnica e se torna um movimento de qualidade em toda a equipe.