@mutineerjs/mutineer 0.2.2 → 0.2.4

package/dist/runner/jest/__tests__/worker-runtime.spec.js

@@ -0,0 +1,148 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { JestWorkerRuntime, createJestWorkerRuntime } from '../worker-runtime.js';
+// Mock the shared utilities
+vi.mock('../../shared/index.js', () => ({
+    getMutantFilePath: vi.fn((file, id) => `/tmp/__mutineer__/mutant_${id}.ts`),
+    setRedirect: vi.fn(),
+    clearRedirect: vi.fn(),
+}));
+// Mock fs sync operations
+const writeFileSyncMock = vi.fn();
+const rmSyncMock = vi.fn();
+vi.mock('node:fs', () => ({
+    default: {
+        existsSync: vi.fn(() => true),
+        writeFileSync: (...args) => writeFileSyncMock(...args),
+        rmSync: (...args) => rmSyncMock(...args),
+    },
+    existsSync: vi.fn(() => true),
+    writeFileSync: (...args) => writeFileSyncMock(...args),
+    rmSync: (...args) => rmSyncMock(...args),
+}));
+// Mock @jest/core
+const mockRunCLI = vi.fn();
+vi.mock('@jest/core', () => ({
+    runCLI: (...args) => mockRunCLI(...args),
+}));
+describe('JestWorkerRuntime', () => {
+    let runtime;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        runtime = new JestWorkerRuntime({
+            workerId: 'w0',
+            cwd: '/project',
+        });
+    });
+    afterEach(() => {
+        // Clean up env vars
+        delete process.env.MUTINEER_REDIRECT_FROM;
+        delete process.env.MUTINEER_REDIRECT_TO;
+    });
+    it('init and shutdown are no-ops', async () => {
+        await expect(runtime.init()).resolves.toBeUndefined();
+        await expect(runtime.shutdown()).resolves.toBeUndefined();
+    });
+    it('runs a mutant and returns killed when tests fail', async () => {
+        mockRunCLI.mockResolvedValueOnce({
+            results: {
+                success: false,
+                numTotalTests: 3,
+                testResults: [{ failureMessage: 'Expected true to be false' }],
+            },
+            globalConfig: {},
+        });
+        const result = await runtime.run({
+            id: 'foo.ts#1',
+            name: 'flipEQ',
+            file: '/project/src/foo.ts',
+            code: 'mutated code',
+            line: 1,
+            col: 0,
+        }, ['/project/tests/foo.test.ts']);
+        expect(result.killed).toBe(true);
+        expect(result.durationMs).toBeGreaterThanOrEqual(0);
+        expect(result.error).toBe('Expected true to be false');
+    });
+    it('returns not killed when tests pass', async () => {
+        mockRunCLI.mockResolvedValueOnce({
+            results: {
+                success: true,
+                numTotalTests: 3,
+                testResults: [],
+            },
+            globalConfig: {},
+        });
+        const result = await runtime.run({
+            id: 'foo.ts#1',
+            name: 'flipEQ',
+            file: '/project/src/foo.ts',
+            code: 'mutated code',
+            line: 1,
+            col: 0,
+        }, ['/project/tests/foo.test.ts']);
+        expect(result.killed).toBe(false);
+    });
+    it('returns killed on runCLI error', async () => {
+        mockRunCLI.mockRejectedValueOnce(new Error('Jest crashed'));
+        const result = await runtime.run({
+            id: 'foo.ts#1',
+            name: 'flipEQ',
+            file: '/project/src/foo.ts',
+            code: 'mutated code',
+            line: 1,
+            col: 0,
+        }, ['/project/tests/foo.test.ts']);
+        expect(result.killed).toBe(true);
+        expect(result.error).toBe('Jest crashed');
+    });
+    it('writes the mutant file and cleans up after run', async () => {
+        mockRunCLI.mockResolvedValueOnce({
+            results: { success: true, testResults: [] },
+            globalConfig: {},
+        });
+        const { getMutantFilePath, setRedirect, clearRedirect } = await import('../../shared/index.js');
+        await runtime.run({
+            id: 'foo.ts#1',
+            name: 'flipEQ',
+            file: '/project/src/foo.ts',
+            code: 'mutated code',
+            line: 1,
+            col: 0,
+        }, ['/project/tests/foo.test.ts']);
+        expect(getMutantFilePath).toHaveBeenCalled();
+        expect(writeFileSyncMock).toHaveBeenCalled();
+        expect(setRedirect).toHaveBeenCalled();
+        expect(clearRedirect).toHaveBeenCalled();
+        expect(rmSyncMock).toHaveBeenCalled();
+    });
+    it('uses jest config when provided', async () => {
+        const runtimeWithConfig = new JestWorkerRuntime({
+            workerId: 'w0',
+            cwd: '/project',
+            jestConfigPath: 'jest.config.ts',
+        });
+        mockRunCLI.mockResolvedValueOnce({
+            results: { success: true, testResults: [] },
+            globalConfig: {},
+        });
+        await runtimeWithConfig.run({
+            id: 'foo.ts#1',
+            name: 'flipEQ',
+            file: '/project/src/foo.ts',
+            code: 'mutated code',
+            line: 1,
+            col: 0,
+        }, ['/project/tests/foo.test.ts']);
+        const callArgs = mockRunCLI.mock.calls[0][0];
+        expect(callArgs.config).toBe('jest.config.ts');
+    });
+});
+describe('createJestWorkerRuntime', () => {
+    it('returns a JestWorkerRuntime instance', () => {
+        const runtime = createJestWorkerRuntime({
+            workerId: 'w1',
+            cwd: '/project',
+        });
+        expect(runtime).toBeInstanceOf(JestWorkerRuntime);
+    });
+});

