~10 min de lecture

Tes tests générés par l'IA sont verts du premier coup : c'est exactement le problème

TL;DR

Un test n'a de valeur que s'il peut être rouge. Or un agent à qui tu demandes "ajoute des tests" après coup les déduit du code : il encode ce que le code fait, pas ce qu'il devrait faire. Quatre patterns reviennent : le test qui consacre le bug, le test qui réimplémente le calcul, le test qui vérifie le mock, et l'assertion incapable d'échouer. La parade, inverser la charge de la preuve : donner la spec au lieu du code, exiger des valeurs attendues écrites en dur, et pour chaque test la modification du code qui le ferait échouer, appliquée et exécutée, pas promise.

Tu viens de finir une feature. Tu lances ton agent : "ajoute des tests sur invoice-discount.ts". Deux minutes plus tard, quatorze tests, tous verts du premier coup, couverture à 92 %. Tu merges. Un mois plus tard, un client signale qu'il n'a pas eu sa remise alors que son panier faisait pile 100 EUR. Tu ouvres le fichier : la fonction fautive est couverte à 100 %, et le test qui la couvre affirme noir sur blanc que ce comportement est le bon.

Personne n'a menti. L'agent a fait exactement ce que tu as demandé. Le problème est dans la demande.

Pourquoi "après coup" change tout

Un test vaut par sa capacité à échouer. Un test qui serait vert quel que soit le code qu'on lui mettrait en face ne vérifie rien. C'est l'idée de falsifiabilité : une vérification n'a de sens que si un monde existe où elle échoue.

Un test écrit avant le code, ou depuis le ticket, connaît ce monde : écrit sans regarder le code, il peut le contredire. Un test généré après le code et depuis le code, non, par construction. L'agent lit ta fonction mieux que n'importe qui, branche par branche, et produit un test qui décrit fidèlement chaque branche. Fonction juste, test juste. Fonction fausse, test faux de la même façon, et vert.

Un humain qui teste après coup a le même biais, mais sa mémoire du ticket le fait tiquer devant une ligne qui la contredit. L'agent n'a pas cette mémoire : sauf si tu la lui donnes, sa seule source de vérité est le code, qu'il recopie avec aplomb, comme il imite le pattern majoritaire de ta codebase.

Quatre formes de recopie, donc quatre pièges. Les exemples sont en Vitest, le runner que ng new installe par défaut depuis Angular 21 ; les pièges sont les mêmes avec Jest ou Jasmine, seule la syntaxe change.

Piège 1 : le test qui consacre le bug

La spec du ticket : remise de 10 % dès 100 EUR d'achat, 100 EUR inclus. Le code livré :

// invoice-discount.ts
export function applyDiscount(subtotal: number): number {
  if (subtotal > 100) {
    return subtotal * 0.9;
  }
  return subtotal;
}

Le > aurait dû être un >= : à exactement 100 EUR, pas de remise. C'est le bug. Maintenant, les tests que l'agent génère en lisant ce code :

import { describe, expect, it } from 'vitest';
import { applyDiscount } from './invoice-discount';

describe('applyDiscount', () => {
  it('applique 10 % de remise au-dessus de 100', () => {
    expect(applyDiscount(150)).toBe(135);
  });

  it("n'applique pas de remise à exactement 100", () => {
    expect(applyDiscount(100)).toBe(100);
  });
});

Regarde le deuxième test. L'agent a vu la branche, l'a testée, lui a même donné un titre explicite. Le bug n'est plus un bug : c'est un comportement documenté, vérifié en CI. Le correctif légitime arrivera avec un test rouge, et un relecteur pressé en conclura qu'il casse quelque chose.

Le piège le plus coûteux des quatre, parce qu'invisible au diff : un test propre, bien nommé, avec une vraie assertion. Sa seule faute : avoir pris le code pour la spec.

Piège 2 : le test qui réimplémente le calcul

Ici l'agent ne recopie pas la conclusion, il recopie le raisonnement.

// vat.ts
export function totalWithVat(
  lines: readonly { amountCents: number }[],
): number {
  const subtotal = lines.reduce((sum, line) => sum + line.amountCents, 0);
  return Math.round(subtotal * 1.2);
}
// Generated: the expected value reuses the code's own formula
it('calcule le total TTC', () => {
  const lines = [{ amountCents: 1999 }, { amountCents: 333 }];
  const subtotal = lines.reduce((sum, line) => sum + line.amountCents, 0);

  expect(totalWithVat(lines)).toBe(Math.round(subtotal * 1.2));
});

Ce test est une tautologie : il compare la fonction à une copie de sa propre formule. Si la spec comptable exigeait un arrondi ligne à ligne plutôt que sur le total, les deux membres de l'assertion seraient faux ensemble. Ici, l'arrondi global rend 2798 centimes, l'arrondi ligne à ligne 2799, et le test resterait vert avec l'un comme avec l'autre tant que code et test partagent la formule.

Le symptôme saute aux yeux : une valeur attendue calculée au lieu d'une valeur littérale. La règle de relecture : la valeur attendue se pose en dur (toBe(2798)), calculée une fois depuis la spec. Si tu ne sais pas la calculer sans relire le code, tu ne connais pas la spec, et le test ne fait que retarder le moment de l'admettre.

