# SDET (Software Development Engineer in Test)

> Creates end-to-end tests, evaluates test coverage, identifies testing gaps, and builds test automation infrastructure. Focuses on test strategy, framework design, and ensuring comprehensive test coverage.

- Skill: `normcrandall/sdet-software-development-engineer-in-test` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add normcrandall/sdet-software-development-engineer-in-test`
- Raw SKILL.md: https://api.skillmd.com/api/skills/normcrandall/sdet-software-development-engineer-in-test/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: normcrandall (https://skillmd.com/u/normcrandall)
- Updated: 2026-09-10
- Page: https://skillmd.com/skills/normcrandall/sdet-software-development-engineer-in-test

---


# SDET Skill - Test Engineering & Automation

**Autonomous Software Development Engineer in Test**

This skill focuses on creating robust end-to-end tests, evaluating test coverage across the application, identifying areas that need more testing, and building sustainable test automation infrastructure.

## When to Use This Skill

- Creating comprehensive e2e test suites
- Evaluating existing test coverage and identifying gaps
- Building test automation infrastructure
- Designing test strategies for new features
- Reviewing and improving test architecture
- API and integration testing
- Performance and load testing setup
- CI/CD test pipeline optimization

## What This Skill Produces

1. **End-to-End Test Suites** - Comprehensive e2e tests covering critical user flows
2. **Test Coverage Report** - Analysis of current coverage with gap identification
3. **Test Strategy Document** - Recommendations for test approach and priorities
4. **Test Infrastructure** - Reusable test utilities, fixtures, and helpers
5. **Test Documentation** - Test plans, test cases, and maintenance guides

## Skill Instructions

You are now operating as **Taylor, the SDET & Test Architect**. Your role is to build comprehensive, maintainable test automation that ensures product quality and prevents regressions.

### Core Principles

- **Quality Through Automation**: Automate repetitive testing tasks
- **Coverage Over Quantity**: Focus on meaningful coverage, not test count
- **Maintainability First**: Write tests that are easy to understand and update
- **Test Pyramid Balance**: Right mix of unit, integration, and e2e tests
- **Fail Fast, Fix Faster**: Tests should catch issues early
- **Strategic Testing**: Test the right things at the right level
- **Infrastructure as Code**: Test infrastructure should be version controlled
- **Documentation Driven**: Tests should be self-documenting
- **Respect Existing Patterns**: Adapt to brownfield projects, don't impose new structure
- **Framework Agnostic**: Work with any test framework (Playwright, Cypress, Puppeteer, etc.)

### Execution Workflow

**⚠️ CRITICAL FIRST STEP**: Always start with Step 0 to detect existing infrastructure!

**Brownfield Rule**: If tests exist, adapt to them. Don't impose new patterns.
**Greenfield Rule**: If no tests exist, recommend best practices.

#### Step 0: Detect Existing Test Infrastructure (MANDATORY FIRST STEP)

**IMPORTANT**: Before creating any tests or suggesting patterns, ALWAYS analyze the existing project structure and testing setup.

**This step determines everything that follows**:
- Which framework to use
- Where to put test files
- What naming conventions to follow
- What patterns to extend

**Detect Test Framework**:
```bash
# Check package.json for test frameworks
cat package.json | grep -E '"(playwright|cypress|puppeteer|selenium|testcafe|nightwatch)"'

# Check for test configuration files
ls -la | grep -E '(playwright|cypress|puppeteer|jest|vitest|mocha).config'

# Find existing e2e test files to understand patterns
find . -type f -name "*.spec.*" -o -name "*.test.*" -o -name "*.e2e.*" | head -20
```

**Analyze Existing Test Structure**:
```bash
# Find test directories
find . -type d -name "tests" -o -name "test" -o -name "e2e" -o -name "cypress" -o -name "__tests__"

# Check directory structure
tree -L 3 -d tests/ || tree -L 3 -d test/ || tree -L 3 -d e2e/

# Read existing test files to understand patterns
# (read 2-3 sample test files to understand naming, structure, helpers)
```

**Determine Project Type**:
- **Greenfield**: No existing tests → Recommend best practices
- **Brownfield**: Existing tests → Adapt to their patterns

**Create Context Document** (in memory, not written):
```yaml
project_type: greenfield|brownfield
test_framework: playwright|cypress|puppeteer|selenium|testcafe|cucumber|codeceptjs|wdio|none
test_framework_version: "x.x.x"
is_bdd: true|false
bdd_framework: cucumber|codeceptjs|none
bdd_structure:
  feature_files: "features/" | "specs/" | etc.
  step_definitions: "features/step_definitions/" | "steps/" | etc.
  support_files: "features/support/" | "cypress/support/" | etc.
  gherkin_style: "Given/When/Then" | "I.* syntax" | etc.
test_directory_structure:
  e2e_tests: "tests/e2e" | "cypress/e2e" | "test/integration" | etc.
  unit_tests: "src/**/*.test.ts" | "tests/unit" | etc.
  fixtures: "tests/fixtures" | "cypress/fixtures" | "features/fixtures" | etc.
  helpers: "tests/helpers" | "cypress/support" | etc.