package/dist/runner/orchestrator.js

@@ -12,51 +12,31 @@
 import path from 'node:path';
 import os from 'node:os';
 import { normalizePath } from '../utils/normalizePath.js';
-import { render } from 'ink';
-import { createElement } from 'react';
 import { autoDiscoverTargetsAndTests } from './discover.js';
 import { listChangedFiles } from './changed.js';
 import { loadMutineerConfig } from './config.js';
-import { Progress } from '../utils/progress.js';
-import { computeSummary, printSummary } from '../utils/summary.js';
-import { loadCoverageData, loadPerTestCoverageData, isLineCovered, } from '../utils/coverage.js';
-import { createVitestAdapter, isCoverageRequestedInArgs, } from './vitest/index.js';
+import { createVitestAdapter } from './vitest/index.js';
 import { createJestAdapter } from './jest/index.js';
 import { createLogger } from '../utils/logger.js';
-import { PoolSpinner } from '../utils/PoolSpinner.js';
-// CLI argument parsing
-import { parseCliOptions } from './args.js';
-// Cache management
-import { clearCacheOnStart, saveCacheAtomic, readMutantCache, keyForTests, hash, } from './cache.js';
-// Variant enumeration
-import { enumerateVariantsForTarget, filterTestsByCoverage, getTargetFile, } from './variants.js';
+import { extractConfigPath, parseCliOptions } from './args.js';
+import { clearCacheOnStart, readMutantCache } from './cache.js';
+import { getTargetFile, enumerateAllVariants } from './variants.js';
+import { resolveCoverageConfig, loadCoverageAfterBaseline, } from './coverage-resolver.js';
+import { prepareTasks } from './tasks.js';
+import { executePool } from './pool-executor.js';
 const log = createLogger('orchestrator');
-let testMap;
 // Per-mutant test timeout (ms). Can be overridden with env MUTINEER_MUTANT_TIMEOUT_MS
 const MUTANT_TIMEOUT_MS = (() => {
     const raw = process.env.MUTINEER_MUTANT_TIMEOUT_MS;
     const n = raw ? Number(raw) : NaN;
     return Number.isFinite(n) && n > 0 ? n : 30_000;
 })();
