e2e-test

name	e2e-test
description	[Testing] Use when generating, updating, or maintaining E2E tests from recordings, specs, or code changes.

[BLOCKING] Execute skill steps in declared order. NEVER skip, reorder, or merge steps without explicit user approval. [BLOCKING] Before each step or sub-skill call, update task tracking: set in_progress when step starts, set completed when step ends. [BLOCKING] Every completed/skipped step MUST include brief evidence or explicit skip reason. [BLOCKING] If Task tools are unavailable, create and maintain an equivalent step-by-step plan tracker with the same status transitions.

Quick Summary

Goal: [Testing] Use when generating, updating, or maintaining E2E tests from recordings, specs, or code changes. Supports Playwright, Selenium, Cypress, and other frameworks.

Workflow:

1. Detect — classify request scope and target artifacts.
2. Execute — apply required steps with evidence-backed actions.
3. Verify — confirm constraints, output quality, and completion evidence.

Key Rules:

• MUST ATTENTION keep claims evidence-based (file:line) with confidence >80% to act.
• MUST ATTENTION keep task tracking updated as each step starts/completes.
• NEVER skip mandatory workflow or skill gates.

⚠️ MANDATORY: Read Project E2E Reference (FIRST)

BEFORE ANY E2E WORK, you MUST ATTENTION:

# 1. Read project-specific E2E patterns (REQUIRED)
head -100 docs/project-reference/e2e-test-reference.md

# 2. Read project config for framework, paths, commands
grep -A 50 '"e2eTesting"' docs/project-config.json

# 3. Find TC codes you need to implement
grep -r "TC-.*-E2E-" docs/specs/ docs/business-features/

The e2eTesting section in docs/project-config.json contains:

• Framework, language, paths, run commands, TC code format
• Project-specific best practices and entry points

When investigating/fixing E2E failures, update docs/project-reference/e2e-test-reference.md with learnings.

• docs/project-reference/domain-entities-reference.md — Domain entity catalog, relationships, cross-service sync (read when task involves business entities/models)

---

Framework Detection (SECOND STEP)

Detect the project's E2E stack before generating tests:

# TypeScript/JavaScript
grep -l "playwright\|cypress\|selenium\|webdriver" package.json 2>/dev/null
ls playwright.config.* cypress.config.* wdio.conf.* 2>/dev/null