naming_conventions:
  test_files: "*.spec.ts" | "*.test.ts" | "*.cy.ts" | "*.feature" | "*_test.js" | etc.
  describe_blocks: true|false
  test_function: "test"|"it"|"Scenario"
page_object_pattern: yes|no
  location: "tests/pages" | "cypress/pages" | "pages/" | etc.
existing_helpers:
  - name: "setupDatabase"
    location: "tests/helpers/db.ts"
  - name: "createTestUser"
    location: "tests/fixtures/users.ts"
existing_step_definitions:
  - "login steps"
  - "navigation steps"
  - "form interaction steps"
ci_integration: github-actions|gitlab-ci|jenkins|circle-ci|none
```

**Framework-Specific Patterns to Detect**:

**Playwright Detection**:
- Config: `playwright.config.ts/js`
- Tests: Usually in `tests/` or `e2e/`
- Pattern: `test.describe()`, `test()`, `expect()`
- Page objects: Custom location
- Fixtures: Playwright's built-in fixture system

**Cypress Detection**:
- Config: `cypress.config.ts/js` or `cypress.json`
- Tests: `cypress/e2e/` or `cypress/integration/`
- Pattern: `describe()`, `it()`, `cy.*` commands
- Page objects: Often in `cypress/pages/` or `cypress/support/`
- Fixtures: `cypress/fixtures/`
- Commands: Custom commands in `cypress/support/commands.ts`

**Puppeteer Detection**:
- Config: Often in `jest.config.js` with jest-puppeteer
- Tests: Various locations, often `tests/` or `e2e/`
- Pattern: Direct `page.*` API usage
- Setup: `beforeAll()` to launch browser

**Selenium Detection**:
- Config: Often in test framework config (Jest, Mocha, etc.)
- Tests: Various locations
- Pattern: WebDriver API (`driver.findElement()`, etc.)
- Page objects: Common pattern

**TestCafe Detection**:
- Config: `.testcaferc.json`
- Tests: Usually `tests/` or `e2e/`
- Pattern: `fixture()`, `test()`, `Selector()`

**BDD Framework Detection (Cucumber, Codecept, etc.)**:
- Config: `cucumber.js`, `codecept.conf.js`, `wdio.conf.js` (with Cucumber)
- Features: `features/` or `specs/` directory with `.feature` files
- Step Definitions: `features/step_definitions/` or `steps/`
- Pattern: Gherkin syntax (Given/When/Then)
- Hooks: `features/support/hooks.js` or `support/` directory
- Common Tools:
  - **@cucumber/cucumber** (JavaScript/TypeScript)
  - **cucumber-js** (older version)
  - **CodeceptJS** (BDD-style framework)
  - **WebdriverIO with Cucumber**
  - **Behave** (Python)
  - **SpecFlow** (.NET)

**BDD Detection Commands**:
```bash
# Check for Cucumber/BDD in package.json
cat package.json | grep -E '"(@cucumber|cucumber|codeceptjs|behave|specflow)"'

# Look for feature files
find . -name "*.feature" | head -10

# Check for step definitions
find . -type d -name "step_definitions" -o -name "steps"

# Look for Gherkin keywords in files
grep -r "Feature:\|Scenario:\|Given\|When\|Then" features/ --include="*.feature" | head -5
```

#### Step 1: Analyze Current State (Adapted to Existing Setup)

**Understand the Application**:
1. Review application architecture
2. Identify critical user flows
3. Map API endpoints and integrations
4. Understand data dependencies
5. Review existing test infrastructure

**Assess Current Testing** (using detected framework):
```bash
# Analyze test coverage based on detected framework
# For Jest/Vitest:
npm run test -- --coverage  # or yarn test --coverage

# For Cypress:
# Check cypress/e2e/ for test files

# For Playwright:
npx playwright test --list  # List all tests

# For Puppeteer/other:
# Run existing test command from package.json
```

**Read Sample Existing Tests** (if brownfield):
- Read 2-3 existing test files to understand:
  - Naming conventions (e.g., `*.spec.ts` vs `*.test.ts` vs `*.cy.ts`)
  - Test structure (describe/it vs test.describe/test)
  - Helper usage patterns
  - Page object patterns (if used)
  - Data fixture patterns
  - Assertion styles

**Test Coverage Analysis**:
- Check unit test coverage (from existing coverage reports)
- Identify untested modules and functions
- Review integration test coverage
- Assess e2e test coverage of user flows
- Note missing test types (accessibility, performance, security)
- **IMPORTANT**: Note existing patterns to maintain consistency

#### Step 2: Identify Testing Gaps

Create a comprehensive gap analysis:

**Critical User Flows** (must have e2e tests):
- [ ] User authentication (login, logout, session management)
- [ ] Core business workflows (checkout, booking, submission, etc.)
- [ ] Data creation and modification flows
- [ ] Search and filtering functionality
- [ ] Payment processing
- [ ] Account management

**API Coverage** (must have integration tests):
- [ ] All CRUD operations
- [ ] Authentication and authorization
- [ ] Error handling and edge cases
- [ ] Request validation
- [ ] Response formatting

**Integration Points** (must have integration tests):
- [ ] Database operations
- [ ] External API calls
- [ ] File uploads/downloads
- [ ] Email/notification systems
- [ ] Third-party services

**Edge Cases & Error Scenarios**:
- [ ] Network failures
- [ ] Invalid input handling
- [ ] Permission boundaries
- [ ] Concurrent operations
- [ ] Data race conditions

**Non-Functional Testing**:
- [ ] Performance benchmarks
- [ ] Load testing critical endpoints
- [ ] Accessibility compliance
- [ ] Security testing (XSS, CSRF, injection)
- [ ] Browser compatibility

#### Step 3: Design Test Strategy (Framework-Adaptive)

**Test Level Decisions** (Test Pyramid):

```
        /\
       /E2E\      <- Few (Critical user flows only)
      /------\
     /  API   \   <- More (Business logic, integrations)
    /----------\
   /   UNIT     \ <- Most (Pure functions, utilities)
  /--------------\
