# Testen & Debuggen (/de/docs/verdent-for-vscode/task-based-guides/testing-debugging)
> Testing- und Debugging-Workflows mit Verdent
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 [#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 [#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 [#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.
Verdent analysiert Ihre vorhandenen Tests, um Ihre Konventionen abzugleichen. Je einheitlicher Ihre vorhandenen Testmuster sind, desto besser passen die von Verdent generierten Tests zum Stil Ihres Projekts.
***
## Unterstützte Test-Frameworks [#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.
**Unit-Testing-Frameworks:**
```javascript Jest
test('sum returns correct result', () => {
expect(sum(2, 3)).toBe(5);
});
```
```javascript Mocha
const assert = require('assert');
describe('sum', () => {
it('returns correct result', () => {
assert.strictEqual(sum(2, 3), 5);
});
});
```
```javascript Vitest
import { describe, it, expect } from 'vitest';
it('sum returns correct result', () => {
expect(sum(2, 3)).toBe(5);
});
```
```javascript Jasmine
describe('sum', () => {
it('returns correct result', () => {
expect(sum(2, 3)).toEqual(5);
});
});
```
**Framework-spezifisches Testen:**
* **React Testing Library** – Nutzerorientiertes Testen von React-Komponenten
* **Vue Test Utils** – Offizielle Testing-Bibliothek für Vue.js
**End-to-End-Testing:**
* **Cypress** – End-to-End- und Komponententests
* **Playwright** – Browserübergreifendes End-to-End-Testing
* **Puppeteer** – Testen mit Headless Chrome
* **Pytest** – Das beliebteste Testing-Framework für Python
* **unittest** – Integriertes Testing-Framework für Python
* **nose2** – Erweitert unittest um Plugins
* **doctest** – In Docstrings eingebettete Tests
Verdent generiert Tests mit passenden Fixtures, Parametrisierung und Assertion-Mustern, die zu Ihrem Python-Teststil passen.
* **JUnit** – Standard-Testing-Framework für Java (JUnit 4, JUnit 5)
* **TestNG** – Testing-Framework mit erweiterten Funktionen
* **Mockito** – Mocking-Framework für Java
* **AssertJ** – Fluent Assertion-Bibliothek
Verdent erstellt Tests mit Annotationen, Lifecycle-Methoden und Assertions nach Java-Testkonventionen.
* **RSpec** (Ruby) – Framework für verhaltensgetriebene Entwicklung
* **PHPUnit** (PHP) – Unit-Testing-Framework für PHP
* **Go testing** (Go) – Integriertes Testing-Paket für Go
* **xUnit** (C#/.NET) – Testing-Framework für .NET
* **Catch2** (C++) – Modernes Testing-Framework für C++
Verdent passt sich den Test-Idiomen Ihrer Sprache an und generiert Tests, die zu den Konventionen Ihres Projekts passen.
Verdent erkennt Ihr Testing-Framework anhand Ihrer Projektkonfiguration und vorhandenen Tests und generiert automatisch Tests, die zu Ihrem Setup passen.
***
## Integrationstests generieren [#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
Integrationstests profitieren von isolierten Testumgebungen. Verdent kann helfen, Datenbank-Fixtures einzurichten und externe Dienste zu mocken.
Integrationstests überprüfen, dass Komponenten korrekt zusammenarbeiten. Sie sind komplexer als Unit-Tests, bieten aber mehr Sicherheit, dass reale Workflows wie erwartet funktionieren.
***
## Testabdeckung verbessern [#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 [#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.
Beschreiben Sie, was nicht stimmt und was Sie erwartet haben:
```
This function returns undefined instead of the user object. Debug it.
```
Verdent wird:
* Die Funktionsimplementierung lesen
* Den Ausführungsablauf verfolgen
* Identifizieren, wo der Codepfad falsch läuft (fehlende Return-Anweisung, falsche Bedingung, Async/Await-Problem)
* Eine Lösung mit Erklärung vorschlagen
* Testfälle vorschlagen, um Regressionen zu vermeiden
**Beispiel:**
```
The login form redirects to the home page even when credentials are invalid
```
Verdent wird:
* Die Logik der Anmeldeformular-Übermittlung untersuchen
* Den Authentifizierungsablauf verfolgen
* Den Fehler identifizieren (Weiterleitung erfolgt, bevor die asynchrone Validierung abgeschlossen ist)
* Eine Lösung vorschlagen (auf die Validierung warten, bevor weitergeleitet wird)
Performance-Analyse anfordern:
```
The product search is slow when the database has 10,000+ products
```
Verdent wird:
* Die Implementierung der Suchanfrage analysieren
* Ineffizienzen identifizieren (N+1-Abfragen, fehlender Datenbankindex, ineffizienter Algorithmus)
* Optimierungen vorschlagen (Datenbankindex hinzufügen, Abfragen bündeln, Ergebnisse cachen)
Performance-Debugging hilft, Engpässe in Algorithmen, Datenbankabfragen oder API-Antworten zu identifizieren, die Ihre Anwendung verlangsamen.
Verstehen, wie Code ausgeführt wird:
```
Why does this API endpoint return a 500 error when the email parameter is missing?
```
Verdent wird:
* Die Anfragebearbeitung vom Endpunkt über die Validierung bis zur Datenbank verfolgen
* Identifizieren, wo der Fehler auftritt (Zugriff auf eine Eigenschaft von undefined)
* Erklären, warum der Fehler auftritt (fehlende Null-Prüfung vor dem Eigenschaftszugriff)
* Eine defensive Lösung vorschlagen (Parameter validieren, bevor sie verwendet werden)
Die Verfolgung des Ausführungsablaufs hilft Ihnen zu verstehen, welchen Pfad Ihr Code nimmt und wo er vom erwarteten Verhalten abweicht.
Fügen Sie Fehlermeldungen oder Stack-Traces direkt in den Chat ein. Verdent analysiert den Fehler, lokalisiert den problematischen Code und erklärt, was mit genauen Dateipfaden und Zeilennummern schiefgelaufen ist.
***
## Diagnose anhand von Fehlermeldungen und Protokollen [#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.
Fehlermeldungen und Stack-Traces einfügen:
```
TypeError: Cannot read property 'name' of undefined
at UserProfile.render (UserProfile.jsx:45)
at processComponent (react-dom.js:2103)
```
Fügen Sie dies in Verdent ein:
```
I'm getting this error: [paste stack trace]
```
Verdent wird:
* Den Fehlertyp identifizieren (TypeError durch Zugriff auf null/undefined)
* Die genaue Zeile lokalisieren (`UserProfile.jsx:45`)
* Den Code an dieser Stelle lesen
* Erklären, warum es passiert (Nutzerobjekt ist undefined, bevor die Daten geladen werden)
* Lösungen vorschlagen:
* Null-Prüfung hinzufügen: `if (!user) return `
* Optional Chaining verwenden: `user?.name`
* Sicherstellen, dass Daten geladen werden, bevor die Komponente gerendert wird
Protokolldateien oder Konsolenausgaben zur Analyse einfügen:
```
Analyze these logs and tell me why the API requests are failing:
[paste 50 lines of log output]
```
Verdent wird:
* Die Protokolle nach Fehlermustern durchsuchen
* Authentifizierungsfehler, Netzwerk-Timeouts oder Datenbankfehler identifizieren
* Die Abfolge der Ereignisse verfolgen, die zum Fehler geführt haben
* Lösungen basierend auf dem Fehlermuster vorschlagen
Die Protokollanalyse hilft, Muster über mehrere Fehler hinweg zu erkennen und die Abfolge der Ereignisse zu verstehen, die zu Fehlern geführt haben.
Bei komplexen Problemen nutzt Verdent mehrstufiges Debugging:
1. **Fehlerprotokolle analysieren**, um den Fehlerpunkt zu identifizieren
2. **Relevanten Code lesen**, um die Implementierung zu verstehen
3. **Ausführungsablauf verfolgen**, um herauszufinden, wo etwas schiefläuft
4. **Lösungen vorschlagen** mit Codebeispielen
5. **Tests generieren**, um Regressionen zu vermeiden
**Beispiel:**
```
The shopping cart total is sometimes incorrect. Here are the error logs: [paste logs]
```
Verdent wird:
1. Protokolle analysieren und feststellen, wann der Fehler auftritt (wenn Rabattcodes angewendet werden)
2. Die Rabattberechnungslogik lesen
3. Den Fehler identifizieren (Rabatt wird vor der Steuer berechnet, nicht danach)
4. Eine Lösung vorschlagen (Berechnungsschritte neu anordnen)
5. Testfälle vorschlagen (Warenkorb mit Rabatt, Warenkorb mit Steuer, Warenkorb mit beidem)
***
## Best Practices [#best-practices]
Schreiben Sie Tests während der Entwicklung von Funktionen, nicht erst danach. Verdent kann Tests direkt nach dem Erstellen neuer Funktionen oder Komponenten generieren.
Verdent passt sich den Testmustern Ihres Projekts an. Halten Sie eine einheitliche Teststruktur ein, damit Verdent Tests generiert, die zu Ihren Konventionen passen.
Bitten Sie Verdent, Grenzbedingungen, Fehlerszenarien und ungewöhnliche Eingaben zu testen: „Schreibe Tests einschließlich Grenzfällen für ungültige Eingaben und Grenzwerte.“
Paraphrasieren Sie Fehler nicht. Fügen Sie den vollständigen Stack-Trace für eine genaue Diagnose und schnellere Lösung ein.
Geben Sie beim Debuggen klar an, was Sie erwartet haben und was tatsächlich passiert ist. Dieser Kontext hilft Verdent, die Grundursache zu identifizieren.
Fordern Sie für kritische Funktionen eine umfassende Testgenerierung mit mehrstufigen Zyklen an: „Generiere umfassende Tests für das Zahlungsmodul und überprüfe, dass sie alle bestehen.“
Fordern Sie nach dem Refactoring von Code Tests an, um zu überprüfen, dass die Funktionalität erhalten bleibt: „Generiere Tests, um zu überprüfen, dass das refaktorierte Authentifizierungsmodul korrekt funktioniert.“
Fordern Sie nach dem Beheben eines Fehlers einen Test an, um eine Regression zu vermeiden: „Schreibe einen Test, der sicherstellt, dass dieser Fehler nicht erneut auftritt.“
***
## Siehe auch [#siehe-auch]
Erfahren Sie, wie Sie mit der KI-Unterstützung von Verdent neue Funktionen schreiben
Verbessern Sie die Codequalität durch sichere Refactoring-Workflows