claude-autopm 2.8.2 → 2.8.3

package/packages/plugin-testing/commands/test-performance.md

@@ -0,0 +1,1041 @@
+# test:performance
+
+Comprehensive testing performance optimization across all testing frameworks with Context7-verified best practices.
+
+## Description
+
+Unified performance optimization for entire test ecosystem:
+- Jest unit/integration testing
+- Playwright E2E testing
+- Vitest component testing
+- Database testing optimization
+- CI/CD pipeline optimization
+- Test infrastructure best practices
+
+## Required Documentation Access
+
+**MANDATORY:** Before optimization, query Context7 for testing best practices:
+
+**Documentation Queries:**
+- `mcp://context7/nodejs-testing/performance` - Node.js testing performance patterns
+- `mcp://context7/jest/optimization` - Jest optimization strategies
+- `mcp://context7/playwright/performance` - Playwright E2E optimization
+- `mcp://context7/vitest/concurrent` - Vitest concurrent testing
+- `mcp://context7/testing/database` - Database testing optimization
+- `mcp://context7/testing/ci-cd` - CI/CD pipeline optimization
+
+**Why This is Required:**
+- Ensures optimization follows industry best practices
+- Applies proven patterns across all test types
+- Validates framework-specific optimizations
+- Prevents flaky tests and race conditions
+- Optimizes resource utilization
+
+## Usage
+
+```bash
+/test:performance [options]
+```
+
+## Options
+
+- `--scope <unit|e2e|integration|database|all>` - Optimization scope (default: all)
+- `--analyze-only` - Analyze without applying changes
+- `--output <file>` - Write optimization report
+- `--framework <jest|playwright|vitest|all>` - Target framework
+- `--ci-optimize` - Optimize for CI/CD environment
+
+## Examples
+
+### Full Test Suite Optimization
+```bash
+/test:performance
+```
+
+### Framework-Specific Optimization
+```bash
+/test:performance --framework jest
+/test:performance --framework playwright
+```
+
+### CI/CD Pipeline Optimization
+```bash
+/test:performance --ci-optimize
+```
+
+### Analyze Current Performance
+```bash
+/test:performance --analyze-only --output performance-report.md
+```
+
+### Database Tests Only
+```bash
+/test:performance --scope database
+```
+
+## Optimization Categories
+
+### 1. Cross-Framework Parallel Execution (Context7-Verified)
+
+**Pattern from Context7 (/goldbergyoni/nodejs-testing-best-practices):**
+
+#### Package.json Scripts
+```json
+{
+  "scripts": {
+    "test": "npm-run-all --parallel test:unit test:integration",
+    "test:unit": "jest --testPathPattern=unit --maxWorkers=50%",
+    "test:integration": "jest --testPathPattern=integration --maxWorkers=2",
+    "test:e2e": "playwright test --workers=4",
+    "test:all": "npm-run-all test:unit test:integration test:e2e",
+    "test:ci": "npm-run-all --parallel test:unit test:integration && npm run test:e2e"
+  }
+}
+```
+
+**Benefits:**
+- Run unit and integration tests in parallel
+- Different worker configurations per test type
+- Sequential E2E after faster tests
+
+**Performance Impact:**
+- Sequential: 25 minutes (unit: 5m + integration: 10m + E2E: 10m)
+- Parallel: 15 minutes (unit||integration: 10m + E2E: 10m)
+- Improvement: 1.67x faster (10 minutes saved)
+
+#### GitHub Actions Parallel Jobs
+```yaml
+# .github/workflows/test.yml
+name: Test Suite
+on: [push, pull_request]
+
+jobs:
+  unit-tests:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        shard: [1/3, 2/3, 3/3]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+          cache: 'npm'
+      - run: npm ci
+      - run: npm run test:unit -- --shard=${{ matrix.shard }}
+
+  integration-tests:
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:13
+        env:
+          POSTGRES_PASSWORD: postgres
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+          cache: 'npm'
+      - run: npm ci
+      - run: npm run test:integration
+        env:
+          DATABASE_URL: postgresql://postgres:postgres@postgres:5432/test
+
+  e2e-tests:
+    runs-on: ubuntu-latest
+    needs: [unit-tests, integration-tests]
+    strategy:
+      matrix:
+        shard: [1/4, 2/4, 3/4, 4/4]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+          cache: 'npm'
+      - run: npm ci
+      - run: npx playwright install --with-deps
+      - run: npm run test:e2e -- --shard=${{ matrix.shard }}
+```
+
+**Benefits:**
+- Parallel job execution across test types
+- Unit tests sharded 3 ways (3x speedup)
+- E2E tests sharded 4 ways (4x speedup)
+- Integration tests run concurrently with unit tests
+- E2E only runs if unit/integration pass
+
+**Performance Impact:**
+- Sequential: 25 minutes
+- Parallel with sharding: 5 minutes (5x faster)
+
+**Cost Analysis:**
+- Sequential: 25 runner-minutes
+- Parallel: 35 runner-minutes (unit: 3×2.5 + integration: 10 + E2E: 4×2.5)
+- Trade-off: 40% more runner-minutes, but 5x faster delivery
+
+### 2. Database Testing Optimization (Context7-Verified)
+
+**Pattern from Context7 (/goldbergyoni/nodejs-testing-best-practices):**
+
+#### Optimized Docker Compose for All Databases
+```yaml
+# docker-compose.test.yml
+version: "3.9"
+
+services:
+  # PostgreSQL optimized for testing
+  postgres:
+    image: postgres:15-alpine
+    command: |
+      postgres
+      -c fsync=off
+      -c synchronous_commit=off
+      -c full_page_writes=off
+      -c random_page_cost=1.0
+      -c shared_buffers=256MB
+      -c effective_cache_size=512MB
+      -c maintenance_work_mem=64MB
+    tmpfs:
+      - /var/lib/postgresql/data
+    environment:
+      POSTGRES_USER: test
+      POSTGRES_PASSWORD: test
+      POSTGRES_DB: testdb
+    ports:
+      - "5432:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U test"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+  # MySQL optimized for testing
+  mysql:
+    image: mysql:8.0
+    command: |
+      --default-authentication-plugin=mysql_native_password
+      --innodb_flush_log_at_trx_commit=0
+      --innodb_flush_method=O_DIRECT_NO_FSYNC
+      --innodb_doublewrite=0
+      --sync_binlog=0
+    tmpfs:
+      - /var/lib/mysql
+    environment:
+      MYSQL_ROOT_PASSWORD: test
+      MYSQL_DATABASE: testdb
+    ports:
+      - "3306:3306"
+    healthcheck:
+      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+  # MongoDB optimized for testing
+  mongodb:
+    image: mongo:7-jammy
+    command: mongod --nojournal --wiredTigerCacheSizeGB 0.25
+    tmpfs:
+      - /data/db
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: test
+      MONGO_INITDB_ROOT_PASSWORD: test
+    ports:
+      - "27017:27017"
+    healthcheck:
+      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+  # Redis optimized for testing
+  redis:
+    image: redis:7-alpine
+    command: redis-server --save "" --appendonly no --maxmemory 256mb
+    tmpfs:
+      - /data
+    ports:
+      - "6379:6379"
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+```
+
+**Performance Impact per Database:**
+- PostgreSQL: 10x faster (fsync=off + tmpfs)
+- MySQL: 8x faster (innodb optimizations + tmpfs)
+- MongoDB: 8x faster (nojournal + tmpfs)
+- Redis: 15x faster (no persistence + tmpfs)
+
+#### Test Setup with Database Optimization
+```javascript
+// test/setup-db.js
+import { execSync } from 'child_process';
+import { setTimeout } from 'timers/promises';
+
+export default async function setupDatabase() {
+  // Start optimized database containers
+  console.log('Starting test databases...');
+  execSync('docker-compose -f docker-compose.test.yml up -d', {
+    stdio: 'inherit'
+  });
+
+  // Wait for health checks
+  console.log('Waiting for databases to be ready...');
+  await setTimeout(5000);
+
+  // Verify all databases are healthy
+  const services = ['postgres', 'mysql', 'mongodb', 'redis'];
+  for (const service of services) {
+    const result = execSync(
+      `docker-compose -f docker-compose.test.yml ps ${service} --format json`,
+      { encoding: 'utf-8' }
+    );
+    const status = JSON.parse(result);
+    if (status.Health !== 'healthy') {
+      throw new Error(`${service} is not healthy: ${status.Health}`);
+    }
+  }
+
+  console.log('All databases ready!');
+}
+
+// test/teardown-db.js
+import { execSync } from 'child_process';
+
+export default async function teardownDatabase() {
+  console.log('Stopping test databases...');
+  execSync('docker-compose -f docker-compose.test.yml down -v', {
+    stdio: 'inherit'
+  });
+}
+```
+
+#### Jest Configuration with Database
+```javascript
+// jest.config.js
+module.exports = {
+  globalSetup: './test/setup-db.js',
+  globalTeardown: './test/teardown-db.js',
+
+  testTimeout: 30000,
+  maxWorkers: '50%',
+
+  // Database test configuration
+  projects: [
+    {
+      displayName: 'postgres',
+      testMatch: ['**/test/postgres/**/*.test.js'],
+      setupFilesAfterEnv: ['<rootDir>/test/postgres-setup.js'],
+    },
+    {
+      displayName: 'mongodb',
+      testMatch: ['**/test/mongodb/**/*.test.js'],
+      setupFilesAfterEnv: ['<rootDir>/test/mongodb-setup.js'],
+    },
+  ],
+};
+```
+
+### 3. Vitest Concurrent Testing (Context7-Verified)
+
+**Pattern from Context7 (/vitest-dev/vitest):**
+
+#### Vitest Configuration with Concurrency
+```typescript
+// vitest.config.ts
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    // Enable concurrent test execution
+    threads: true,
+    maxThreads: 8,
+    minThreads: 1,
+
+    // Pool options
+    pool: 'threads', // or 'forks' for better isolation
+
+    // Browser testing
+    browser: {
+      enabled: false,
+      name: 'chromium',
+      provider: 'playwright',
+      instances: 4, // Parallel browser instances
+    },
+
+    // Coverage
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/',
+        'test/',
+        '**/*.test.ts',
+        '**/*.spec.ts',
+      ],
+    },
+
+    // Test sharding
+    shard: process.env.CI
+      ? { index: Number(process.env.VITEST_SHARD_INDEX) || 1,
+          total: Number(process.env.VITEST_SHARD_TOTAL) || 1 }
+      : undefined,
+  },
+});
+```
+
+#### Concurrent Test Patterns
+```typescript
+import { describe, test, expect } from 'vitest';
+
+// Concurrent tests in suite
+describe.concurrent('API endpoints', () => {
+  test('GET /users', async () => {
+    const response = await fetch('http://localhost:3000/users');
+    expect(response.status).toBe(200);
+  });
+
+  test('GET /posts', async () => {
+    const response = await fetch('http://localhost:3000/posts');
+    expect(response.status).toBe(200);
+  });
+
+  test('GET /comments', async () => {
+    const response = await fetch('http://localhost:3000/comments');
+    expect(response.status).toBe(200);
+  });
+});
+
+// Sequential suite with concurrent tests
+describe.sequential('Database operations', () => {
+  test.concurrent('insert user', async () => {
+    await db.users.insert({ name: 'John' });
+  });
+
+  test.concurrent('insert post', async () => {
+    await db.posts.insert({ title: 'Test' });
+  });
+});
+
+// Control concurrency limit
+describe.concurrent('Rate-limited API', { concurrent: 2 }, () => {
+  // Only 2 tests run concurrently
+  test('request 1', async () => { /* ... */ });
+  test('request 2', async () => { /* ... */ });
+  test('request 3', async () => { /* ... */ });
+  test('request 4', async () => { /* ... */ });
+});
+```
+
+**Performance Impact:**
+- Sequential: 10 seconds (10 tests × 1s each)
+- Concurrent: 2 seconds (10 tests / 5 threads = 2s)
+- Improvement: 5x faster
+
+#### Vitest Test Sharding
+```bash
+# Run sharded tests locally
+vitest run --shard=1/3
+vitest run --shard=2/3
+vitest run --shard=3/3
+
+# GitHub Actions
+VITEST_SHARD_INDEX=1 VITEST_SHARD_TOTAL=3 vitest run
+```
+
+### 4. Test Cleanup Best Practices (Context7-Verified)
+
+**Pattern from Context7 (/goldbergyoni/nodejs-testing-best-practices):**
+
+#### Transaction-Based Cleanup (PostgreSQL/MySQL)
+```javascript
+// test/transaction-setup.js
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+beforeEach(async () => {
+  // Start transaction for test isolation
+  await prisma.$executeRaw`BEGIN`;
+});
+
+afterEach(async () => {
+  // Rollback transaction (instant cleanup)
+  await prisma.$executeRaw`ROLLBACK`;
+});
+
+afterAll(async () => {
+  await prisma.$disconnect();
+});
+
+// Usage in tests
+describe('User service', () => {
+  it('should create user', async () => {
+    const user = await prisma.user.create({
+      data: { name: 'John', email: 'john@example.com' }
+    });
+
+    expect(user.name).toBe('John');
+    // Automatically rolled back after test
+  });
+});
+```
+
+**Benefits:**
+- Instant cleanup (no DELETE queries)
+- Perfect test isolation
+- No leftover data
+
+**Performance Impact:** 5x faster cleanup (500ms → 100ms)
+
+#### Truncate Tables Strategy
+```javascript
+// test/truncate-setup.js
+import { sequelize } from '../src/database';
+
+const tables = ['users', 'posts', 'comments', 'likes'];
+
+afterEach(async () => {
+  // Disable foreign key checks
+  await sequelize.query('SET FOREIGN_KEY_CHECKS = 0');
+
+  // Truncate all tables
+  await Promise.all(
+    tables.map(table =>
+      sequelize.query(`TRUNCATE TABLE ${table}`)
+    )
+  );
+
+  // Re-enable foreign key checks
+  await sequelize.query('SET FOREIGN_KEY_CHECKS = 1');
+});
+```
+
+**Performance Impact:** 3x faster than DELETE FROM
+
+#### MongoDB Cleanup
+```javascript
+// test/mongodb-setup.js
+import { MongoClient } from 'mongodb';
+
+let client;
+let db;
+
+beforeAll(async () => {
+  client = await MongoClient.connect('mongodb://test:test@localhost:27017');
+  db = client.db('testdb');
+});
+
+afterEach(async () => {
+  // Drop all collections (fastest cleanup)
+  const collections = await db.listCollections().toArray();
+  await Promise.all(
+    collections.map(({ name }) => db.collection(name).drop())
+  );
+});
+
+afterAll(async () => {
+  await client.close();
+});
+```
+
+**Performance Impact:** 10x faster than deleteMany
+
+### 5. HTTP Mocking for Performance (Context7-Verified)
+
+**Pattern from Context7 (/goldbergyoni/nodejs-testing-best-practices):**
+
+#### Unified HTTP Interceptor
+```javascript
+// test/http-mock.js
+import nock from 'nock';
+
+export function setupHttpMocks() {
+  beforeEach(() => {
+    // Enable HTTP interception
+    nock.cleanAll();
+    nock.enableNetConnect('127.0.0.1'); // Allow localhost
+  });
+
+  afterEach(() => {
+    // Verify all mocks were used
+    if (!nock.isDone()) {
+      console.error('Unused HTTP mocks:', nock.pendingMocks());
+      nock.cleanAll();
+    }
+  });
+
+  afterAll(() => {
+    nock.restore();
+  });
+}
+
+// Common API mocks
+export const apiMocks = {
+  users: {
+    getAll: () => nock('https://api.example.com')
+      .get('/users')
+      .reply(200, [
+        { id: 1, name: 'John' },
+        { id: 2, name: 'Jane' }
+      ]),
+
+    getOne: (id, data) => nock('https://api.example.com')
+      .get(`/users/${id}`)
+      .reply(200, data),
+
+    create: (data) => nock('https://api.example.com')
+      .post('/users', data)
+      .reply(201, { id: 123, ...data }),
+
+    error: (code, message) => nock('https://api.example.com')
+      .get(/\/users\/.*/)
+      .reply(code, { error: message }),
+  },
+};
+
+// Usage in tests
+import { setupHttpMocks, apiMocks } from './http-mock';
+
+describe('User service', () => {
+  setupHttpMocks();
+
+  it('should fetch users', async () => {
+    apiMocks.users.getAll();
+
+    const users = await userService.fetchUsers();
+    expect(users).toHaveLength(2);
+  });
+
+  it('should handle errors', async () => {
+    apiMocks.users.error(404, 'User not found');
+
+    await expect(userService.fetchUser(999))
+      .rejects.toThrow('User not found');
+  });
+});
+```
+
+**Performance Impact:**
+- Real HTTP: 500ms per test
+- Mocked HTTP: 5ms per test
+- Improvement: 100x faster
+
+### 6. Memory Optimization (Context7-Verified)
+
+**Pattern from Context7 (/goldbergyoni/nodejs-testing-best-practices):**
+
+#### Jest Memory Configuration
+```javascript
+// jest.config.js
+module.exports = {
+  // Limit memory per worker
+  maxWorkers: '50%',
+  workerIdleMemoryLimit: '512MB',
+
+  // Clear mocks between tests
+  clearMocks: true,
+  resetMocks: true,
+  restoreMocks: true,
+
+  // Detect memory leaks
+  detectLeaks: process.env.CI ? true : false,
+  detectOpenHandles: process.env.CI ? true : false,
+
+  // Test timeout
+  testTimeout: 30000,
+};
+```
+
+#### Package.json Scripts
+```json
+{
+  "scripts": {
+    "test": "NODE_OPTIONS='--max-old-space-size=4096' jest",
+    "test:leaks": "jest --detectLeaks --runInBand",
+    "test:handles": "jest --detectOpenHandles --forceExit"
+  }
+}
+```
+
+### 7. CI/CD Pipeline Optimization (Context7-Verified)
+
+**Pattern from Context7:**
+
+#### Optimized GitHub Actions Workflow
+```yaml
+# .github/workflows/test-optimized.yml
+name: Optimized Test Pipeline
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+env:
+  NODE_VERSION: 18
+  CACHE_VERSION: v1
+
+jobs:
+  # Job 1: Setup and Cache
+  setup:
+    runs-on: ubuntu-latest
+    outputs:
+      cache-key: ${{ steps.cache-keys.outputs.node-modules }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Generate cache keys
+        id: cache-keys
+        run: |
+          echo "node-modules=${{ env.CACHE_VERSION }}-${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}" >> $GITHUB_OUTPUT
+
+      - uses: actions/setup-node@v3
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+          cache: 'npm'
+
+      - name: Cache node modules
+        uses: actions/cache@v3
+        id: cache
+        with:
+          path: node_modules
+          key: ${{ steps.cache-keys.outputs.node-modules }}
+
+      - name: Install dependencies
+        if: steps.cache.outputs.cache-hit != 'true'
+        run: npm ci
+
+  # Job 2: Unit Tests (3 shards)
+  unit-tests:
+    needs: setup
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        shard: [1, 2, 3]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+
+      - name: Restore node modules
+        uses: actions/cache@v3
+        with:
+          path: node_modules
+          key: ${{ needs.setup.outputs.cache-key }}
+
+      - name: Run unit tests
+        run: npm run test:unit -- --shard=${{ matrix.shard }}/3 --coverage
+
+      - name: Upload coverage
+        uses: actions/upload-artifact@v3
+        with:
+          name: coverage-unit-${{ matrix.shard }}
+          path: coverage/
+
+  # Job 3: Integration Tests
+  integration-tests:
+    needs: setup
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:15-alpine
+        env:
+          POSTGRES_PASSWORD: postgres
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --tmpfs /var/lib/postgresql/data
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+
+      - name: Restore node modules
+        uses: actions/cache@v3
+        with:
+          path: node_modules
+          key: ${{ needs.setup.outputs.cache-key }}
+
+      - name: Run integration tests
+        run: npm run test:integration
+        env:
+          DATABASE_URL: postgresql://postgres:postgres@postgres:5432/test
+
+  # Job 4: E2E Tests (4 shards)
+  e2e-tests:
+    needs: [unit-tests, integration-tests]
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        shard: [1, 2, 3, 4]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+
+      - name: Restore node modules
+        uses: actions/cache@v3
+        with:
+          path: node_modules
+          key: ${{ needs.setup.outputs.cache-key }}
+
+      - name: Cache Playwright browsers
+        uses: actions/cache@v3
+        with:
+          path: ~/.cache/ms-playwright
+          key: playwright-${{ runner.os }}-${{ hashFiles('**/package-lock.json') }}
+
+      - name: Install Playwright
+        run: npx playwright install --with-deps
+
+      - name: Run E2E tests
+        run: npm run test:e2e -- --shard=${{ matrix.shard }}/4
+
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: playwright-report-${{ matrix.shard }}
+          path: playwright-report/
+```
+
+**Performance Impact:**
+- Sequential pipeline: 35 minutes
+- Optimized parallel: 6 minutes (5.8x faster)
+- Cost: Same runner-minutes, much faster feedback
+
+## Optimization Output
+
+```
+🚀 Comprehensive Test Performance Analysis
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Project: Full Stack Application
+Testing Frameworks: Jest, Playwright, Vitest
+Total Tests: 2,134 (Unit: 1,247 | Integration: 400 | E2E: 487)
+
+📊 Current Performance Baseline
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Test Suite Breakdown:
+  - Unit tests (Jest): 8m 34s
+  - Integration tests (Jest): 12m 45s
+  - E2E tests (Playwright): 28m 34s
+  Total Sequential: 49m 53s
+
+  CI/CD Pipeline: 55m 12s
+  - Setup: 2m 15s
+  - Unit: 8m 34s
+  - Integration: 12m 45s
+  - E2E: 28m 34s
+  - Coverage: 3m 04s
+
+⚡ Parallel Execution Optimization
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Current: Sequential execution
+  Recommended: Parallel with sharding
+
+  💡 Optimizations:
+  1. Unit tests: 3 shards → 2m 51s (3x faster)
+  2. Integration: 2 workers → 6m 23s (2x faster)
+  3. E2E tests: 4 shards → 7m 8s (4x faster)
+
+  New Timeline (Parallel):
+  - Setup: 1m 30s (cached dependencies)
+  - Unit || Integration: 6m 23s (parallel jobs)
+  - E2E: 7m 8s (depends on unit+integration)
+  Total: 15m 1s (3.3x faster)
+
+💾 Database Optimization
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ⚠️  Using production-like database configuration
+  Current: 12m 45s for integration tests
+
+  💡 Optimizations:
+  1. tmpfs storage → 10x faster I/O
+  2. Disable fsync → 3x faster writes
+  3. Transaction rollback cleanup → 5x faster
+  4. Connection pooling → 2x faster
+
+  Docker Compose generated with:
+  - PostgreSQL: fsync=off + tmpfs
+  - MongoDB: nojournal + tmpfs
+  - Redis: no persistence + tmpfs
+
+  ⚡ Impact:
+  - Current: 12m 45s
+  - Optimized: 1m 17s (10x faster)
+
+🌐 HTTP Mocking
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ⚠️  234 tests making real HTTP requests
+
+  💡 Optimization: Use nock for interception
+
+  ⚡ Impact:
+  - Current: 117s total (500ms × 234 tests)
+  - With nock: 1.2s total (5ms × 234 tests)
+  - Speedup: 100x faster, 0% flaky
+
+  HTTP mock library configured ✓
+
+📈 CI/CD Pipeline Optimization
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Current Pipeline: 55m 12s
+
+  Optimizations Applied:
+  1. Dependency caching → 2m 15s → 30s (4.5x faster)
+  2. Parallel test jobs → Run simultaneously
+  3. Test sharding → Linear speedup
+  4. Browser caching → 1m 30s → 10s (9x faster)
+  5. Optimized databases → 12m 45s → 1m 17s (10x faster)
+
+  New Pipeline Timeline:
+  - Setup (cached): 30s
+  - Unit (3 shards) || Integration: 2m 51s (parallel)
+  - E2E (4 shards): 7m 8s
+  Total: 10m 29s (5.3x faster)
+
+  GitHub Actions workflow generated ✓
+
+🎯 Summary
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Total Optimizations: 24
+
+  🔴 Critical: 6 (parallel execution, sharding, database)
+  🟡 High Impact: 10 (HTTP mocking, caching, cleanup)
+  🟢 Low Impact: 8 (configuration, grouping)
+
+  Performance Improvements:
+
+  Local Development:
+  - Before: 49m 53s
+  - After: 7m 8s (7x faster)
+
+  CI/CD Pipeline:
+  - Before: 55m 12s
+  - After: 10m 29s (5.3x faster)
+
+  Test Reliability:
+  - Flaky tests (real HTTP/DB): 8% failure rate
+  - Optimized (mocked/isolated): <1% failure rate
+
+  Resource Usage:
+  - Database I/O: 10x faster (tmpfs)
+  - Network requests: 100x faster (mocked)
+  - Memory usage: 40% reduction
+  - Storage: 80% reduction (traces/videos on failure)
+
+  Cost Impact:
+  - CI runner-minutes: +20% (more parallelism)
+  - Delivery speed: 5.3x faster
+  - Developer productivity: +400% (faster feedback)
+
+  Run with --apply to implement all optimizations
+```
+
+## Implementation
+
+This command uses multiple agents for comprehensive optimization:
+
+1. **@frontend-testing-engineer** - Component testing optimization
+2. **@nodejs-backend-engineer** - Integration test optimization
+3. **@e2e-test-engineer** - E2E test optimization
+
+**Workflow:**
+1. Query Context7 for best practices across all frameworks
+2. Analyze current test suite performance
+3. Identify optimization opportunities per framework
+4. Configure parallel execution and sharding
+5. Optimize database testing infrastructure
+6. Generate CI/CD pipeline configuration
+7. Apply all optimizations with verification
+
+## Best Practices Applied
+
+Based on Context7 documentation from multiple sources:
+
+1. **Parallel Execution** - Run test types concurrently
+2. **Test Sharding** - Distribute across CI runners (3-4x speedup)
+3. **Database Optimization** - tmpfs + fsync=off (10x speedup)
+4. **HTTP Mocking** - nock interception (100x speedup)
+5. **Transaction Cleanup** - Instant rollback (5x speedup)
+6. **CI/CD Caching** - Dependencies and browsers (4-9x speedup)
+7. **Conditional Traces** - Only on failures (12x faster, 10x less storage)
+
+## Related Commands
+
+- `/jest:optimize` - Jest-specific optimization
+- `/playwright:optimize` - E2E-specific optimization
+- `/test:setup` - Initial test configuration
+- `/test:coverage` - Coverage analysis
+
+## Troubleshooting
+
+### Tests Still Slow
+- Check database configuration (tmpfs enabled?)
+- Verify HTTP mocking is active
+- Review test sharding distribution
+- Check worker configuration
+
+### Flaky Tests
+- Mock all external dependencies
+- Use transaction-based cleanup
+- Check for shared state
+- Verify test isolation
+
+### Out of Memory
+- Reduce `maxWorkers` value
+- Increase `--max-old-space-size`
+- Check for memory leaks with `--detectLeaks`
+
+### CI/CD Pipeline Slow
+- Implement test sharding
+- Enable dependency caching
+- Use optimized Docker images
+- Parallelize test jobs
+
+## Installation
+
+```bash
+# Install testing frameworks
+npm install --save-dev jest @playwright/test vitest
+
+# Install utilities
+npm install --save-dev nock npm-run-all
+
+# Setup databases
+docker-compose -f docker-compose.test.yml up -d
+
+# Verify setup
+npm run test:performance -- --analyze-only
+```
+
+## Version History
+
+- v2.0.0 - Initial Schema v2.0 release with Context7 integration
+- Unified testing optimization across Jest, Playwright, Vitest
+- Database optimization with tmpfs
+- HTTP mocking patterns
+- CI/CD pipeline optimization
+- Test sharding strategies