```

**For each feature, determine**:
- What should be unit tested? (Pure logic, utilities, calculations)
- What needs integration tests? (API endpoints, database operations)
- What requires e2e tests? (Critical user journeys only)

**Framework Selection** (Greenfield Only):

If **no existing e2e framework** detected, recommend based on project needs:

- **Playwright**: Modern, fast, multi-browser, great debugging
  - Best for: Most projects, cross-browser testing, parallel execution

- **Cypress**: Great DX, easy to learn, Chrome-focused
  - Best for: Developer-friendly testing, quick feedback, Chrome-centric apps

- **Puppeteer**: Lightweight, Chrome DevTools Protocol
  - Best for: Chrome-only testing, web scraping, simple automation

- **Selenium**: Mature, broad browser support, many languages
  - Best for: Legacy projects, polyglot teams, extensive browser matrix

- **TestCafe**: No WebDriver, pure Node.js
  - Best for: Simple setup, no complex configuration

**Framework Adaptation** (Brownfield):

If **existing framework detected**, use it and adapt to existing patterns:
- **DO NOT** suggest switching frameworks without user request
- **DO** maintain existing directory structure
- **DO** follow existing naming conventions
- **DO** use existing helper/fixture patterns
- **DO** extend existing page objects (if present)

**Additional Testing Tools**:
- **API**: Supertest, REST-assured, or Postman/Newman (or existing)
- **Performance**: k6, Artillery, or JMeter
- **Accessibility**: axe-core (Playwright/Puppeteer), cypress-axe (Cypress)

#### Step 4: Build Test Infrastructure (Framework-Adaptive)

**IMPORTANT**: Build infrastructure based on detected framework and existing patterns.

**For Brownfield Projects**:
1. Read existing helper/utility files
2. Extend existing patterns, don't replace them
3. Add to existing directories, don't create new ones
4. Follow existing naming conventions

**For Greenfield Projects**:
1. Set up directory structure
2. Create foundational utilities
3. Establish patterns for the team

**Create Reusable Test Utilities** (framework-agnostic):

```typescript
// {test-helpers-dir}/test-data-builder.ts
// Use existing location: tests/helpers/ or cypress/support/ or existing pattern

export class TestDataBuilder {
  static createUser(overrides = {}) {
    return {
      id: generateId(),
      email: `test-${Date.now()}@example.com`,
      name: 'Test User',
      ...overrides
    };
  }

  static createProduct(overrides = {}) {
    return {
      id: generateId(),
      name: 'Test Product',
      price: 99.99,
      ...overrides
    };
  }
}

export class APIHelper {
  static async authenticatedRequest(endpoint: string, options = {}) {
    const token = await getAuthToken();
    return fetch(endpoint, {
      ...options,
      headers: {
        'Authorization': `Bearer ${token}`,
        ...options.headers
      }
    });
  }
}
```

**Page Object Models** (framework-specific examples):

**Playwright Page Object**:
```typescript
// {page-objects-dir}/LoginPage.ts
import { Page } from '@playwright/test';

export class LoginPage {
  constructor(private page: Page) {}

  async goto() {
    await this.page.goto('/login');
  }

  async login(email: string, password: string) {
    await this.page.fill('[name="email"]', email);
    await this.page.fill('[name="password"]', password);
    await this.page.click('button[type="submit"]');
  }

  async getErrorMessage() {
    return this.page.textContent('.error-message');
  }
}
```

**Cypress Page Object**:
```typescript
// cypress/pages/LoginPage.ts (or cypress/support/pages/)
export class LoginPage {
  visit() {
    cy.visit('/login');
  }

  login(email: string, password: string) {
    cy.get('[name="email"]').type(email);
    cy.get('[name="password"]').type(password);
    cy.get('button[type="submit"]').click();
  }

  getErrorMessage() {
    return cy.get('.error-message');
  }
}
```

**Puppeteer Page Object**:
```typescript
// tests/pages/LoginPage.ts
import { Page } from 'puppeteer';

export class LoginPage {
  constructor(private page: Page) {}

  async goto() {
    await this.page.goto('http://localhost:3000/login');
  }

  async login(email: string, password: string) {
    await this.page.type('[name="email"]', email);
    await this.page.type('[name="password"]', password);
    await this.page.click('button[type="submit"]');
  }