-import { cleanupMutineerDirs } from './cleanup.js';
 // Re-export readMutantCache for external use
 export { readMutantCache } from './cache.js';
 export async function runOrchestrator(cliArgs, cwd) {
-    // Load configuration
-    const configPath = cliArgs.find((arg, i) => arg === '--config' || arg === '-c'
-        ? cliArgs[i + 1]
-        : arg.startsWith('--config=') || arg.startsWith('-c='));
-    const cfgPath = configPath?.startsWith('--config=')
-        ? configPath.slice(9)
-        : configPath?.startsWith('-c=')
-            ? configPath.slice(3)
-            : cliArgs.includes('--config')
-                ? cliArgs[cliArgs.indexOf('--config') + 1]
-                : cliArgs.includes('-c')
-                    ? cliArgs[cliArgs.indexOf('-c') + 1]
-                    : undefined;
+    // 1. Parse CLI arguments and load configuration
+    const cfgPath = extractConfigPath(cliArgs);
     const cfg = await loadMutineerConfig(cwd, cfgPath);
-    // Parse CLI options
     const opts = parseCliOptions(cliArgs, cfg);
     await clearCacheOnStart(cwd);
     // Create test runner adapter
@@ -67,56 +47,17 @@ export async function runOrchestrator(cliArgs, cwd) {
         config: cfg,
         cliArgs,
     });
-    // Detect coverage configuration from the adapter
-    const coverageConfig = await adapter.detectCoverageConfig();
-    const wantsPerTestCoverageFromConfig = coverageConfig.perTestEnabled;
-    const coveragePreference = cfg.coverage;
-    const wantsCoverageRun = coveragePreference === true
-        ? true
-        : coveragePreference === false
-            ? false
-            : isCoverageRequestedInArgs(cliArgs) || coverageConfig.coverageEnabled;
-    // Load pre-existing coverage data if provided
-    let coverageData = null;
-    let perTestCoverage = null;
-    if (opts.coverageFilePath) {
-        log.info(`Loading coverage data from ${opts.coverageFilePath}...`);
-        coverageData = await loadCoverageData(opts.coverageFilePath, cwd);
-        log.info(`Loaded coverage for ${coverageData.coveredLines.size} files`);
-    }
-    // If --only-covered-lines but no coverage file, we'll generate it during baseline
-    const needsCoverageFromBaseline = opts.wantsOnlyCoveredLines && !coverageData;
-    const hasCoverageProviderInstalled = adapter.hasCoverageProvider();
-    const rawPerTestCoverage = opts.wantsPerTestCoverage ||
-        wantsPerTestCoverageFromConfig ||
-        (opts.wantsOnlyCoveredLines && hasCoverageProviderInstalled);
-    const wantsPerTestCoverage = opts.runner === 'jest' ? false : rawPerTestCoverage;
-    if (opts.runner === 'jest' && rawPerTestCoverage) {
-        log.warn('Per-test coverage is not supported for Jest; continuing without per-test coverage.');
-    }
-    if (needsCoverageFromBaseline && !hasCoverageProviderInstalled) {
-        log.warn('The "onlyCoveredLines" option requires a coverage provider to generate coverage data.');
-        log.warn('Please install the appropriate coverage package (or disable onlyCoveredLines).');
-        process.exitCode = 1;
-        return;
-    }
-    if (opts.wantsOnlyCoveredLines &&
-        coverageData &&
-        !hasCoverageProviderInstalled) {
-        log.warn('The "onlyCoveredLines" option is enabled, but no coverage provider is installed.');
-        log.warn('Running baseline tests without injecting per-test coverage; existing coverageFile will be used for filtering.');
-    }
+    // 2. Resolve coverage configuration
+    const coverage = await resolveCoverageConfig(opts, cfg, adapter, cliArgs);
+    if (process.exitCode)
+        return; // resolveCoverageConfig sets exitCode on fatal errors
     log.info(`Mutineer starting in ${opts.wantsChangedWithDeps
         ? 'changed files with dependencies'
         : opts.wantsChanged
             ? 'changed files only'
             : 'full'} mode${opts.wantsOnlyCoveredLines ? ' (only covered lines)' : ''}...`);
     log.info(`Using concurrency=${opts.concurrency} (cpus=${os.cpus().length})`);
