# Test e debug (/it/docs/verdent-for-vscode/task-based-guides/testing-debugging)
> Flussi di lavoro di test e debug con Verdent
Verdent for VS Code ti aiuta a scrivere test completi e a eseguire il debug dei problemi attraverso cicli multipass di generazione-test-riparazione, analisi degli errori e miglioramenti automatici della copertura dei test. Genera test unitari, di integrazione ed end-to-end che rispecchiano il framework di test e lo stile del tuo progetto.
### Cosa imparerai [#cosa-imparerai]
* Generare test unitari che coprono casi limite e comportamenti attesi
* Lavorare con tutti i principali framework di test (Jest, Pytest, JUnit, ecc.)
* Creare test di integrazione che verificano flussi di lavoro con più componenti
* Migliorare la copertura dei test individuando e testando i percorsi di codice non coperti
* Eseguire il debug dei problemi usando l'analisi dei messaggi di errore e il tracciamento dell'esecuzione
* Diagnosticare i bug a partire da stack trace, log degli errori e comportamenti inattesi
### Prerequisiti [#prerequisiti]
Prima di eseguire test e debug con Verdent:
* Visual Studio Code con l'estensione Verdent installata
* Un codebase o un workspace di progetto aperto in VS Code
* Un abbonamento Verdent attivo con crediti disponibili
* Un framework di test configurato nel tuo progetto (facoltativo per la generazione di test)
***
## Scrivere test unitari [#scrivere-test-unitari]
Verdent genera test unitari che rispecchiano il framework di test e lo stile del tuo progetto. Analizza i test esistenti per comprendere i tuoi pattern, quindi genera test con setup, asserzioni e mocking appropriati.
**Esempio:**
```
Write unit tests for the calculateDiscount function
```
Verdent farà quanto segue:
* Esaminerà l'implementazione della funzione `calculateDiscount`
* Identificherà i parametri di input e i valori di ritorno
* Analizzerà i test esistenti per rispecchiare le tue convenzioni (struttura dei test, stile delle asserzioni, pattern di denominazione)
* Genererà test che coprono:
* **Percorso principale**: input validi con output attesi
* **Casi limite**: valori di confine, zero, numeri negativi, valori massimi
* **Input non validi**: null, undefined, tipi errati
* **Comportamento atteso**: validazione della logica di business
**Struttura dei test generati:**
Verdent crea test seguendo i pattern del tuo progetto:
* **Organizzazione della suite di test**: blocchi describe, classi di test o struttura a moduli
* **Setup e teardown**: hook before/after che rispecchiano i tuoi test esistenti
* **Asserzioni**: usando la libreria di asserzioni del tuo progetto (expect, assert, should, ecc.)
* **Mocking**: rispecchiando i tuoi pattern di mocking (jest.mock, sinon, unittest.mock)
* **Convenzioni di denominazione**: nomi dei test che seguono lo stile che hai stabilito
**Cicli multipass di generazione-test-riparazione:**
Per test completi, Verdent usa cicli multipass:
1. **Genera**: crea la suite di test iniziale
2. **Esegui**: esegue i test per verificarne il funzionamento
3. **Ripara**: corregge i test falliti o migliora la copertura
4. **Itera**: ripete finché i test non passano e la copertura non è sufficiente
Questo garantisce che i test non vengano solo scritti, ma funzionino effettivamente in modo corretto con il tuo codebase.
Verdent analizza i tuoi test esistenti per rispecchiare le tue convenzioni. Più i tuoi pattern di test esistenti sono coerenti, meglio i test generati da Verdent si allineeranno allo stile del tuo progetto.
***
## Framework di test supportati [#framework-di-test-supportati]
Verdent supporta tutti i principali framework di test tra i diversi linguaggi di programmazione e stack tecnologici senza richiedere configurazioni aggiuntive.
**Framework di test unitari:**
```javascript Jest
test('sum returns correct result', () => {
expect(sum(2, 3)).toBe(5);
});
```
```javascript Mocha
const assert = require('assert');
describe('sum', () => {
it('returns correct result', () => {
assert.strictEqual(sum(2, 3), 5);
});
});
```
```javascript Vitest
import { describe, it, expect } from 'vitest';
it('sum returns correct result', () => {
expect(sum(2, 3)).toBe(5);
});
```
```javascript Jasmine
describe('sum', () => {
it('returns correct result', () => {
expect(sum(2, 3)).toEqual(5);
});
});
```
**Test specifici per framework:**
* **React Testing Library** - Test di componenti React orientati all'utente
* **Vue Test Utils** - Libreria di test ufficiale di Vue.js
**Test end-to-end:**
* **Cypress** - Test end-to-end e di componenti
* **Playwright** - Test end-to-end cross-browser
* **Puppeteer** - Test con Chrome headless
* **Pytest** - Il framework di test Python più diffuso
* **unittest** - Framework di test integrato in Python
* **nose2** - Estende unittest con plugin
* **doctest** - Test incorporati nelle docstring
Verdent genera test con fixture, parametrizzazione e pattern di asserzione appropriati, che rispecchiano il tuo stile di test in Python.
* **JUnit** - Framework di test standard per Java (JUnit 4, JUnit 5)
* **TestNG** - Framework di test con funzionalità avanzate
* **Mockito** - Framework di mocking per Java
* **AssertJ** - Libreria di asserzioni fluent
Verdent crea test con annotazioni, metodi del ciclo di vita e asserzioni che seguono le convenzioni di test di Java.
* **RSpec** (Ruby) - Framework per lo sviluppo behavior-driven
* **PHPUnit** (PHP) - Framework di test unitari per PHP
* **Go testing** (Go) - Pacchetto di test integrato in Go
* **xUnit** (C#/.NET) - Framework di test per .NET
* **Catch2** (C++) - Framework di test moderno per C++
Verdent si adatta agli idiomi di test del tuo linguaggio e genera test che rispecchiano le convenzioni del tuo progetto.
Verdent riconosce il tuo framework di test dalla configurazione del progetto e dai test esistenti, generando automaticamente test che rispecchiano il tuo setup.
***
## Generare test di integrazione [#generare-test-di-integrazione]
Verdent genera test di integrazione che verificano come più componenti, servizi o moduli funzionano insieme. Crea test che simulano flussi di lavoro reali, comprese interazioni con API, operazioni sul database, flussi di autenticazione e percorsi utente multi-step.
**Esempio:**
```
Write integration tests for the user registration flow
```
Verdent genera test che verificano il flusso completo:
1. **Invio del modulo**: l'utente invia il modulo di registrazione con dati validi
2. **Validazione**: il backend valida il formato dell'email, la robustezza della password e la completezza dei dati
3. **Inserimento nel database**: il record utente viene creato nel database
4. **Invio dell'email**: viene inviata l'email di conferma (simulata o reale)
5. **Login riuscito**: il nuovo utente può accedere immediatamente con le proprie credenziali
**Struttura dei test di integrazione:**
Verdent crea test di integrazione con:
* **Setup del test**: seeding del database, inizializzazione dei servizi, creazione dei dati di test
* **Simulazione del flusso di lavoro**: operazioni multi-step in sequenza
* **Verifica dello stato**: controllo dello stato del database, delle risposte di API, degli effetti collaterali
* **Mocking dei servizi esterni**: servizi di email, API di pagamento, integrazioni di terze parti
* **Teardown del test**: pulizia dei dati di test, rollback del database, arresto dei servizi
**Esempi di scenari di test:**
```
Write integration tests for the checkout and payment process
```
Verdent testa:
* L'aggiunta di articoli al carrello
* L'applicazione di codici sconto
* Il calcolo dei totali con tasse e spedizione
* L'elaborazione del pagamento (con gateway di pagamento simulato)
* La creazione del record dell'ordine nel database
* L'invio dell'email di conferma
* L'aggiornamento dell'inventario
**Isolamento dei test:**
Verdent garantisce che i test di integrazione siano correttamente isolati:
* Ogni test parte con uno stato del database pulito
* Le chiamate ai servizi esterni sono simulate per prevenire effetti collaterali
* I test possono essere eseguiti in qualsiasi ordine senza dipendenze
* La pulizia avviene anche se i test falliscono
I test di integrazione beneficiano di ambienti di test isolati: Verdent può aiutarti a configurare le fixture del database e a simulare i servizi esterni.
I test di integrazione verificano che i componenti funzionino correttamente insieme. Sono più complessi dei test unitari, ma offrono una maggiore garanzia che i flussi di lavoro reali funzionino come previsto.
***
## Migliorare la copertura dei test [#migliorare-la-copertura-dei-test]
Verdent analizza il tuo codebase per individuare funzioni, branch e casi limite non testati, quindi genera test per migliorare la copertura. Esamina la tua suite di test esistente e individua le lacune in cui i percorsi di codice non vengono esercitati.
**Esempio:**
```
Analyze test coverage and write tests for uncovered code paths in the payment module
```
Verdent farà quanto segue:
1. **Analizzare i test esistenti**: esaminare ciò che è attualmente testato
2. **Individuare le lacune di copertura**: trovare funzioni specifiche, branch condizionali, percorsi di gestione degli errori e casi limite privi di test
3. **Generare i test mancanti**: creare test mirati al codice non coperto
4. **Verificare il miglioramento della copertura**: eseguire i test per confermare l'aumento della copertura
**Cosa individua Verdent:**
* **Funzioni non testate**: funzioni prive di qualsiasi copertura di test
* **Branch condizionali**: istruzioni if/else in cui un branch non è testato
* **Percorsi di gestione degli errori**: blocchi try/catch o callback di errore senza test di fallimento
* **Casi limite**: valori di confine, gestione di null/undefined, coercizione di tipo
* **Punti di integrazione**: chiamate a API, operazioni sul database, interazioni con servizi esterni
**Esempio di miglioramento della copertura:**
```
Improve test coverage for the UserService class
```
Verdent individua:
* `getUserById` ha test per ID validi ma non per ID non validi
* `updateUser` manca di test per i fallimenti di validazione
* `deleteUser` manca di test per i controlli di autorizzazione
* I percorsi di gestione degli errori in `createUser` non sono testati
Quindi genera test mirati specificamente a queste lacune, aumentando la copertura dal 65% al 95%.
**Metriche di copertura:**
Verdent ti aiuta a raggiungere percentuali di copertura più elevate e a intercettare potenziali bug in codice precedentemente non testato:
* **Copertura delle righe**: percentuale di righe di codice eseguite dai test
* **Copertura dei branch**: percentuale di branch condizionali testati
* **Copertura delle funzioni**: percentuale di funzioni con almeno un test
* **Copertura delle istruzioni**: percentuale di istruzioni eseguite
***
## Debug con Verdent [#debug-con-verdent]
Verdent aiuta nel debug analizzando i messaggi di errore, tracciando il flusso di esecuzione, individuando le cause profonde e suggerendo correzioni. Incolla i log degli errori, descrivi il comportamento inatteso o chiedi a Verdent di investigare problemi specifici.
Descrivi cosa non funziona e cosa ti aspettavi:
```
This function returns undefined instead of the user object. Debug it.
```
Verdent farà quanto segue:
* Leggerà l'implementazione della funzione
* Traccerà il flusso di esecuzione
* Individuerà dove il percorso di codice va storto (istruzione return mancante, condizionale errata, problema con async/await)
* Proporrà una correzione con relativa spiegazione
* Suggerirà casi di test per prevenire regressioni
**Esempio:**
```
The login form redirects to the home page even when credentials are invalid
```
Verdent farà quanto segue:
* Esaminerà la logica di invio del modulo di login
* Traccerà il flusso di autenticazione
* Individuerà il bug (il redirect avviene prima che la validazione asincrona sia completata)
* Proporrà una correzione (attendere la validazione prima del redirect)
Richiedi un'analisi delle prestazioni:
```
The product search is slow when the database has 10,000+ products
```
Verdent farà quanto segue:
* Analizzerà l'implementazione della query di ricerca
* Individuerà l'inefficienza (query N+1, indice del database mancante, algoritmo inefficiente)
* Suggerirà un'ottimizzazione (aggiungere un indice al database, raggruppare le query, memorizzare i risultati in cache)
Il debug delle prestazioni aiuta a individuare i colli di bottiglia negli algoritmi, nelle query del database o nelle risposte di API che rallentano la tua applicazione.
Comprendi come viene eseguito il codice:
```
Why does this API endpoint return a 500 error when the email parameter is missing?
```
Verdent farà quanto segue:
* Traccerà la gestione della richiesta dall'endpoint alla validazione fino al database
* Individuerà dove si verifica l'errore (accesso a una proprietà di undefined)
* Spiegherà perché si verifica l'errore (controllo null mancante prima dell'accesso alla proprietà)
* Suggerirà una correzione difensiva (validare i parametri prima di usarli)
Il tracciamento del flusso di esecuzione ti aiuta a comprendere il percorso seguito dal tuo codice e dove devia dal comportamento atteso.
Incolla i messaggi di errore o gli stack trace direttamente nella chat. Verdent analizza l'errore, individua il codice problematico e spiega cosa è andato storto, con percorsi dei file e numeri di riga specifici.
***
## Diagnosticare da messaggi di errore e log [#diagnosticare-da-messaggi-di-errore-e-log]
Incolla messaggi di errore, stack trace o file di log direttamente nella chat. Verdent analizza l'errore, individua il file di origine e il numero di riga, spiega la causa e suggerisce una correzione.
Incolla messaggi di errore e stack trace:
```
TypeError: Cannot read property 'name' of undefined
at UserProfile.render (UserProfile.jsx:45)
at processComponent (react-dom.js:2103)
```
Incolla questo in Verdent:
```
I'm getting this error: [paste stack trace]
```
Verdent farà quanto segue:
* Identificherà il tipo di errore (TypeError da accesso a null/undefined)
* Individuerà la riga esatta (`UserProfile.jsx:45`)
* Leggerà il codice in quella posizione
* Spiegherà perché si verifica (l'oggetto user è undefined prima che i dati vengano caricati)
* Proporrà correzioni:
* Aggiungere un controllo null: `if (!user) return `
* Usare l'optional chaining: `user?.name`
* Assicurarsi che i dati vengano caricati prima del rendering del componente
Incolla file di log o output della console per l'analisi:
```
Analyze these logs and tell me why the API requests are failing:
[paste 50 lines of log output]
```
Verdent farà quanto segue:
* Scansionerà i log alla ricerca di pattern di errore
* Individuerà fallimenti di autenticazione, timeout di rete o errori del database
* Traccerà la sequenza di eventi che ha portato al fallimento
* Suggerirà correzioni in base al pattern di errore
L'analisi dei log aiuta a individuare pattern tra più fallimenti e a comprendere la sequenza di eventi che ha portato agli errori.
Per problemi complessi, Verdent usa il debug multi-step:
1. **Analizza i log degli errori** per individuare il punto di fallimento
2. **Legge il codice pertinente** per comprendere l'implementazione
3. **Traccia il flusso di esecuzione** per trovare dove le cose vanno storte
4. **Suggerisce correzioni** con esempi di codice
5. **Genera test** per prevenire regressioni
**Esempio:**
```
The shopping cart total is sometimes incorrect. Here are the error logs: [paste logs]
```
Verdent farà quanto segue:
1. Analizzerà i log e individuerà quando si verifica il bug (quando vengono applicati i codici sconto)
2. Leggerà la logica di calcolo dello sconto
3. Individuerà il bug (lo sconto è calcolato prima delle tasse, non dopo)
4. Proporrà una correzione (riordinare i passaggi di calcolo)
5. Suggerirà casi di test (carrello con sconto, carrello con tasse, carrello con entrambi)
***
## Best practice [#best-practice]
Scrivi i test man mano che sviluppi le funzionalità, non dopo il completamento. Verdent può generare test immediatamente dopo la creazione di nuove funzioni o componenti.
Verdent rispecchia i pattern di test del tuo progetto. Mantieni una struttura di test coerente affinché Verdent generi test allineati alle tue convenzioni.
Chiedi a Verdent di testare condizioni di confine, scenari di errore e input insoliti: "Scrivi test che includano casi limite per input non validi e valori di confine."
Non parafrasare gli errori. Incolla lo stack trace completo per una diagnosi accurata e una risoluzione più rapida.
Quando esegui il debug, indica chiaramente cosa ti aspettavi che accadesse e cosa è effettivamente accaduto. Questo contesto aiuta Verdent a individuare la causa profonda.
Per le funzionalità critiche, richiedi una generazione completa di test con cicli multipass: "Genera test completi per il modulo di pagamento e verifica che passino tutti."
Dopo aver eseguito il refactoring del codice, richiedi test per verificare che la funzionalità sia preservata: "Genera test per verificare che il modulo di autenticazione sottoposto a refactoring funzioni correttamente."
Dopo aver corretto un bug, richiedi un test per prevenire regressioni: "Scrivi un test che garantisca che questo bug non si ripeta."
***
## Vedi anche [#vedi-anche]
Scopri come scrivere nuove funzionalità con l'assistenza AI di Verdent
Migliora la qualità del codice attraverso flussi di lavoro di refactoring sicuri