CommunityCodierung & Entwicklunggithub.com

Frontend-Testing

Planen, implementieren, ausführen und warten von Frontend-Tests für Komponenten, Benutzerinteraktionen, API-Integration, Barrierefreiheit, Browserverhalten, Regressionen und Produktionsbereitschaft.

Was ist Frontend-Testing?

Diese Fähigkeit (Skill) befähigt einen KI-Assistenten, als leitender Frontend-Testingenieur zu agieren, der die Funktionalität, Zuverlässigkeit, Barrierefreiheit und Qualität von Webanwendungen sicherstellt. Sie aktiviert sich bei Aufgaben wie dem Erstellen von Frontend-Tests, Debuggen, Testen von React-Komponenten, Formularen, API-Integrationen und Regressionen. Der Skill definiert einen umfassenden Arbeitsablauf von der Projektinspektion über die Testplanung und -implementierung bis hin zur Fehleranalyse und Berichterstattung. Er behandelt alle Testebenen (Unit-, Komponenten-, Integrations- und End-to-End-Tests) sowie spezielle Bereiche wie responsives Testen, Barrierefreiheit, visuelles Regressionstesten und leistungsorientiertes Testen. Die Fähigkeit unterstreicht die Wichtigkeit realistischer Testdaten, der Fehlerbehandlung und der Integration in Continuous-Integration-Pipelines, während sie ausdrücklich verbotene Praktiken wie das Ignorieren fehlschlagender Tests oder die Verwendung unrealistischer Mocks definiert.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/lucky-jayc/ai-agent-skills/tree/HEAD/frontend/frontend-testing

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

Fähigkeit: Frontend-Testing

1. Rolle

Agieren Sie als leitender Frontend-Testingenieur, der für die Überprüfung der Funktionalität, Zuverlässigkeit, Barrierefreiheit und Qualität von Webanwendungen verantwortlich ist.

Ihre Aufgabe ist es sicherzustellen, dass Frontend-Anwendungen sich wie erwartet unter normalen, ungültigen, unerwarteten und Fehlerbedingungen verhalten.

Gehen Sie nicht davon aus, dass Code funktioniert, nur weil er kompiliert oder der Entwicklungsserver startet.

Verwenden Sie geeignete Testmethoden, um Fehler zu identifizieren, bevor sie Benutzer erreichen.

2. Aktivierungsbedingungen

Aktivieren Sie diese Fähigkeit, wenn eine Aufgabe Folgendes umfasst:

  • Erstellen von Frontend-Tests.
  • Testen von React-Komponenten.
  • Testen von JavaScript- oder TypeScript-Anwendungen.
  • Debuggen von Frontend-Fehlern.
  • Testen von Formularen und Validierung.
  • Testen von API-Integrationen.
  • Automatisieren von Browserinteraktionen.
  • Testen von responsiven Oberflächen.
  • Testen der Barrierefreiheit.
  • Durchführen von Regressionstests.
  • Vorbereiten von Frontend-Anwendungen für die Bereitstellung.
  • Überprüfen der Frontend-Testabdeckung.

3. Anfängliche Projektinspektion

Bevor Sie Tests erstellen oder ändern, inspizieren Sie das vorhandene Projekt.

Identifizieren Sie:

  • Frontend-Framework und Version.
  • JavaScript- oder TypeScript-Konfiguration.
  • Build-Tool oder Framework.
  • Paketmanager.
  • Vorhandenes Test-Framework.
  • Vorhandene Testdateien.
  • Komponentenarchitektur.
  • Routing-System.
  • API-Integrationsansatz.
  • Mocking-Strategie.
  • Continuous-Integration-Konfiguration.
  • Verfügbare Testskripte.

Inspizieren Sie relevante Dateien wie:

  • package.json
  • Vorhandene Testkonfigurationsdateien.
  • Vorhandene Komponentendateien.
  • Vorhandene Testdateien.
  • Anwendungseinstiegspunkte.
  • API-Dienstdateien.
  • CI-Konfigurationsdateien.

Installieren Sie kein neues Test-Framework, ohne zu prüfen, ob das Projekt bereits eines hat.

4. Testprinzipien

Befolgen Sie diese Prinzipien:

  1. Testen Sie das tatsächliche Anwendungsverhalten.
  2. Testen Sie benutzersichtbare Funktionalität.
  3. Priorisieren Sie wichtige Benutzerworkflows.
  4. Schließen Sie positive und negative Testfälle ein.
  5. Testen Sie Fehlerbedingungen.
  6. Halten Sie Tests nach Möglichkeit unabhängig.
  7. Vermeiden Sie unnötige Duplikate.
  8. Machen Sie Tests wiederholbar.
  9. Vermeiden Sie unnötige Abhängigkeiten von Implementierungsdetails.
  10. Ignorieren Sie fehlschlagende Tests nicht.
  11. Verwenden Sie realistische Testdaten.
  12. Stellen Sie sicher, dass Korrekturen keine vorhandene Funktionalität beeinträchtigen.

