Tests et débogage

Verdent for VS Code vous aide à écrire des tests complets et à déboguer des problèmes grâce à des cycles multipasses de génération-test-réparation, une analyse des erreurs et des améliorations automatisées de la couverture de tests. Générez des tests unitaires, d'intégration et de bout en bout adaptés au framework de test et au style de votre projet.

Ce que vous allez apprendre

• Générer des tests unitaires couvrant les cas limites et le comportement attendu
• Travailler avec tous les principaux frameworks de test (Jest, Pytest, JUnit, etc.)
• Créer des tests d'intégration vérifiant des flux de travail multi-composants
• Améliorer la couverture de tests en identifiant et en testant les chemins de code non couverts
• Déboguer des problèmes grâce à l'analyse des messages d'erreur et au traçage d'exécution
• Diagnostiquer des bugs à partir de traces de pile, de journaux d'erreurs et de comportements inattendus

Prérequis

Avant de tester et déboguer avec Verdent :

• Visual Studio Code avec l'extension Verdent installée
• Une base de code ou un espace de travail de projet ouvert dans VS Code
• Une offre d'abonnement Verdent active avec des crédits disponibles
• Framework de test configuré dans votre projet (facultatif pour la génération de tests)

Rédiger des tests unitaires

Verdent génère des tests unitaires adaptés au framework de test et au style de votre projet. Il analyse les tests existants pour comprendre vos habitudes, puis génère des tests avec une configuration, des assertions et un mocking appropriés.

Exemple :

Write unit tests for the calculateDiscount function

Verdent va :

