Il est important deécrire des tests unitaires clairs et efficaces qui fonctionnent réellement pendant le processus de développement du logiciel. Les tests unitaires séparent les éléments de code individuels et confirment qu’ils fonctionnent comme prévu.

Des tests unitaires efficaces non seulement attrapent les erreurs mais aident également à être confiant que votre code peut être maintenu et est fiable. Cependant, il faut du temps et des ressources pour créer manuellement une suite de tests unitaires approfondie.

Il y a eu quelques développements récents en intelligence artificielle qui promettent d’aider à automatiser les processus de développement de tests unitaires. En février, des chercheurs à Meta ont publié un document sur L’amélioration automatisée des tests unitaires en utilisant des grands modèles de langage. Cela a présenté une méthode innovante pour l’automatisation des tests unitaires.

Leur recherche se concentre sur un nouvel outil appelé TestGen-LLM, qui explore les possibilités d’utiliser les LLM pour analyser les tests unitaires existants et les améliorer afin d’augmenter la couverture du code.

Bien que le code de TestGen-LLM n’ait pas été publié, je présenterai dans cet article une alternative open source inspirée par leurs recherches. Vous apprendrez comment il génère des ensembles de tests, pourquoi il est meilleur que la plupart des LLM et où obtenir cette technologie et commencer à l’essayer.

Table des matières

Meta’s TestGen-LLM

Meta’s TestGen-LLM traite la tâche chronophage de l’écriture de tests unitaires en utilisant le pouvoir des Gros Modèles de Langue (LLMs). Des LLMs généraux tels que Gemini ou ChatGPT pourraient éprouver des difficultés avec le domaine spécifique du code de tests unitaires, de la syntaxe de test et de l’élaboration de tests ne contribuant pas de valeur. Cependant, TestGen-LLM est spécialement conçu pour les tests unitaires.

Cette spécialisation lui permet de comprendre les subtilités de la structure du code et de la logique de test, ce qui conduit à des jeux de tests plus ciblés et à la génération de tests réellement contribuant à l’augmentation de la couverture du code.

TestGen-LLM est capable d’évaluer les tests unitaires et de déterminer les domaines à améliorer. Il réalise cela en utilisant sa compréhension des patrons de test communs sur lesquels il a été entraîné. Cependant, la génération de tests seule n’est pas suffisante pour une couverture de code adéquate.

Les chercheurs de Meta ont implémenté des mesures de protection dans TestGen-LLM pour assurer l’efficacité des tests qu’il écrit. Ces mesures de protection, appelées filtres, agissent comme un mécanisme de contrôle de qualité. Elles éliminent les suggestions qui :

  • ne seraient pas compilables

  • s’échouent systématiquement, ou

  • n’améliorent pas effectivement la couverture du code (suggestions déjà couvertes par d’autres tests).

Comment fonctionne TestGen-LLM ?

TestGen-LLM utilise une approche nommée « Ingénierie du logiciel basée sur LLM assurée » (Assured LLMSE). TestGen-LLM augmente simplement une classe de tests existante avec des cas de test supplémentaires, conservant tous les cas de test existants et garantissant ainsi qu’il n’y aura pas de régression.

Flux de travail de génération de tests(De la publication TestGen_LLM)

TestGen-LLM génère une série de tests, puis filtre les tests qui ne fonctionnent pas et élimine ceux qui échouent. Enfin, il rejette ceux qui ne font pas augmenter la couverture du code.

Apres avoir utilisé TestGen-LLM pour automatiser un ensemble de tests, Meta a utilisé un examinateur humain pour accepter ou rejeter les tests où les tests générés avaient un taux d’acceptation de 73% dans les meilleurs cas rapportés.

D’après le document, TestGen-LLM génère un seul test lors de chaque exécution, qui est ensuite ajouté à un ensemble de tests existant écrit précédemment par un développeur. Cependant, il ne génère pas nécessairement des tests pour n’importe quel ensemble de tests.

L’efficacité de TestGen-LLM a été démontrée lors des test-a-thons internes de Meta.ici, l’outil a été utilisé pour analyser les ensembles de tests existants et proposer des améliorations. Les résultats étaient prometteurs :

“75% des cas de test de TestGen-LLM se construisent correctement, 57% sont fiables, et 25% augmentent la couverture. Pendant les test-a-thons d’Instagram et de Facebook de Meta, il a amélioré 11,5% de toutes les classes auxquelles il a été appliqué, et 73% de ses recommandations ont été acceptées pour la mise en production par les ingénieurs logiciels de Meta”.

Les recommandations de TestGen-LLM ont été jugées utiles et pertinentes par les développeurs qui ont participé aux test-a-thons.

Implémentation Open Source (Cover-Agent)