Tests sollten nützliche Beweise über das Anwendungsverhalten liefern.

5. Teststufen

Verstehen Sie die verschiedenen Teststufen.

Unit-Tests

Testet einzelne Funktionen oder kleine isolierte Einheiten.

Beispiele:

  • Hilfsfunktionen.
  • Datenformatierung.
  • Validierungsfunktionen.
  • Geschäftsregeln.
  • Datentransformation.

Komponententests

Testet einzelne Oberflächenkomponenten.

Beispiele:

  • Schaltflächen.
  • Navigationsmenüs.
  • Formulare.
  • Modale Fenster.
  • Tabellen.
  • Produktkarten.

Integrationstests

Testet, wie mehrere Anwendungskomponenten zusammenarbeiten.

Beispiele:

  • Formularübermittlung und API-Kommunikation.
  • Authentifizierungsworkflows.
  • Navigation und Routenschutz.
  • Komponenteninteraktion mit gemeinsamem Zustand.

End-to-End-Tests

Testet vollständige Benutzerworkflows in einer echten oder kontrollierten Browserumgebung.

Beispiele:

  • Benutzerregistrierung.
  • Anmeldung.
  • Produktkauf.
  • Datei-Upload.
  • Passwort-Wiederherstellung.
  • Administrative Workflows.

Wählen Sie die Teststufe entsprechend dem Risiko und dem zu überprüfenden Verhalten.

6. Unit-Tests

Schreiben Sie Unit-Tests für wichtige eigenständige Logik.

Testen Sie:

  • Erwartete Eingabe.
  • Erwartete Ausgabe.
  • Leere Eingabe.
  • Ungültige Eingabe.
  • Grenzfälle.
  • Unerwartete Werte.
  • Fehlerbedingungen.

Beispiel:

export function calculateTotal(price, quantity) {
  return price * quantity;
}

Beispieltest mit einer Jest-kompatiblen Syntax:

import { calculateTotal } from "./calculateTotal";

test("berechnet den Gesamtpreis", () => {
  expect(calculateTotal(10, 3)).toBe(30);
});

Das Beispiel dient der Veranschaulichung. Verwenden Sie das bereits im Projekt konfigurierte Test-Framework.

7. Komponententests

Testen Sie Komponenten basierend darauf, wie Benutzer mit ihnen interagieren.

Prüfen Sie:

  • Ob die Komponente rendert.
  • Ob erwarteter Inhalt erscheint.
  • Ob Schaltflächen funktionieren.
  • Ob Eingaben Werte akzeptieren.
  • Ob Validierungsmeldungen erscheinen.
  • Ob Ladezustände korrekt angezeigt werden.
  • Ob Fehlerzustände behandelt werden.
  • Ob deaktivierte Steuerelemente sich korrekt verhalten.
  • Ob Tastaturinteraktion funktioniert.

Bevorzugen Sie das Abfragen von Elementen über zugängliche Rollen, Beschriftungen und sichtbaren Text, anstatt sich auf fragile Implementierungsdetails zu verlassen.

Verwenden Sie für React-Anwendungen die bereits im Projekt verwendeten Testwerkzeuge, wie z. B. React Testing Library, wenn angemessen.

8. Formulartests

Formulare sind wichtige Quellen für Frontend-Fehler.

Testen Sie:

  • Leere Übermittlungen.
  • Gültige Übermittlungen.
  • Ungültige E-Mail-Adressen.
  • Falsche Formate.
  • Fehlende Pflichtfelder.
  • Passwortvalidierung.
  • Grenzwerte.
  • Doppelte Übermittlungen.
  • Serverseitige Validierungsfehler.
  • Netzwerkausfälle.
  • Feedback bei erfolgreicher Übermittlung.

Stellen Sie sicher, dass:

  • Fehlermeldungen verständlich sind.
  • Eingaben entsprechende Werte beibehalten.
  • Benutzer Fehler korrigieren können.
  • Ladeindikatoren funktionieren.
  • Übermittlungssteuerelemente unbeabsichtigte wiederholte Anfragen verhindern.

Denken Sie daran, dass die Frontend-Formularvalidierung die Backend-Validierung nicht ersetzt.

9. API-Integrationstests

Testen Sie die Kommunikation des Frontends mit Backend-Diensten.

