O que são testes parametrizados e orientados por dados?

Question

Accepted Answer

**Testes parametrizados (orientados por dados)** executam a **mesma lógica de teste com múltiplos conjuntos de entradas e saídas esperadas** — evitando duplicar o teste para cada caso. Eles facilitam testar muitos cenários (incluindo casos extremos) de forma concisa.

## O problema: testes duplicados

```text
Without parameterization, testing many input/output cases means COPYING the test:
  test('add 2+3', () => expect(add(2,3)).toBe(5));
  test('add 0+0', () => expect(add(0,0)).toBe(0));
  test('add -1+1', () => expect(add(-1,1)).toBe(0));
  → lots of near-identical, repetitive tests (tedious, hard to maintain)
```

## Testes parametrizados — um teste, muitos casos

```js
// run the SAME test logic over a TABLE of cases (Jest's test.each)
test.each([
  [2, 3, 5],
  [0, 0, 0],
  [-1, 1, 0],
  [100, 200, 300],
])('add(%i, %i) === %i', (a, b, expected) => {
  expect(add(a, b)).toBe(expected);     // one logic, run per case
});
// → each row is a separate reported test case; add a case = add a row
```

A maioria dos frameworks oferece suporte a isso (Jest `test.each`, pytest `@parametrize`, JUnit `@ParameterizedTest`).

## Benefícios

```text
✓ CONCISE — test many scenarios without duplicating the test body
✓ Easy to ADD CASES — just add a row of data (great for edge cases / many inputs)
✓ Each case reported SEPARATELY — you see exactly which input failed
✓ Clear, maintainable — the data table documents the cases
→ Ideal for functions with many input/output combinations and edge cases.
```

## Por que isso importa

Compreender testes parametrizados (orientados por dados) é valioso porque eles facilitam **testar muitos cenários de forma concisa**, o que respalda testes minuciosos (especialmente casos extremos), portanto é conhecimento prático útil.

O problema que eles resolvem — testar muitas combinações de entrada/saída exigiria, caso contrário, **duplicar o teste para cada caso** (tedioso, repetitivo, difícil de manter) — é real, e testes parametrizados o resolvem executando a **mesma lógica de teste em uma tabela de casos**.

Isso torna testes de muitos cenários **concisos** (um corpo de teste, muitos casos), facilita **adicionar casos** (basta adicionar uma linha de dados — o que incentiva testar mais entradas e **casos extremos**, apoiando a cobertura abrangente de casos extremos que detecta bugs), relata **cada caso separadamente** (para que você veja exatamente qual entrada falhou, ajudando na depuração) e mantém os testes mantíveis (a tabela de dados documenta claramente os casos).

Compreender que a maioria dos frameworks oferece suporte a isso (o `test.each` do Jest, o `@parametrize` do pytest, o `@ParameterizedTest` do JUnit) torna aplicável praticamente em diferentes pilhas de tecnologia.

Testes parametrizados são ideais para funções com muitas combinações de entrada/saída — comuns para funções utilitárias, validadores, analisadores e cálculos — onde permitem testar toda a gama de casos (incluindo limites e casos extremos) sem o ônus do código de teste duplicado.

Esta forma concisa e mantível de alcançar ampla cobertura de entradas incentiva testes mais minuciosos.

Como testar muitos cenários (especialmente casos extremos) é importante para testes minuciosos e testes parametrizados tornam isso conciso e mantível (evitando testes duplicados, incentivando ampla cobertura de entradas), e como compreendê-los e seu suporte de framework é útil para testes eficazes, compreender testes parametrizados e orientados por dados é conhecimento valioso e praticamente relevante — uma técnica útil para testar muitos casos de forma concisa, apoiando a cobertura abrangente de casos extremos que testes eficazes exigem, e uma ferramenta útil aplicada sempre que funções têm muitas combinações de entrada/saída para verificar.