La recherche TestGen-LLM de Meta a beaucoup de potentiel pour transformer les tests unitaires et la génération automatisée de tests. L’outil pourrait probablement aider à améliorer la couverture du code et accélérer la création de tests en utilisant des LLM particulièrement entraînées sur du code. Cependant, cette technologie n’est pas disponible pour n’importe qui, car le code de TestGen-LLM n’a pas été publié.

Les développeurs intéressés par cette technologie sont vraisemblablement frustrés par l’absence de code disponible au public. Après tout, l’étude de TestGen-LLM de Meta offre une première image de l’avenir du test automatisé.

Il est très attrayant de pouvoir plonger dans les détails des nouvelles technologies, comprendre les processus de décision et peut-être même influencer leur évolution. Cependant, l’absence du code de Meta constitue un obstacle, mais il existe une implémentation open source appelée Cover-Agent qui peut servir de solution de remplacement utile.

CodiumAI's Cover-Agent est la première implémentation open source d’un outil de test automatisé basé sur TestGen-LLM. Inspiré par la recherche de Meta, Cover-Agent se trouve à la pointe des développements open source dans le domaine du test unitaire assisté par IA.

Pourquoi des LLM axées sur les tests sont-ils nécessaires ?

Puisque la plupart des LLM (comme ChatGPT et Gemini) sont capables de générer des tests, pourquoi s’intéresser à une nouvelle technologie ?

Bien, Cover-Agent et TestGen-LLM ont été créés pour constituer l’étape suivante dans l’évolution de l’unité de test efficient. Leur objectif est d’éviter les embûches communes que les développeurs rencontrent lors de la génération de tests avec des LLM, telles que :

  • LLM Hallucination

  • Génération de tests qui neajoutent pas de valeur

  • Génération de tests qui omettent certaines parties du code, résultant en un faible coveragedu code

Pour surmonter de tels défis (spécifiquement pour les tests de regression unitaires), les chercheurs de TestGen-LLM ont élaboré les critères suivants que les tests générés doivent remplir avant que les tests puissent être acceptés :

  • Le test généré compile-t-il et s’exécute-t-il correctement ?

  • Le test augmente-t-il le coveragedu code ?

  • Ajoute-t-il de la valeur ?

  • Répond-il aux autres exigences supplémentaires que nous puissions avoir ?

Ces questions et problèmes fondamentaux sont résolus avant que le test généré ne soit considéré comme une amélioration par rapport à la technologie existante. Cover-Agent fournit des tests qui répondent à ces questions et problèmes à un niveau étonnamment élevé.

Comment fonctionne Cover-Agent ?

Cover-Agent fait partie d’une suite d’outils plus large conçue pour automatiser la création de tests unitaires pour les projets de logiciels. En utilisant le modèle d’IA génératrice TestGen-LLM, il vise à simplifier et accélérer le processus de test, garantissant un développement de logiciel de haute qualité.

Le système se compose de plusieurs composants :

  • Exécuteur de tests : Exécute les commandes ou scripts pour lancer le jeu de tests et générer des rapports de couverture de code.

  • Analyseur de couverture : Valide que la couverture de code augmente à mesure que les tests sont ajoutés, garantissant que les nouveaux tests contribuent à l’efficacité globale des tests.

  • Constructeur de prompt : Rassemble les données nécessaires depuis la base de code et construit le prompt à transmettre au Grand Modèle de Langue (LLM).

  • Appelant AI : Interagit avec l’LLM pour générer des tests à partir du prompt fourni.

Ces composants travaillent ensemble avec TestGen-LLM pour générer uniquement des tests garantis à améliorer le code existant.

Comment utiliser Cover-Agent

Exigences

Avant de pouvoir utiliser Cover-Agent, vous devez remplir les exigences suivantes :

  • OPENAI_API_KEY défini dans vos variables d’environnement, qui est requis pour appeler l’OpenAI API.

  • Outil de couverture de code : Un rapport de couverture de code Cobertura XML est requis pour que l’outil fonctionne correctement. Par exemple, en Python, vous pourriez utiliser pytest-cov. Ajoutez l’option --cov-report=xml lors de l’exécution de Pytest.

Installation

Si vous exécutez Cover-Agent directement depuis le dépôt, vous aurez également besoin :

  • Python installé sur votre système.

  • Poetry installé pour gérer les dépendances des paquets Python. Vous trouverez les instructions d’installation de Poetry ici.

Exécution autonome

Vous pouvez installer Cover-Agent en tant que package Python Pip ou l’exécuter indépendamment.

Python Pip

Pour installer le package Python Pip directement via GitHub, exécutez la commande suivante :

pip install git+https://github.com/Codium-ai/cover-agent.git

Binaire

Vous pouvez exécuter le binaire sans aucun environnement Python installé sur votre système (par exemple, dans un conteneur Docker qui ne contient pas Python). Vous pouvez télécharger la version de sortie pour votre système en naviguant vers la page de sortie du projet.

