Testen & Debuggen

Verdent for VS Code hilft Ihnen, umfassende Tests zu schreiben und Probleme durch mehrstufige Generate-Test-Repair-Zyklen, Fehleranalysen und automatisierte Verbesserungen der Testabdeckung zu debuggen. Erstellen Sie Unit-, Integrations- und End-to-End-Tests, die zum Testing-Framework und Stil Ihres Projekts passen.

Das lernen Sie

• Unit-Tests generieren, die Grenzfälle und erwartetes Verhalten abdecken
• Mit allen wichtigen Testing-Frameworks arbeiten (Jest, Pytest, JUnit usw.)
• Integrationstests erstellen, die Workflows mit mehreren Komponenten überprüfen
• Die Testabdeckung verbessern, indem nicht getestete Codepfade identifiziert und getestet werden
• Probleme mithilfe von Fehlermeldungsanalyse und Ausführungsverfolgung debuggen
• Fehler anhand von Stack-Traces, Fehlerprotokollen und unerwartetem Verhalten diagnostizieren

Voraussetzungen

Bevor Sie mit Verdent testen und debuggen:

• Visual Studio Code mit installierter Verdent-Erweiterung
• Eine Codebasis oder ein Projekt-Arbeitsbereich, der in VS Code geöffnet ist
• Aktives Verdent-Abonnement mit verfügbaren Credits
• Konfiguriertes Testing-Framework in Ihrem Projekt (optional für die Testgenerierung)

Unit-Tests schreiben

Verdent generiert Unit-Tests, die zum Testing-Framework und Stil Ihres Projekts passen. Es analysiert vorhandene Tests, um Ihre Muster zu verstehen, und generiert dann Tests mit passendem Setup, Assertions und Mocking.

Beispiel:

Write unit tests for the calculateDiscount function

Verdent wird:

• Die Implementierung der Funktion calculateDiscount untersuchen
• Eingabeparameter und Rückgabewerte identifizieren
• Vorhandene Tests analysieren, um Ihre Konventionen abzugleichen (Teststruktur, Assertion-Stil, Namensmuster)
• Tests generieren, die Folgendes abdecken:
  • Happy Path: Gültige Eingaben mit erwarteten Ausgaben
  • Grenzfälle: Grenzwerte, null, negative Zahlen, Maximalwerte
  • Ungültige Eingaben: null, undefined, falsche Typen
  • Erwartetes Verhalten: Validierung der Geschäftslogik

Generierte Teststruktur:

Verdent erstellt Tests, die den Mustern Ihres Projekts folgen:

• Organisation der Testsuite: Describe-Blöcke, Testklassen oder Modulstruktur
• Setup und Teardown: Before/After-Hooks passend zu Ihren vorhandenen Tests
• Assertions: Verwendung der Assertion-Bibliothek Ihres Projekts (expect, assert, should usw.)
• Mocking: Passend zu Ihren Mocking-Mustern (jest.mock, sinon, unittest.mock)
• Namenskonventionen: Testnamen nach Ihrem etablierten Stil

Mehrstufige Generate-Test-Repair-Zyklen:

Für umfassendes Testen nutzt Verdent mehrstufige Zyklen:

1. Generieren: Erstellen der initialen Testsuite
2. Ausführen: Tests ausführen, um zu prüfen, ob sie funktionieren
3. Reparieren: Fehlgeschlagene Tests korrigieren oder die Abdeckung verbessern
4. Iterieren: Wiederholen, bis die Tests bestehen und die Abdeckung ausreichend ist

Dadurch wird sichergestellt, dass Tests nicht nur geschrieben werden, sondern auch tatsächlich korrekt mit Ihrer Codebasis funktionieren.

Unterstützte Test-Frameworks

Verdent unterstützt alle wichtigen Testing-Frameworks in verschiedenen Programmiersprachen und Technologie-Stacks, ohne dass eine zusätzliche Konfiguration erforderlich ist.

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 erkennt Ihr Testing-Framework anhand Ihrer Projektkonfiguration und vorhandenen Tests und generiert automatisch Tests, die zu Ihrem Setup passen.

Integrationstests generieren

Verdent generiert Integrationstests, die überprüfen, wie mehrere Komponenten, Dienste oder Module zusammenarbeiten. Es erstellt Tests, die reale Workflows simulieren, einschließlich API-Interaktionen, Datenbankoperationen, Authentifizierungsabläufen und mehrstufigen Nutzerabläufen.

Beispiel:

Write integration tests for the user registration flow

Verdent generiert Tests, die den vollständigen Ablauf überprüfen:

1. Formularübermittlung: Nutzer übermittelt Registrierungsformular mit gültigen Daten
2. Validierung: Backend validiert E-Mail-Format, Passwortstärke, Datenvollständigkeit
3. Datenbankeinfügung: Nutzerdatensatz wird in der Datenbank erstellt
4. E-Mail-Versand: Bestätigungs-E-Mail wird gesendet (gemockt oder tatsächlich)
5. Erfolgreiche Anmeldung: Neuer Nutzer kann sich sofort mit seinen Zugangsdaten anmelden

