cover agent

L'agent de couverture de Codiumai vise à aider à augmenter efficacement la couverture du code, en générant automatiquement des tests qualifiés pour améliorer les suites de test existantes

Table des matières

• Nouvelles et mises à jour
• Aperçu
• Installation et utilisation
• Développement
• Feuille de route

Nouvelles et mises à jour

2024-11-05:

Nouveau mode - Analyser un dépôt entier, identifier automatiquement les fichiers de test, le contexte de collecte automatique pour chaque fichier de test et étendre la suite de tests avec de nouveaux tests. Voir plus de détails ici.

Agent de couverture

Bienvenue à Cover-Agent. Ce projet ciblé utilise une IA générative pour automatiser et améliorer la génération de tests (actuellement principalement des tests unitaires), visant à rationaliser les flux de travail de développement. Cover-Agent peut fonctionner via un terminal et devrait être intégré dans les plates-formes CI populaires.

Nous invitons la communauté à collaborer et à étendre les capacités de l'agent de couverture, poursuivant son développement en tant que solution de pointe dans le domaine automatisé de génération de tests unitaires. Nous souhaitons également inspirer les chercheurs à tirer parti de cet outil open source pour explorer de nouvelles techniques de génération de test.

Aperçu

Cet outil fait partie d'une suite plus large de services publics conçus pour automatiser la création de tests unitaires pour les projets logiciels. En utilisant des modèles d'IA génératifs avancés, il vise à simplifier et à accélérer le processus de test, en garantissant un développement de logiciels de haute qualité. Le système comprend plusieurs composants:

1. Test Runner: Exécute la commande ou les scripts pour exécuter la suite de test et générer des rapports de couverture de code.
2. Parser de couverture: valide que la couverture du code augmente à mesure que les tests sont ajoutés, garantissant que les nouveaux tests contribuent à l'efficacité globale des tests.
3. Invite Builder: rassemble les données nécessaires de la base de code et construit l'invite à être transmise au modèle de grande langue (LLM).
4. AI CAPLEUR: interagit avec le LLM pour générer des tests en fonction de l'invite fournie.

Installation et utilisation

Exigences

Avant de commencer, assurez-vous d'avoir ce qui suit:

• OPENAI_API_KEY SET dans vos variables d'environnement, qui est requise pour appeler l'API OpenAI.
• Outil de couverture de code: un rapport de couverture de code Cobertura XML est requis pour que l'outil fonctionne correctement.
  • Par exemple, dans Python, on pourrait utiliser pytest-cov . Ajoutez l'option --cov-report=xml lors de l'exécution de pyTest.
  • Remarque: Nous travaillons activement à ajouter plus de types de couverture, mais n'hésitez pas à ouvrir un RP et à contribuer à cover_agent/CoverageProcessor.py

Si vous exécutez directement à partir du référentiel, vous aurez également besoin:

• Python installé sur votre système.
• Poésie installée pour gérer les dépendances de package Python. Des instructions d'installation pour la poésie peuvent être trouvées sur https://python-poetry.org/docs/.

Exécution autonome

L'agent de couverture peut être installé en tant que package Python PIP ou s'exécuter en tant qu'exécutable autonome.

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

Le binaire peut être exécuté sans aucun environnement Python installé sur votre système (par exemple dans un conteneur Docker qui ne contient pas de python). Vous pouvez télécharger la version de votre système en accédant à la page de version du projet.

Configuration du référentiel

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

poetry install

Exécution du code

Après avoir téléchargé l'exécutable ou installé le package PIP, vous pouvez exécuter l'agent de couverture pour générer et valider les tests unitaires. Exécutez-le à partir de 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> " 
  --project-root " <path_to_project_root> " 
  --code-coverage-report-path " <path_to_coverage_report> " 
  --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 l'exemple de code ci-dessous pour essayer l'agent de couverture. (Notez que le fichier usage_examples fournit des exemples plus élaborés sur la façon d'utiliser l'agent de couverture)

Python

Suivez les étapes du fichier readme.md situé dans le répertoire templated_tests/python_fastapi/ pour configurer un environnement, puis revenez à la racine du référentiel, et exécutez la commande suivante pour ajouter des tests à l'exemple Python Fastapi :

cover-agent 
  --source-file-path " templated_tests/python_fastapi/app.py " 
  --test-file-path " templated_tests/python_fastapi/test_app.py " 
  --project-root " templated_tests/python_fastapi " 
  --code-coverage-report-path " templated_tests/python_fastapi/coverage.xml " 
  --test-command " pytest --cov=. --cov-report=xml --cov-report=term " 
  --test-command-dir " templated_tests/python_fastapi " 
  --coverage-type " cobertura " 
  --desired-coverage 70 
  --max-iterations 10

Aller

Pour un exemple en utilisant cd GO dans templated_tests/go_webservice , configurez le projet suivant le README.md . Pour travailler avec les rapports de couverture, vous devez installer gocov et gocov-xml . Exécutez les commandes suivantes pour installer ces outils:

go install github.com/axw/gocov/[email protected]
go install github.com/AlekSi/[email protected]

puis exécutez la commande suivante:

cover-agent 
  --source-file-path " app.go " 
  --test-file-path " app_test.go " 
  --code-coverage-report-path " coverage.xml " 
  --test-command " go test -coverprofile=coverage.out && gocov convert coverage.out | gocov-xml > coverage.xml " 
  --test-command-dir $( pwd ) 
  --coverage-type " cobertura " 
  --desired-coverage 70 
  --max-iterations 1

Java

Pour un exemple utilisant cd Java dans templated_tests/java_gradle , configurez le projet suivant le Readme.md. Pour travailler avec les rapports de la couverture Jacoco, suivez la section Readme.md Exigences: puis exécutez la commande suivante:

cover-agent 
  --source-file-path= " src/main/java/com/davidparry/cover/SimpleMathOperations.java " 
  --test-file-path= " src/test/groovy/com/davidparry/cover/SimpleMathOperationsSpec.groovy " 
  --code-coverage-report-path= " build/reports/jacoco/test/jacocoTestReport.csv " 
  --test-command= " ./gradlew clean test jacocoTestReport " 
  --test-command-dir= $( pwd ) 
  --coverage-type= " jacoco " 
  --desired-coverage=70 
  --max-iterations=1

Sorties

Quelques fichiers de débogage seront sortis localement dans le référentiel (qui font partie du .gitignore )

• run.log : une copie de l'enregistreur qui est jeté sur votre stdout
• test_results.html : un tableau de résultats qui contient les éléments suivants pour chaque test généré:
  • État de test
  • Raison de défaillance (le cas échéant)
  • Code de sortie,
  • stderr
  • stdout
  • Test généré

Journalisation supplémentaire

Si vous définissez une variable d'environnement WANDB_API_KEY , les invites, les réponses et les informations supplémentaires seront enregistrées en poids et biais.

Utilisation d'autres LLM

Ce projet utilise Litellm pour communiquer avec OpenAI et d'autres LLMs hébergés (prenant en charge plus de 100 LLMS à ce jour). Pour utiliser un modèle différent autre que la valeur par défaut OpenAI, vous devrez:

1. Exporter toutes les variables d'environnement nécessaires au LLM pris en charge suivant les instructions LitellM.
2. Appelez le nom du modèle à l'aide de l'option --model lors de l'appel de l'agent de couverture.

Par exemple (comme le montre le guide Litellm Quick Start):

 export VERTEX_PROJECT= " hardy-project "
export VERTEX_LOCATION= " us-west "

cover-agent 
  ...
  --model " vertex_ai/gemini-pro " 

Point de terminaison compatible OpenAI

 export OPENAI_API_KEY= " <your api key> " # If <your-api-base> requires an API KEY, set this value.

cover-agent 
  ...
  --model " openai/<your model name> " 
  --api-base " <your-api-base> " 

Point final compatible Azure Openai

 export AZURE_API_BASE= " <your api base> " # azure api base
export AZURE_API_VERSION= " <your api version> " # azure api version (optional)
export AZURE_API_KEY= " <your api key> " # azure api key

cover-agent 
  ...
  --model " azure/<your deployment name> " 

Développement

Voir le développement pour plus d'informations sur la façon de contribuer à ce projet.

Feuille de route

Vous trouverez ci-dessous la feuille de route des fonctionnalités planifiées, avec l'état de mise en œuvre actuel:

• Génère automatiquement des tests unitaires pour vos projets logiciels, en utilisant des modèles AI avancés pour assurer une couverture complète des tests et une assurance qualité. (similaire à Meta)
  • Pouvoir générer des tests pour différents langages de programmation
  • Pouvoir traiter une grande variété de scénarios de test
  • Générer une analyse du comportement pour le code testé et générer des tests en conséquence
  • Vérifiez le test de la floconneuse, par exemple en fonctionnant 5 fois comme suggéré par Testgen-llm
• Couvrir plus de douleurs de génération de tests
  • Générer de nouveaux tests qui sont axés sur le PR changeset
  • Exécutez sur un repo / base de code entier et tentez d'améliorer toutes les suites de test existantes
• Améliorer la convivialité
  • Connecteurs pour les actions GitHub, Jenkins, Circleci, Travis CI, et plus
  • Intégrer dans des bases de données, des API, de l'opentélémétrie et d'autres sources de données pour extraire des E / S pertinentes pour la génération de tests
  • Ajouter un fichier de paramètre

Qodoai

La mission de Qodoai est de permettre aux équipes de développement occupés d'augmenter et de maintenir leur intégrité de code. Nous proposons divers outils, notamment des versions "Pro" de nos outils open source, qui sont destinées à gérer la complexité de code de niveau d'entreprise et sont conscients de la base de code multi-REPO.

Essayez la version pro de Cover Agent, Qodo Cover!