Was macht Coverage Guard?
Stelle 100% Testabdeckung für jedes JavaScript/TypeScript-Projekt sicher. Erkennt automatisch den Test-Runner, richtet die Testinfrastruktur ein, falls sie fehlt, schreibt Tests für nicht abgedeckte Komponenten und wiederholt den Vorgang, bis jede Datei 100% Abdeckung erreicht.
Überblick
Dieser Skill durchläuft eine vollständige Pipeline:
- Erkennen des Runners & der Infrastruktur → 2. Scannen der Quell- und Testdateien → 3. Einrichten falls fehlend → 4. Generieren neuer Tests → 5. Ausführen der Abdeckung → 6. Schließen von Lücken → 7. Verifizieren → wiederholen bis 100%
Schritt-für-Schritt-Workflow
Phase 1: Umgebung erkennen
Überprüfe package.json im Projektstamm, um Folgendes zu ermitteln:
cat package.json
Identifiziere den Test-Runner und das Abdeckungstool:
| Indikator | Runner | Coverage-Befehl |
|---|---|---|
"vitest" in devDependencies | Vitest | npx vitest --coverage |
"jest" in devDependencies | Jest | npx jest --coverage |
"react-scripts" in devDependencies | react-scripts (Jest) | npx react-scripts test --coverage |
"next" in devDependencies | Next.js (Jest) | npx next test --coverage oder überprüfe jest.config |
"@angular/core" in dependencies | Angular (Karma/Jasmine) | ng test --code-coverage |
"@playwright/test" in devDependencies | Playwright | npx playwright test (kein eingebautes Coverage; verwende @playwright/test mit istanbul) |
"mocha" in devDependencies | Mocha | npx mocha (Coverage via c8/nyc) |
"cypress" in devDependencies | Cypress | npx cypress run (Coverage via @cypress/code-coverage) |
"ava" in devDependencies | AVA | npx ava (Coverage via c8) |
| Keiner gefunden | Keiner → weiter zu Phase 2 → Phase 3 Einrichtung |
Phase 2: Quell- und vorhandene Testdateien scannen
Finde alle Quelldateien (Komponenten, Module, Hilfsfunktionen), die Tests benötigen:
# Übliche Quellverzeichnisse
find src -type f \( -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.jsx" \) ! -name "*.test.*" ! -name "*.spec.*" ! -name "*.d.ts" ! -path "*/node_modules/*" ! -path "*/dist/*" ! -path "*/build/*" ! -path "*/.next/*"
Finde alle vorhandenen Testdateien:
find src -type f \( -name "*.test.*" -o -name "*.spec.*" \) ! -path "*/node_modules/*"
Ordne jeder Quelldatei eine Testdatei zu:
src/components/Button.tsx→src/components/Button.test.tsxodersrc/components/__tests__/Button.test.tsxsrc/utils/format.ts→src/utils/format.test.tsodersrc/utils/__tests__/format.test.ts- Folge der vorhandenen Projektkonvention für die Platzierung von Testdateien
Klassifiziere jede Quelldatei:
- Hat Test → zur Coverage-Analyse hinzufügen
- Kein Test → für Testgenerierung markieren
Phase 3: Testinfrastruktur einrichten (falls nicht vorhanden)
Wenn in Phase 1 kein Test-Runner erkannt wurde, frage den Benutzer interaktiv:
? Kein Test-Framework erkannt. Welches möchtest du einrichten?
1) Vitest (Empfohlen — schnell, modern, natives ESM)
2) Jest (Am weitesten verbreitet)
3) react-scripts (Create React App)
4) Keines — überspringen, ich richte es manuell ein
Sobald der Benutzer ausgewählt hat, installiere Abhängigkeiten und erstelle die Konfiguration:
Vitest-Einrichtung:
npm install -D vitest @vitest/coverage-v8
Erstelle vitest.config.ts:
import { defineConfig } from 'vitest/config'
export default defineConfig({
test: {
coverage: {
provider: 'v8',
reporter: ['text', 'json', 'html'],
exclude: [
'**/node_modules/**',
'**/dist/**',
'**/*.config.*',
'**/*.d.ts',
],
},
},
})
Füge zu package.json-Skripten hinzu:
{
"scripts": {
"test": "vitest",
"test:coverage": "vitest --coverage"
}
}
Jest-Einrichtung:
npm install -D jest @types/jest ts-jest
npx ts-jest config:init
npm install -D jest @testing-library/react @testing-library/jest-dom jest-environment-jsdom
Erstelle jest.config.ts:
export default {
testEnvironment: 'jsdom',
transform: {
'^.+\\.tsx?$': 'ts-jest',
},
coverageReporters: ['text', 'json', 'html'],
collectCoverageFrom: ['src/**/*.{ts,tsx}', '!src/**/*.d.ts'],
}
Füge zu package.json-Skripten hinzu:
{
"scripts": {
"test": "jest",
"test:coverage": "jest --coverage"
}
}
react-scripts-Einrichtung:
npm install -D @testing-library/react @testing-library/jest-dom @testing-library/user-event
Coverage ist bereits eingebaut:
{
"scripts": {
"test": "react-scripts test",
"test:coverage": "react-scripts test --coverage"
}
}
Führe nach der Einrichtung einen schnellen Test aus, um zu bestätigen, dass alles funktioniert:
npm test
Wenn es fehlschlägt, behebe Konfigurationsprobleme, bevor du fortfährst.
Phase 4: Tests für ungetestete Quelldateien schreiben
Analysiere für jede Quelldatei, die keine Testdatei hat, den Quellcode:
- Lese die Quelldatei
- Identifiziere:
- Alle exportierten Funktionen, Klassen, Komponenten
- Rückgabetypen und mögliche Rückgabepfade
- Parameter und deren Typen (erforderlich, optional, Standardwerte)
- Props-Interface (für React-Komponenten)
- Asynchrones Verhalten (Promises, async/await)
- Seiteneffekte (API-Aufrufe, localStorage usw.)
- Fehlerzustände und Randfälle
- Generiere die Testdatei gemäß den Projektkonventionen:
- Verwende die API des erkannten Test-Runners (
describe/it/expectfür Jest/Vitest usw.) - Für React: verwende
@testing-library/react(render,screen,fireEvent) - Mocke externe Abhängigkeiten
- Decke alle Verzweigungen, Randfälle und Fehlerpfade ab
- Verwende die API des erkannten Test-Runners (
React-Komponentenbeispiel (src/components/Button.tsx → src/components/Button.test.tsx):
import { render, screen, fireEvent } from '@testing-library/react'
import { Button } from './Button'
describe('Button', () => {
it('wird mit Label gerendert', () => {
render(<Button label="Klick mich" />)
expect(screen.getByText('Klick mich')).toBeInTheDocument()
})
it('ruft onClick beim Klicken auf', () => {
const onClick = vi.fn() // jest.fn() für Jest
render(<Button label="Klick" onClick={onClick} />)
fireEvent.click(screen.getByText('Klick'))
expect(onClick).toHaveBeenCalledTimes(1)
})
it('ist deaktiviert, wenn disabled prop true ist', () => {
render(<Button label="Klick" disabled />)
expect(screen.getByText('Klick')).toBeDisabled()
})
})
Hilfsfunktionsbeispiel (src/utils/format.ts → src/utils/format.test.ts):
import { formatCurrency, truncate } from './format'
describe('formatCurrency', () => {
it('formatiert ganzzahligen Betrag', () => {
expect(formatCurrency(1000)).toBe('$1.000,00')
})
it('formatiert Dezimalbetrag', () => {
expect(formatCurrency(99.95)).toBe('$99,95')
})
it('behandelt Null', () => {
expect(formatCurrency(0)).toBe('$0,00')
})
it('behandelt negative Werte', () => {
expect(formatCurrency(-50)).toBe('-$50,00')
})
})
Phase 5: Coverage-Bericht ausführen
Führe den entsprechenden Coverage-Befehl basierend auf dem erkannten Runner aus:
| Runner | Befehl |
|---|---|
| Vitest | npx vitest --coverage --reporter=verbose |
| Jest | npx jest --coverage --verbose |
| react-scripts | npx react-scripts test --coverage --watchAll=false |
| Andere | Verwende den konfigurierten Coverage-Befehl des Projekts |
Analysiere die Ausgabe, um Folgendes zu identifizieren:
- Dateien unter 100% Abdeckung
- Nicht abgedeckte Zeilen, Verzweigungen, Funktionen und Anweisungen
- Spezifische Zeilennummern, die Tests benötigen
- Dateien mit 0% Abdeckung (keine Tests vorhanden)
Phase 6: Coverage-Lücken analysieren und schließen
Analysiere für jede Datei unter 100% (einschließlich Dateien aus Phase 4, die jetzt Tests haben, aber nicht bei 100% sind):
- Lese die Quelldatei und ihre Testdatei nebeneinander
- Verstehe, was die nicht abgedeckten Zeilen/Funktionen/Verzweigungen tun
- Identifiziere, welche Randfälle in den Tests fehlen
- Schreibe gezielte Tests, um die Lücken zu schließen:
- Nicht abgedeckte Verzweigungen: Teste sowohl
if- als auchelse-Pfade, ternäre Bedingungen - Nicht abgedeckte Funktionen: Teste alle möglichen Rückgabepfade
- Nicht abgedeckte Zeilen: Verfolge die Logik und schreibe einen Fall, der sie erreicht
- Nicht abgedeckte asynchrone Pfade: Teste sowohl aufgelöste als auch abgelehnte Promise-Zweige
- Nicht abgedeckte Fehlerbehandlung: Teste Fehler-Callbacks, Catch-Blöcke, Fehlergrenzen
Verwende die Muster des erkannten Test-Runners:
- Vitest:
vi.mock(),vi.spyOn(),vi.fn() - Jest:
jest.mock(),jest.spyOn(),jest.fn() - react-scripts: Wie Jest
Phase 7: Verifizieren
Führe die Coverage nach dem Hinzufügen/Aktualisieren von Tests erneut aus:
# Verwende den erkannten Befehl
npx vitest --coverage # für Vitest
npx jest --coverage # für Jest
Bestätige, dass alle Dateien 100% bei Anweisungen, Verzweigungen, Funktionen und Zeilen anzeigen.
Phase 8: Wiederholen
Wenn die Abdeckung immer noch unter 100% liegt, gehe zurück zu Phase 6.
Konfiguration nach Runner
Vitest-Coverage-Konfiguration
Stelle sicher, dass vitest.config.ts:
import { defineConfig } from 'vitest/config'
export default defineConfig({
test: {
coverage: {
provider: 'v8',
reporter: ['text', 'json', 'html'],
exclude: [
'**/node_modules/**',
'**/dist/**',
'**/*.config.*',
'**/*.d.ts',
],
},
},
})
Jest-Coverage-Konfiguration
Stelle sicher, dass jest.config.ts Folgendes enthält:
export default {
collectCoverage: true,
coverageReporters: ['text', 'json', 'html'],
collectCoverageFrom: [
'src/**/*.{ts,tsx,js,jsx}',
'!src/**/*.d.ts',
'!src/**/*.test.*',
'!src/**/*.spec.*',
],
}
Tipps
- Beginne mit Dateien, die bereits Tests haben, aber eine niedrige Abdeckung aufweisen – schnellste Erfolge
- Bearbeite dann zuerst ungetestete Dateien mit der einfachsten Logik
- Für React-Komponenten: Teste Rendering, Benutzerinteraktionen, bedingtes Rendering, Fehlerzustände und leere/Ladezustände
- Für Hilfsfunktionen: Teste Randfälle (leere Strings, null/undefined, Grenzwerte, Sonderzeichen)
- Für API-Dienste: Teste Erfolgsantwort, Fehlerantwort, Ladezustand, Timeout und Netzwerkfehler
- Wenn toter Code gefunden wird (unmöglich abzudecken), schlage vor, ihn zu entfernen oder einen Coverage-Ignore-Kommentar hinzuzufügen:
- Vitest/V8:
/* c8 ignore next */oder/* c8 ignore next 3 */ - Jest/Istanbul:
/* istanbul ignore next */oder/* istanbul ignore if */
- Vitest/V8:
- Ändere KEINE Logik des Quellcodes – füge nur Tests hinzu oder aktualisiere sie
- Folge den vorhandenen Testmustern des Projekts (Dateibenennung, Ordnerstruktur, Mocking-Stil)
- Für Dateien mit 0 Tests: Erstelle eine umfassende Testdatei, die zuerst alle Hauptpfade abdeckt, und iteriere dann
Erkennungspriorität
Beim Scannen nach Quelldateien überprüfe in dieser Reihenfolge der üblichen Verzeichnisstrukturen:
src/app/(Next.js App-Verzeichnis)components/lib/utils/server/(Next.js/Node.js)pages/(Next.js Pages-Verzeichnis)- Root-Level
*.ts/*.tsx-Dateien
Beispiel
Benutzer: "Coverage-Bericht zeigt login.ts bei 72%, behebe es"
Agentenaktionen:
- Führe
npx vitest --coverage --reporter=verboseaus, sehe login.ts hat nicht abgedeckte Zeilen 45-52 (Fehlerzweig vonvalidateEmail) - Lese Quelle, verstehe, dass
validateEmailbei ungültigen E-Mails wirft - Füge Testfälle für ungültige E-Mail-Eingaben in
login.test.tshinzu - Führe Coverage erneut aus — login.ts jetzt bei 100%
Benutzer: "Wir verwenden jest, überprüfe Coverage"
- Führe
npx jest --coverage --verboseaus, identifiziere nicht abgedeckte Dateien - Finde
src/components/Header.tsxbei 0% — kein Test vorhanden - Lese Header.tsx-Quelle, erstelle
src/components/Header.test.tsx - Führe Coverage erneut aus — Header.tsx jetzt bei 100%
Benutzer: "Es gibt keine Testeinrichtung in diesem Projekt, füge Coverage hinzu"
- Erkenne keinen Test-Runner in package.json
- Frage Benutzer: "Kein Test-Framework erkannt. Vitest installieren? (Empfohlen)"
- Benutzer bestätigt → installiere vitest + @vitest/coverage-v8, erstelle vitest.config.ts
- Scanne src/, finde 8 Quelldateien, 0 Testdateien
- Schreibe Tests für alle 8 Dateien
- Führe Coverage aus — alle bei 100%