Cosa sono i test fixture e i metodi setup/teardown?

Question

Accepted Answer

**I test fixture** sono la configurazione fissa (dati, oggetti, stato) di cui i test hanno bisogno per essere eseguiti, e i metodi **setup/teardown** preparano e puliscono questo contesto prima e dopo i test. Riducono la duplicazione e garantiscono che i test vengano eseguiti in uno stato coerente e isolato.

## Setup e teardown

```text
SETUP → runs BEFORE tests to prepare the context (create objects, data, connections)
TEARDOWN → runs AFTER tests to CLEAN UP (close connections, delete data, reset state)
→ frameworks provide hooks:
  beforeEach / afterEach → before/after EACH test (fresh state per test — common)
  beforeAll / afterAll → once before/after ALL tests in a group (shared expensive setup)
```

```js
describe('UserService', () => {
  let service, db;
  beforeEach(() => {                 // fresh setup for EACH test (isolation)
    db = createTestDb();
    service = new UserService(db);
  });
  afterEach(() => db.close());        // clean up after each test

test('creates a user', () => { /* uses the fresh service/db */ });
});
```

## Fixture — dati/stato di test riutilizzabili

```text
FIXTURES → predefined data/objects tests use (a known starting state):
  → e.g. a sample user, a set of records, a configured object
  → FACTORIES → generate test data flexibly (build objects with sensible defaults +
    overrides) — better than hardcoded data for varied scenarios
→ reduce duplication; give tests consistent, known data to work with
```

## Best practice

```text
✓ Prefer beforeEach (fresh state per test) → ISOLATION (tests don't affect each other)
✓ Clean up in teardown → no leftover state causing flaky/order-dependent tests
✓ Keep setup minimal and clear; use factories for flexible test data
✓ Don't share MUTABLE state across tests (a cause of flakiness/order-dependence)
```

## Perché è importante

Capire i test fixture e i metodi setup/teardown è importante perché sono **essenziali per scrivere test puliti, isolati e manutenibili**, quindi è una conoscenza pratica utile.

I test hanno bisogno di un contesto iniziale coerente (dati, oggetti, stato), e i metodi **setup/teardown** (gli hook `beforeEach`/`afterEach` e `beforeAll`/`afterAll` forniti dai framework) preparano questo contesto prima dei test e lo puliscono dopo — riducendo la duplicazione (il setup condiviso viene scritto una sola volta anziché in ogni test) e garantendo che i test vengano eseguiti in uno stato noto.

Capire questi hook e quando utilizzare ciascuno (beforeEach per uno stato fresco per ogni test, beforeAll per setup condiviso costoso) è necessario per organizzare bene i test.

Capire i **fixture** (dati e oggetti di test predefiniti che danno ai test uno stato iniziale noto) e le **factory** (generare dati di test in modo flessibile con valori predefiniti sensati e override, meglio dei dati hardcoded per scenari variati) è importante per fornire ai test dati coerenti e gestibili.

Cosa più importante, capire le **best practice** è collegato alla qualità dei test: preferire `beforeEach` per **stato fresco per ogni test** garantisce **isolamento** (i test non si influenzano a vicenda — cruciale per test affidabili), **pulire nel teardown** previene lo stato residuo che causa test fragili e dipendenti dall'ordine (una fonte comune di fragilità), e **non condividere stato mutabile tra i test** evita la dipendenza dall'ordine e la fragilità.

Queste pratiche supportano direttamente l'isolamento dei test e il determinismo di cui i buoni test hanno bisogno.

Poiché i test hanno bisogno di setup e cleanup coerenti, e poiché i fixture e setup/teardown (usati bene, con isolamento e cleanup appropriati) riducono la duplicazione e garantiscono lo stato isolato e deterministico su cui si basano i test affidabili, capire i test fixture e i metodi setup/teardown è una conoscenza pratica e rilevante — importante per scrivere test puliti, isolati e manutenibili, supportando direttamente l'isolamento e il determinismo che distinguono i test affidabili da quelli fragili, un'abilità utile applicata nell'organizzazione di praticamente ogni suite di test.