Non vuoi configurarlo manualmente? Incolla un collegamento a questa pagina in una sessione Devin e chiedigli di impostare tutto per te. Il tuo monorepo di e-commerce ha più di 30 moduli ma solo pochi offrono una copertura dei test significativa. Vuoi passare dal 44% di copertura complessiva all'80% — iniziando dagli 8 peggiori. Prima di avviare sessioni parallele, ti occorre un [playbook](/it/product-guides/creating-playbooks) che garantisca che tutte e 8 le sessioni seguano lo stesso approccio alla scrittura dei test. Chiedi a Devin di creare il playbook per te — ti basta descrivere le tue convenzioni di testing in una qualsiasi sessione: ```txt Create a test-writing playbook theme={null} Create a playbook for writing unit tests in our monorepo. It should enforce: 1. Use Vitest with TypeScript. Import from `vitest`. 2. Follow the AAA pattern (Arrange, Act, Assert). 3. Mock external dependencies — never call real APIs, databases, or third-party services. 4. Use test helpers from `src/test/helpers.ts` (e.g., `createMockUser()`, `setupTestDB()`). 5. Place test files at `{module}/__tests__/{filename}.test.ts`. 6. Cover success paths, error paths, and edge cases for every exported function. 7. Run `npm test -- --coverage --reporter=json` and verify the module exceeds 80% line coverage. 8. Open a PR with the new tests. Include the before/after coverage numbers in the PR description. ``` Questo playbook diventa l'insieme di istruzioni condivise per ogni sessione parallela. Puoi anche aggiungere voci in [Knowledge](/it/product-guides/knowledge) sulle tue utility per i test, sui pattern di mocking o su qualsiasi particolarità specifica del progetto (ad esempio, "chiama sempre `resetMocks()` in `afterEach`"). Al termine della giornata di lavoro, apri una nuova sessione Devin dalla [home page di Devin](https://app.devin.ai/?utm_source=docs\&utm_medium=use-case-gallery) e descrivi l’attività batch. 1. Seleziona dal menu a discesa il playbook per la scrittura dei test 2. Descrivi l’attività nel prompt: ```txt Batch notturno per la copertura dei test — 8 moduli theme={null} Esegui `npm run test:coverage` sul nostro repository. Identifica gli 8 moduli con la copertura delle linee di codice più bassa (ignora tutto ciò che si trova sotto src/generated/). Per ogni modulo, avvia una sessione Devin in parallelo usando il playbook selezionato. Ogni sessione deve: - Leggere il codice sorgente del modulo e gli eventuali test esistenti - Scrivere nuovi unit test per portare la copertura delle linee di codice oltre l'80% - Eseguire l'intera suite di test per confermare che nulla si rompa - Aprire una PR con i nuovi file di test e un riepilogo della copertura prima/dopo ``` 3. Esamina le sessioni proposte — Devin elenca ogni modulo con la copertura attuale e conferma quali sessioni verranno create: ``` Proposed sessions (8 modules, all below 50% coverage): 1. src/services/PaymentService — 31% coverage 2. src/services/UserService — 38% coverage 3. src/api/routes/billing — 42% coverage 4. src/middleware/auth — 44% coverage 5. src/services/NotificationSvc — 47% coverage 6. src/components/Checkout — 49% coverage 7. src/utils/validation — 51% coverage 8. src/services/SearchService — 53% coverage Start 8 parallel sessions? (y/n) ``` 4. Approva il batch e chiudi il laptop. Tutte e otto le sessioni vengono avviate contemporaneamente su macchine Devin separate, ciascuna seguendo il tuo playbook in modo indipendente. Entro la mattina, ogni sessione si sarà conclusa e avrà aperto la propria PR. Vedrai 8 PR nel tuo repository, ciascuna contenente nuovi file di test e un riepilogo della copertura: ``` Module | Before | After | PR | Status -----------------------------|--------|--------|--------|-------- src/services/PaymentService | 31% | 87% | #412 | Ready src/services/UserService | 38% | 84% | #413 | Ready src/api/routes/billing | 42% | 91% | #414 | Ready src/middleware/auth | 44% | 82% | #415 | Ready src/services/NotificationSvc | 47% | 85% | #416 | Ready src/components/Checkout | 49% | 83% | #417 | Ready src/utils/validation | 51% | 93% | #418 | Ready src/services/SearchService | 53% | 86% | #419 | Ready Overall coverage: 44% -> 68% (+24 pts across targeted modules) ``` Unisci le PR nell'ordine che preferisci — poiché ogni sessione aggiunge solo nuovi file di test al proprio modulo, i conflitti sono rari. Se due sessioni hanno modificato un helper di test condiviso, risolvi il conflitto manualmente oppure chiedi a Devin di sistemarlo. Un singolo batch notturno non raggiungerà il tuo obiettivo dell'80% sull'intera codebase. La sera successiva, esegui un secondo passaggio per il livello successivo di moduli: ```txt Seconda esecuzione notturna per la coverage theme={null} Siamo al 68% complessivo e dobbiamo arrivare all’80%. Esegui di nuovo il report di coverage, trova i 6 moduli con la coverage più bassa successivi (salta tutto ciò che è già sopra l’80%) e avvia un altro batch usando lo stesso playbook per la scrittura dei test. ``` Puoi anche passare dai test unitari ai test di integrazione per i flussi utente critici: ```txt Batch di test di integrazione per i flussi critici theme={null} Identifica i nostri 5 flussi utente più critici (signup, login, checkout, reset della password, eliminazione dell’account). Avvia una sessione parallela per ciascuno per scrivere test di integrazione end-to-end usando Playwright. Ogni sessione deve testare il happy path più 2-3 scenari di errore. ``` Due notti di sessioni parallele possono portare una codebase da meno del 50% di coverage a oltre l'80% — un lavoro che richiederebbe a un ingegnere settimane di impegno dedicato.

{title}