CommunitySchreiben & Editierengithub.com

Coverage Guard

Eine KI-Agent-Fähigkeit, die 100% Testabdeckung für jedes JavaScript/TypeScript-Projekt erzwingt. Funktioniert mit Vitest, Jest, react-scripts und anderen Test-Runnern. Kompatibel mit opencode, Claude Code, Cursor, Windsurf und GitHub Copilot.

Was ist Coverage Guard?

Coverage Guard ist ein KI-Agent-Skill, der Entwicklerteams dabei unterstützt, eine vollständige Testabdeckung (100 %) in JavaScript- und TypeScript-Projekten zu erreichen. Der Skill erkennt automatisch den verwendeten Test-Runner (z. B. Vitest, Jest, react-scripts, Playwright, Mocha, Cypress, AVA) und führt einen mehrphasigen Workflow aus: Erkennung der Testumgebung, Scannen von Quell- und Testdateien, Einrichten der Testinfrastruktur (falls nicht vorhanden), Generieren neuer Tests, Ausführen der Codeabdeckungsanalyse und zielgerichtetes Schließen von Lücken – und wiederholt den Vorgang, bis 100% Abdeckung erreicht ist. Der Skill ist mit opencode, Claude Code, Cursor, Windsurf und GitHub Copilot kompatibel und unterstützt sowohl React-Komponenten (mit @testing-library/react) als auch reine Utility-Funktionen. Er generiert keine toten Code-Blöcke und respektiert bestehende Konventionen wie Dateibenennung, Ordnerstruktur und Mocking-Stil. Durch die iterative Vorgehensweise – Erkennung, Testgenerierung, Ausführung und Lückenschließung – stellt der Skill sicher, dass auch komplexe Anwendungen systematisch auf 100% Abdeckung gebracht werden.

Funktioniert mit✓Claude Code~Codex CLI✓Cursor✓OpenCode✓Windsurf
npx skills add sametcelikbicak/coverage-guard

Installed? Explore more Schreiben & Editieren skills: steipete/notion, langchain-ai/langchain, bytedance/podcast-generation · View all 6 →

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

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:

  1. 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:

IndikatorRunnerCoverage-Befehl
"vitest" in devDependenciesVitestnpx vitest --coverage
"jest" in devDependenciesJestnpx jest --coverage
"react-scripts" in devDependenciesreact-scripts (Jest)npx react-scripts test --coverage
"next" in devDependenciesNext.js (Jest)npx next test --coverage oder überprüfe jest.config
"@angular/core" in dependenciesAngular (Karma/Jasmine)ng test --code-coverage
"@playwright/test" in devDependenciesPlaywrightnpx playwright test (kein eingebautes Coverage; verwende @playwright/test mit istanbul)
"mocha" in devDependenciesMochanpx mocha (Coverage via c8/nyc)
"cypress" in devDependenciesCypressnpx cypress run (Coverage via @cypress/code-coverage)
"ava" in devDependenciesAVAnpx ava (Coverage via c8)
Keiner gefundenKeiner → 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.tsx oder src/components/__tests__/Button.test.tsx
  • src/utils/format.ts → src/utils/format.test.ts oder src/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:

  1. Lese die Quelldatei
  2. 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
  3. Generiere die Testdatei gemäß den Projektkonventionen:
    • Verwende die API des erkannten Test-Runners (describe/it/expect fü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

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:

RunnerBefehl
Vitestnpx vitest --coverage --reporter=verbose
Jestnpx jest --coverage --verbose
react-scriptsnpx react-scripts test --coverage --watchAll=false
AndereVerwende 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):

  1. Lese die Quelldatei und ihre Testdatei nebeneinander
  2. Verstehe, was die nicht abgedeckten Zeilen/Funktionen/Verzweigungen tun
  3. Identifiziere, welche Randfälle in den Tests fehlen
  4. Schreibe gezielte Tests, um die Lücken zu schließen:
  • Nicht abgedeckte Verzweigungen: Teste sowohl if- als auch else-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 */
  • Ä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:

  1. src/
  2. app/ (Next.js App-Verzeichnis)
  3. components/
  4. lib/
  5. utils/
  6. server/ (Next.js/Node.js)
  7. pages/ (Next.js Pages-Verzeichnis)
  8. Root-Level *.ts / *.tsx-Dateien

Beispiel

Benutzer: "Coverage-Bericht zeigt login.ts bei 72%, behebe es"

Agentenaktionen:

  1. Führe npx vitest --coverage --reporter=verbose aus, sehe login.ts hat nicht abgedeckte Zeilen 45-52 (Fehlerzweig von validateEmail)
  2. Lese Quelle, verstehe, dass validateEmail bei ungültigen E-Mails wirft
  3. Füge Testfälle für ungültige E-Mail-Eingaben in login.test.ts hinzu
  4. Führe Coverage erneut aus — login.ts jetzt bei 100%

Benutzer: "Wir verwenden jest, überprüfe Coverage"

  1. Führe npx jest --coverage --verbose aus, identifiziere nicht abgedeckte Dateien
  2. Finde src/components/Header.tsx bei 0% — kein Test vorhanden
  3. Lese Header.tsx-Quelle, erstelle src/components/Header.test.tsx
  4. Führe Coverage erneut aus — Header.tsx jetzt bei 100%

Benutzer: "Es gibt keine Testeinrichtung in diesem Projekt, füge Coverage hinzu"

  1. Erkenne keinen Test-Runner in package.json
  2. Frage Benutzer: "Kein Test-Framework erkannt. Vitest installieren? (Empfohlen)"
  3. Benutzer bestätigt → installiere vitest + @vitest/coverage-v8, erstelle vitest.config.ts
  4. Scanne src/, finde 8 Quelldateien, 0 Testdateien
  5. Schreibe Tests für alle 8 Dateien
  6. Führe Coverage aus — alle bei 100%

Verwandte Skills