CommunityCodierung & Entwicklunggithub.com

tests-guidelines

Eine Coding-Skill zur testgetriebenen Entwicklung (TDD) mit 80%+ Testabdeckung über Unit-, Integrations- und E2E-Tests. Auslöser: /tests-guidelines, „tests“, „coverage“, „unit test“, „integration test“, „TDD“.

Was ist tests-guidelines?

Diese Skill implementiert einen vollständigen Test-Driven-Development-Workflow für KI-Assistenten. Sie stellt sicher, dass während der Arbeit – sei es beim Hinzufügen neuer Features, Beheben von Bugs oder Refactoring – stets die Tests vor dem Code geschrieben werden und eine Gesamtabdeckung von mindestens 80 % erreicht wird. Der Workflow unterscheidet klar zwischen Unit-, Integrations- und E2E-Tests und bietet detaillierte Anleitungen zum Erkennen des korrekten Test-Runners (npm, pnpm, yarn oder Bun nativen Test Runner) anhand der Projektkonfiguration. Die Skill enthält konkrete Code-Beispiele für Jest/Vitest, Bun und Playwright sowie Patterns für das Mocken externer Dienste wie Supabase, Redis und OpenAI. Ziel ist es, eine robuste Testsuite aufzubauen, die als Sicherheitsnetz für schnelles und zuverlässiges Refactoring und Deployment dient.

Funktioniert mit✓Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/orenatobr/tests-guidelines/tree/HEAD/skills/tests-guidelines

Installed? Explore more Codierung & Entwicklung skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

In Ihrer bevorzugten KI fragen

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

Dokumentation


name: tests-guidelines description: Verwenden beim Schreiben von Tests oder bei TDD: neue Features, Bugfixes, Refactoring. Erzwingt test-first-Entwicklung mit 80%+ Abdeckung über Unit-, Integrations- und E2E-Tests. Auslöser: /tests-guidelines, "tests", "coverage", "unit test", "integration test", "TDD". license: MIT source: https://github.com/affaan-m/everything-claude-code (Skill tdd-workflow, MIT), angepasst

Test-Driven Development Workflow

Diese Skill stellt sicher, dass die gesamte Codeentwicklung den TDD-Prinzipien mit umfassender Testabdeckung folgt.

Wann aktivieren

  • Schreiben neuer Features oder Funktionalitäten
  • Beheben von Bugs oder Problemen
  • Refactoring von vorhandenem Code
  • Hinzufügen von API-Endpunkten
  • Erstellen neuer Komponenten

Kernprinzipien

1. Tests VOR Code

Immer zuerst Tests schreiben, dann Code implementieren, um die Tests zu bestehen.

2. Abdeckungsanforderungen

  • Mindestens 80 % Abdeckung (Unit + Integration + E2E)
  • Alle Randfälle abgedeckt
  • Fehlerszenarien getestet
  • Grenzbedingungen überprüft

3. Testarten

Unit-Tests

  • Einzelne Funktionen und Hilfsmittel
  • Komponentenlogik
  • Reine Funktionen
  • Helfer und Hilfsprogramme

Integrationstests

  • API-Endpunkte
  • Datenbankoperationen
  • Service-Interaktionen
  • Externe API-Aufrufe

E2E-Tests (Playwright)

  • Kritische Benutzerabläufe
  • Vollständige Workflows
  • Browser-Automatisierung
  • UI-Interaktionen

TDD-Workflow-Schritte

Schritt 0: Test-Runner erkennen

Gehen Sie nicht von npm test aus. Die Befehle in den folgenden Schritten und Beispielen verwenden <test>, <test-watch> und <coverage> als Platzhalter für den tatsächlichen Runner des Projekts. Lösen Sie diese einmalig vor Beginn auf:

  1. Finden Sie den Runner des Projekts. Lesen Sie package.json (packageManager, scripts.test), die Lockdatei, pyproject.toml / pytest.ini, go.mod, Cargo.toml. Der erste Treffer gewinnt; nehmen Sie nicht npm test an.

  2. Unterscheiden Sie den Paketmanager vom Test-Runner. Sie sind nicht dasselbe. Ein Projekt kann Bun zum Installieren von Abhängigkeiten verwenden, aber dennoch Jest oder Vitest ausführen. Untersuchen Sie scripts.test in package.json und die Testdateien:

    • scripts.test ruft jest / vitest auf -> Ausführung über den erkannten PM (npm test, pnpm test, yarn test oder bun run test).
    • scripts.test ist bun test, oder Testdateien importieren { test, expect } from "bun:test", oder es gibt keine Jest/Vitest-Konfiguration, aber Bun ist vorhanden -> Verwenden Sie Buns nativen Runner (bun test). Siehe Bun-Natives-Test-Muster unten.
    • Python: <test> = pytest, <coverage> = pytest --cov --cov-fail-under=80. Go: go test ./... und go test -cover ./.... Rust: cargo test.