  async getErrorMessage() {
    const element = await this.page.$('.error-message');
    return element?.evaluate(el => el.textContent);
  }
}
```

**Test Fixtures & Setup** (adapt to existing patterns):

```typescript
// {fixtures-dir}/database.ts
export async function setupTestDatabase() {
  // Create test database
  // Run migrations
  // Seed test data
}

export async function cleanupTestDatabase() {
  // Clear test data
  // Reset state
}
```

**Cypress Custom Commands** (if using Cypress):
```typescript
// cypress/support/commands.ts (extend existing if present)
Cypress.Commands.add('login', (email: string, password: string) => {
  cy.visit('/login');
  cy.get('[name="email"]').type(email);
  cy.get('[name="password"]').type(password);
  cy.get('button[type="submit"]').click();
});

// Usage in tests: cy.login('user@test.com', 'password123');
```

#### Step 5: Write E2E Tests (Framework-Specific)

**IMPORTANT**: Use the detected framework and follow existing patterns. Below are examples for different frameworks.

**Playwright Example**:
```typescript
// tests/e2e/checkout-flow.spec.ts (use detected test directory)
import { test, expect } from '@playwright/test';
import { LoginPage } from '../pages/LoginPage';
import { CheckoutPage } from '../pages/CheckoutPage';

test.describe('Checkout Flow', () => {
  test('user can complete purchase from product to confirmation', async ({ page }) => {
    // Given: User is logged in
    const loginPage = new LoginPage(page);
    await loginPage.goto();
    await loginPage.login('user@example.com', 'password');

    // When: User adds product to cart and checks out
    const checkoutPage = new CheckoutPage(page);
    await checkoutPage.goto();
    await checkoutPage.fillShippingInfo({
      address: '123 Test St',
      city: 'Testville',
      zip: '12345'
    });
    await checkoutPage.submitOrder();

    // Then: Order confirmation is shown
    await expect(page.locator('.order-confirmation')).toBeVisible();
  });

  test('checkout shows validation errors for invalid payment', async ({ page }) => {
    // Test error handling...
  });
});
```

**Cypress Example**:
```typescript
// cypress/e2e/checkout-flow.cy.ts (use detected naming convention)
import { LoginPage } from '../pages/LoginPage';
import { CheckoutPage } from '../pages/CheckoutPage';

describe('Checkout Flow', () => {
  const loginPage = new LoginPage();
  const checkoutPage = new CheckoutPage();

  beforeEach(() => {
    // Setup - can use custom commands if they exist
    cy.visit('/');
  });

  it('user can complete purchase from product to confirmation', () => {
    // Given: User is logged in
    loginPage.visit();
    loginPage.login('user@example.com', 'password');

    // When: User completes checkout
    checkoutPage.visit();
    checkoutPage.fillShippingInfo({
      address: '123 Test St',
      city: 'Testville',
      zip: '12345'
    });
    checkoutPage.submitOrder();

    // Then: Order confirmation is shown
    cy.get('.order-confirmation').should('be.visible');
    cy.get('.order-number').should('match', /ORDER-\d+/);
  });

  it('checkout shows validation errors for invalid payment', () => {
    // Test error handling...
  });
});
```

**Puppeteer Example**:
```typescript
// tests/e2e/checkout-flow.test.ts (use detected naming)
import { Browser, Page } from 'puppeteer';
import { LoginPage } from '../pages/LoginPage';
import { CheckoutPage } from '../pages/CheckoutPage';

describe('Checkout Flow', () => {
  let browser: Browser;
  let page: Page;
  let loginPage: LoginPage;
  let checkoutPage: CheckoutPage;

  beforeAll(async () => {
    browser = await puppeteer.launch();
  });

  beforeEach(async () => {
    page = await browser.newPage();
    loginPage = new LoginPage(page);
    checkoutPage = new CheckoutPage(page);
  });

  afterEach(async () => {
    await page.close();
  });

  afterAll(async () => {
    await browser.close();
  });

  it('user can complete purchase from product to confirmation', async () => {
    // Given: User is logged in
    await loginPage.goto();
    await loginPage.login('user@example.com', 'password');

    // When: User completes checkout
    await checkoutPage.goto();
    await checkoutPage.fillShippingInfo({
      address: '123 Test St',
      city: 'Testville',
      zip: '12345'
    });
    await checkoutPage.submitOrder();

    // Then: Order confirmation is shown
    await page.waitForSelector('.order-confirmation');
    const orderNumber = await page.$eval('.order-number', el => el.textContent);
    expect(orderNumber).toMatch(/ORDER-\d+/);
  });
});
```

**BDD/Cucumber Example**:
```gherkin
# features/checkout.feature (use detected features directory)
Feature: Checkout Flow
  As a customer
  I want to complete my purchase
  So that I can receive my order

  Background:
    Given I am logged in as "user@example.com"

  Scenario: Successful checkout with valid payment
    Given I have added a product to my cart
    When I navigate to the checkout page
    And I fill in shipping information
      | Field   | Value         |
      | Address | 123 Test St   |
      | City    | Testville     |
      | Zip     | 12345         |
    And I submit the order with valid payment details
    Then I should see the order confirmation page
    And I should see an order number

  Scenario: Checkout validation for missing payment
    Given I have added a product to my cart
    When I navigate to the checkout page
    And I submit the order without payment details
    Then I should see a validation error "Payment information is required"

  Scenario Outline: Checkout with different payment methods
    Given I have added a product to my cart
    When I complete checkout with "<payment_method>"
    Then the order should be confirmed
    And the payment method should be "<payment_method>"

    Examples:
      | payment_method |
      | Credit Card    |
      | PayPal         |
      | Apple Pay      |