-    const enableCoverageForBaseline = needsCoverageFromBaseline ||
-        wantsPerTestCoverage ||
-        wantsCoverageRun ||
-        (opts.wantsOnlyCoveredLines && hasCoverageProviderInstalled);
-    // Enumerate changed files if requested
+    // 3. Enumerate changed files if requested
     const changedAbs = opts.wantsChanged || opts.wantsChangedWithDeps
         ? new Set(listChangedFiles(cwd, {
             includeDeps: opts.wantsChangedWithDeps,
@@ -124,12 +65,10 @@ export async function runOrchestrator(cliArgs, cwd) {
             maxDepth: cfg.dependencyDepth,
         }))
         : null;
-    const variants = [];
+    // 4. Discover targets and tests
     const cache = await readMutantCache(cwd);
-    // Always run discovery to build testMap (maps source files → test files)
     const discovered = await autoDiscoverTargetsAndTests(cwd, cfg);
-    testMap = discovered.testMap;
-    // Use explicit targets if provided, otherwise use discovered targets
+    const testMap = discovered.testMap;
     const targets = cfg.targets?.length
         ? [...cfg.targets]
         : (cfg.autoDiscover ?? true)
@@ -142,7 +81,7 @@ export async function runOrchestrator(cliArgs, cwd) {
         const absFile = normalizePath(path.isAbsolute(file) ? file : path.join(cwd, file));
         if (changedAbs && !changedAbs.has(absFile))
             continue;
-        const testsAbs = testMap?.get(normalizePath(absFile));
+        const testsAbs = testMap.get(normalizePath(absFile));
         if (testsAbs) {
             for (const t of testsAbs)
                 allTestFiles.add(t);
@@ -153,235 +92,44 @@ export async function runOrchestrator(cliArgs, cwd) {
         log.info('No tests found for targets. Exiting.');
         return;
     }
-    // Run baseline tests first (with coverage if needed for filtering)
-    log.info(`Running ${baselineTests.length} baseline tests${enableCoverageForBaseline ? ' (collecting coverage)' : ''}\u2026`);
+    // 5. Run baseline tests (with coverage if needed for filtering)
+    log.info(`Running ${baselineTests.length} baseline tests${coverage.enableCoverageForBaseline ? ' (collecting coverage)' : ''}\u2026`);
     const baselineOk = await adapter.runBaseline(baselineTests, {
-        collectCoverage: enableCoverageForBaseline ?? false,
-        perTestCoverage: wantsPerTestCoverage ?? false,
+        collectCoverage: coverage.enableCoverageForBaseline,
+        perTestCoverage: coverage.wantsPerTestCoverage,
     });
     if (!baselineOk) {
         process.exitCode = 1;
         return;
     }
     log.info('\u2713 Baseline tests complete');
-    // Load coverage from baseline if we generated it
-    if (needsCoverageFromBaseline) {
-        const defaultCoveragePath = path.join(cwd, 'coverage', 'coverage-final.json');
-        log.info(`Loading coverage data from ${defaultCoveragePath}...`);
-        try {
-            coverageData = await loadCoverageData(defaultCoveragePath, cwd);
-            log.info(`Loaded coverage for ${coverageData.coveredLines.size} files`);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            log.warn(`Warning: Could not load coverage data: ${msg}`);
-            log.warn('Continuing without coverage filtering.');
-        }
-    }
-    // Load per-test coverage if requested
-    if (wantsPerTestCoverage) {
-        const reportsDir = path.join(cwd, 'coverage');
-        log.info('Loading per-test coverage data...');
-        perTestCoverage = await loadPerTestCoverageData(reportsDir, cwd);
-        if (!perTestCoverage) {
-            log.warn('Per-test coverage data not found. Continuing without per-test test pruning.');
-        }
-        else {
-            log.info(`Loaded per-test coverage for ${perTestCoverage.size} tests`);
-        }
-    }
-    // Enumerate variants for targets in parallel. Keep order deterministic by mapping then flattening.
-    const enumerated = await Promise.all(targets.map(async (target) => {
-        const file = getTargetFile(target);
-        const absFile = normalizePath(path.isAbsolute(file) ? file : path.join(cwd, file));
-        if (changedAbs && !changedAbs.has(absFile))
-            return [];
-        log.debug('Target file: ' + absFile);
-        const files = await enumerateVariantsForTarget(cwd, target, cfg.include, cfg.exclude, cfg.maxMutantsPerFile);
-        const testsAbs = testMap?.get(normalizePath(absFile));
-        const tests = testsAbs ? Array.from(testsAbs) : [];
-        log.debug(`  found ${files.length} variants, linked to ${tests.length} tests`);
-        // Filter by coverage if enabled
-        let filtered = files;
-        if (coverageData) {
-            filtered = files.filter((v) => isLineCovered(coverageData, absFile, v.line));
-            if (filtered.length !== files.length) {
-                log.debug(`  filtered ${files.length} -> ${filtered.length} variants by coverage`);
-            }
-        }
-        return filtered.map((v) => ({ ...v, tests }));
-    }));
-    for (const list of enumerated)
-        variants.push(...list);
+    // 6. Load coverage from baseline if we generated it
+    const updatedCoverage = await loadCoverageAfterBaseline(coverage, cwd);
+    // 7. Enumerate mutation variants
+    const variants = await enumerateAllVariants({
+        cwd,
+        targets,
+        testMap,
+        changedFiles: changedAbs,
+        coverageData: updatedCoverage.coverageData,
+        config: cfg,
+    });
     if (!variants.length) {
-        const msg = coverageData
+        const msg = updatedCoverage.coverageData
             ? 'No mutants to test (all mutations are on uncovered lines). Exiting.'
             : 'No mutants to test. Exiting.';
         log.info(msg);
         return;
     }
-    const progress = new Progress(variants.length, {
-        mode: opts.progressMode === 'bar' ? 'bar' : 'list',
-        stream: 'stderr',
-    });
-    // Track mutation testing duration
-    const mutationStartTime = Date.now();
-    // Precompute task metadata for faster worker loops (sort tests, compute keys once)
-    const tasks = variants.map((v) => {
-        let tests = Array.from(v.tests);
-        if (perTestCoverage && tests.length) {
-            const before = tests.length;
-            tests = filterTestsByCoverage(perTestCoverage, tests, v.file, v.line);
-            if (tests.length !== before) {
-                log.debug(`Pruned tests ${before} -> ${tests.length} for mutant ${v.name} via per-test coverage`);
-            }
-        }
-        tests.sort();
-        const testSig = hash(keyForTests(tests));
-        const codeSig = hash(v.code);
-        const key = `${testSig}:${codeSig}`;
-        return { v, tests, key };
+    // 8. Prepare tasks and execute via worker pool
+    const tasks = prepareTasks(variants, updatedCoverage.perTestCoverage);
+    await executePool({
+        tasks,
+        adapter,
+        cache,
+        concurrency: opts.concurrency,
+        progressMode: opts.progressMode,
+        minKillPercent: opts.minKillPercent,
+        cwd,
     });
-    const workerCount = Math.max(1, Math.min(opts.concurrency, tasks.length));
-    // Ensure we only finish once
-    let finished = false;
-    const finishOnce = () => {
-        if (finished)
-            return;
-        finished = true;
-        const durationMs = Date.now() - mutationStartTime;
-        // Finish progress display first
-        progress.finish();
-        // Compute and print a human-friendly summary
-        const summary = computeSummary(cache);
-        printSummary(summary, cache, durationMs);
-        if (opts.minKillPercent !== undefined) {
-            const killRateString = summary.killRate.toFixed(2);
-            const thresholdString = opts.minKillPercent.toFixed(2);
-            if (summary.killRate < opts.minKillPercent) {
-                const note = summary.evaluated === 0 ? ' No mutants were executed.' : '';
-                log.error(`Mutation kill rate ${killRateString}% did not meet required ${thresholdString}% threshold.${note}`);
-                // Set exit code and let caller/CLI decide if it should terminate abruptly
-                process.exitCode = 1;
-            }
-            else {
-                log.info(`Mutation kill rate ${killRateString}% meets required ${thresholdString}% threshold`);
-            }
-        }
-    };
-    // Initialize test runner adapter
-    const workerLogSuffix = workerCount < opts.concurrency ? ` (requested ${opts.concurrency})` : '';
-    log.info(`Initializing ${adapter.name} worker pool with ${workerCount} workers...${workerLogSuffix}`);
-    const poolStart = Date.now();
-    // Ink spinner on stderr while workers start up
-    let spinnerInstance = null;
-    if (process.stderr.isTTY) {
-        spinnerInstance = render(createElement(PoolSpinner, { message: 'Starting pool...' }), { stdout: process.stderr, stderr: process.stderr });
-    }
-    try {
-        await adapter.init(workerCount);
-    }
-    finally {
-        if (spinnerInstance) {
-            spinnerInstance.unmount();
-            spinnerInstance = null;
-        }
-    }
-    const poolDurationMs = Date.now() - poolStart;
-    log.info(`\u2713 Worker pool ready (${poolDurationMs}ms)`);
-    progress.start();
-    let nextIdx = 0;
-    /**
-     * Process a single mutant task: check cache, run tests if needed, update cache and progress.
-     * This function is designed to be called by multiple workers concurrently.
-     */
-    async function processTask(task) {
-        const { v, tests, key } = task;
-        log.debug('Cache ' + JSON.stringify(cache));
-        // Check if already cached
-        const cached = cache[key];
-        if (cached) {
-            progress.update(cached.status);
-            return;
-        }
-        // Skip if no tests import this file
-        if (tests.length === 0) {
-            cache[key] = {
-                status: 'skipped',
-                file: v.file,
-                line: v.line,
-                col: v.col,
-                mutator: v.name,
-            };
-            progress.update('skipped');
-            return;
-        }
-        log.debug(`Running tests for mutant ${v.name} ${JSON.stringify(tests)}`);
-        // Run mutant via test runner adapter
-        const result = await adapter.runMutant({
-            id: v.id,
-            name: v.name,
-            file: v.file,
-            code: v.code,
-            line: v.line,
-            col: v.col,
-        }, tests);
-        const status = result.status;
-        cache[key] = {
-            status,
-            file: v.file,
-            line: v.line,
-            col: v.col,
-            mutator: v.name,
-        };
-        progress.update(status);
-    }
-    /**
-     * Worker coroutine: process mutant tasks from the queue until exhausted.
-     * Multiple workers run concurrently, sharing the task queue.
-     */
-    async function worker() {
-        while (true) {
-            const i = nextIdx++;
-            if (i >= tasks.length)
-                break;
-            await processTask(tasks[i]);
-        }
-    }
-    const workers = [];
-    // Register signal handlers so Ctrl+C / SIGTERM still triggers cleanup
-    let signalCleanedUp = false;
-    const signalHandler = async (signal) => {
-        if (signalCleanedUp)
-            return;
-        signalCleanedUp = true;
-        log.info(`\nReceived ${signal}, cleaning up...`);
-        finishOnce();
-        await adapter.shutdown();
-        await cleanupMutineerDirs(cwd);
-        process.exit(1);
-    };
-    process.on('SIGINT', () => void signalHandler('SIGINT'));
-    process.on('SIGTERM', () => void signalHandler('SIGTERM'));
-    try {
-        // Spawn worker coroutines
-        for (let i = 0; i < workerCount; i++)
-            workers.push(worker());
-        // Wait for all workers to complete
-        await Promise.all(workers);
-        // Persist results to disk
-        await saveCacheAtomic(cwd, cache);
-    }
-    finally {
-        // Remove signal handlers to avoid double cleanup
-        process.removeAllListeners('SIGINT');
-        process.removeAllListeners('SIGTERM');
-        if (!signalCleanedUp) {
-            finishOnce();
-            // Shutdown adapter
-            await adapter.shutdown();
-            // Clean up all __mutineer__ temp directories
-            await cleanupMutineerDirs(cwd);
-        }
-    }
 }

package/dist/runner/pool-executor.d.ts

@@ -0,0 +1,17 @@
+import type { MutantCacheEntry } from '../types/mutant.js';
+import type { TestRunnerAdapter } from './types.js';
+import type { MutantTask } from './tasks.js';
+export interface PoolExecutionOptions {
+    tasks: MutantTask[];
+    adapter: TestRunnerAdapter;
+    cache: Record<string, MutantCacheEntry>;
+    concurrency: number;
+    progressMode: 'bar' | 'list' | 'quiet';
+    minKillPercent?: number;
+    cwd: string;
+}
+/**
+ * Execute all mutant tasks through the worker pool.
+ * Handles worker init, progress display, signal handling, and cleanup.
+ */
+export declare function executePool(opts: PoolExecutionOptions): Promise<void>;