Runner-Befehlsmatrix:

Runner<test><test-watch><coverage><lint>
npmnpm testnpm test -- --watchnpm run test:coveragenpm run lint
pnpmpnpm testpnpm test --watchpnpm test:coveragepnpm lint
yarnyarn testyarn test --watchyarn test:coverageyarn lint
Bun (Skript führt jest/vitest aus)bun run testbun run test --watchbun run test:coveragebun run lint
Bun (nativ bun:test)bun testbun test --watchbun test --coveragebun run lint

bun test (Buns eingebauter Runner) ist nicht dasselbe wie bun run test (das das test-Skript in package.json ausführt). Die falsche Wahl zu treffen, ist ein häufiger Fehler – z. B. bricht das Ausführen von Jest über npx/bun run in einem ESM-only-Projekt, während bun test die Suite nativ ausführt. Bestätigen Sie, was das Projekt erwartet, bevor Sie das ROTE Tor passieren, und ersetzen Sie dann <test> / <coverage> überall dort, wo unten npm test steht.

Schritt 1: Benutzerreisen schreiben

Als [Rolle] möchte ich [Aktion], um [Nutzen]

Beispiel:
Als Benutzer möchte ich Märkte semantisch durchsuchen,
um relevante Märkte auch ohne exakte Suchbegriffe zu finden.

Schritt 2: Testfälle generieren

Erstellen Sie für jede Benutzerreise umfassende Testfälle:

describe('Semantische Suche', () => {
  it('gibt relevante Märkte für die Abfrage zurück', async () => {
    // Testimplementierung
  })

  it('behandelt leere Abfrage ordnungsgemäß', async () => {
    // Randfall testen
  })

  it('greift auf Teilstring-Suche zurück, wenn Redis nicht verfügbar ist', async () => {
    // Fallback-Verhalten testen
  })

  it('sortiert Ergebnisse nach Ähnlichkeitswert', async () => {
    // Sortierlogik testen
  })
})

Schritt 3: Tests ausführen (Sie sollten fehlschlagen)

<test>
# Tests sollten fehlschlagen - wir haben noch nicht implementiert

Schritt 4: Code implementieren

Schreiben Sie minimalen Code, um die Tests zu bestehen:

// Von Tests geleitete Implementierung
export async function searchMarkets(query: string) {
  // Implementierung hier
}

Schritt 5: Tests erneut ausführen

<test>
# Tests sollten jetzt bestehen

Schritt 6: Refactoring

Verbessern Sie die Codequalität, während die Tests grün bleiben:

  • Duplikate entfernen
  • Benennung verbessern
  • Leistung optimieren
  • Lesbarkeit verbessern

Schritt 7: Abdeckung überprüfen

<coverage>
# Überprüfen, ob 80%+ Abdeckung erreicht wurde

Testmuster

Unit-Test-Muster (Jest/Vitest)

import { render, screen, fireEvent } from '@testing-library/react'
import { Button } from './Button'

describe('Button-Komponente', () => {
  it('rendert mit korrektem Text', () => {
    render(<Button>Klick mich</Button>)
    expect(screen.getByText('Klick mich')).toBeInTheDocument()
  })

  it('ruft onClick beim Klicken auf', () => {
    const handleClick = jest.fn()
    render(<Button onClick={handleClick}>Klick</Button>)

    fireEvent.click(screen.getByRole('button'))

    expect(handleClick).toHaveBeenCalledTimes(1)
  })

  it('ist deaktiviert, wenn disabled-Prop true ist', () => {
    render(<Button disabled>Klick</Button>)
    expect(screen.getByRole('button')).toBeDisabled()
  })
})

Bun-Natives-Test-Muster (bun:test)

Wenn das Projekt Buns eingebauten Runner verwendet (siehe Schritt 0), importieren Sie von bun:test und führen Sie mit bun test aus – nicht bun run test. Die API ähnelt Jest, sodass describe / it / expect und die meisten Matcher übernommen werden können.