Piège 3 : le test qui vérifie le mock

Le préféré des suites générées sur les services :

// invoice-api.ts
import { HttpClient } from '@angular/common/http';
import { Injectable, inject } from '@angular/core';
import { Observable } from 'rxjs';

export type Invoice = { id: string; ref: string; amountCents: number };

@Injectable({ providedIn: 'root' })
export class InvoiceApi {
  private readonly http = inject(HttpClient);

  byStatus(status: string): Observable<Invoice[]> {
    return this.http.get<Invoice[]>('/api/invoices', { params: { status } });
  }
}
import { HttpClient } from '@angular/common/http';
import { TestBed } from '@angular/core/testing';
import { of } from 'rxjs';
import { describe, expect, it, vi } from 'vitest';
import { InvoiceApi, Invoice } from './invoice-api';

const fakeInvoices: Invoice[] = [
  { id: '1', ref: 'F-2026-01', amountCents: 1999 },
];

describe('InvoiceApi', () => {
  it('récupère les factures par statut', () => {
    const get = vi.fn().mockReturnValue(of(fakeInvoices));
    TestBed.configureTestingModule({
      providers: [{ provide: HttpClient, useValue: { get } }],
    });

    const api = TestBed.inject(InvoiceApi);
    let result: Invoice[] | undefined;
    api.byStatus('paid').subscribe((invoices) => (result = invoices));

    expect(get).toHaveBeenCalledWith('/api/invoices', {
      params: { status: 'paid' },
    });
    expect(result).toEqual(fakeInvoices);
  });
});

Décompose. Un : le mock a été appelé avec les arguments que le code lui passe, c'est la ligne du service recopiée en syntaxe toHaveBeenCalledWith. Deux : la valeur retournée par le mock ressort du service, tu testes vi.fn(). Aucune des deux assertions ne peut attraper un code faux ; elles n'attrapent qu'un code modifié. Si le vrai backend attend le paramètre state et pas status, ce test reste vert : la bonne réponse vit dans le contrat HTTP, et le contrat n'apparaît nulle part.

L'agent adore ce pattern pour une raison mécanique : c'est le test le plus facile à générer en lisant uniquement le fichier. Pour un code qui ne fait que relayer l'appel à HttpClient (du passe-plat), la vérification honnête se fait à la frontière, avec HttpTestingController, URL et paramètres pris dans la doc de l'API. Recopie-les du service, et tu refais la même tautologie avec un outil plus propre ; les pièges de l'outil lui-même sont dans arrête de mocker HttpClient.

Piège 4 : l'assertion qui ne peut pas être rouge

Dernier pattern, le plus facile à attraper en review :

// sort-invoices.ts
export type Invoice = { ref: string; dueDate: string };

export function sortByDueDate(invoices: readonly Invoice[]): Invoice[] {
  return [...invoices].sort((a, b) => a.dueDate.localeCompare(b.dueDate));
}
// Generated: assertions that do not constrain the result
const invoices: Invoice[] = [
  { ref: 'F-001', dueDate: '2026-07-01' },
  { ref: 'F-002', dueDate: '2026-03-15' },
  { ref: 'F-003', dueDate: '2026-12-09' },
];

it('trie les factures par échéance', () => {
  const result = sortByDueDate(invoices);

  expect(result).toBeDefined();
  expect(result).toHaveLength(invoices.length);
});

Ce test est vert si la fonction trie, vert si elle ne trie pas, vert si elle trie dans le mauvais sens ou par référence. toBeDefined, toBeTruthy, not.toThrow, un toHaveLength seul : des assertions qui contraignent la forme du résultat sans en contraindre le contenu. Un agent les produit volontiers : aucune hallucination possible sur une valeur qu'on ne vérifie pas.

La version qui prouve quelque chose remplace les deux assertions par une seule :

it('trie les factures par échéance croissante', () => {
  const result = sortByDueDate(invoices);

  expect(result.map((i) => i.ref)).toEqual(['F-002', 'F-001', 'F-003']);
});

Inverse le sens du tri, remplace dueDate par ref dans le comparateur, supprime le tri : rouge dans les trois cas. Pas par hasard : la fixture décorrèle exprès l'ordre des références et celui des échéances. Avec des références qui croissent comme les dates (F-2026-03, F-2026-07, F-2026-12), le tri par ref rendrait l'ordre attendu et resterait vert. Même un bon test se vérifie en le mettant au rouge.

Le protocole : inverser la charge de la preuve

Le point commun des quatre pièges : le code comme seule source de vérité. Le remède est dans la demande, pas dans la relecture. Avant :

Ajoute des tests sur invoice-discount.ts.

Après :

Écris les tests de applyDiscount dans invoice-discount.spec.ts.

Spec (ticket FACT-231) : remise de 10 % dès 100 EUR d'achat,
100 EUR inclus. Pas de remise en dessous.

1. Écris les tests depuis cette spec, SANS ouvrir
   invoice-discount.ts. Lance-les ensuite. Si un test échoue,
   ne le "corrige" pas pour le faire passer : liste l'écart
   entre la spec et le code, et attends mon arbitrage.
