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! ✌️✨