Como você adiciona testes a código legado?

Question

Accepted Answer

**Código legado** (frequentemente sem testes, difícil de modificar) é desafiador para testar — pode ter dependências emaranhadas e nenhum teste. Adicionar testes com segurança envolve técnicas como **testes de caracterização**, **seams** para quebrar dependências e melhoria incremental, possibilitando mudanças mais seguras.

## O desafio do código legado

```text
Legacy code is often: untested, tightly coupled, hard to understand, risky to change:
  → no tests → changing it is dangerous (you can't tell if you broke something)
  → hard to test → dependencies are tangled (can't isolate units); not designed for testing
→ a chicken-and-egg problem: to change safely you need tests, but it's hard to test.
```

## Testes de caracterização (definir comportamento atual)

```text
CHARACTERIZATION (golden master) tests → capture the code's CURRENT behavior as-is
  (even if you don't fully understand it / it has bugs):
  → write tests asserting what it ACTUALLY does now → a SAFETY NET
  → then you can refactor/change with confidence that behavior is preserved
→ Don't assert what it SHOULD do — assert what it DOES, to protect against regressions.
```

## Quebrando dependências (seams)

```text
To isolate hard-to-test code, find/create SEAMS (places to substitute dependencies):
  → extract dependencies behind interfaces; inject them; use the smallest safe refactors
    to make code testable (Michael Feathers' techniques)
  → carefully break dependencies so you can get the code under test, then test, then refactor
```

## Abordagem incremental

```text
✓ Add tests AROUND code BEFORE changing it (a safety net for the change)
✓ Focus on areas you're CHANGING / high-risk / high-value (not the whole codebase at once)
✓ Improve incrementally — leave code a bit better each time (the "boy scout rule")
✓ Use characterization tests to capture behavior, then refactor toward testability
```

## Por que isso importa

Compreender como adicionar testes a código legado é conhecimento valioso de nível sênior porque **a maioria do trabalho do mundo real envolve código existente, frequentemente sem testes**, e melhorá-lo com segurança é um desafio comum e importante, então é praticamente relevante.

Código legado (sem testes, acoplado, difícil de modificar) apresenta um **problema de ovo e galinha**: para mudá-lo com segurança você precisa de testes, mas é difícil testá-lo (dependências emaranhadas, não projetado para testes) — e modificar código sem testes é perigoso porque você não consegue dizer se quebrou algo.

Compreender as técnicas para resolver isso é conhecimento prático valioso. **Testes de caracterização** (capturando o comportamento *atual* do código como está, afirmando o que ele realmente faz em vez do que deveria — mesmo se não totalmente compreendido) proporcionam uma **rede de segurança** que permite refatorar e modificar com confiança de que o comportamento existente é preservado — uma técnica chave para trabalhar com código que você não compreende totalmente.

Compreender **quebra de dependências via seams** (encontrar ou criar lugares para substituir dependências, usando refatorações mínimas e seguras para tornar código emaranhado testável — as técnicas do trabalho de Michael Feathers em código legado) é essencial para colocar código difícil de testar sob testes.

Compreender a **abordagem incremental** — adicionar testes ao redor do código antes de modificá-lo (uma rede de segurança para a mudança), focando em áreas sendo modificadas ou alto risco/alto valor (não todo o código de uma vez), e melhorando incrementalmente (a regra do escoteiro) — reflete a forma pragmática e realista de melhorar sistemas legados ao longo do tempo.

Como a maioria do desenvolvimento do mundo real envolve código legado existente, frequentemente sem testes, que deve ser mudado com segurança (uma situação comum e desafiadora), e já que compreender as técnicas (testes de caracterização como rede de segurança, seams para quebrar dependências, melhoria incremental) permite fazer isso, compreender como adicionar testes a código legado é conhecimento valioso de nível sênior — praticamente relevante para a realidade comum de trabalhar com código existente sem testes, refletindo a experiência e técnicas necessárias para melhorar sistemas legados com segurança, uma competência importante para engenheiros sênior que frequentemente devem tornar código sem testes mais seguro para modificar.