2. Valeurs attendues en littéraux, calculées depuis la spec.
   Interdiction de les recalculer avec la formule du code.
3. Pas de toBeDefined, toBeTruthy ou toHaveLength isolé :
   chaque test compare un contenu.
4. Pour chaque test, trouve la modification d'une ligne du
   code qui le ferait échouer. Applique-la, lance le test,
   colle le rouge obtenu, puis annule-la. S'il n'en existe
   pas, supprime le test.

La consigne 1 ferme le piège du bug consacré : des tests écrits depuis la spec FACT-231 mettent applyDiscount(100) en rouge, et ce rouge est une trouvaille, pas un échec. C'est la moitié utile du TDD récupérée après coup. Elle ferme aussi le piège du mock, à une condition : pour un passe-plat HTTP, la spec à coller est le contrat de l'API (la doc, un exemple de requête réelle), vérifié via HttpTestingController. Au passage, interdire la lecture de l'implémentation se vérifie dans la trace de l'agent, là où un processus d'équipe l'impose difficilement à un humain pressé.

La consigne 2 ferme la réimplémentation, la 3 les assertions molles. La consigne 4 est un test de mutation artisanal : une mutation est une modification volontaire du code (un > qui devient >=, un + qui devient -) qu'un test digne de ce nom doit détecter. Exiger le rouge exécuté, pas seulement annoncé, empêche l'agent de promettre une preuve qu'il n'a pas vue ; les outils de mutation font ensuite pareil à l'échelle de la suite.

Dernière précaution : ne tiens pas l'écart remonté par la consigne 1 pour un bug sur la seule parole de l'agent ; il a pu mal lire la spec. Le filtrage d'un constat plausible mais faux est détaillé dans la revue de code par agent.

Et la couverture, dans tout ça ?

Les quatre pièges passent la couverture haut la main, et c'est logique : elle mesure quelles lignes ont été exécutées, pas ce qui a été vérifié. Le test du piège 4 exécute 100 % de sortByDueDate et n'en vérifie rien. Une suite générée gonfle le chiffre sans gonfler la preuve : le tableau de bord rassure au moment précis où il devrait inquiéter.

Le score de mutation (la part de ces modifications volontaires que ta suite détecte) fait mieux, mais moins que tu ne l'espères. Rejoue les mutants (les versions du code ainsi modifiées) contre les tests de cet article ; un test tue un mutant quand il passe au rouge sur lui. Le test qui consacre le bug tue son mutant (> vers >=), le test du mock tue les siens (URL ou paramètre modifiés). Le score n'attrape que l'assertion molle du piège 4 et une partie de la réimplémentation du piège 2. Un chiffre mesure si un test peut être rouge, pas s'il est rouge pour la bonne raison ; contre le bug consacré et le mock vérifié, seule la spec fait foi.

Récap actionnable

  1. Pouvoir être rouge est nécessaire, pas suffisant. Quelle erreur du code ferait échouer ce test généré ? Pas de réponse, pas de test. L'inverse existe aussi : un test peut rougir quand le code change (pièges 1 et 3) sans rougir quand il est faux.
  2. Donne la spec, pas le code. "Ajoute des tests" sans spec signifie "décris le code tel qu'il est, bugs compris". Colle le ticket dans la demande, interdis la lecture de l'implémentation. Pour un passe-plat HTTP, la spec, c'est le contrat de l'API.
  3. Un test généré qui échoue est une trouvaille. Interdis à l'agent de le "corriger" en silence : l'écart entre spec et code, c'est toi qui l'arbitres.
  4. Valeur attendue en dur, toujours. Une valeur attendue recalculée avec la formule du code compare le code à sa propre copie.
  5. Bannis les assertions de forme. toBeDefined, toBeTruthy, toHaveLength isolé : sur un tableau, le test reste vert pour toute erreur qui garde la longueur, donc ne prouve presque rien.
  6. Exige la preuve de rouge, exécutée. La modification d'une ligne qui met le test au rouge, appliquée et lancée, pas promise. Sans elle, le test se supprime.
  7. Ne confonds pas couverture et vérification. La couverture compte les lignes exécutées ; les quatre pièges la font monter sans prouver ce qui compte. Même le score de mutation ne voit ni le bug consacré ni le mock vérifié.

Déléguer l'écriture des tests à un agent n'est ni un progrès ni une faute : c'est un amplificateur. Avec le code pour seule source, il industrialise la tautologie. Avec une spec, des valeurs en dur et une preuve de rouge exigée, il écrit en deux minutes la suite que tu aurais mis une heure à écrire, et elle prouve quelque chose. Ce que l'agent te rend a la forme exacte de ce que ta demande lui apprend.

📧 Reste informé(e) !

Reçois les derniers articles et conseils EasyAngularKit directement dans ta boîte mail.

S'inscrire gratuitement

AngularKit

Suite d'outils pour développeurs Angular francophones. Apprends, modernise tes réflexes, audite ta codebase.

Produits

Contact

Légal

© 2026 AngularKit. Tous droits réservés.