Configuration du référentiel

Exécutez la commande suivante pour installer toutes les dépendances et exécuter le projet à partir des sources :

poetry install

Exécution du code

Après avoir téléchargé l’exécutable ou installé le package Pip, vous pouvez maintenant exécuter Cover-Agent pour générer et valider des tests unitaires.

Exécutez-le depuis la ligne de commande en utilisant la commande suivante :

cover-agent \
--source-file-path "path_to_source_file" \
--test-file-path "path_to_test_file" \
--code-coverage-report-path "path_to_coverage_report.xml" \
--test-command "test_command_to_run" \
--test-command-dir "directory_to_run_test_command/" \
--coverage-type "type_of_coverage_report" \
--desired-coverage "desired_coverage_between_0_and_100" \
--max-iterations "max_number_of_llm_iterations" \
 --included-files "<optional_list_of_files_to_include>"

Vous pouvez utiliser les projets exemples contenus dans ce référentiel pour exécuter ce code en tant que test.

Arguments de commande

  • source-file-path: Chemin du fichier contenant les fonctions ou le bloc de code que vous souhaitez tester.

  • test-file-path: Chemin du fichier où les tests seront écrits par l’agent. Il est préférable de créer un squelette de ce fichier avec au moins un test et les instructions d’importation nécessaires.

  • chemin-rapport-couverture-code : Chemin où le rapport de couverture de code est enregistré.

  • commande-test : Commande pour exécuter les tests (par exemple pytest).

  • dossier-commande-test : Dossier où la commande de test doit s’exécuter. Assignez-le à la racine ou à l’emplacement de votre fichier principal pour éviter les problèmes d’importations relatives.

  • type-couverture : Type de couverture à utiliser. Cobertura est un bon choix par défaut.

  • couverture-souhaitée : Objectif de couverture. Plus elle est élevée, plus c’est bon, quoique 100% soit souvent impraticable.

  • iterations-maximes : Nombre de fois que l’agent devrait réessayer de générer du code de test. Plus les itérations sont nombreuses, plus l’utilisation de jetons OpenAI peut être élevée.

  • additional-instructions: Instructions supplémentaires pour s’assurer que le code est écrit d’une certaine manière. Par exemple, ici nous précisons que le code doit être formaté pour fonctionner dans une classe de test.

Lorsque la commande est exécutée, l’agent commence à écrire et à itérer sur les tests.

Comment utiliser Cover-Agent

Il est temps d’essayer Cover-Agent. Nous utiliserons une simple application calculator.py pour comparer la couverture de code entre le test manuel et automatisé.

Test manuel

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

C’est le fichier test_calculator.py placé dans le dossier test.

# tests/test_calculator.py
from calculator import add, subtract, multiply, divide

class TestCalculator:

    def test_add(self):
        assert add(2, 3) == 5

Pour voir la couverture de test, nous devons installer pytest-cov, une extension de pytest pour le rapport de couverture mentionnée plus tôt.

pip install pytest-cov

Exécutez l’analyse de couverture avec :

pytest --cov=calculator

La sortie montre :

Name            Stmts   Miss  Cover
-----------------------------------
calculator.py      10      5    50%
-----------------------------------
TOTAL              10      5    50%

La sortie ci-dessus montre que 5 des 10 instructions dans calculator.py ne sont pas exécutées, ce qui ne permet qu’une couverture de code de 50%. Pour une base de code plus grande, cela deviendra un problème sérieux et entraînera des retards.

Maintenant, voyons si cover-agent peut faire mieux.

Test automatisé avec Cover-Agent

Pour configurer Codium’s Cover-Agent, suivez ces étapes :

Premièrement, installez Cover-Agent :

pip install git+https://github.com/Codium-ai/cover-agent.git

Assurez-vous que votre OPENAI_API_KEY est défini dans vos variables d’environnement, car il est requis pour l’API OpenAI.

Ensuite, écrivez les commandes pour démarrer la génération de tests dans le terminal :

cover-agent \
--source-file-path "calculator.py" \
--test-file-path "tests/test_calculator.py" \
--code-coverage-report-path "coverage.xml" \
--test-command "pytest --cov=. --cov-report=xml --cov-report=term" \
--test-command-dir "./" \
--coverage-type "cobertura" \
--desired-coverage 80 \
--max-iterations 3 \
--openai-model "gpt-4o" \
--additional-instructions "Since I am using a test class, each line of code (including the first line) needs to be prepended with 4 whitespaces. This is extremely important to ensure that every line returned contains that 4 whitespace indent; otherwise, my code will not run."

Cela génère le code suivant :

import pytest
from calculator import add, subtract, multiply, divide

