Kapitel 10

Testen und Qualität

Lernen Sie, wie Sie KI einsetzen, um die Effizienz und Qualität von Tests zu verbessern, und machen Sie sich mit Best Practices für die KI-gestützte Generierung von Testfällen, das Schreiben von Testcode, die Testoptimierung und mehr vertraut.

KI-gestütztes Testen mit Sequential Thinking lernen

Der Einsatz von KI im Testen umfasst mehrere Aspekte und verwendetMethoden des strukturierten DenkensKann Ihnen helfen, systematisch Folgendes zu beherrschen:

1
Überblick über Testarten
Unit-Tests, Integrationstests und E2E-Tests schnell verstehen
2
KI-gestützte Generierung von Testfällen
Generierung von Testfällen für Unit-, Integrations- und E2E-Tests
3
KI-gestütztes Schreiben von Testcode
Verwendung von Test-Frameworks, Generierung von Mock-Daten, Vorbereitung von Testdaten
4
KI-gestützte Testoptimierung
Leistungsoptimierung, Coverage-Analyse, Test-Refactoring
5
KI-gesteuerte Testautomatisierung
CI/CD-Integration, Generierung von Testberichten, Fehlerprognose

Überblick über Testarten

Verstehen Sie schnell die Testarten und erhalten Sie Hintergrundwissen für die KI-Praxis.

Unit-Test

Eine einzelne Funktion oder Komponente testen, mit schnellem Feedback und hoher Abdeckung.

Integrationstests

Die Zusammenarbeit mehrerer Module testen und Schnittstellen sowie Datenflüsse verifizieren.

E2E-Tests

End-to-End-Tests, die echte Benutzeraktionen simulieren.

Leistungstest

Systemleistung und Belastbarkeit testen.

Best Practices für KI beim Testen

KI einsetzen, um die Testeffizienz und -qualität zu verbessern, mit KI-gestützten Praktiken entlang des gesamten Prozesses von der Testfallgenerierung bis zur Testautomatisierung.

KI-gestützte Generierung von Testfällen

KI verwenden, um Unit-Testfälle zu generieren

Beschreibe der KI die Funktionalität und lass sie vollständige Testfälle generieren:

Prompt-Vorlage:

Ich muss Unit-Testfälle für die folgende Funktion generieren:

// utils/calculateTotal.ts
export function calculateTotal(items: Item[]): number {
  if (!items || items.length === 0) return 0
  return items.reduce((sum, item) => {
    if (item.price && item.quantity) {
      return sum + item.price * item.quantity
    }
    return sum
  }, 0)
}

interface Item {
  price?: number
  quantity?: number
}

Bitte verwenden Sie Jest/Vitest, um Testfälle zu generieren, einschließlich:
- Tests für normale Fälle
- Tests für Grenzfälle (leeres Array, null, undefined)
- Tests für Ausnahmefälle (fehlende price oder quantity)
- Tests mit describe und it organisieren
- Klare Testbeschreibungen verwenden

Beispiele für von KI generierte Testfälle

// utils/calculateTotal.test.ts
import { describe, it, expect } from 'vitest'
import { calculateTotal } from './calculateTotal'

describe('calculateTotal', () => {
  it('should return 0 for empty array', () => {
    expect(calculateTotal([])).toBe(0)
  })

  it('should return 0 for null or undefined', () => {
    expect(calculateTotal(null as any)).toBe(0)
    expect(calculateTotal(undefined as any)).toBe(0)
  })

  it('should calculate total for valid items', () => {
    const items = [
      { price: 10, quantity: 2 },
      { price: 5, quantity: 3 }
    ]
    expect(calculateTotal(items)).toBe(35) // 10*2 + 5*3 = 35
  })

  it('should ignore items without price', () => {
    const items = [
      { price: 10, quantity: 2 },
      { quantity: 3 }
    ]
    expect(calculateTotal(items)).toBe(20)
  })

  it('should ignore items without quantity', () => {
    const items = [
      { price: 10, quantity: 2 },
      { price: 5 }
    ]
    expect(calculateTotal(items)).toBe(20)
  })

  it('should handle zero price or quantity', () => {
    const items = [
      { price: 0, quantity: 2 },
      { price: 10, quantity: 0 }
    ]
    expect(calculateTotal(items)).toBe(0)
  })
})

