Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Test unitari e di integrazione automatizzati

Lezione 7 di 20 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Automatizza la scrittura dei test
  2. Genera test unitari
  3. Genera test di integrazione
  4. Copri un intero progetto
  5. Migliora i test esistenti
  6. Test per tipo di componente
  7. Configura AGENTS.md per i test
  8. Punti chiave

Automatizza la scrittura dei test

I test sono la prima cosa che si taglia quando il tempo stringe, e il debito tecnico che costa di più in seguito. Codex cambia le regole del gioco: generare una copertura completa per un modulo diventa questione di minuti invece che di un intero pomeriggio. Ma devi chiedere qualcosa di più di «scrivi i test», un’istruzione che produce solo una manciata di casi nominali: verdi, rassicuranti e inutili.

Genera test unitari

La leva principale è nominare tu stesso i casi limite. Conosci il tuo dominio aziendale; l’agente non sa che uno sconto superiore al 100% accade una volta ogni trimestre nei tuoi dati.

"Generate unit tests for src/lib/pricing.ts. 
Use Vitest. Cover all edge cases: negative price, 
discount > 100%, invalid currency, zero quantity."

Codex analizza il codice sorgente, identifica le funzioni esportate, ne comprende la logica e produce quindi una suite che copre sia i percorsi normali sia i casi che hai citato.

// src/lib/pricing.test.ts
import { describe, it, expect } from "vitest";
import { calculatePrice, applyDiscount, formatPrice } from "./pricing";

describe("calculatePrice", () => {
  it("calculates total price for a positive quantity", () => {
    expect(calculatePrice(10, 3)).toBe(30);
  });

  it("returns 0 for a quantity of zero", () => {
    expect(calculatePrice(10, 0)).toBe(0);
  });

  it("throws an error for a negative price", () => {
    expect(() => calculatePrice(-5, 1)).toThrow("Invalid price");
  });
});

describe("applyDiscount", () => {
  it("applies a standard discount", () => {
    expect(applyDiscount(100, 20)).toBe(80);
  });

  it("rejects a discount greater than 100%", () => {
    expect(() => applyDiscount(100, 150)).toThrow();
  });
});

Un dettaglio merita ispezione: il messaggio di errore atteso, «Invalid price», è stato tratto dall’implementazione reale, non inventato. Questa è la firma di un test scritto partendo dal codice piuttosto che da un modello, ed è la prima cosa da verificare quando si revisiona una suite generata.

Genera test di integrazione

Per una route API o un servizio che tocca il database, devi fornire più contesto, specialmente riguardo a cosa mockare.

"Generate integration tests for src/api/routes/orders.ts.
Use supertest for HTTP requests. Mock the Stripe 
service with vi.mock. Test scenarios: order creation, 
order with non-existent product, failed payment."

Codex distingue chiaramente tra i due livelli di test: configura i mock appropriati, gestisce il setup e il teardown del database di test e simula i servizi esterni. Nominare esplicitamente Stripe e supertest gli impedisce di inventare infrastrutture parallele a quelle che il tuo team utilizza già.

Copri un intero progetto

Su un progetto strutturalmente privo di test, un task globale è più efficace di una serie di richieste file per file.

"Analyze all .ts files in src/lib/ and src/services/. 
For each file without a corresponding .test.ts file, 
generate unit tests. Aim for branch coverage > 80%."

Codex elabora quindi i file uno per uno, adattando i test a ciascun modulo; conta diversi minuti di esecuzione per una suite completa. Esegui questo task su una cartella alla volta piuttosto che sull’intera directory src/: oltre quel limite, la pull request diventa troppo grande per essere revisionata e una suite di test approvata senza essere letta non protegge nessuno.

Migliora i test esistenti

Codex non si limita a creare; può anche diagnosticare una suite che rassicura senza proteggere.

"Analyze tests in src/__tests__/. Identify:
- Tests that check only one path (happy path)
- Vague assertions (toBeTruthy instead of toBe)
- Tests that share mutable state
Fix these issues."

Questi tre sintomi spiegano la maggior parte delle suite verdi che lasciano passare i bug. Il terzo è il più insidioso: i test che condividono stato mutabile passano finché vengono eseguiti nell’ordine usuale, e iniziano a fallire casualmente il giorno in cui abiliti il parallelismo.

Test per tipo di componente

Il tipo di test da richiedere dipende direttamente dalla natura del codice e l’istruzione cambia di conseguenza.

Tipo di codiceTipo di testIstruzione per Codex
Funzione di utilitàUnitario«Testa tutti i possibili input e output»
Route APIIntegrazione«Testa con supertest, mocka i servizi esterni»
Componente ReactRendering«Testa il rendering e le interazioni con Testing Library»
Servizio con DBIntegrazione«Usa un DB di test, resetta tra ogni test»

Configura AGENTS.md per i test

Piuttosto che ripetere queste scelte per ogni task, scrivile una volta per tutte in una sezione dedicata di AGENTS.md.

## Tests
- Framework: Vitest
- Command: `npm run test`
- Coverage: `npm run test:coverage`
- Convention: .test.ts files next to source code
- Mocks: use vi.mock(), no manual mocks
- Assertions: prefer toBe/toEqual over toBeTruthy/toBeFalsy
- Each test must be independent (no shared state)

Con queste sette righe, Codex applica le tue convenzioni a ogni test che genera, anche quando uno sviluppatore di fretta formula la sua richiesta in tre parole. Questo è il modo più economico per rendere la qualità dei tuoi test indipendente dalla qualità delle istruzioni.

Punti chiave

  • Codex genera test adattati al tuo codice, non test generici
  • Specifica i casi limite che vuoi coprire nelle tue istruzioni
  • Codex distingue tra test unitari e test di integrazione
  • Usa AGENTS.md per definire le tue convenzioni di testing
  • Codex può migliorare i test esistenti, non solo crearne di nuovi