Vitestモノレポ単体テストとパフォーマンス最適化 (2026)

// Example: vitest.workspace.ts defining unified workspace configuration
import { defineWorkspace } from 'vitest/config';

export default defineWorkspace([
  'packages/*',
  'apps/*',
  {
    extends: './vite.config.ts',
    test: {
      name: 'core-utilities',
      root: './packages/core',
      environment: 'node',
      setupFiles: ['./test/setup.ts'],
    },
  },
  {
    extends: './vite.config.ts',
    test: {
      name: 'ui-components',
      root: './packages/ui',
      environment: 'happy-dom', // Faster than jsdom for UI component tests
      setupFiles: ['./test/setup.ts'],
    },
  },
]);

// Shared test environment initialization script (test/setup.ts)
import { beforeAll, afterEach, vi } from 'vitest';

beforeAll(() => {
  // Global test setup runs once per worker pool instance
  process.env.NODE_ENV = 'test';
  process.env.TZ = 'UTC';
});

afterEach(() => {
  // Clear all mock call histories without resetting implementation behavior
  vi.clearAllMocks();
});

// vite.config.ts: Enterprise Vitest performance tuning configuration
import { defineConfig } from 'vitest/config';
import path from 'path';

export default defineConfig({
  resolve: {
    alias: {
      // Map monorepo packages directly to TypeScript source files
      '@company/core': path.resolve(__dirname, './packages/core/src/index.ts'),
      '@company/ui': path.resolve(__dirname, './packages/ui/src/index.ts'),
      '@company/utils': path.resolve(__dirname, './packages/utils/src/index.ts'),
    },
  },
  test: {
    globals: true,
    pool: 'threads',
    poolOptions: {
      threads: {
        maxThreads: process.env.CI ? 8 : undefined,
        minThreads: process.env.CI ? 4 : undefined,
        useAtomics: true,
        isolate: false, // Disabling isolation provides 2x speed gains for pure unit tests
      },
    },
    coverage: {
      provider: 'v8', // Native V8 coverage is 4x faster than Istanbul AST instrumentation
      reporter: ['text', 'json', 'html'],
      exclude: ['node_modules/', 'test/'],
    },
    deps: {
      optimizer: {
        web: {
          enabled: true,
        },
      },
    },
  },
});

// Worker thread memory inspection utility
import { parentPort } from 'worker_threads';

if (parentPort) {
  parentPort.on('message', (message) => {
    if (message.type === 'CHECK_MEMORY') {
      const memoryUsage = process.memoryUsage();
      parentPort?.postMessage({
        type: 'MEMORY_STATS',
        rss: Math.round(memoryUsage.rss / 1024 / 1024),
        heapUsed: Math.round(memoryUsage.heapUsed / 1024 / 1024),
      });
    }
  });
}

// Custom Vitest plugin to detect and report slow barrel file imports during test runs
import { Plugin } from 'vite';

export function barrelFileProfilerPlugin(): Plugin {
  return {
    name: 'vitest-barrel-profiler',
    transform(code, id) {
      if (id.includes('/src/index.ts') || id.includes('/src/components/index.ts')) {
        const exportCount = (code.match(/export \*/g) || []).length;
        if (exportCount > 15) {
          console.warn(`[Vitest Performance Warning] Large barrel file detected: ${id} (${exportCount} re-exports)`);
        }
      }
      return null;
    },
  };
}

// Example: Bypassing barrel exports via Vite path resolution
// Before (slow - loads entire UI library AST):
// import { Button } from '@company/ui';

// After (fast - loads only Button component and direct dependencies):
// import { Button } from '@company/ui/src/components/Button';

// Using Vitest server options to optimize module resolution
export const performanceTestConfig = {
  test: {
    server: {
      deps: {
        inline: [
          // Inline external monorepo packages to allow Vite to transform them natively
          /@company\/.*/,
        ],
      },
    },
  },
};