Von KI generierte Integrations-Test-Szenarien

Prompt:

Ich muss Integrations-Test-Szenarien für die Benutzerregistrierungs-API erstellen:

API: POST /api/users/register
Anforderungstext: { email, password, name }
Antwort: { id, email, name, createdAt }

Bitte generieren Sie Testfälle, die Folgendes enthalten:
- Erfolgreiches Registrierungs-Szenario
- Szenario, in dem die E-Mail bereits existiert
- Szenario mit unzureichender Passwortstärke
- Szenario mit fehlendem Pflichtfeld
- Die Testdatenbank verwenden
- Testdaten bereinigen

KI generiert den E2E-Testablauf

Prompt:

Ich muss E2E-Tests für den Warenkorb-Workflow generieren:

Benutzerablauf:
1. Die Startseite besuchen
2. Nach Produkten suchen
3. Produkt in den Warenkorb legen
4. Warenkorb anzeigen
5. Zur Kasse gehen
6. Bestellinformationen ausfüllen
7. Bestellung absenden

Bitte verwenden Sie Playwright, um vollständigen E2E-Testcode zu generieren, einschließlich:
- Seitennavigation
- Element-Lokalisierung
- Benutzerinteraktionen
- Assertions-Prüfungen
- Fehlerbehandlung

Grundlagen der TDD-Praxis

Die Kernkonzepte beibehalten und sich darauf konzentrieren, zu zeigen, wie KI TDD unterstützt. Mit KI lassen sich Testfälle, Implementierungscode und Refactoring-Vorschläge schnell generieren.

Rot

Fehlschlagende Tests schreiben und das erwartete Verhalten definieren

Grün (Green)

Die minimale Implementierung schreiben, damit die Tests bestehen

Refactoring (Refactor)

Code optimieren und die Tests bestehen lassen

KI-gestütztes TDD

KI kann in jeder Phase von TDD helfen: Testfälle generieren, schnelle Implementierung und Refactoring-Vorschläge. Siehe den obigen Abschnitt „KI-gestützte TDD-Praxis“ für detaillierte Beispiele und Prompt-Vorlagen.

Grundlagen von Testwerkzeugen

Die Einführung in die Kernwerkzeuge beibehalten und den Schwerpunkt darauf legen, wie KI bei der Werkzeugauswahl unterstützt.

Jest

JavaScript-Testframework mit integrierten Assertions und Mocks

Vitest

Schnelles Test-Framework, native Vite-Unterstützung, TypeScript-freundlich

Playwright

E2E-Testframework, Unterstützung für mehrere Browser

Auswahl KI-gestützter Tools

Verwenden Sie KI, um anhand der Projektanforderungen die passenden Testwerkzeuge auszuwählen. Beschreiben Sie der KI die Projekteigenschaften (Next.js, TypeScript, Bedarf an E2E-Tests usw.), und sie empfiehlt die passende Kombination von Tools und einen Konfigurationsplan.

Grundlagen der Qualitätssicherung

Die Kernkonzepte beibehalten und vor allem zeigen, wie KI die Qualitätssicherung unterstützt.

Teststrategie

  • Testpyramide: viele Unit-Tests + eine angemessene Anzahl von Integrationstests + eine kleine Anzahl von E2E-Tests
  • Kritische Pfade priorisieren: die Prüfung der zentralen Geschäftslogik priorisieren
  • Grenzwerttest: Randbedingungen und Ausnahmefälle testen

Codeabdeckung

  • Zeilenabdeckung: Anteil der ausgeführten Codezeilen
  • Zweigabdeckung: Anteil der ausgeführten Code-Zweige
  • Ziel:Kerncode 80 %+ , gesamt 60 %+

KI-gestützte Qualitätssicherung

KI kann Teststrategien analysieren, Qualitätsberichte erstellen und nicht abgedeckte Codepfade identifizieren. Detaillierte Beispiele und Prompt-Vorlagen finden Sie in den obigen Abschnitten „KI-gestützte Abdeckungsanalyse“ und „KI-gesteuerte Testautomatisierung“.

Praxisbeispiele