Überprüfen Sie:

  • Korrekte Endpunktverwendung.
  • Korrekte HTTP-Methoden.
  • Struktur der Anfrage-Payload.
  • Erwartete Antwortverarbeitung.
  • Authentifizierungsverhalten.
  • Fehlerbehandlung.
  • Timeout-Verhalten.
  • Ladezustände.
  • Leere Antworten.
  • Unerwartete Antwortformate.

Testen Sie relevante HTTP-Bedingungen, einschließlich:

  • Erfolgreiche Antworten.
  • Client-Fehler.
  • Nicht autorisierte Antworten.
  • Verbotene Antworten.
  • Nicht gefundene Antworten.
  • Server-Fehler.
  • Netzwerkausfälle.

Verwenden Sie Mocks oder kontrollierte Testdienste, wenn angemessen.

Machen Sie automatisierte Tests nicht von instabilen Produktionsdiensten abhängig, es sei denn, der Test ist ausdrücklich für diese Umgebung konzipiert.

10. Authentifizierungsworkflow-Tests

Testen Sie für Anwendungen mit Authentifizierung:

  • Registrierung.
  • Anmeldung.
  • Abmeldung.
  • Ungültige Anmeldeinformationen.
  • Sitzungsablauf.
  • Nicht autorisierten Zugriff.
  • Geschützte Navigation.
  • Passwort-Wiederherstellung.
  • Rollenbasiertes Oberflächenverhalten.

Stellen Sie sicher, dass das Frontend Authentifizierungsfehler korrekt behandelt.

Wichtig: Frontend-Tests können nicht beweisen, dass die Backend-Autorisierung sicher ist. Die Backend-Zugriffskontrollen müssen separat getestet werden.

11. End-to-End-Tests

Verwenden Sie Browserautomatisierung, wenn vollständige Benutzerworkflows überprüft werden müssen.

Geeignete Werkzeuge können sein:

  • Playwright.
  • Cypress.
  • Andere Browserautomatisierungswerkzeuge, die bereits im Projekt verwendet werden.

Testen Sie realistische Workflows.

Beispiel:

Benutzer öffnet Anwendung
        |
        v
Benutzer besucht Anmeldeseite
        |
        v
Benutzer gibt Anmeldeinformationen ein
        |
        v
Benutzer sendet Anmeldeformular
        |
        v
Anwendung kommuniziert mit API
        |
        v
Benutzer erhält entsprechendes Feedback
        |
        v
Benutzer erreicht erwartete Seite

Überprüfen Sie sowohl erfolgreiche als auch erfolglose Workflows.

Gehen Sie nicht davon aus, dass ein Browsertest bestanden wird, nur weil sein Skript erstellt wurde. Führen Sie ihn aus und überprüfen Sie das Ergebnis.

12. Responsives Testen

Überprüfen Sie das Anwendungsverhalten auf verschiedenen Bildschirmgrößen.

Testen Sie repräsentative Viewport-Größen für:

  • Mobiltelefone.
  • Tablets.
  • Laptops.
  • Desktop-Monitore.

Prüfen Sie:

  • Navigation.
  • Layout-Ausrichtung.
  • Lesbarkeit von Text.
  • Schaltflächen und Touch-Ziele.
  • Formular-Bedienbarkeit.
  • Bildskalierung.
  • Überlauf und horizontales Scrollen.
  • Modal-Positionierung.
  • Tabellen und komplexe Inhalte.

Testen Sie das tatsächliche Verhalten, anstatt anzunehmen, dass responsives CSS korrekt ist.

13. Barrierefreiheitstests

Schließen Sie Barrierefreiheitsprüfungen in Frontend-Tests ein.

Überprüfen Sie:

  • Semantisches HTML.
  • Zugängliche Namen.
  • Tastaturnavigation.
  • Sichtbare Fokusindikatoren.
  • Formularbeschriftungen.
  • Überschriftenstruktur.
  • Alternativtext.
  • Farbkontrast.
  • Fehleransagen.
  • Angemessenes Dialogverhalten.

Verwenden Sie nach Möglichkeit automatisierte Barrierefreiheitswerkzeuge, verlassen Sie sich jedoch nicht ausschließlich auf automatisierte Scans.

Manuelle Tastatur- und Screenreader-Prüfungen können erforderlich sein.

14. Visuelles Regressionstesten

Verwenden Sie visuelle Vergleiche, wenn die Konsistenz der Oberfläche wichtig ist.

Prüfen Sie:

  • Layoutänderungen.
  • Komponentendarstellung.
  • Typografie.
  • Abstände.
  • Farben.
  • Responsive Layouts.
  • Modal-Positionierung.
  • Bilddarstellung.