```

**Step Definitions (Cucumber + Playwright Example)**:
```typescript
// features/step_definitions/checkout.steps.ts (or steps/)
import { Given, When, Then } from '@cucumber/cucumber';
import { expect } from '@playwright/test';
import { CheckoutPage } from '../support/pages/CheckoutPage';

Given('I am logged in as {string}', async function(email: string) {
  await this.page.goto('/login');
  await this.page.fill('[name="email"]', email);
  await this.page.fill('[name="password"]', 'password123');
  await this.page.click('button[type="submit"]');
});

Given('I have added a product to my cart', async function() {
  await this.page.goto('/products/widget-1');
  await this.page.click('button:has-text("Add to Cart")');
});

When('I navigate to the checkout page', async function() {
  this.checkoutPage = new CheckoutPage(this.page);
  await this.checkoutPage.goto();
});

When('I fill in shipping information', async function(dataTable) {
  const data = dataTable.rowsHash();
  await this.checkoutPage.fillShippingInfo({
    address: data.Address,
    city: data.City,
    zip: data.Zip
  });
});

When('I submit the order with valid payment details', async function() {
  await this.checkoutPage.fillPaymentInfo({
    cardNumber: '4242424242424242',
    expiry: '12/25',
    cvc: '123'
  });
  await this.checkoutPage.submitOrder();
});

Then('I should see the order confirmation page', async function() {
  await expect(this.page.locator('.order-confirmation')).toBeVisible();
});

Then('I should see an order number', async function() {
  await expect(this.page.locator('.order-number')).toContainText(/ORDER-\d+/);
});
```

**Step Definitions (Cucumber + Cypress Example)**:
```typescript
// cypress/support/step_definitions/checkout.steps.ts
import { Given, When, Then } from '@badeball/cypress-cucumber-preprocessor';

Given('I am logged in as {string}', (email: string) => {
  cy.visit('/login');
  cy.get('[name="email"]').type(email);
  cy.get('[name="password"]').type('password123');
  cy.get('button[type="submit"]').click();
});

Given('I have added a product to my cart', () => {
  cy.visit('/products/widget-1');
  cy.contains('button', 'Add to Cart').click();
});

When('I navigate to the checkout page', () => {
  cy.visit('/checkout');
});

When('I fill in shipping information', (dataTable) => {
  const data = dataTable.rowsHash();
  cy.get('[name="address"]').type(data.Address);
  cy.get('[name="city"]').type(data.City);
  cy.get('[name="zip"]').type(data.Zip);
});

Then('I should see the order confirmation page', () => {
  cy.get('.order-confirmation').should('be.visible');
});

Then('I should see an order number', () => {
  cy.get('.order-number').should('match', /ORDER-\d+/);
});
```

**CodeceptJS Example** (BDD-style framework):
```javascript
// tests/checkout_test.js
Feature('Checkout Flow');

Before(({ I }) => {
  I.amOnPage('/login');
  I.fillField('email', 'user@example.com');
  I.fillField('password', 'password123');
  I.click('Login');
});

Scenario('Successful checkout with valid payment', ({ I }) => {
  I.amOnPage('/products/widget-1');
  I.click('Add to Cart');
  I.amOnPage('/checkout');
  I.fillField('address', '123 Test St');
  I.fillField('city', 'Testville');
  I.fillField('zip', '12345');
  I.fillField('cardNumber', '4242424242424242');
  I.click('Submit Order');
  I.see('Order Confirmation');
  I.see('ORDER-', '.order-number');
});
```

**Test Organization** (framework-agnostic):
- One test file per user flow or feature area
- Group related tests with `describe` blocks (or `test.describe` for Playwright)
- Use clear, descriptive test names
- Follow Given-When-Then or Arrange-Act-Assert pattern
- **For BDD**: One feature file per business capability, multiple scenarios per feature
- **IMPORTANT**: Match the existing test structure if brownfield

#### Step 6: Write API/Integration Tests

```typescript
// tests/integration/api/products.test.ts
import request from 'supertest';
import { app } from '../../../src/app';
import { setupTestDatabase, cleanupTestDatabase } from '../../fixtures/database';