Anhand praktischer Codebeispiele lernen Sie, wie Sie KI einsetzen, um die Effizienz und Qualität von Tests zu verbessern.

Von KI generierte Testfälle

Vollständiges Beispiel zur Generierung von Testfällen (Prompt + Ergebnis):

// 1. Anforderungen an die KI übergeben
Prompt: "Generiere Unit-Tests für die Funktion calculateTotal, einschließlich Normalfällen, Grenzfällen und Ausnahmefällen..."

// 2. Von der KI generierte Testfälle
describe('calculateTotal', () => {
  it('should return 0 for empty array', () => {
    expect(calculateTotal([])).toBe(0)
  })
  
  it('should calculate total for valid items', () => {
    const items = [
      { price: 10, quantity: 2 },
      { price: 5, quantity: 3 }
    ]
    expect(calculateTotal(items)).toBe(35)
  })
  
  // ... weitere Testfälle
})

KI-optimierter Testcode

Beispiel für die Optimierung von Testcode (Vorher-Nachher-Vergleich):

Vor der Optimierung (45 Sekunden)
// Jeder Test ruft die echte API auf
describe('UserService', () => {
  it('should fetch user', async () => {
    const user = await fetchUser('1') // echter API-Aufruf
    expect(user.id).toBe('1')
  })
  
  it('should update user', async () => {
    const user = await fetchUser('1') // wiederholter Aufruf
    await updateUser('1', { name: 'New' })
    expect(user.name).toBe('New')
  })
})
Nach KI-Optimierung (5 Sekunden)
// KI-Empfehlung: Mock statt der echten API verwenden
vi.mock('./api', () => ({
  fetchUser: vi.fn().mockResolvedValue({ id: '1', name: 'Test' }),
  updateUser: vi.fn().mockResolvedValue({ id: '1', name: 'New' })
}))

describe('UserService', () => {
  it('should fetch user', async () => {
    const user = await fetchUser('1')
    expect(user.id).toBe('1')
  })
  
  it('should update user', async () => {
    await updateUser('1', { name: 'New' })
    expect(updateUser).toHaveBeenCalledWith('1', { name: 'New' })
  })
})

KI-Analyseabdeckung

Beispiele für Abdeckungsanalyse und ergänzende Empfehlungen:

// KI-Abdeckungsbericht
Abdeckung: 65 %

Nicht abgedeckter Code:
- utils/validation.ts: 45 %
  - Der Fehlerbehandlungszweig von validateEmail ist nicht getestet
  - Grenzfälle von validatePassword sind nicht getestet

Von der KI vorgeschlagene zusätzliche Testfälle:
it('should return false for invalid email', () => {
  expect(validateEmail('invalid')).toBe(false)
  expect(validateEmail('invalid@')).toBe(false)
  expect(validateEmail('@domain.com')).toBe(false)
})

Lernergebnisse

Nach Abschluss dieses Kapitels werden Sie:

  • 1Überblick über Testarten (Unit-Tests, Integrationstests, E2E-Tests, Leistungstests) und ihre Anwendungsszenarien verstehen
  • 2Beherrschen Sie die Verwendung von KI zur Generierung von Testfällen (Unit-Tests, Integrationstests, Generierung von E2E-Testfällen)
  • 3In der Lage sein, KI zur Unterstützung beim Schreiben von Testcode zu nutzen (Syntax von Testframeworks, Generierung von Mock-Daten, Vorbereitung von Testdaten)
  • 4Kann KI verwenden, um die Testleistung zu analysieren und zu optimieren (Analyse von Leistungsengpässen, Optimierung der Testausführungsgeschwindigkeit, Test-Refactoring)
  • 5Die Methoden der KI-gestützten Coverage-Analyse beherrschen (Analyse von Coverage-Berichten, Identifizierung nicht abgedeckter Codepfade, Vorschläge für zusätzliche Testfälle)
  • 6Kann KI-gestützte Testautomatisierung nutzen (Generierung von CI/CD-Konfigurationen, Analyse von Testberichten, Vorhersage der Ursachen von Testfehlern)
  • 7AI-gestützte TDD-Praktiken meistern (Generierung von Testfällen, Generierung von Minimalimplementierungscode, Refactoring-Vorschläge)