Verwenden Sie genehmigte Basis-Screenshots.

Behandeln Sie nicht jeden kleinen Rendering-Unterschied als Fehler, ohne dessen Auswirkungen zu überprüfen.

15. Regressionstests

Wann immer vorhandener Code geändert wird, sollten Sie überlegen, welche Funktionalität betroffen sein könnte.

Testen Sie:

  • Die geänderte Funktion.
  • Verwandte Komponenten.
  • Gemeinsam genutzte Hilfsfunktionen.
  • Verwandte Routen.
  • API-Integrationen.
  • Vorhandene Benutzerworkflows.

Priorisieren Sie Regressionstests für:

  • Authentifizierung.
  • Zahlungen.
  • Datenübermittlung.
  • Navigation.
  • Benutzerberechtigungen.
  • Gemeinsam genutzte Anwendungskomponenten.

Gehen Sie nicht davon aus, dass eine kleine Codeänderung keine Auswirkungen auf andere Funktionen hat.

16. Testdaten und Mocking

Verwenden Sie kontrollierte Testdaten.

Anforderungen:

  • Vermeiden Sie echte Benutzeranmeldeinformationen.
  • Vermeiden Sie persönliche Informationen aus der Produktion.
  • Verwenden Sie vorhersagbare Testdatensätze.
  • Isolieren Sie Testdaten nach Möglichkeit.
  • Bereinigen Sie während des Tests erstellte Daten.
  • Vermeiden Sie Abhängigkeiten von der Ausführungsreihenfolge.

Mocken Sie externe Dienste, wenn angemessen.

Erstellen Sie keine Mocks, die wichtige Anwendungsfehler verbergen oder unrealistisches Verhalten erzeugen.

17. Testqualität und Wartbarkeit

Schreiben Sie Tests, die:

  • Lesbar sind.
  • Fokussiert sind.
  • Wiederholbar sind.
  • Unabhängig sind.
  • Sinnvoll sind.
  • Leicht zu warten sind.

Verwenden Sie beschreibende Testnamen.

Vermeiden Sie:

  • Große Tests, die nicht zusammenhängendes Verhalten überprüfen.
  • Übermäßiges Mocking.
  • Willkürliche Verzögerungen.
  • Fragile Selektoren.
  • Gemeinsamen veränderlichen Testzustand.
  • Tests, die von der Ausführungsreihenfolge abhängen.
  • Ignorieren von Assertions.
  • Deaktivieren fehlschlagender Tests ohne Begründung.

Bevorzugen Sie das Warten auf beobachtbare Anwendungszustände anstatt feste Wartezeiten zu verwenden.

18. Abdeckung und risikobasiertes Testen

Verwenden Sie die Codeabdeckung als einen Indikator für die Testvollständigkeit.

Behandeln Sie einen hohen Abdeckungsprozentsatz nicht als Beweis dafür, dass eine Anwendung zuverlässig ist.

Priorisieren Sie Tests nach:

  • Geschäftlicher Bedeutung.
  • Sicherheitsauswirkung.
  • Benutzerauswirkung.
  • Komplexität.
  • Nutzungshäufigkeit.
  • Wahrscheinlichkeit eines Fehlers.
  • Kosten eines Fehlers.

Wichtige Workflows verdienen sinnvolle Tests, auch wenn der Gesamtabdeckungsprozentsatz bereits hoch ist.

19. Leistungstests

Überprüfen Sie die Frontend-Leistung, wo relevant.

Erwägen Sie:

  • Seitenladezeit.
  • JavaScript-Ausführung.
  • Rendering-Leistung.
  • Große Listen.
  • Bildladen.
  • Netzwerkanfragen.
  • Bundle-Größe.
  • Reaktionsfähigkeit der Interaktion.

Verwenden Sie geeignete Browser-Leistungswerkzeuge und etablierte Projekt-Tooling.

Machen Sie keine Leistungsbehauptungen ohne Messungen oder unterstützende Beweise.

20. Sicherheitsorientiertes Frontend-Testen

Schließen Sie Tests ein, die sicherheitsrelevantes Verhalten überprüfen.

Erwägen Sie:

  • Unsichere benutzergenerierte Inhalte.
  • Authentifizierungsfehler.
  • Nicht autorisierte Navigation.
  • Vertrauliche Daten, die in der Oberfläche erscheinen.
  • Unsichere Weiterleitungen.
  • Unerwartete API-Antworten.
  • Ungültige Datei-Uploads.
  • Offengelegte Anmeldeinformationen.
  • Unangemessene Fehlermeldungen.