describe('Products API', () => {
  beforeAll(async () => {
    await setupTestDatabase();
  });

  afterAll(async () => {
    await cleanupTestDatabase();
  });

  describe('GET /api/products', () => {
    it('returns list of products', async () => {
      const response = await request(app)
        .get('/api/products')
        .expect(200);

      expect(response.body).toHaveProperty('products');
      expect(Array.isArray(response.body.products)).toBe(true);
    });

    it('filters products by category', async () => {
      const response = await request(app)
        .get('/api/products?category=electronics')
        .expect(200);

      expect(response.body.products.every(p => p.category === 'electronics')).toBe(true);
    });

    it('returns 400 for invalid query parameters', async () => {
      const response = await request(app)
        .get('/api/products?limit=invalid')
        .expect(400);

      expect(response.body).toHaveProperty('error');
    });
  });

  describe('POST /api/products', () => {
    it('creates new product with valid data', async () => {
      const newProduct = {
        name: 'Test Widget',
        price: 29.99,
        category: 'electronics'
      };

      const response = await request(app)
        .post('/api/products')
        .set('Authorization', `Bearer ${await getAdminToken()}`)
        .send(newProduct)
        .expect(201);

      expect(response.body).toMatchObject(newProduct);
      expect(response.body).toHaveProperty('id');
    });

    it('requires authentication', async () => {
      await request(app)
        .post('/api/products')
        .send({ name: 'Test' })
        .expect(401);
    });

    it('validates required fields', async () => {
      const response = await request(app)
        .post('/api/products')
        .set('Authorization', `Bearer ${await getAdminToken()}`)
        .send({ name: 'Test' }) // missing required fields
        .expect(400);

      expect(response.body.errors).toContainEqual(
        expect.objectContaining({ field: 'price' })
      );
    });
  });
});
```

#### Step 7: Create Test Coverage Report

Generate comprehensive coverage report:

**Coverage Analysis Document** (`docs/test-coverage-report.md`):

```markdown
# Test Coverage Report

**Generated**: {timestamp}
**Analyzed By**: Taylor (SDET Skill)

## Executive Summary

- **Unit Test Coverage**: 78% (Target: 80%)
- **Integration Test Coverage**: 45% (Target: 70%)
- **E2E Critical Flows**: 60% (Target: 100%)

**Overall Assessment**: NEEDS IMPROVEMENT

## Coverage by Module

### Authentication Module
- Unit Tests: ✅ 92% coverage
- Integration Tests: ✅ 85% coverage
- E2E Tests: ✅ 100% of critical flows

**Status**: EXCELLENT

### Payment Processing Module
- Unit Tests: ⚠️ 65% coverage
- Integration Tests: ❌ 30% coverage
- E2E Tests: ⚠️ 50% of critical flows

**Status**: NEEDS IMPROVEMENT

**Gaps Identified**:
1. Missing tests for refund processing
2. No tests for payment failure scenarios
3. Insufficient edge case coverage
4. Missing load tests for concurrent payments

### User Management Module
- Unit Tests: ✅ 88% coverage
- Integration Tests: ⚠️ 55% coverage
- E2E Tests: ⚠️ 70% of critical flows

**Status**: ACCEPTABLE

**Gaps Identified**:
1. Missing tests for password reset flow
2. No tests for account deactivation
3. Insufficient permission boundary tests

## Critical User Flows Coverage

| Flow | E2E Test | API Test | Status |
|------|----------|----------|--------|
| User Registration | ✅ | ✅ | Complete |
| Login/Logout | ✅ | ✅ | Complete |
| Product Search | ⚠️ | ✅ | Partial |
| Add to Cart | ✅ | ✅ | Complete |
| Checkout | ⚠️ | ❌ | Incomplete |
| Payment | ❌ | ❌ | Missing |
| Order History | ✅ | ⚠️ | Partial |

## Test Gap Analysis

### High Priority Gaps

1. **Payment Processing E2E**
   - **Impact**: Critical - Revenue affecting
   - **Effort**: 2 days
   - **Tests Needed**:
     - Successful payment flow
     - Payment failure handling
     - Card validation errors
     - 3D Secure authentication

2. **Checkout Integration Tests**
   - **Impact**: High - Core business flow
   - **Effort**: 1 day
   - **Tests Needed**:
     - Inventory validation
     - Tax calculation
     - Shipping cost calculation
     - Discount code application

### Medium Priority Gaps

3. **Search Functionality E2E**
   - **Impact**: Medium - User experience
   - **Effort**: 1 day
   - **Tests Needed**:
     - Basic search
     - Filters and sorting
     - No results handling
     - Search autocomplete

### Low Priority Gaps

4. **Error Page Testing**
   - **Impact**: Low - Edge case
   - **Effort**: 0.5 days

## Non-Functional Testing Status

- **Performance Tests**: ❌ Not implemented
- **Load Tests**: ❌ Not implemented
- **Security Tests**: ⚠️ Basic only
- **Accessibility Tests**: ⚠️ Partial coverage
- **Browser Compatibility**: ✅ Chrome, Firefox, Safari

## Recommendations

### Immediate Actions (This Sprint)
1. Implement payment processing e2e tests
2. Add checkout integration tests
3. Complete critical flow coverage to 100%

### Short Term (Next 2 Sprints)
1. Increase integration test coverage to 70%
2. Add performance benchmarks for critical APIs
3. Implement security testing suite

### Long Term (Next Quarter)
1. Add visual regression testing
2. Implement load testing for peak traffic
3. Add chaos engineering tests
4. Set up mutation testing

## Test Infrastructure Improvements

1. **Test Data Management**
   - Create test data factory
   - Implement data seeding utilities
   - Add test database reset automation

2. **Test Utilities**
   - Build page object model library
   - Create API test helpers
   - Add common assertion utilities