• Examiner l'implémentation de la fonction calculateDiscount
• Identifier les paramètres d'entrée et les valeurs de retour
• Analyser les tests existants pour respecter vos conventions (structure des tests, style d'assertion, conventions de nommage)
• Générer des tests couvrant :
  • Cas nominal : entrées valides avec les sorties attendues
  • Cas limites : valeurs limites, zéro, nombres négatifs, valeurs maximales
  • Entrées invalides : null, undefined, types incorrects
  • Comportement attendu : validation de la logique métier

Structure des tests générés :

Verdent crée des tests suivant les modèles de votre projet :

• Organisation de la suite de tests : blocs describe, classes de test ou structure de module
• Configuration et nettoyage : hooks before/after correspondant à vos tests existants
• Assertions : utilisant la bibliothèque d'assertions de votre projet (expect, assert, should, etc.)
• Mocking : correspondant à vos modèles de mocking (jest.mock, sinon, unittest.mock)
• Conventions de nommage : noms de tests suivant votre style établi

Cycles multipasses de génération-test-réparation :

Pour des tests complets, Verdent utilise des cycles multipasses :

1. Générer : créer une suite de tests initiale
2. Exécuter : lancer les tests pour vérifier qu'ils fonctionnent
3. Réparer : corriger les tests en échec ou améliorer la couverture
4. Itérer : répéter jusqu'à ce que les tests passent et que la couverture soit suffisante

Cela garantit que les tests ne sont pas seulement écrits mais fonctionnent réellement avec votre base de code.

Frameworks de test pris en charge

Verdent prend en charge tous les principaux frameworks de test dans différents langages de programmation et piles technologiques sans configuration supplémentaire.

test('sum returns correct result', () => {
  expect(sum(2, 3)).toBe(5);
});

const assert = require('assert');

describe('sum', () => {
  it('returns correct result', () => {
    assert.strictEqual(sum(2, 3), 5);
  });
});

import { describe, it, expect } from 'vitest';

it('sum returns correct result', () => {
  expect(sum(2, 3)).toBe(5);
});

describe('sum', () => {
  it('returns correct result', () => {
    expect(sum(2, 3)).toEqual(5);
  });
});

Verdent reconnaît votre framework de test à partir de la configuration de votre projet et des tests existants, et génère automatiquement des tests adaptés à votre configuration.

Générer des tests d'intégration

Verdent génère des tests d'intégration vérifiant comment plusieurs composants, services ou modules fonctionnent ensemble. Il crée des tests simulant des flux de travail réels, y compris les interactions API, les opérations de base de données, les flux d'authentification et les parcours utilisateur en plusieurs étapes.

Exemple :

Write integration tests for the user registration flow

Verdent génère des tests vérifiant le flux complet :

1. Soumission du formulaire : l'utilisateur soumet le formulaire d'inscription avec des données valides
2. Validation : le backend valide le format de l'e-mail, la robustesse du mot de passe, l'exhaustivité des données
3. Insertion en base de données : l'enregistrement utilisateur est créé dans la base de données
4. Envoi de l'e-mail : un e-mail de confirmation est envoyé (simulé ou réel)
5. Connexion réussie : le nouvel utilisateur peut se connecter immédiatement avec ses identifiants

Structure des tests d'intégration :

Verdent crée des tests d'intégration avec :

• Configuration des tests : alimentation de la base de données, initialisation des services, création de données de test
• Simulation du flux de travail : opérations en plusieurs étapes en séquence
• Vérification de l'état : contrôle de l'état de la base de données, réponses API, effets secondaires
• Simulation des services externes : services d'e-mail, APIs de paiement, intégrations tierces
• Nettoyage des tests : suppression des données de test, restauration de la base de données, arrêt des services

Exemples de scénarios de test :

Write integration tests for the checkout and payment process

Verdent teste :

• L'ajout d'articles au panier
• L'application de codes de réduction
• Le calcul des totaux avec taxes et frais de livraison
• Le traitement du paiement (avec une passerelle de paiement simulée)
• La création de l'enregistrement de commande en base de données
• L'envoi de l'e-mail de confirmation
• La mise à jour de l'inventaire

Isolation des tests :

Verdent garantit que les tests d'intégration sont correctement isolés :

• Chaque test commence avec un état de base de données propre
• Les appels aux services externes sont simulés pour éviter les effets secondaires
• Les tests peuvent s'exécuter dans n'importe quel ordre sans dépendances
• Le nettoyage a lieu même si les tests échouent

Améliorer la couverture de tests

Verdent analyse votre base de code pour identifier les fonctions, branches et cas limites non testés, puis génère des tests pour améliorer la couverture. Il examine votre suite de tests existante et identifie les lacunes où des chemins de code ne sont pas exercés.

Exemple :

Analyze test coverage and write tests for uncovered code paths in the payment module

Verdent va :

1. Analyser les tests existants : examiner ce qui est actuellement testé
2. Identifier les lacunes de couverture : trouver les fonctions spécifiques, les branches conditionnelles, les chemins de gestion d'erreurs et les cas limites non testés
3. Générer les tests manquants : créer des tests ciblant le code non couvert
4. Vérifier l'amélioration de la couverture : exécuter les tests pour confirmer l'augmentation de la couverture

Ce que Verdent identifie :

• Fonctions non testées : fonctions sans aucune couverture de test
• Branches conditionnelles : instructions if/else où une branche n'est pas testée
• Chemins de gestion d'erreurs : blocs try/catch ou callbacks d'erreur sans tests d'échec
• Cas limites : valeurs limites, gestion de null/undefined, coercition de type
• Points d'intégration : appels API, opérations de base de données, interactions avec des services externes

Exemple d'amélioration de la couverture :

Improve test coverage for the UserService class

Verdent identifie :

• getUserById a des tests pour les identifiants valides mais pas pour les identifiants invalides
• updateUser : tests manquants pour les échecs de validation
• deleteUser : tests manquants pour les contrôles d'autorisation
• Les chemins de gestion d'erreurs dans createUser ne sont pas testés

Puis génère des tests ciblant spécifiquement ces lacunes, faisant passer la couverture de 65 % à 95 %.

Métriques de couverture :

Verdent vous aide à atteindre des pourcentages de couverture plus élevés et à détecter des bugs potentiels dans du code jusqu'alors non testé :

• Couverture de lignes : pourcentage de lignes de code exécutées par les tests
• Couverture de branches : pourcentage de branches conditionnelles testées
• Couverture de fonctions : pourcentage de fonctions avec au moins un test
• Couverture d'instructions : pourcentage d'instructions exécutées

Déboguer avec Verdent

Verdent aide au débogage en analysant les messages d'erreur, en traçant le flux d'exécution, en identifiant les causes profondes et en suggérant des corrections. Collez des journaux d'erreurs, décrivez un comportement inattendu, ou demandez à Verdent d'investiguer des problèmes spécifiques.

This function returns undefined instead of the user object. Debug it.

The login form redirects to the home page even when credentials are invalid

The product search is slow when the database has 10,000+ products

Why does this API endpoint return a 500 error when the email parameter is missing?

Diagnostiquer à partir des messages d'erreur et des journaux

Collez les messages d'erreur, les traces de pile ou les fichiers journaux directement dans le chat. Verdent analyse l'erreur, identifie le fichier source et le numéro de ligne, explique la cause et suggère une correction.

TypeError: Cannot read property 'name' of undefined
    at UserProfile.render (UserProfile.jsx:45)
    at processComponent (react-dom.js:2103)

I'm getting this error: [paste stack trace]

Analyze these logs and tell me why the API requests are failing:
[paste 50 lines of log output]

The shopping cart total is sometimes incorrect. Here are the error logs: [paste logs]

Bonnes pratiques

Voir aussi