class TestCalculator:

    def test_add(self):
        assert(add(2, 3), 5

    def test_subtract(self):
        """
        Test subtracting two numbers.
        """
        assert subtract(5, 3) == 2
        assert subtract(3, 5) == -2

    def test_multiply(self):
        """
        Test multiplying two numbers.
        """
        assert multiply(2, 3) == 6
        assert multiply(-2, 3) == -6
        assert multiply(2, -3) == -6
        assert multiply(-2, -3) == 6

    def test_divide(self):
        """
        Test dividing two numbers.
        """
        assert divide(6, 3) == 2
        assert divide(-6, 3) == -2
        assert divide(6, -3) == -2
        assert divide(-6, -3) == 2

    def test_divide_by_zero(self):
        """
        Test dividing by zero, should raise ValueError.
        """
        with pytest.raises(ValueError, match="Cannot divide by zero"):
            divide(5, 0)

Vous pouvez voir que l’agent a également écrit des tests pour vérifier les erreurs dans les cas extrêmes.

Maintenant, il est temps de tester la couverture de nouveau :

pytest --cov=calculator

Sortie :

Name            Stmts   Miss  Cover
-----------------------------------
calculator.py      10      0   100%
-----------------------------------
TOTAL              10      0   100%

Dans cet exemple, nous avons atteint 100% de couverture de code. Pour de plus grands codeurs, la procédure est relativement la même. Vous pouvez lire cette guide pour un tour d’horizon sur un code plus large.

Bien que Cover-Agent représente une avancée significative, il est important de noter que cette technologie est encore à ses débuts. Une recherche et un développement continu sont cruciaux pour une amélioration ultérieure et une adoption plus large, et CodiumAI vous invite à faire votre contribution à cet outil open source.

Avantages de l’Open Source Cover-Agent

La nature open source de Cover-Agent offre plusieurs avantages qui devraient aider à propulser la technologie à l’avancement. Parmi eux :

  • Accessibilité : Sa nature open source permet des expériences de test basées sur LLM et est accessible aux développeurs de différents horizonsCela augmentera le nombre d’utilisateurs et mènera au développement de meilleure technologie et à plus d’applications..

  • Coopération : Les développeurs sont en mesure de faire des contributions, de suggérer des améliorations, de proposer de nouvelles fonctionnalités et de signaler des problèmes. Cover-Agent se développera rapidement en un projet parfait pour les développeurs..

  • Transparence : Les informations sur les opérations internes sont disponibles et cela favorise la confiance, ce qui augmentera finalement le potentiel de la technologie.

En plus de ses avantages open-source, Cover-Agent offre aux développeurs une série de avantages propres :

  • Accès Simple : Les développeurs peuvent installer et expérimenter facilement des tests basés sur LLM. Cela permet une exploration directe et immédiate des capacités de la technologie sans disruption significative de leur workflow.

  • Personnalisation selon des besoins spécifiques : La nature open-source de Cover-Agent permet aux développeurs deAdapter l’outil à leurs exigences spécifiques de projet. Cela pourrait涉及modifier le modèle LLM utilisé, ajuster les données d’entraînement pour mieux refléter leur code source, ou intégrer Cover-Agent avec des cadres de test existants. Cette niveau de personnalisation donne aux développeurs le pouvoir de tirer partie de la puissance des tests basés sur LLM de façon alignée avec leurs besoins de projet.

  • Intégration facile : Il est facilement intégré avec VSCode (un éditeur de code populaire), ce qui rend l’intégration avec les workflows existants aisée. Vous pouvez également le intégrer facilement avec des tests écrits à la main existants.diy9>

Comment pouvez-vous contribuer à Cover-Agent ?

Le code source de Cover-Agent est disponible au public via ce dépôt GitHub. Ils encourageont les développeurs de tous les horizons à tester leur produit et à apporter leurs contributions pour améliorer et faire grandir cette nouvelle technologie.

Conclusion

Les outils d’amélioration des tests basés sur les LLM (Large Language Models) possèdent un potentiel immense pour révolutionner la manière dont les développeurs approchent des tests unitaires. En exploitant le pouvoir des grands modèles de langue spécialement entraînés sur du code, ces outils peuvent automatiser la création de tests, améliorer la couverture du code et, en fin de compte, augmenter la qualité du logiciel.

Bien que la recherche de Meta avec TestGen-LLM offre des vues précieuses, l’absence de code disponible au public entrave la large adoption et le développement en cours. Heureusement, Cover-Agent a fourni une solution accessible et personnalisable. Elle donne aux développeurs la possibilité d’expérimenter avec les tests basés sur les LLM et de contribuer à leur évolution.

Le potentiel de TestGen-LLM et de Cover-Agent est immense, et leur développement futur grâce aux contributions des développeurs conduira à une nouvelle plateforme qui transformera définitivement la génération automatique de tests.

Connectez-vous avec moi sur LinkedIn et Twitter si vous avez trouvé cela utile.