O que é teste unitário?

Question

Accepted Answer

**Teste unitário** verifica **unidades** individuais de código (funções, métodos, classes) em **isolamento** — verificando que cada pequena parte funciona corretamente por si só. Testes unitários são rápidos, focados e formam a base de uma boa estratégia de testes.

## O que é um teste unitário

```text
A UNIT test verifies the smallest testable piece (a function/method) in ISOLATION:
  → test ONE thing; give inputs, check the output/behavior
  → ISOLATED from dependencies (database, network, other units) — mock/stub those
  → FAST (no real I/O), focused, deterministic
```

## Exemplo

```js
// the function under test
function add(a, b) { return a + b; }

// a unit test (Jest)
test('add returns the sum of two numbers', () => {
  expect(add(2, 3)).toBe(5);          // input → expected output
  expect(add(-1, 1)).toBe(0);         // test cases, including edge cases
});

// test logic/behavior of a single unit
test('Cart.total sums item prices', () => {
  const cart = new Cart();
  cart.add({ price: 10 });
  cart.add({ price: 5 });
  expect(cart.total).toBe(15);
});
```

## Características de bons testes unitários

```text
✓ FAST — run in milliseconds (so you run many, often)
✓ ISOLATED — test one unit; mock external dependencies; independent of other tests
✓ DETERMINISTIC — same result every time (no flakiness)
✓ Test BEHAVIOR/outcomes (not implementation details); clear and readable
✓ Cover normal cases, EDGE CASES, and error conditions
```

## Por que isso importa

Entender testes unitários é fundamental porque **testes unitários são a base de uma boa estratégia de testes** — a base da pirâmide de testes — então é conhecimento essencial e obrigatório.

Um teste unitário verifica o **menor trecho de código testável (uma função ou método) em isolamento**, verificando que funciona corretamente por si só com entradas fornecidas produzindo saídas esperadas.

Entender isso — testar uma coisa por vez, isolado de dependências (mockando sistemas externos como bancos de dados e redes), rápido e determinístico — é o cerne dos testes unitários.

Testes unitários são valiosos porque são **rápidos** (executados em milissegundos, então você pode executar muitos frequentemente para feedback rápido), **focados** (apontando exatamente o que quebrou quando falham) e formam a **base** que a maioria de um conjunto de testes deve consistir.

Entender as **características de bons testes unitários** — rápidos, isolados (mockando dependências, independentes de outros testes), determinísticos (sem instabilidade), testando comportamento e resultados (não detalhes de implementação, para que testes não quebrem durante refatoração) e cobrindo casos normais, casos extremos e condições de erro — é importante para escrever testes eficazes que forneçam valor real em vez de testes frágeis ou de baixo valor.

Teste unitário é a forma mais comum e fundamental de testes, central para TDD, CI/CD e desenvolvimento confiante.

Como testes unitários são a base de testes (a base da pirâmide, os testes mais numerosos e frequentemente executados) e entender o que são e como escrever bons (isolados, rápidos, focados, testando comportamento) é essencial para qualquer estratégia de testes, entender testes unitários é conhecimento essencial e fundamental — a pedra angular dos testes de software que todo desenvolvedor deve entender e praticar, fundamental para verificar a correção do código e permitir o desenvolvimento confiante e seguro que bons testes proporcionam.