// Automated AST transformer script using Babel to replace barrel imports
import { transformSync } from '@babel/core';
import type { PluginObj } from '@babel/core';

export function rewriteBarrelImportsPlugin(): PluginObj {
  return {
    visitor: {
      ImportDeclaration(path) {
        const source = path.node.source.value;
        if (source === '@company/ui') {
          const specifiers = path.node.specifiers;
          const newImports = specifiers.map((spec) => {
            if (spec.type === 'ImportSpecifier' && spec.imported.type === 'Identifier') {
              const name = spec.imported.name;
              return `import ${name} from '@company/ui/src/components/${name}';`;
            }
            return null;
          }).filter(Boolean);

          if (newImports.length > 0) {
            path.replaceWithMultiple(
              newImports.map((code) => transformSync(code as string, { configFile: false })?.ast?.program.body[0]!)
            );
          }
        }
      },
    },
  };
}

# GitHub Actions workflow demonstrating Vitest caching and changed file filtering
name: Monorepo Unit Tests
on: [pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0 # Full depth required for git diff detection

      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'npm'

      - name: Restore Vitest Transform Cache
        uses: actions/cache@v4
        with:
          path: node_modules/.vitest
          key: vitest-cache-${{ runner.os }}-${{ hashFiles('**/package-lock.json') }}-${{ github.sha }}
          restore-keys: |
            vitest-cache-${{ runner.os }}-${{ hashFiles('**/package-lock.json') }}-

      - name: Run Affected Unit Tests Only
        run: |
          npx vitest run --changed origin/main --passWithNoTests

// Script: Automating test suite partitioning across CI shards
import { execSync } from 'child_process';

function runShardedVitest(shardIndex: number, totalShards: number) {
  console.log(`Executing Vitest shard ${shardIndex} of ${totalShards}...`);
  
  const command = `npx vitest run --shard=${shardIndex}/${totalShards} --reporter=github-actions`;
  
  try {
    execSync(command, { stdio: 'inherit' });
    console.log(`Shard ${shardIndex} completed successfully.`);
  } catch (error) {
    console.error(`Shard ${shardIndex} failed.`);
    process.exit(1);
  }
}

// Read CI environment matrix variables
const shardIndex = parseInt(process.env.CI_NODE_INDEX || '1', 10);
const totalShards = parseInt(process.env.CI_NODE_TOTAL || '1', 10);

runShardedVitest(shardIndex, totalShards);

// Custom test filter script matching altered workspace dependencies
import { getChangedFiles } from './git-utils';
import { findAffectedPackages } from './monorepo-graph';

export async function runIncrementalTestSuite() {
  const changedFiles = await getChangedFiles('origin/main');
  const affectedPackages = findAffectedPackages(changedFiles);

  console.log(`Affected packages identified: ${affectedPackages.join(', ')}`);
  
  if (affectedPackages.length === 0) {
    console.log('No workspace packages affected by changes. Skipping test run.');
    return;
  }

  const packageFilter = affectedPackages.map(pkg => `--project=${pkg}`).join(' ');
  execSync(`npx vitest run ${packageFilter}`, { stdio: 'inherit' });
}

// Diagnostic script to audit Vitest execution times across packages
import fs from 'fs';

interface TestReport {
  numTotalTestSuites: number;
  numPassedTestSuites: number;
  startTime: number;
  testResults: Array<{ name: string; status: string }>;
}

function auditTestPerformance(reportPath: string) {
  if (!fs.existsSync(reportPath)) {
    console.error(`Report file not found at ${reportPath}`);
    return;
  }

  const rawData = fs.readFileSync(reportPath, 'utf-8');
  const report: TestReport = JSON.parse(rawData);
  
  console.log(`Total Test Suites: ${report.numTotalTestSuites}`);
  console.log(`Execution Completed in: ${((Date.now() - report.startTime) / 1000).toFixed(2)}s`);
}

auditTestPerformance('./vitest-report.json');