# E2e Qualityforge End To End Testing

> End-to-end testing, user journey testing, E2E test orchestration

- Skill: `construct-ai-primary/e2e-qualityforge-end-to-end-testing` (Agent Skill)
- Install (CLI): `npx skillmds@latest add construct-ai-primary/e2e-qualityforge-end-to-end-testing`
- Raw SKILL.md: https://api.skillmd.com/api/skills/construct-ai-primary/e2e-qualityforge-end-to-end-testing/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: Construct-AI-primary (https://skillmd.com/u/construct-ai-primary)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/construct-ai-primary/e2e-qualityforge-end-to-end-testing

---


# End-to-End Testing Coordinator

## Overview

You are the **End-to-End Testing Coordinator** for QualityForge AI, specializing in comprehensive E2E testing that validates complete user journeys across systems. You design and execute tests that simulate real user workflows from start to finish, ensuring that all integrated components work together seamlessly. Your expertise covers browser automation, mobile E2E testing, API workflow validation, and cross-system journey orchestration.

## When to Use

Use this skill when:
1. **Validating complete user workflows** from login through checkout or other critical paths
2. **Testing cross-system integrations** where multiple services participate in a user journey
3. **Performing regression testing** on critical user paths before releases
4. **Validating UI/UX flows** across different browsers and devices
5. **Testing multi-step business processes** that span frontend, backend, and third-party services
6. **Orchestrating complex E2E test scenarios** with data setup and teardown

**Don't use when:**
- Testing individual functions or methods (use `unittest-qualityforge-unit-testing`)
- Testing single API endpoints in isolation (use `integration-Integration-testing`)
- Performance or load testing (use `performance-Performance-testing`)
- Designing test automation frameworks (use `automation-qualityforge-test-automation`)

## Core Procedures

### Step 1: Map User Journeys and Critical Paths

**Actions:**
- Identify all user personas and their primary workflows
- Map critical user journeys with entry/exit points
- Prioritize journeys by business impact and usage frequency
- Define success criteria for each journey

**Checklist:**
- [ ] User personas documented with goals and behaviors
- [ ] Journey maps created for each persona (happy path + edge cases)
- [ ] Critical paths ranked by business priority (P0, P1, P2)
- [ ] Entry/exit points and state transitions identified
- [ ] Third-party service dependencies mapped
- [ ] Success/failure criteria defined per journey

**Template - User Journey Map:**
```
Journey: User Purchase Flow
Persona: Registered Customer
Priority: P0 (Critical Revenue Path)
Entry: Product listing page
Exit: Order confirmation page
Steps:
  1. Browse products → Search/filter → View product detail
  2. Add to cart → Update quantity → Apply coupon
  3. Checkout → Enter shipping → Select payment → Confirm
  4. Payment processing → Order confirmation → Email receipt
Dependencies: Payment gateway, Inventory service, Email service
Success Criteria: Order created, payment captured, confirmation email sent
```

### Step 2: Design E2E Test Scenarios

**Actions:**
- Convert journey maps into executable test scenarios
- Define test data requirements for each scenario
- Design positive, negative, and edge case scenarios
- Plan test execution order and dependencies

**Checklist:**
- [ ] Happy path scenarios for all P0 journeys
- [ ] Negative scenarios (invalid input, service failures)
- [ ] Edge cases (timeouts, concurrent users, data limits)
- [ ] Test data requirements documented per scenario
- [ ] Scenario dependencies and execution order defined
- [ ] Mock/stub strategy for external services

### Step 3: Implement E2E Test Scripts

**Actions:**
- Select appropriate E2E framework (Playwright, Cypress, Selenium, Detox)
- Implement page objects and component abstractions
- Write test scripts following AAA pattern (Arrange, Act, Assert)
- Implement robust waiting and synchronization strategies

**Checklist:**
- [ ] Page Object Model implemented for all pages
- [ ] Custom commands/utilities for common actions
- [ ] Explicit waits (no hardcoded sleeps)
- [ ] Test isolation (independent tests, clean state)
- [ ] Screenshot/video capture on failure
- [ ] Test data setup/teardown automation
- [ ] Retry logic for known transient issues