import { describe, it, expect, mock } from 'bun:test'
import { searchMarkets } from './search'

describe('searchMarkets', () => {
  it('gibt eine leere Liste für eine leere Abfrage zurück', async () => {
    expect(await searchMarkets('')).toEqual([])
  })

  it('sortiert Ergebnisse nach Ähnlichkeitswert', async () => {
    const results = await searchMarkets('election')
    expect(results).toEqual([...results].sort((a, b) => b.score - a.score))
  })
})
bun test              # einmal ausführen (ROTES/GRÜNES Tor)
bun test --watch      # Watch-Modus während der Entwicklung
bun test --coverage   # Abdeckungsbericht
  • Mocken Sie Module mit mock.module(...) / mock(...) aus bun:test anstelle von jest.mock(...).
  • Konfigurieren Sie Abdeckungsschwellen in bunfig.toml unter [test] (z. B. coverageThreshold) anstelle des Jest coverageThresholds-Konfigurationsblocks.

API-Integrationstest-Muster

import { NextRequest } from 'next/server'
import { GET } from './route'

describe('GET /api/markets', () => {
  it('gibt Märkte erfolgreich zurück', async () => {
    const request = new NextRequest('http://localhost/api/markets')
    const response = await GET(request)
    const data = await response.json()

    expect(response.status).toBe(200)
    expect(data.success).toBe(true)
    expect(Array.isArray(data.data)).toBe(true)
  })

  it('validiert Abfrageparameter', async () => {
    const request = new NextRequest('http://localhost/api/markets?limit=invalid')
    const response = await GET(request)

    expect(response.status).toBe(400)
  })

  it('behandelt Datenbankfehler ordnungsgemäß', async () => {
    // Datenbankfehler simulieren
    const request = new NextRequest('http://localhost/api/markets')
    // Fehlerbehandlung testen
  })
})

E2E-Test-Muster (Playwright)

import { test, expect } from '@playwright/test'

test('Benutzer kann Märkte suchen und filtern', async ({ page }) => {
  // Zur Märkte-Seite navigieren
  await page.goto('/')
  await page.click('a[href="/markets"]')

  // Prüfen, ob Seite geladen ist
  await expect(page.locator('h1')).toContainText('Märkte')

  // Nach Märkten suchen
  await page.fill('input[placeholder="Märkte durchsuchen"]', 'election')

  // Auf Entprellung und Ergebnisse warten
  await page.waitForTimeout(600)

  // Prüfen, ob Suchergebnisse angezeigt werden
  const results = page.locator('[data-testid="market-card"]')
  await expect(results).toHaveCount(5, { timeout: 5000 })

  // Prüfen, ob Ergebnisse den Suchbegriff enthalten
  const firstResult = results.first()
  await expect(firstResult).toContainText('election', { ignoreCase: true })

  // Nach Status filtern
  await page.click('button:has-text("Aktiv")')

  // Prüfen, ob gefilterte Ergebnisse angezeigt werden
  await expect(results).toHaveCount(3)
})

test('Benutzer kann einen neuen Markt erstellen', async ({ page }) => {
  // Zuerst anmelden
  await page.goto('/creator-dashboard')

  // Markterstellungsformular ausfüllen
  await page.fill('input[name="name"]', 'Testmarkt')
  await page.fill('textarea[name="description"]', 'Testbeschreibung')
  await page.fill('input[name="endDate"]', '2025-12-31')

  // Formular absenden
  await page.click('button[type="submit"]')

  // Erfolgsmeldung prüfen
  await expect(page.locator('text=Markt erfolgreich erstellt')).toBeVisible()

  // Weiterleitung zur Marktseite prüfen
  await expect(page).toHaveURL(/\/markets\/testmarkt/)
})

Testdatei-Organisation

src/
├── components/
│   ├── Button/
│   │   ├── Button.tsx
│   │   ├── Button.test.tsx          # Unit-Tests
│   │   └── Button.stories.tsx       # Storybook
│   └── MarketCard/
│       ├── MarketCard.tsx
│       └── MarketCard.test.tsx
├── app/
│   └── api/
│       └── markets/
│           ├── route.ts
│           └── route.test.ts         # Integrationstests
└── e2e/
    ├── markets.spec.ts               # E2E-Tests
    ├── trading.spec.ts
    └── auth.spec.ts