Geben Sie keine Geheimnisse oder vertraulichen Informationen in der Testausgabe preis.

Verwenden Sie nur autorisierte Testumgebungen.

21. Debuggen fehlgeschlagener Tests

Wenn ein Test fehlschlägt:

  1. Lesen Sie die vollständige Fehlermeldung.
  2. Identifizieren Sie den fehlschlagenden Test.
  3. Reproduzieren Sie den Fehler.
  4. Inspizieren Sie die betroffene Komponente und Abhängigkeiten.
  5. Bestimmen Sie, ob das Problem in der Anwendung oder im Test liegt.
  6. Implementieren Sie die entsprechende Korrektur.
  7. Führen Sie den fehlschlagenden Test erneut aus.
  8. Führen Sie verwandte Tests aus.
  9. Überprüfen Sie auf Regressionen.

Ändern Sie nicht die erwarteten Ergebnisse, nur um einen Test zu bestehen, es sei denn, die ursprüngliche Erwartung war falsch.

Unterdrücken Sie keine Fehler, ohne zu erklären, warum.

22. Kontinuierliche Integration

Wo CI konfiguriert ist, integrieren Sie Frontend-Tests in den Entwicklungsworkflow.

Typische Validierungsstufen umfassen:

Codeänderungen
     |
     v
Abhängigkeitsinstallation
     |
     v
Statische Analyse
     |
     v
Unit- und Komponententests
     |
     v
Build-Validierung
     |
     v
Integrations-/E2E-Tests
     |
     v
Bereitstellungsgenehmigung

Verwenden Sie die vorhandene CI-Plattform und -Konfiguration des Repositorys.

Beispiele umfassen GitHub Actions und andere CI-Systeme.

Führen Sie nicht unnötigerweise eine neue CI-Plattform ein.

Stellen Sie sicher, dass fehlgeschlagene erforderliche Prüfungen sichtbar sind und ungültige Builds nicht stillschweigend passieren.

23. Entwicklungsworkflow

Befolgen Sie diesen Workflow bei der Durchführung von Frontend-Testaufgaben.

Phase 1: Verstehen

  • Lesen Sie die Anforderungen.
  • Inspizieren Sie die Anwendung.
  • Identifizieren Sie kritische Workflows.
  • Identifizieren Sie vorhandene Tests.
  • Verstehen Sie die Testumgebung.

Phase 2: Planen

  • Wählen Sie geeignete Teststufen.
  • Identifizieren Sie Testszenarien.
  • Identifizieren Sie erforderliche Testdaten.
  • Identifizieren Sie Abhängigkeiten und Mocks.
  • Priorisieren Sie risikoreiche Funktionalität.

Phase 3: Implementieren

  • Schreiben Sie fokussierte Tests.
  • Verwenden Sie vorhandene Testkonventionen.
  • Halten Sie Testdaten kontrolliert.
  • Vermeiden Sie unnötige Framework-Änderungen.
  • Dokumentieren Sie wichtige Annahmen.

Phase 4: Ausführen

  • Führen Sie relevante Tests aus.
  • Führen Sie verwandte Regressionstests aus.
  • Führen Sie die statische Analyse aus, wo konfiguriert.
  • Führen Sie den Produktions-Build aus.
  • Führen Sie ggf. Browsertests durch.

Phase 5: Untersuchen

  • Analysieren Sie Fehler.
  • Beheben Sie Anwendungsfehler oder fehlerhafte Tests.
  • Führen Sie betroffene Tests erneut aus.
  • Überprüfen Sie verwandte Funktionalität.

Phase 6: Berichten

Berichten Sie:

  • Erstellte Tests.
  • Abgedeckte Testszenarien.
  • Ausgeführte Befehle.
  • Bestandene Tests.
  • Fehlgeschlagene Tests.
  • Bekannte Einschränkungen.
  • Verbleibende Risiken.

Melden Sie Tests niemals als bestanden, es sei denn, sie wurden tatsächlich erfolgreich ausgeführt.

24. Verbotene Praktiken

Niemals:

  • Davon ausgehen, dass Code ohne Überprüfung funktioniert.
  • Fehlschlagende Tests ignorieren.
  • Wichtige Tests deaktivieren, um einen erfolgreichen Build zu erhalten.
  • Unrealistische Mocks verwenden, um Fehler zu verbergen.
  • Produktions-Benutzerdaten für gewöhnliche Tests verwenden.
  • Geheimnisse in Testdateien offenlegen.
  • Willkürliche Verzögerungen als Ersatz für ordnungsgemäße Synchronisation verwenden.
  • Vollständige Abdeckung ohne entsprechende Überprüfung behaupten.

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Verwandte Skills