Como você usa um assistente de IA para escrever testes unitários para uma função existente?

Question

Accepted Answer

Quando bem utilizada, uma IA é excelente na parte de **enumeração** dos testes — ela faz brainstorm de casos extremos e escreve boilerplate rapidamente. Mas você deve **verificar se as asserções são significativas**, porque uma IA escreverá alegremente testes que passam sem provar nada.

## O fluxo de trabalho

1. **Forneça a função e seu contrato** — o que ela deve fazer, os tipos de entrada/saída e como deve lidar com entrada inválida. Os testes não podem ser melhores do que a especificação que você descreve.
2. **Peça explicitamente por casos extremos** — limites (0, vazio, máx) e caminhos de erro (null, negativo, tipo errado), não apenas o caminho feliz.
3. **Verifique se as asserções são significativas** — um teste que afirma o comportamento atual do código (mesmo se com bug) é inútil. Verifique se cada asserção codifica o contrato *pretendido*.

## Por que isso importa

```js
// Function under test, with its contract:
// applyDiscount(price, percent) -> price reduced by percent.
// Contract: percent must be 0..100; throws RangeError otherwise. price >= 0.
function applyDiscount(price, percent) {
  if (percent < 0 || percent > 100) throw new RangeError('percent out of range');
  return price - (price * percent) / 100;
}
```

```js
// AI-suggested test cases (Jest) — note the edge and error paths, not just happy path:
test('applies a normal discount', () => {
  expect(applyDiscount(100, 20)).toBe(80);       // happy path
});
test('0% leaves price unchanged', () => {
  expect(applyDiscount(100, 0)).toBe(100);       // boundary: lower edge
});
test('100% makes it free', () => {
  expect(applyDiscount(100, 100)).toBe(0);       // boundary: upper edge
});
test('rejects percent above 100', () => {
  expect(() => applyDiscount(100, 150)).toThrow(RangeError); // error path
});
```

A IA propôs os casos extremos (0 e 100) e o caminho de erro que você poderia esquecer. Seu trabalho é confirmar que `toBe(80)` é o valor esperado *correto*, não apenas o que a função retorna.

## Por que isso importa

A parte difícil dos testes não é digitar os blocos `test(...)` — é **pensar nos casos que você perderia de outra forma**, e uma IA é genuinamente boa nisso. Mas ela não tem ideia do que seu código *deve* fazer a menos que você diga, então sem supervisão, ela tende a escrever **testes que espelham a implementação** (eles passam, mas passariam mesmo se a função estivesse errada). Tratando a IA como um gerador de casos extremos enquanto você possui as asserções, você obtém cobertura ampla e correção real — velocidade da IA, julgamento seu.