Che cos'è il unit testing?

Question

Accepted Answer

**Unit testing** verifica singole **unità** di codice (funzioni, metodi, classi) in **isolamento** — controllando che ogni piccolo pezzo funzioni correttamente da solo. Gli unit test sono veloci, focalizzati e formano la base di una buona strategia di testing.

## Che cos'è un unit test

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

## Esempio

```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);
});
```

## Caratteristiche dei buoni unit test

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

## Perché è importante

Comprendere il unit testing è fondamentale perché **gli unit test sono la base di una buona strategia di testing** — il fondamento della piramide dei test — quindi è essenziale, una conoscenza indispensabile.

Un unit test verifica il **pezzo di codice più piccolo e testabile (una funzione o un metodo) in isolamento**, controllando che funzioni correttamente da solo con input dati producendo output attesi.

Comprendere questo — testare una cosa alla volta, isolata dalle dipendenze (mockando sistemi esterni come database e reti), veloce e deterministico — è il cuore del unit testing.

Gli unit test sono preziosi perché sono **veloci** (eseguiti in millisecondi, quindi puoi eseguirne molti frequentemente per un feedback rapido), **focalizzati** (identificando esattamente cosa è andato male quando falliscono), e formano il **fondamento** che la maggior parte di una suite di test dovrebbe costituire.

Comprendere le **caratteristiche dei buoni unit test** — veloce, isolato (mockando le dipendenze, indipendente da altri test), deterministico (senza instabilità), testando il comportamento e gli esiti (non i dettagli di implementazione, così i test non si rompono al refactoring), e coprendo casi normali, casi limite e condizioni di errore — è importante per scrivere test efficaci che forniscono valore reale piuttosto che test fragili o di basso valore.

Il unit testing è la forma di testing più comune e fondamentale, centrale a TDD, CI/CD e sviluppo consapevole.

Poiché gli unit test sono il fondamento del testing (il fondamento della piramide, i test più numerosi ed eseguiti frequentemente) e comprendere cosa sono e come scrivere buoni (isolati, veloci, focalizzati, testando il comportamento) è essenziale per qualsiasi strategia di testing, comprendere il unit testing è conoscenza essenziale, fondamentale — la pietra angolare del testing software che ogni sviluppatore dovrebbe comprendere e praticare, fondamentale per verificare la correttezza del codice e abilitare lo sviluppo consapevole e sicuro che il buon testing fornisce.