Come aggiungi test al codice legacy?

Question

Accepted Answer

**Codice legacy** (spesso untested, difficile da modificare) è impegnativo da testare — potrebbe avere dipendenze intricate e nessun test. Aggiungere test in sicurezza comporta tecniche come **characterization test**, **seams** per spezzare le dipendenze, e miglioramento incrementale, che permettono modifiche più sicure.

## La sfida del codice legacy

```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.
```

## Characterization test (bloccare il comportamento attuale)

```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.
```

## Spezzare le dipendenze (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
```

## Approccio incrementale

```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
```

## Perché è importante

Capire come aggiungere test al codice legacy è conoscenza preziosa di livello senior perché **la maggior parte del lavoro reale riguarda codice esistente, spesso untested**, e migliorarlo in sicurezza è una sfida comune e importante, quindi è praticamente rilevante.

Il codice legacy (untested, strettamente accoppiato, difficile da modificare) presenta un vero **problema del pollo e l'uovo**: per modificarlo in sicurezza hai bisogno di test, ma è difficile da testare (dipendenze intricate, non progettato per il testing) — e modificare codice untested è pericoloso perché non puoi dire se hai rotto qualcosa.

Capire le tecniche per affrontare questo è conoscenza pratica preziosa. I **characterization test** (catturare il comportamento *attuale* del codice così com'è, asserire quello che fa effettivamente piuttosto che quello che dovrebbe — anche se non completamente compreso) forniscono una **rete di sicurezza** che ti permette di refactorizzare e modificare con fiducia che il comportamento esistente sia preservato — una tecnica chiave per lavorare con codice che non comprendi completamente.

Capire lo **spezzare le dipendenze via seams** (trovare o creare posti per sostituire le dipendenze, usando refactor minimali e sicuri per rendere testabile il codice intricato — le tecniche dal lavoro di Michael Feathers sul codice legacy) è essenziale per portare il codice difficile da testare sotto test.

Capire l'**approccio incrementale** — aggiungere test attorno al codice prima di modificarlo (una rete di sicurezza per il cambiamento), focalizzarsi su aree in corso di modifica o ad alto rischio/alto valore (non l'intero codebase contemporaneamente), e migliorare incrementalmente (la regola del boy scout) — riflette il modo pragmatico e realistico di migliorare i sistemi legacy nel tempo.

Poiché la maggior parte dello sviluppo reale riguarda codice legacy esistente, spesso untested, che deve essere modificato in sicurezza (una situazione comune e impegnativa), e poiché capire le tecniche (characterization test per una rete di sicurezza, seams per spezzare le dipendenze, miglioramento incrementale) rende possibile farlo, capire come aggiungere test al codice legacy è conoscenza preziosa di livello senior — praticamente rilevante per la realtà comune di lavorare con codice legacy untested, riflettendo l'esperienza e le tecniche necessarie per migliorare in sicurezza i sistemi legacy, una competenza importante per gli ingegneri senior che frequentemente devono rendere il codice untested più sicuro da modificare.