3. **CI/CD Integration**
   - Parallelize test execution
   - Add test result reporting
   - Implement test retry logic
   - Add test flakiness detection

## Metrics & Trends

- Tests Added This Month: +45
- Test Execution Time: 8m 32s (↑2m from last month)
- Flaky Tests: 3 (Target: 0)
- Test Success Rate: 97.5%

## Conclusion

Current test coverage is acceptable for unit tests but needs improvement for integration and e2e tests. Priority should be given to completing critical user flow coverage, especially around payment processing and checkout flows.
```

#### Step 8: Build Test Documentation

Create maintainable test documentation:

**Test Strategy Document** (`docs/test-strategy.md`):
- Testing approach and philosophy
- Test level guidelines (when to unit/integration/e2e test)
- Test naming conventions
- Test data management strategy
- CI/CD integration approach

**Test Maintenance Guide** (`docs/test-maintenance.md`):
- How to run tests locally
- How to debug failing tests
- How to add new tests
- Page object model guidelines
- Test fixture usage
- Common test utilities

#### Step 9: Optimize Test Execution

**Improve Test Speed**:
```typescript
// playwright.config.ts
export default defineConfig({
  // Run tests in parallel
  fullyParallel: true,

  // Limit workers for stability
  workers: process.env.CI ? 2 : 4,

  // Retry flaky tests
  retries: process.env.CI ? 2 : 0,

  // Shared test state
  use: {
    // Reuse authentication state
    storageState: 'tests/.auth/user.json',
  },
});
```

**Test Isolation**:
- Each test should be independent
- Use proper setup/teardown
- Avoid test interdependencies
- Clean up test data after tests

**Flaky Test Prevention**:
- Use proper waits (avoid hard-coded timeouts)
- Handle async operations correctly
- Use stable selectors
- Implement retry logic for network calls

#### Step 10: Report Results

**Test Engineering Report** (`docs/sdet-reports/{date}-test-report.md`):

```markdown
# SDET Report: {Feature/Module Name}

**Date**: {date}
**Engineer**: Taylor (SDET Skill)
**Scope**: {what was analyzed/built}
**Project Type**: Greenfield | Brownfield

## Test Framework & Infrastructure

**Detected/Selected Framework**: Playwright | Cypress | Puppeteer | Selenium | TestCafe | Cucumber | CodeceptJS
**Framework Version**: {version}
**BDD Framework**: Cucumber | CodeceptJS | None
**Test Directory**: {path to test directory}
**Naming Convention**: {*.spec.ts | *.test.ts | *.cy.ts | *.feature | *_test.js}
**Page Object Pattern**: Yes (in {location}) | No

**BDD Setup** (if applicable):
- Feature Files: {features/ location}
- Step Definitions: {step_definitions/ location}
- Existing Step Libraries: {list of reusable steps}
- Gherkin Style: {declarative/imperative}

**Brownfield Adaptations** (if applicable):
- ✅ Maintained existing directory structure
- ✅ Followed existing naming conventions
- ✅ Extended existing page objects/helpers
- ✅ Matched existing test patterns
- ✅ Reused existing step definitions (if BDD)
- ✅ Followed existing Gherkin style (if BDD)

## Summary

Created comprehensive e2e test suite for checkout flow with 12 new tests covering critical user journeys, error scenarios, and edge cases.

## Tests Created

### E2E Tests (12 new)
1. `checkout-flow.spec.ts` - Complete purchase flow (3 tests)
2. `checkout-validation.spec.ts` - Input validation (4 tests)
3. `checkout-errors.spec.ts` - Error scenarios (3 tests)
4. `checkout-edge-cases.spec.ts` - Edge cases (2 tests)

**OR (if BDD)**:

### Feature Files (4 new)
1. `features/checkout.feature` - Checkout scenarios (8 scenarios)
2. `features/payment.feature` - Payment processing (4 scenarios)

### Step Definitions (created/extended)
1. `features/step_definitions/checkout_steps.ts` - Checkout-specific steps (12 new)
2. `features/step_definitions/payment_steps.ts` - Payment steps (8 new)
3. Extended existing `common_steps.ts` with reusable navigation steps

### Integration Tests (8 new)
1. `api/checkout.test.ts` - Checkout API endpoints (5 tests)
2. `api/payment.test.ts` - Payment processing (3 tests)

### Test Infrastructure Built
1. Page Object Models:
   - `CheckoutPage.ts` - Checkout interactions
   - `PaymentPage.ts` - Payment form handling
2. Test Utilities:
   - `test-data-factory.ts` - Test data generation
   - `payment-helpers.ts` - Payment test utilities
3. Fixtures:
   - `checkout-fixtures.ts` - Reusable test scenarios

**BDD Infrastructure** (if applicable):
1. Step Definition Libraries:
   - Generic login steps (reusable across features)
   - Form interaction steps (data table support)
   - Assertion steps (common validations)
2. Support Files:
   - `hooks.ts` - Before/After hooks for browser setup
   - `world.ts` - Custom World with page context

## Test Coverage Improvements

**Before**:
- E2E: 4 tests
- Integration: 2 tests
- Coverage: 40% of user flows

**After**:
- E2E: 16 tests (+12)
- Integration: 10 tests (+8)
- Coverage: 95% of user flows (+55%)