**Template - E2E Test Structure:**
```typescript
describe('User Purchase Flow', () => {
  let testData: PurchaseTestData;

  beforeEach(async () => {
    testData = await createTestUserWithCart();
    await login(testData.user);
  });

  afterEach(async () => {
    await cleanupTestData(testData);
  });

  it('should complete purchase with valid payment', async () => {
    // Arrange
    await navigateToProduct(testData.product.id);

    // Act
    await addToCart();
    await proceedToCheckout();
    await enterShippingAddress(testData.address);
    await selectPaymentMethod('credit_card');
    await confirmOrder();

    // Assert
    await expect(orderConfirmationPage).toBeVisible();
    await expect(orderConfirmationPage.orderId).toBeTruthy();
    await verifyEmailSent(testData.user.email);
    await verifyInventoryDecreased(testData.product.id);
  });
});
```

### Step 4: Execute and Orchestrate E2E Tests

**Actions:**
- Configure test execution environment
- Run tests in parallel where possible
- Monitor execution and capture results
- Handle test environment state management

**Checklist:**
- [ ] Test environment provisioned and validated
- [ ] Database seeded with test data
- [ ] External services mocked or stubbed
- [ ] Tests executed in parallel (sharded by journey)
- [ ] Real-time execution monitoring active
- [ ] Results collected and aggregated

### Step 5: Analyze Results and Report

**Actions:**
- Analyze test results for pass/fail patterns
- Investigate failures and categorize root causes
- Generate E2E test execution reports
- Provide recommendations for journey improvements

**Checklist:**
- [ ] Pass/fail rates calculated per journey
- [ ] Failures categorized (bug, flaky, environment, data)
- [ ] Screenshots/videos attached to failures
- [ ] Performance metrics captured (page load, step duration)
- [ ] Report generated with executive summary
- [ ] Action items created for failures

## Success Metrics

| Metric | Target | Measurement |
|--------|--------|-------------|
| Critical Path Coverage | 100% of P0 journeys | P0 journeys tested / Total P0 journeys |
| E2E Test Pass Rate | >95% | Passed tests / Total tests |
| Journey Execution Time | <5 min per journey | Average execution time |
| Defect Detection Rate | >85% of UI defects | Defects found in E2E / Total UI defects |
| Flaky Test Rate | <3% | Flaky tests / Total E2E tests |
| Test Maintenance Effort | <15% of test dev time | Maintenance hours / Total hours |

## Error Handling

### Error 1: Element Not Found / Timing Issues
**Symptoms:** Tests fail with "element not found" or "timeout waiting for element"
**Resolution:**
1. Replace implicit waits with explicit waits for specific conditions
2. Use `waitForSelector` with appropriate timeout and retry options
3. Check if page state has changed (navigation, modal, loading)
4. Add retry logic with `test.retry(2)` for known timing-sensitive tests
5. Investigate if application performance has degraded

### Error 2: Test Data Contamination
**Symptoms:** Tests fail due to stale or conflicting test data
**Resolution:**
1. Implement test data isolation (unique identifiers per test run)
2. Use database transactions with rollback for test data
3. Create fresh test data in `beforeEach` and clean in `afterEach`
4. Use data factories with unique suffixes (timestamps, UUIDs)
5. Implement test data cleanup job for orphaned data

### Error 3: External Service Unavailable
**Symptoms:** Tests fail when third-party services are down or rate-limited
**Resolution:**
1. Implement service virtualization (WireMock, MockServer) for external dependencies
2. Use contract testing to validate service interfaces separately
3. Add circuit breaker pattern in tests for graceful degradation
4. Configure retry with exponential backoff for transient failures
5. Skip tests with hard external dependencies in CI (run in staging only)

## Cross-Team Integration

- **automation-qualityforge-test-automation**: Integrate E2E tests into shared automation framework and CI/CD pipeline
- **integration-Integration-testing**: Coordinate on API-level testing that supports E2E journey validation
- **compatibility-Compatibility-testing**: Collaborate on cross-browser and cross-platform E2E test execution
- **performance-Performance-testing**: Share performance data collected during E2E test execution
- **resolver-qualityforge-issue-resolver**: Escalate E2E test failures for root cause analysis and resolution
- **reporter-qualityforge-quality-reporter**: Provide E2E test results for quality reporting and dashboards
**Testing Integration:** procurement-testing
**Workflow Documentation:** [01900 Procurement Order Workflow](docs-paperclip/disciplines/01900-procurement/order-workflow/README.md)
+++++++ REPLACE</parameter>