PlaywrightとCypressのパフォーマンスとメモリのベンチマーク2026

// Example: Measuring Node.js worker RSS memory usage during test execution
import { test, expect } from '@playwright/test';
import v8 from 'v8';

test('verify dashboard performance under memory inspection', async ({ page }) => {
  const initialMemory = process.memoryUsage().rss;
  
  await page.goto('https://app.example.com/dashboard');
  await page.waitForSelector('.data-table-loaded');
  
  const heapStats = v8.getHeapStatistics();
  const currentMemory = process.memoryUsage().rss;
  
  // Log memory delta across test boundaries to monitor worker growth
  console.log(`Initial RSS: ${Math.round(initialMemory / 1024 / 1024)} MB`);
  console.log(`Current RSS: ${Math.round(currentMemory / 1024 / 1024)} MB`);
  console.log(`V8 Heap Limit: ${Math.round(heapStats.heap_size_limit / 1024 / 1024)} MB`);
  
  expect(currentMemory - initialMemory).toBeLessThan(150 * 1024 * 1024);
});

// Cypress config: Tuning test isolation and memory cleanup in cypress.config.ts
import { defineConfig } from 'cypress';

export default defineConfig({
  e2e: {
    baseUrl: 'https://app.example.com',
    testIsolation: 'strict',
    numTestsKeptInMemory: 0, // Mandatory for preventing memory leaks in large suites
    experimentalMemoryManagement: true,
    viewportWidth: 1280,
    viewportHeight: 720,
    setupNodeEvents(on, config) {
      on('before:browser:launch', (browser = {}, launchOptions) => {
        if (browser.family === 'chromium' && browser.name !== 'electron') {
          // Disable background throttling to maximize rendering speed
          launchOptions.args.push('--disable-background-timer-throttling');
          launchOptions.args.push('--disable-backgrounding-occluded-windows');
          launchOptions.args.push('--disable-renderer-backgrounding');
        }
        return launchOptions;
      });
    },
  },
});

// Playwright network interception performance optimization pattern
import { test, expect } from '@playwright/test';

test('intercept heavy external analytics without proxy latency', async ({ page }) => {
  // Fulfill third-party scripts instantly with empty response to speed up load times
  await page.route('**/*.{png,jpg,jpeg,svg,css}', route => route.abort());
  await page.route('**/analytics.js', route => route.fulfill({
    status: 200,
    contentType: 'application/javascript',
    body: 'console.log("analytics stubbed");',
  }));

  await page.goto('/analytics-dashboard');
  await expect(page.locator('.main-chart')).toBeVisible();
});

// Playwright config: Optimizing parallel workers and memory in playwright.config.ts
import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  testDir: './e2e',
  fullyParallel: true,
  workers: process.env.CI ? '50%' : undefined, // Use half available CPU cores on CI
  retries: process.env.CI ? 2 : 0,
  reporter: [['html', { open: 'never' }], ['list']],
  use: {
    baseURL: 'https://app.example.com',
    trace: 'on-first-retry', // Retain traces only on failure to conserve RAM and disk
    video: 'on-first-retry',
    screenshot: 'only-on-failure',
    actionTimeout: 10000,
    navigationTimeout: 15000,
  },
  projects: [
    {
      name: 'chromium',
      use: { ...devices['Desktop Chrome'] },
    },
  ],
});

// Node.js script to run V8 heap profiling on automated test runs
const { spawn } = require('child_process');
const fs = require('fs');

function monitorTestProcess(command, args) {
  const child = spawn(command, args);
  const logFile = fs.createWriteStream('./memory-profile.csv');
  logFile.write('timestamp_ms,rss_mb,heap_total_mb,heap_used_mb\n');

  const interval = setInterval(() => {
    const mem = process.memoryUsage();
    const timestamp = Date.now();
    const rss = (mem.rss / 1024 / 1024).toFixed(2);
    const heapTotal = (mem.heapTotal / 1024 / 1024).toFixed(2);
    const heapUsed = (mem.heapUsed / 1024 / 1024).toFixed(2);

    logFile.write(`${timestamp},${rss},${heapTotal},${heapUsed}\n`);
  }, 2000);

  child.on('close', (code) => {
    clearInterval(interval);
    logFile.end();
    console.log(`Test process finished with code ${code}. Memory log saved.`);
  });
}

// Execute benchmark monitor
monitorTestProcess('npx', ['playwright', 'test']);

// Custom memory diagnostic utility for Playwright test hooks
import { test as baseTest } from '@playwright/test';
import gc from 'v8';

export const test = baseTest.extend({
  memoryDiagnostics: [async ({}, use) => {
    const memBefore = process.memoryUsage();
    await use();
    const memAfter = process.memoryUsage();
    
    const rssDelta = Math.round((memAfter.rss - memBefore.rss) / 1024 / 1024);
    if (rssDelta > 50) {
      console.warn(`Potential memory leak detected in spec: RSS grew by ${rssDelta} MB`);
    }
  }, { auto: true }],
});

#!/usr/bin/env bash
# Optimized CI Execution script for Playwright on GitHub Actions / GitLab CI

set -euo pipefail

echo "Starting high-concurrency Playwright test run..."

# Limit Node memory allocation to prevent unexpected OOM kills
export NODE_OPTIONS="--max-old-space-size=4096"

# Run Playwright tests with explicit worker count matching available CPU threads
npx playwright test \
  --workers=4 \
  --reporter=github,html \
  --max-failures=10

echo "Playwright test suite completed successfully."

// Custom Playwright teardown pattern for deterministic state and memory cleanup
import { test as base } from '@playwright/test';

export const test = base.extend({
  authenticatedPage: async ({ page }, use) => {
    // Setup session state fast via API tokens rather than UI login forms
    await page.goto('/login');
    await page.evaluate(() => {
      localStorage.setItem('auth_token', 'mocked-jwt-session-token');
    });
    
    await use(page);
    
    // Explicit cleanup after test completion to release DOM memory immediately
    await page.evaluate(() => localStorage.clear());
    await page.close();
  },
});

# GitHub Actions workflow snippet for optimized Playwright testing
name: End-to-End Tests
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        shard: [1/4, 2/4, 3/4, 4/4]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'npm'
      - name: Install dependencies
        run: npm ci
      - name: Install Playwright Browsers
        run: npx playwright install --with-deps chromium
      - name: Run Playwright tests
        run: npx playwright test --shard=${{ matrix.shard }}

// Calculation model for estimated monthly CI infrastructure expenditure
function calculateCIMonthlyCost(
  totalTests: number,
  dailyRuns: number,
  avgDurationMinutes: number,
  costPerMinute: number
): number {
  const workingDaysPerMonth = 22;
  const totalMonthlyMinutes = dailyRuns * avgDurationMinutes * workingDaysPerMonth;
  return totalMonthlyMinutes * costPerMinute;
}

const cypressMonthlyCost = calculateCIMonthlyCost(1000, 20, 16.3, 0.008);
const playwrightMonthlyCost = calculateCIMonthlyCost(1000, 20, 8.3, 0.008);

console.log(`Estimated Monthly Cypress CI Cost: $${cypressMonthlyCost.toFixed(2)}`);
console.log(`Estimated Monthly Playwright CI Cost: $${playwrightMonthlyCost.toFixed(2)}`);
console.log(`Monthly Savings with Playwright: $${(cypressMonthlyCost - playwrightMonthlyCost).toFixed(2)}`);