Struktur des Integrationstests:

Verdent erstellt Integrationstests mit:

• Test-Setup: Datenbank-Seeding, Dienstinitialisierung, Erstellung von Testdaten
• Workflow-Simulation: Mehrstufige Operationen in Reihenfolge
• Zustandsüberprüfung: Prüfung von Datenbankzustand, API-Antworten, Nebeneffekten
• Mocking externer Dienste: E-Mail-Dienste, Zahlungs-APIs, Drittanbieter-Integrationen
• Test-Teardown: Bereinigung der Testdaten, Datenbank-Rollback, Herunterfahren der Dienste

Beispiel-Testszenarien:

Write integration tests for the checkout and payment process

Verdent testet:

• Hinzufügen von Artikeln zum Warenkorb
• Anwenden von Rabattcodes
• Berechnung der Gesamtsummen mit Steuer und Versand
• Zahlungsabwicklung (mit gemocktem Payment-Gateway)
• Erstellung des Bestelldatensatzes in der Datenbank
• Versand der Bestätigungs-E-Mail
• Aktualisierung des Lagerbestands

Testisolation:

Verdent stellt sicher, dass Integrationstests ordnungsgemäß isoliert sind:

• Jeder Test beginnt mit einem sauberen Datenbankzustand
• Aufrufe externer Dienste werden gemockt, um Nebeneffekte zu vermeiden
• Tests können in beliebiger Reihenfolge ohne Abhängigkeiten ausgeführt werden
• Die Bereinigung erfolgt auch dann, wenn Tests fehlschlagen

Testabdeckung verbessern

Verdent analysiert Ihre Codebasis, um nicht getestete Funktionen, Verzweigungen und Grenzfälle zu identifizieren, und generiert dann Tests zur Verbesserung der Abdeckung. Es untersucht Ihre vorhandene Testsuite und identifiziert Lücken, in denen Codepfade nicht durchlaufen werden.

Beispiel:

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

Verdent wird:

1. Vorhandene Tests analysieren: Untersuchen, was derzeit getestet wird
2. Abdeckungslücken identifizieren: Bestimmte Funktionen, bedingte Verzweigungen, Fehlerbehandlungspfade und Grenzfälle finden, für die Tests fehlen
3. Fehlende Tests generieren: Tests erstellen, die auf nicht abgedeckten Code abzielen
4. Verbesserung der Abdeckung überprüfen: Tests ausführen, um die Steigerung der Abdeckung zu bestätigen

Was Verdent identifiziert:

• Nicht getestete Funktionen: Funktionen ohne jegliche Testabdeckung
• Bedingte Verzweigungen: If/else-Anweisungen, bei denen ein Zweig nicht getestet wird
• Fehlerbehandlungspfade: Try/catch-Blöcke oder Fehler-Callbacks ohne Fehlertests
• Grenzfälle: Grenzwerte, Behandlung von null/undefined, Typkonvertierung
• Integrationspunkte: API-Aufrufe, Datenbankoperationen, Interaktionen mit externen Diensten

Beispiel für eine Verbesserung der Abdeckung:

Improve test coverage for the UserService class

Verdent identifiziert:

• getUserById hat Tests für gültige IDs, aber nicht für ungültige IDs
• updateUser fehlende Tests für Validierungsfehler
• deleteUser fehlende Tests für Autorisierungsprüfungen
• Fehlerbehandlungspfade in createUser sind ungetestet

Anschließend werden Tests generiert, die gezielt auf diese Lücken abzielen und die Abdeckung von 65 % auf 95 % erhöhen.

Abdeckungsmetriken:

Verdent hilft Ihnen, höhere Abdeckungsprozentsätze zu erreichen und potenzielle Fehler in bisher ungetestetem Code zu erkennen:

• Zeilenabdeckung: Prozentsatz der von Tests ausgeführten Codezeilen
• Verzweigungsabdeckung: Prozentsatz der getesteten bedingten Verzweigungen
• Funktionsabdeckung: Prozentsatz der Funktionen mit mindestens einem Test
• Anweisungsabdeckung: Prozentsatz der ausgeführten Anweisungen

Debuggen mit Verdent

Verdent hilft beim Debuggen, indem es Fehlermeldungen analysiert, den Ausführungsablauf verfolgt, Grundursachen identifiziert und Lösungen vorschlägt. Fügen Sie Fehlerprotokolle ein, beschreiben Sie unerwartetes Verhalten oder bitten Sie Verdent, bestimmte Probleme zu untersuchen.

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?

Diagnose anhand von Fehlermeldungen und Protokollen

Fügen Sie Fehlermeldungen, Stack-Traces oder Protokolldateien direkt in den Chat ein. Verdent analysiert den Fehler, identifiziert die Quelldatei und Zeilennummer, erklärt die Ursache und schlägt eine Lösung vor.

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]

Best Practices

Siehe auch