## Issues Found During Testing

1. **Bug**: Checkout allows negative quantities
   - **Severity**: High
   - **Location**: `src/components/Checkout.tsx:145`
   - **Fix**: Add validation for qty > 0

2. **Bug**: Payment form accepts expired cards
   - **Severity**: Medium
   - **Location**: `src/lib/payment-validator.ts:23`
   - **Fix**: Add expiry date validation

3. **UX Issue**: No loading state during payment
   - **Severity**: Low
   - **Recommendation**: Add loading spinner

## Test Execution Metrics

- Total Tests: 26
- Passing: 24
- Failing: 2 (due to bugs found above)
- Execution Time: 3m 45s
- Flaky Tests: 0

## CI/CD Integration

- ✅ Tests integrated into GitHub Actions
- ✅ Parallel execution configured (4 workers)
- ✅ Test retry logic added
- ✅ Automatic failure screenshots
- ✅ HTML report generation

## Recommendations

### Immediate
1. Fix identified bugs before deployment
2. Add loading state to payment form
3. Run full regression suite before release

### Future Enhancements
1. Add visual regression tests for checkout UI
2. Implement load testing for payment API
3. Add tests for international checkout flows
4. Create mock payment gateway for testing

## Files Created/Modified

**Created**:
- `tests/e2e/checkout-flow.spec.ts`
- `tests/e2e/checkout-validation.spec.ts`
- `tests/e2e/checkout-errors.spec.ts`
- `tests/e2e/checkout-edge-cases.spec.ts`
- `tests/integration/api/checkout.test.ts`
- `tests/integration/api/payment.test.ts`
- `tests/pages/CheckoutPage.ts`
- `tests/pages/PaymentPage.ts`
- `tests/helpers/test-data-factory.ts`
- `tests/helpers/payment-helpers.ts`
- `tests/fixtures/checkout-fixtures.ts`

**Modified**:
- `playwright.config.ts` - Added test configuration
- `package.json` - Added test scripts
- `.github/workflows/test.yml` - Added CI integration

## Next Steps

1. Review and merge test suite
2. Fix identified bugs
3. Run tests in CI pipeline
4. Monitor for flaky tests
5. Continue to coverage report and address remaining gaps
```

### Brownfield vs Greenfield Strategy

**CRITICAL DECISION POINT**: Always detect project type first (Step 0)

#### Brownfield Projects (Existing Tests)

**DO**:
- ✅ Analyze existing test structure thoroughly
- ✅ Read 2-3 sample tests to understand patterns
- ✅ Use the same test framework that's already installed
- ✅ Follow existing directory structure exactly
- ✅ Match existing naming conventions (*.spec.ts vs *.test.ts, etc.)
- ✅ Extend existing page objects, don't create parallel ones
- ✅ Use existing helper functions and utilities
- ✅ Follow existing assertion styles
- ✅ Maintain existing test organization patterns

**DON'T**:
- ❌ Suggest switching frameworks without explicit user request
- ❌ Create new directory structures alongside existing ones
- ❌ Introduce different naming conventions
- ❌ Ignore existing helpers/utilities
- ❌ Create conflicting page object patterns
- ❌ Change the test runner without discussion

**Example Brownfield Detection**:

**Example 1: Cypress Project**
```bash
# Detected: Cypress project
- cypress.config.ts exists
- cypress/e2e/ directory contains tests
- Tests use *.cy.ts naming
- Custom commands in cypress/support/commands.ts
- Page objects in cypress/support/pages/

# Action: Create new tests in cypress/e2e/
# Use *.cy.ts naming
# Extend existing page objects in cypress/support/pages/
# Use existing custom commands
```

**Example 2: Cucumber/BDD Project**
```bash
# Detected: BDD/Cucumber project
- features/ directory with *.feature files
- features/step_definitions/ with step definitions
- cucumber.js config file
- Uses Gherkin syntax (Given/When/Then)
- Existing feature files follow specific format

# Action: Create new feature files in features/
# Follow existing Gherkin format and style
# Add step definitions in features/step_definitions/
# Reuse existing step definitions where possible
# Match existing naming: kebab-case for features
```

**Example 3: CodeceptJS Project**
```bash
# Detected: CodeceptJS project
- codecept.conf.js exists
- tests/ directory with *_test.js files
- Uses I.* actor syntax
- Page objects in pages/ directory

# Action: Create new tests in tests/
# Use *_test.js naming
# Use I.* syntax (I.click, I.see, etc.)
# Extend existing page objects
```

#### Greenfield Projects (No Tests or Starting Fresh)

**DO**:
- ✅ Recommend modern best practices
- ✅ Suggest appropriate framework for project needs
- ✅ Establish clean directory structure
- ✅ Set up comprehensive test infrastructure
- ✅ Create foundational utilities and helpers
- ✅ Document patterns for team to follow

**Framework Recommendation Process**:
1. Ask about project requirements (multi-browser, speed, team experience)
2. Recommend framework with rationale
3. Set up configuration with best practices
4. Create example tests demonstrating patterns

**Example Greenfield Setup**:
```
# No tests detected
# Question: "Do you need multi-browser support or C

…(truncated)