Mocken externer Dienste

Supabase-Mock

jest.mock('@/lib/supabase', () => ({
  supabase: {
    from: jest.fn(() => ({
      select: jest.fn(() => ({
        eq: jest.fn(() => Promise.resolve({
          data: [{ id: 1, name: 'Testmarkt' }],
          error: null
        }))
      }))
    }))
  }
}))

Redis-Mock

jest.mock('@/lib/redis', () => ({
  searchMarketsByVector: jest.fn(() => Promise.resolve([
    { slug: 'testmarkt', similarity_score: 0.95 }
  ])),
  checkRedisHealth: jest.fn(() => Promise.resolve({ connected: true }))
}))

OpenAI-Mock

jest.mock('@/lib/openai', () => ({
  generateEmbedding: jest.fn(() => Promise.resolve(
    new Array(1536).fill(0.1) // Mockt 1536-dim Embedding
  ))
}))

Testabdeckungsüberprüfung

Abdeckungsbericht ausführen

<coverage>

Abdeckungsschwellen

{
  "jest": {
    "coverageThresholds": {
      "global": {
        "branches": 80,
        "functions": 80,
        "lines": 80,
        "statements": 80
      }
    }
  }
}

Häufige Testfehler, die vermieden werden sollten

FEHLER: FALSCH: Testen von Implementierungsdetails

// Testen Sie nicht den internen Zustand
expect(component.state.count).toBe(5)

BESTANDEN: RICHTIG: Testen des benutzersichtbaren Verhaltens

// Testen Sie, was Benutzer sehen
expect(screen.getByText('Anzahl: 5')).toBeInTheDocument()

FEHLER: FALSCH: Anfällige Selektoren

// Bricht leicht
a wait page.click('.css-class-xyz')

BESTANDEN: RICHTIG: Semantische Selektoren

// Widerstandsfähig gegenüber Änderungen
a wait page.click('button:has-text("Absenden")')
a wait page.click('[data-testid="submit-button"]')

FEHLER: FALSCH: Keine Testisolierung

// Tests hängen voneinander ab
test('erstellt Benutzer', () => { /* ... */ })
test('aktualisiert denselben Benutzer', () => { /* hängt vom vorherigen Test ab */ })

BESTANDEN: RICHTIG: Unabhängige Tests

// Jeder Test richtet seine eigenen Daten ein
test('erstellt Benutzer', () => {
  const user = createTestUser()
  // Testlogik
})

test('aktualisiert Benutzer', () => {
  const user = createTestUser()
  // Aktualisierungslogik
})

Kontinuierliches Testen

Watch-Modus während der Entwicklung

<test-watch>
# Tests werden bei Dateiänderungen automatisch ausgeführt

Pre-Commit-Hook

# Wird vor jedem Commit ausgeführt
<test> && <lint>

CI/CD-Integration

# GitHub Actions
- name: Tests ausführen
  run: <coverage>
- name: Abdeckung hochladen
  uses: codecov/codecov-action@v3

Best Practices

  1. Tests zuerst schreiben – Immer TDD
  2. Eine Behauptung pro Test – Konzentrieren Sie sich auf ein einzelnes Verhalten
  3. Aussagekräftige Testnamen – Erklären, was getestet wird
  4. Arrange-Act-Assert – Klare Teststruktur
  5. Externe Abhängigkeiten mocken – Unit-Tests isolieren
  6. Randfälle testen – Null, undefiniert, leer, groß
  7. Fehlerpfade testen – Nicht nur Happy Paths
  8. Tests schnell halten – Unit-Tests < 50 ms pro Test
  9. Nach Tests aufräumen – Keine Nebeneffekte
  10. Abdeckungsberichte überprüfen – Lücken identifizieren

Erfolgsmetriken

  • 80 %+ Codeabdeckung erreicht
  • Alle Tests bestanden (grün)
  • Keine übersprungenen oder deaktivierten Tests
  • Schnelle Testausführung (< 30 s für Unit-Tests)
  • E2E-Tests decken kritische Benutzerabläufe ab
  • Tests fangen Fehler vor der Produktion

Denken Sie daran: Tests sind nicht optional. Sie sind das Sicherheitsnetz, das zuversichtliches Refactoring, schnelle Entwicklung und Produktionszuverlässigkeit ermöglicht.

Verwandte Skills