E2E Testing Framework

Comprehensive end-to-end test suite for the YourEra platform.

Overview

The E2E test suite is a Playwright-based framework organized into a 5-tier architecture. It validates the entire YourEra platform from health checks through full patient journeys, with 120+ tests across all tiers.

Architecture

┌──────────────────────────────────────────────┐
│  Tier 5: Full Scenarios                      │
│  Complete patient journeys end-to-end         │
├──────────────────────────────────────────────┤
│  Tier 4: UI Tests                            │
│  Browser-based form and portal testing        │
├──────────────────────────────────────────────┤
│  Tier 3: Business Flows                      │
│  Cross-service integration flows              │
├──────────────────────────────────────────────┤
│  Tier 2: API Contracts                       │
│  Endpoint input/output validation             │
├──────────────────────────────────────────────┤
│  Tier 1: Smoke Tests                         │
│  Service health checks (~5s)                  │
└──────────────────────────────────────────────┘

Test Count Summary

Tier 1: Smoke Tests

Smoke tests are the fastest tier, completing in approximately 5 seconds. They verify that every service in the platform is reachable and responding to health check endpoints.

Checks (9 Tests)

Tier 2: API Contracts

API contract tests validate every public and internal API endpoint. Each test sends a well-formed request and validates the response status code, shape, and required fields. Invalid inputs are also tested to verify proper error handling.

Coverage (56+ Tests)

• Admin API — All /api/admin/* endpoints (stats, patients, orders, sync-logs, refund, charge)
• RxQueue API — /api/tasks, /api/task-action, /api/rx-queue/hp-data, /api/practitioners
• Patient API — All /api/patient/* endpoints (profile, prescriptions, shipments, messages, notifications)
• Intake Gateway — /submit-intake, /validate-coupon, /verify-email
• Pharmacy Router — /rx/prescriptions/submit, /rx/prescriptions/:id, webhooks
• Auth Endpoints — OTP send/verify, Canvas HMAC validation, session management

Test Pattern

import { test, expect } from '@playwright/test';
import { adminClient } from '../lib/api-client';

test('GET /api/admin/stats returns dashboard metrics', async () => {
  const res = await adminClient.get('/api/admin/stats');
  expect(res.status).toBe(200);
  expect(res.data).toHaveProperty('revenue');
  expect(res.data).toHaveProperty('pendingRxCount');
  expect(res.data).toHaveProperty('shipmentPipeline');
});

Tier 3: Business Flows

Business flow tests validate cross-service integrations by executing multi-step sequences that span multiple services. These tests use real API calls but may use test-mode flags to avoid side effects.

Flows Tested

Tier 4: UI Tests

UI tests use Playwright's browser automation to test the frontend applications. They verify form validation, navigation, error handling, and user interactions in actual browser contexts.

Test Areas

• Intake Forms — Step navigation, field validation, auto-formatting (DOB, phone), address autocomplete, error states
• Edge Cases — Browser back button, page refresh with draft persistence, expired sessions, network errors
• Admin Portal — Login flow, RxQueue interaction, patient search, order filters
• Patient Portal — Login flow, dashboard rendering, message sending, appointment booking

Browser Configuration

// playwright.config.ts
{
  projects: [
    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
    { name: 'mobile', use: { ...devices['iPhone 14'] } },
  ],
  webServer: {
    command: 'npm run dev',
    port: 5173,
  }
}

Tier 5: Full Scenarios

Scenario tests are the highest-level tests, executing complete patient journeys from intake through prescription delivery. Each scenario combines API calls and browser automation to verify the full workflow.

Scenarios

Running Tests

Commands

Environment Setup

# Install dependencies
npm install

# Install Playwright browsers
npx playwright install

# Copy env template
cp .env.example .env

# Run smoke tests to verify setup
npm run smoke

Adding Tests

File Structure

e2e-tests/
  tests/
    tier-1-smoke/          # Health check tests
    tier-2-api/            # API contract tests
    tier-3-flows/          # Business flow tests
    tier-4-ui/             # Browser UI tests
    tier-5-scenarios/      # Full journey tests
  lib/
    api-client.ts          # HTTP client with auth
    canvas-client.ts       # Canvas FHIR helpers
    stripe-helpers.ts      # Stripe test mode helpers
    state-manager.ts       # Cross-test state sharing
    test-data.ts           # Test data generators

Creating a New Test

1. Choose the appropriate tier directory based on the test scope
2. Create a new .spec.ts file following the naming convention: feature-name.spec.ts
3. Import the appropriate client from lib/ (adminClient, patientClient, etc.)
4. Use the state manager for tests that depend on previously created data
5. Tag the test with @tier-N for filtering

State Management

import { stateManager } from '../lib/state-manager';

// Store data from one test
stateManager.set('testPatientId', patientId);

// Retrieve in a later test
const patientId = stateManager.get('testPatientId');

Test Credentials

All test credentials are stored in the .env file. The .env.example template lists all required variables.

Required Environment Variables