# C# .NET
grep -r "Selenium.WebDriver\|Microsoft.Playwright" **/*.csproj 2>/dev/null

Framework	Config File	Test Extension	Run Command
Playwright	playwright.config.ts	*.spec.ts	npx playwright test
Cypress	cypress.config.ts	*.cy.ts	npx cypress run
WebdriverIO	wdio.conf.js	*.e2e.ts	npx wdio run
Selenium.NET	*.csproj	*Tests.cs	dotnet test

---

Workflow Modes

Mode	Input	Output
from-recording	Recording JSON + feature	Test spec + page object
update-ui	Git diff of UI changes	Updated screenshot baselines
from-changes	Changed test specs or code	Updated test implementations
from-spec	TC codes from test specs	New tests matching specs

---

Core Principles

1. TC Code Traceability (MANDATORY)

Every E2E test MUST ATTENTION have:

• TC code in test name: TC-{MODULE}-E2E-{NNN}
• Tag/trait linking to spec
• Comment linking to feature doc

// TypeScript
test('TC-LR-E2E-001: Submit leave request', async () => { ... });

// C# .NET
[Fact]
[Trait("TC", "TC-LR-E2E-001")]
public async Task SubmitLeaveRequest() { ... }

2. Page Object Model

All frameworks should use Page Object pattern:

• Encapsulate page locators in page class
• Methods represent user actions
• Assertions in test file, not page object

3. Selector Strategy (Priority Order)

1. Semantic classes — BEM (.block__element), component classes
2. Data attributes — [data-testid], [data-cy], [data-test]
3. ARIA/Role — role=button, aria-label
4. Text content — Visible user text (last resort)

AVOID: Generated classes (.ng-star-inserted, .MuiButton-root), positional selectors (:nth-child), XPath

4. Unique Test Data

Tests must generate unique data to be repeatable:

• Append GUIDs/timestamps to test data
• Don't depend on specific database state
• Don't clean up data (creates side effects)

5. Preconditions Documentation

Document what must exist before test runs:

• System: Infrastructure running, APIs healthy
• Data: Seed data exists (users, companies)
• Feature: Configurations complete

---

Steps

1. Detect framework from project files
2. Read project E2E docs for conventions and patterns
3. Load test specs with TC codes from feature docs
4. Generate/update tests following Page Object pattern
5. Run tests using project's configured commands
6. Update e2e-test-reference.md with any learnings

---

Output

Report:

• Files created/modified
• TC codes covered
• Run command to execute tests
• Any preconditions or setup needed

---

Sub-Agent Type Override

MANDATORY: E2E test generation and baseline updates spawn e2e-runner sub-agent (subagent_type: "e2e-runner"), NOT the main agent directly. Rationale: e2e-runner auto-detects the project's E2E stack, maintains test-to-spec TC traceability, and handles visual baseline updates across Playwright, Selenium, Cypress, and other frameworks.

Spawn e2e-runner sub-agent for:

• Generating new E2E tests from recordings or TC codes from specs
• Updating visual screenshot baselines after UI changes
• Maintaining TC code traceability (TC-{MODULE}-E2E-{NNN}) in test implementations

---

Workflow Recommendation

MANDATORY IMPORTANT MUST ATTENTION — NO EXCEPTIONS: If you are NOT already in a workflow, you MUST ATTENTION use AskUserQuestion to ask the user. Do NOT judge task complexity or decide this is "simple enough to skip" — the user decides whether to use a workflow, not you:

1. Activate e2e-from-changes workflow (Recommended) — scout → e2e-test → test → watzup
2. Execute /e2e-test directly — run this skill standalone

---

Skill: e2e-test

Category: [Testing] Trigger: e2e test, e2e from recording, generate e2e, playwright test, cypress test, selenium test, webdriver, puppeteer

Generate and maintain E2E tests using the project's configured testing framework.

• docs/specs/ — Test specifications by module (read existing TCs for E2E scenario coverage; match TC codes to E2E test implementations)

Be skeptical. Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence percentages (Idea should be more than 80%).

---

Sub-Agent Selection — Full routing contract: .claude/skills/shared/sub-agent-selection-guide.md Rule: NEVER use code-reviewer for specialized domains (architecture, security, performance, DB, E2E, integration-test, git).

AI Mistake Prevention — Failure modes to avoid on every task:

Check downstream references before deleting. Deleting components causes documentation and code staleness cascades. Map all referencing files before removal. Verify AI-generated content against actual code. AI hallucinates APIs, class names, and method signatures. Always grep to confirm existence before documenting or referencing. Trace full dependency chain after edits. Changing a definition misses downstream variables and consumers derived from it. Always trace the full chain. Trace ALL code paths when verifying correctness. Confirming code exists is not confirming it executes. Always trace early exits, error branches, and conditional skips — not just happy path. When debugging, ask "whose responsibility?" before fixing. Trace whether bug is in caller (wrong data) or callee (wrong handling). Fix at responsible layer — never patch symptom site. Assume existing values are intentional — ask WHY before changing. Before changing any constant, limit, flag, or pattern: read comments, check git blame, examine surrounding code. Verify ALL affected outputs, not just the first. Changes touching multiple stacks require verifying EVERY output. One green check is not all green checks. Holistic-first debugging — resist nearest-attention trap. When investigating any failure, list EVERY precondition first (config, env vars, DB names, endpoints, DI registrations, data preconditions), then verify each against evidence before forming any code-layer hypothesis. Surgical changes — apply the diff test. Bug fix: every changed line must trace directly to the bug. Don't restyle or improve adjacent code. Enhancement task: implement improvements AND announce them explicitly. Surface ambiguity before coding — don't pick silently. If request has multiple interpretations, present each with effort estimate and ask. Never assume all-records, file-based, or more complex path.

Critical Thinking Mindset — Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence >80% to act. Anti-hallucination: Never present guess as fact — cite sources for every claim, admit uncertainty freely, self-check output for errors, cross-reference independently, stay skeptical of own confidence — certainty without evidence root of all hallucination.

MUST ATTENTION apply critical thinking — every claim needs traced proof, confidence >80% to act. Anti-hallucination: never present guess as fact.

MUST ATTENTION apply AI mistake prevention — holistic-first debugging, fix at responsible layer, surface ambiguity before coding, re-read files after compaction.

Prompt-Enhance Closing Anchors

IMPORTANT MUST ATTENTION follow declared step order for this skill; NEVER skip, reorder, or merge steps without explicit user approval IMPORTANT MUST ATTENTION for every step/sub-skill call: set in_progress before execution, set completed after execution IMPORTANT MUST ATTENTION every skipped step MUST include explicit reason; every completed step MUST include concise evidence IMPORTANT MUST ATTENTION if Task tools unavailable, maintain an equivalent step-by-step plan tracker with synchronized statuses

Closing Reminders

• MANDATORY IMPORTANT MUST ATTENTION break work into small todo tasks using TaskCreate BEFORE starting
• MANDATORY IMPORTANT MUST ATTENTION search codebase for 3+ similar patterns before creating new code
• MANDATORY IMPORTANT MUST ATTENTION cite file:line evidence for every claim (confidence >80% to act)
• MANDATORY IMPORTANT MUST ATTENTION add a final review todo task to verify work quality

[TASK-PLANNING] Before acting, analyze task scope and systematically break it into small todo tasks and sub-tasks using TaskCreate.

[IMPORTANT] Analyze how big the task is and break it into many small todo tasks systematically before starting — this is very important.