Teste Funcional ou Caixa-Preta (Black-box): Uma Introdução descomplicada

No mundo do desenvolvimento de software, a qualidade do produto final é de extrema importância. Uma das maneiras de garantir essa qualidade é através de testes eficazes. Hoje, vamos falar sobre um tipo específico de teste: o teste funcional, também conhecido como teste de caixa-preta.

O que é um caso de teste?

Um caso de teste é uma verificação da ação ou comportamento do software. Estamos essencialmente perguntando: "O software está fazendo? O que é esperado?"

Como encontrar todas as falhas de um software?

Para encontrar todas as falhas e garantir que o software funcione como esperado, precisamos de um conjunto de casos de teste de qualidade ótima. Um bom conjunto de casos de teste 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 definem os requisitos que os casos de teste devem satisfazer. São estabelecidos para garantir que os casos de teste sejam capazes de revelar falhas perceptíveis e críticas no software. Alguns mais conhecidos vamos ver a seguir.

Classe de Equivalência

As classes de equivalência são uma técnica de teste que divide o conjunto de entrada de um software em partições de dados equivalentes, ou seja, um conjunto de dados onde se espera que o comportamento do software seja o mesmo. Cada partição é chamada de classe de equivalência. Se acaso dois testes que pertencem a uma mesma classe pode ser considerada redundante. Podemos dizer também que uma classe de equivalência é uma categoria ou tipo.

Um exemplo com um programa de calculadora simples, é viável dividir cada operação aritmética (como soma, subtração, multiplicação e divisão), em classes de equivalência distintas. Em um contexto de desenvolvimento em JavaScript, pode ser implementada da seguinte 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);
});

Análise de Valor-Limite

A análise de valor-limite é um complemento às classes de equivalência. É usado para identificar erros nos limites dos intervalos de entrada definidos. Este método é útil porque muitas vezes os erros ocorrem nos extremos dos limites de entrada. Em outras palavras, é mais provável que encontremos erros nas bordas dos intervalos de entrada do que no meio.

Continuando o nosso exemplo da calculadora, podemos testar a função de divisão em seus limites. Primeiro, na qual verificamos com o código anterior, se a divisão de um número positivo por um número positivo funciona corretamente. Em seguida, podemos testar se a divisão por zero retorna um erro, como esperado. Por último, testamos se a divisão de um número negativo por um número positivo (aqui eu considero vice-versa também), retorna o valor negativo correto:

// 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);
});

Análise de Causa-efeito

A análise de causa-efeito se concentra na relação entre a entrada (causa) e a saída (efeito) de uma função ou método. Essa análise permite verificar se uma determinada entrada produz o resultado esperado.

No exemplo da calculadora, seria o mesmo código das classes de equivalência, pois aplicando a análise de causa-efeito, seria verificar se cada operação da calculadora está produzindo o resultado esperado; ou seja, se a soma está somando, se a divisão está dividindo, e assim vai. Outro exemplo no caso de uma função que calcula o total de um carrinho de compras, a entrada (causa) seria a lista de itens com seus preços, e a saída (efeito) seria o valor total.

// 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

Agora que demos uma olhada juntos em mais uma ferramenta de teste de software, lembre-se da importância desses testes na próxima vez que estiver desenvolvendo um projeto de software. Tenha em mente que, um software de alta qualidade é aquele que não apenas funciona, mas que também sabe lidar com falhas de forma eficiente.

E aí, gostou? Este artigo foi baseado em minhas anotações do curso de Teste de Software, no qual fui aluna especial no mestrado em Sistemas de Informação da USP pelo professor Dr. Marcelo Eler. Espero que tenha sido útil para você na sua jornada de aprendizado no mundo dos testes de software. ✨
Até a próxima! ✌️