O que é snapshot testing?

Question

Accepted Answer

**Snapshot testing** captura um "snapshot" de alguma saída (comumente a saída renderizada de um componente UI ou uma estrutura de dados) e compara execuções futuras contra ela — sinalizando quando a saída muda. É útil para detectar mudanças não intencionais, mas tem limitações que precisam ser entendidas.

## Como o snapshot testing funciona

```text
1. First run → the test RECORDS the output (e.g. a rendered component) as a SNAPSHOT file
2. Later runs → COMPARE the current output to the saved snapshot:
   → MATCHES → pass; DIFFERS → fail (the output changed)
3. If the change is INTENTIONAL → UPDATE the snapshot (review the diff, then accept)
```

```js
// Jest snapshot test (e.g. a React component)
test('renders correctly', () => {
  const tree = render(<Button label="Click" />).toJSON();
  expect(tree).toMatchSnapshot();    // compares to the stored snapshot
});
```

## Usos e benefícios

```text
✓ Detect UNINTENDED CHANGES — flags when output changes unexpectedly (UI, serialized data)
✓ FAST to write — no manual assertions for complex output; auto-captures the expected result
✓ Good for UI components (catch unexpected rendering changes), config, large data structures
```

## Limitações (use com cuidado)

```text
⚠️ Snapshots don't verify CORRECTNESS — they capture whatever output exists (even if WRONG);
   they only detect CHANGE, not that the output is RIGHT
⚠️ BLINDLY UPDATING snapshots (jest -u without reviewing) → defeats the purpose (accepting
   broken output) — a common bad habit
⚠️ Large/brittle snapshots → change often, get rubber-stamped, low value
→ Use for change detection; keep snapshots small/focused; REVIEW snapshot diffs;
  don't rely on them alone (combine with real assertions for behavior).
```

## Por que isso importa

Entender snapshot testing é valioso porque é uma **técnica comumente utilizada** (especialmente para UI) que é útil quando aplicada bem, mas problemática quando usada incorretamente, então entender tanto seu valor quanto suas limitações é conhecimento prático importante.

Snapshot testing — capturando saída (comumente um componente UI renderizado ou estrutura de dados) e comparando execuções futuras contra o snapshot armazenado — é **útil para detectar mudanças não intencionais**: sinaliza quando a saída muda inesperadamente (capturando mudanças acidentais na renderização de UI ou mudanças em estruturas de dados), é **rápido de escrever** (capturando automaticamente a saída esperada sem precisar fazer assertions manuais de cada detalhe de uma saída complexa), e é adequado para componentes UI, configurações e grandes estruturas de dados.

Entender esses benefícios explica sua popularidade, especialmente em testes de UI.

No entanto, entender as **limitações é criticamente importante** para usá-lo bem: snapshots **não verificam correção** — eles capturam qualquer saída que existe (mesmo que esteja errada), detectando apenas *mudança* não *correção* — então um snapshot pode bloquear uma saída com bugs.

O **maior problema é atualizar snapshots cegamente** (executar o comando de atualização sem revisar o diff), o que derrota o propósito ao aceitar uma saída potencialmente quebrada — um hábito ruim comum.

Snapshots grandes e frágeis que mudam frequentemente são aprovados automaticamente e fornecem pouco valor.

Entender o uso adequado — para detecção de mudanças, mantendo snapshots pequenos e focados, **revisando diffs de snapshot** cuidadosamente, e não confiando neles sozinhos (combinando com assertions de comportamento real) — reflete julgamento maduro que evita o uso inadequado comum.

Como snapshot testing é amplamente utilizado (especialmente para UI) e é útil para detecção de mudanças, mas facilmente abusado (bloqueando saída incorreta, atualizando cegamente), e como entender tanto seu valor quanto suas limitações importantes permite usá-lo bem, entender snapshot testing é conhecimento valioso e praticamente relevante — uma técnica comum para entender corretamente, onde apreciar suas limitações (detecção de mudanças, não correção) e uso adequado (revisar diffs, não atualizar cegamente) é tão importante quanto a técnica em si, refletindo julgamento sólido em testes.