Votre IA écrit des tests qui ne peuvent jamais échouer

Votre IA écrit des tests qui ne peuvent jamais échouer

Vous demandez des tests à une IA. Elle vous donne douze tests au vert. Votre CI passe. Vous fusionnez le code. Trois jours plus tard, un bug arrive en production. Vous regardez les tests. Ils sont passés, mais ils n'ont rien testé.

Un test au vert n'est pas une preuve. C'est une hypothèse. L'IA écrit des hypothèses qui n'échouent jamais.

Regardez cette fonction :

func Discount(total int) int {
    if total > 100 {
        return total - 10
    }
    return total
}

Une IA pourrait écrire ce test :

func TestDiscount(t *testing.T) {
    got := Discount(150)
    if got < 0 {
        t.Errorf("result should not be negative")
    }
}

Ce test est au vert. Il exécute le code, donc votre couverture semble bonne. Mais le test vérifie seulement si le résultat est inférieur à zéro. Si vous transformez la remise en une erreur mathématique, le test reste au vert. Il ne vérifie pas le comportement. Il vérifie seulement que les voyants sont allumés.

C'est un piège. La couverture compte les lignes que vous touchez. Elle ne compte pas les assertions qui comptent vraiment. Un rapport de couverture de 90 % peut masquer un code défectueux.

L'IA cherche le chemin le plus court vers le voyant vert. Elle choisit des assertions faibles et des mocks qui ne testent rien.

Pour corriger cela, utilisez une seule règle : vérifiez qu'un test sait comment échouer.

Modifiez votre code intentionnellement. Si le test reste au vert, le test est inutile. Jetez-le.

Un vrai test ressemble à ceci :

func TestDiscount(t *testing.T) {
    if got := Discount(150); got != 140 {
        t.Errorf("Discount(150) = %d, want 140", got)
    }
}

Si vous cassez la logique, ce test passe au rouge immédiatement. Il mord.

Vous ne pouvez pas faire cela à la main pour chaque test. Utilisez plutôt le mutation testing. Des outils comme Gremlins en Go appliquent de petits changements à votre code. Ils vérifient si vos tests détectent ces changements.

Si un changement ne fait pas échouer un test, vous avez une faille dans votre suite.

J'utilise cela pour le code généré par IA. Je ne laisse pas une IA déclarer son travail terminé. Je mets en place une gate. L'outil mute le code. Si le test reste au vert, l'IA doit le réécrire. L'IA ne décide pas si un test est bon. C'est la mutation qui décide.

Aucun test d'IA n'entre dans ma base de code sans prouver qu'il peut échouer. Un test qui ne peut pas échouer est pire qu'une absence de test. Un test manquant est évident. Un faux test est dangereux.

Arrêtez de faire confiance aux voyants verts. Un test ne vaut que par le rouge qu'il peut produire.

Source: https://dev.to/ohugonnot/your-ai-writes-tests-that-can-never-fail-3i57

Communauté d'apprentissage optionnelle: https://t.me/GyaanSetuAi