No desenvolvimento de software, a qualidade do produto final é essencial. Para garantir essa qualidade, utilizamos testes eficazes. Hoje, vamos explorar um tipo específico de teste: o teste funcional, também conhecido como teste de caixa-preta (black-box).
O que é o Teste Funcional ou Caixa-Preta?
Imagine testar uma caixa fechada: você sabe o que entra e o que deve sair, mas não precisa se preocupar com o que acontece dentro dela. Esse é o princípio por trás do teste funcional.
No teste de caixa-preta, o objetivo é verificar se o sistema funciona conforme esperado, sem olhar para o código interno. Aqui estão alguns pontos importantes:
- Foco externo: O teste funcional olha para o comportamento do software de fora, verificando se ele faz o que deveria.
- Baseado em requisitos: Os testes são projetados com base nos requisitos e especificações do software.
- Entrada e saída: Você fornece entradas ao sistema e verifica se as saídas estão corretas, sem precisar saber como o sistema processa essas entradas internamente.
- Verificação de conformidade: O teste verifica se cada funcionalidade está de acordo com o que foi especificado.
Em resumo, no teste de caixa-preta, você não olha o código. Você se concentra nas entradas e saídas, sem se preocupar com o que acontece por dentro.
Onde os Testes Funcionais podem ser aplicados?
Essa técnica pode ser usada em vários níveis de teste, como:
- Testes Unitários: Testa partes específicas do software, como funções ou métodos.
- Testes de Integração: Verifica se diferentes partes do sistema funcionam bem juntas.
- Testes de Sistema: Testa o sistema completo para garantir que ele funcione como um todo.
- Testes de Aceitação: Garantem que o sistema atenda às expectativas do usuário final.
A seguir, vamos aplicar a técnica black-box nos códigos, usando os critérios mais populares de teste de software com JavaScript.
Como planejar os testes?
Para realizar bons testes, é necessário escolher os valores certos para testar. Isso é feito criando casos de teste, que são cenários projetados para verificar se o software está funcionando conforme o esperado.
O que é um caso de teste?
Um caso de teste é um conjunto de condições e variáveis que determinam se o software está funcionando corretamente. A ideia é perguntar: "O software está fazendo o que deveria?".
Como encontrar todas as falhas de um software?
Para garantir que o software funcione corretamente e encontrar o maior número de falhas possível, precisamos criar um conjunto de casos de teste eficaz, que deve ser:
- Finito e factível;
- Capaz de revelar o maior número de falhas perceptíveis;
- Capaz de revelar as falhas mais críticas ou relevantes do software.
Critérios de Teste
Os critérios de teste são regras que determinam o que precisa ser verificado nos testes. Esses critérios ajudam a garantir que os testes cubram os cenários mais importantes e críticos.
1. Classe de Equivalência
As classes de equivalência dividem os dados de entrada em grupos onde o comportamento do software deve ser igual para todos os membros. Ou seja, se um teste em uma classe funcionar, espera-se que todos os testes nessa classe se comportem da mesma forma.
Por exemplo, em uma calculadora, podemos dividir as operações em classes de equivalência: soma, subtração, multiplicação e divisão. Em cada operação, esperamos que todos os valores válidos se comportem da mesma maneira.
// arquivo: tests/calculadora.test.js
const calculadora = require('../calculadora');
test('verifica se a soma de 2 + 2 é igual a 4', () => {
expect(calculadora.soma(2, 2)).toBe(4);
});
test('verifica se a subtração de 5 - 2 é igual a 3', () => {
expect(calculadora.subtrai(5, 2)).toBe(3);
});
test('verifica se a multiplicação de 3 * 3 é igual a 9', () => {
expect(calculadora.multiplica(3, 3)).toBe(9);
});
test('verifica se a divisão de 10 / 2 é igual a 5', () => {
expect(calculadora.divide(10, 2)).toBe(5);
});
2. Análise de Valor-Limite
A análise de valor-limite complementa as classes de equivalência, verificando os extremos dos intervalos de entrada. Isso é importante porque muitos erros ocorrem nos limites dos dados.
No exemplo da calculadora, podemos testar a função de divisão para garantir que:
- A divisão de um número positivo por outro positivo funcione corretamente.
- A divisão por zero retorne um erro, como esperado.
- A divisão de números negativos e positivos funcione corretamente.
// arquivo: tests/calculadora.test.js
const calculadora = require('../calculadora');
// análise valor-limite para a operação de divisão
test('verifica se a divisão de 10 / 2 é igual a 5', () => {
expect(calculadora.divide(10, 2)).toBe(5);
});
test('verifica se a divisão de 10 / 0 retorna um erro', () => {
expect(() => calculadora.divide(10, 0)).toThrow('Divisão por zero não é permitida');
});
test('verifica se a divisão de -10 / 2 é igual a -5', () => {
expect(calculadora.divide(-10, 2)).toBe(-5);
});
test('verifica se a divisão de 10 / -2 é igual a -5', () => {
expect(calculadora.divide(10, -2)).toBe(-5);
});
3. Análise de Causa-efeito
A análise de causa-efeito examina a relação entre entradas (causas) e saídas (efeitos). O objetivo é verificar se a entrada correta gera a saída esperada.
Causas:
- Cada item no carrinho tem um preço.
- O carrinho pode conter vários itens.
- Pode haver itens com quantidades diferentes ou preços diferentes.
Efeito:
- O total do carrinho deve ser calculado corretamente com base nos preços e quantidades dos itens.
Para demonstrar a análise de causa-efeito, vamos criar diferentes causas (como carrinhos com diferentes combinações de itens) e observar os efeitos (o total calculado corretamente).
// arquivo: tests/calculaTotal.test.js
const calculaTotal = require('../calculaTotal');
test('verifica se o total do carrinho é calculado corretamente', () => {
const carrinho = [
{ item: 'Camiseta', preco: 50 },
{ item: 'Calça', preco: 100 },
{ item: 'Sapato', preco: 200 },
];
expect(calculaTotal(carrinho)).toBe(350);
});
Conclusão: A Jornada do Teste Funcional
O teste funcional é uma ferramenta essencial para garantir que o software esteja funcionando corretamente. Ao aplicar critérios como classes de equivalência, análise de valor-limite e análise de causa-efeito, você pode encontrar falhas e garantir a qualidade do seu software.
Este artigo foi inspirado nas minhas anotações do curso de Teste de Software, em que fui aluna especial no mestrado da USP, com o professor Dr. Marcelo Eler. Espero que tenha sido útil para você e ajude na sua jornada no mundo dos testes de software. Até a próxima! ✌️✨
Top comments (0)