> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Tester 8 modules jamais testés en une nuit

# Tester 8 modules encore non testés en une nuit

Lancez 8 sessions Devin parallèles dans la nuit — chacune écrit des tests unitaires pour un module différent à faible couverture et ouvre une pull request (PR) pour ce module avant le matin.

Try in Devin ↗

Author
Cognition

Category
Optimisation de Devin

> [!TIP]
>
> Vous ne souhaitez pas effectuer cette configuration manuellement ? Collez un lien vers cette page dans une session Devin et demandez-lui de tout configurer pour vous.

**1. Créer un playbook pour l’écriture des tests**

Votre monorepo e-commerce comporte plus de 30 modules, mais seuls quelques-uns disposent d’une couverture de tests significative. Vous voulez passer de 44 % de couverture globale à 80 % — en commençant par les 8 modules les moins bien couverts. Avant de lancer des sessions parallèles, vous avez besoin d’un [playbook](https://docs.devin.ai/fr/product-guides/creating-playbooks.md) qui garantit que les 8 sessions écrivent les tests de la même manière.

Demandez à Devin de créer le playbook pour vous — décrivez simplement vos conventions de test dans n’importe quelle session :

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

Ce playbook devient l’ensemble d’instructions partagé pour chaque session parallèle. Vous pouvez également ajouter des entrées [Knowledge](https://docs.devin.ai/fr/product-guides/knowledge) à propos de vos utilitaires de test, de vos modèles de mocking ou de toute particularité propre au projet (par exemple, "always call `resetMocks()` in `afterEach`").

**2. Lancez 8 sessions parallèles à 18 h**

À la fin de votre journée de travail, ouvrez une nouvelle session Devin depuis la [page d’accueil de Devin](https://app.devin.ai/?utm_source=docs\&utm_medium=use-case-gallery) et décrivez la tâche de traitement par lots.

1. Sélectionnez votre playbook d’écriture de tests dans la liste déroulante
2. Décrivez la tâche dans le prompt :

```txt Traitement nocturne de la couverture de tests — 8 modules theme={null}
Exécutez `npm run test:coverage` sur notre dépôt. Identifiez les 8 modules
avec la couverture de lignes la plus faible (en ignorant tout ce qui se trouve sous src/generated/).

Pour chaque module, démarrez une session Devin en parallèle en utilisant le playbook sélectionné.
Chaque session doit :
- Lire le code source du module et les tests existants
- Écrire de nouveaux tests unitaires pour porter la couverture de lignes au‑delà de 80 %
- Exécuter toute la suite de tests pour confirmer que rien ne casse
- Ouvrir une pull request (PR) avec les nouveaux fichiers de test et un récapitulatif de couverture avant/après
```

3. Passez en revue les sessions proposées — Devin répertorie chaque module avec sa couverture actuelle et indique quelles sessions il va créer :

```
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. Validez le lot et fermez votre ordinateur portable. Les 8 sessions démarrent simultanément sur des machines Devin distinctes, chacune suivant votre playbook indépendamment.

**3. Réveillez-vous avec jusqu’à 8 PR**

Le matin, chaque session sera terminée et aura ouvert sa propre pull request (PR). Vous verrez 8 PR dans votre dépôt, chacune contenant de nouveaux fichiers de test et un récapitulatif de la couverture de tests :

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

Fusionnez les PRs dans n’importe quel ordre — comme chaque session ne fait qu’ajouter de nouveaux fichiers de test à son propre module, les conflits sont rares. Si deux sessions ont modifié un helper de test partagé, résolvez le conflit manuellement ou demandez à Devin de le corriger.

**4. Lancez un second lot pour le niveau suivant**

Un traitement par lots effectué pendant la nuit ne suffira pas à atteindre votre objectif de 80 % sur l’ensemble de la base de code. Le soir suivant, lancez une nouvelle passe pour le niveau de modules suivant :

```txt Deuxième passage de couverture nocturne theme={null}
Nous sommes à 68 % au total et avons besoin de 80 %. Relance le rapport de couverture,
trouve les 6 modules suivants avec la couverture la plus basse (ignore tout ce qui est déjà au-dessus
de 80 %) et démarre un autre lot en utilisant le même guide de rédaction de tests.
```

Vous pouvez aussi passer des tests unitaires aux tests d’intégration pour les parcours utilisateurs critiques :

```txt Série de tests d’intégration pour les parcours critiques theme={null}
Identifie nos 5 parcours utilisateurs les plus critiques (inscription, connexion, paiement,
réinitialisation de mot de passe, suppression de compte). Démarre une session parallèle pour chacun
afin d’écrire des tests d’intégration de bout en bout avec Playwright. Chaque session
doit tester le « happy path » plus 2 à 3 scénarios d’erreur.
```

Deux nuits de sessions parallèles peuvent faire passer une base de code de moins de 50 % de couverture à plus de 80 % — un travail qui prendrait des semaines de travail dédié à un ingénieur.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.