@mutineerjs/mutineer 0.2.3 → 0.3.2

package/dist/runner/coverage-resolver.js

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import { loadCoverageData, loadPerTestCoverageData, } from '../utils/coverage.js';
+import { isCoverageRequestedInArgs } from './vitest/index.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('coverage-resolver');
+/**
+ * Resolve all coverage-related configuration from CLI options, config, and adapter detection.
+ * Returns a unified resolution object used by the orchestrator.
+ */
+export async function resolveCoverageConfig(opts, cfg, adapter, cliArgs) {
+    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;
+    if (opts.coverageFilePath) {
+        log.info(`Loading coverage data from ${opts.coverageFilePath}...`);
+        coverageData = await loadCoverageData(opts.coverageFilePath, process.cwd());
+        log.info(`Loaded coverage for ${coverageData.coveredLines.size} files`);
+    }
+    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 {
+            coverageData: null,
+            perTestCoverage: null,
+            enableCoverageForBaseline: false,
+            wantsPerTestCoverage: false,
+            needsCoverageFromBaseline,
+        };
+    }
+    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.');
+    }
+    const enableCoverageForBaseline = needsCoverageFromBaseline ||
+        wantsPerTestCoverage ||
+        wantsCoverageRun ||
+        (opts.wantsOnlyCoveredLines && hasCoverageProviderInstalled);
+    return {
+        coverageData,
+        perTestCoverage: null,
+        enableCoverageForBaseline,
+        wantsPerTestCoverage,
+        needsCoverageFromBaseline,
+    };
+}
+/**
+ * Load coverage data produced during the baseline run.
+ * Mutates and returns an updated CoverageResolution.
+ */
+export async function loadCoverageAfterBaseline(resolution, cwd) {
+    let { coverageData, perTestCoverage } = resolution;
+    if (resolution.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.');
+        }
+    }
+    if (resolution.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`);
+        }
+    }
+    return { ...resolution, coverageData, perTestCoverage };
+}

package/dist/runner/discover.js

@@ -85,7 +85,8 @@ async function createViteResolver(rootAbs, exts) {
     let plugins = [];
     if (exts.has('.vue')) {
         try {
-            const mod = await import('@vitejs/plugin-vue');
+            const mod = await import(
+            /* @vite-ignore */ '@vitejs/plugin-vue');
             const vue = mod.default ?? mod;
             plugins = typeof vue === 'function' ? [vue()] : [];
         }

package/dist/runner/jest/__tests__/adapter.spec.js

@@ -39,7 +39,7 @@ describe('Jest adapter', () => {
     afterEach(() => {
         vi.useRealTimers();
     });
-    it('initializes pool with override concurrency', async () => {
+    it('initialises pool with override concurrency', async () => {
         const adapter = makeAdapter();
         await adapter.init(4);
         expect(poolInstance?.init).toHaveBeenCalledTimes(1);

package/dist/runner/jest/__tests__/pool.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runner/jest/__tests__/pool.spec.js

@@ -0,0 +1,211 @@
+import { describe, it, expect, vi } from 'vitest';
+import { JestPool, runWithJestPool } from '../pool.js';
+// We'll use the createWorker option to inject mock workers instead of forking processes
+function makeMockWorker(id) {
+    const worker = {
+        id,
+        _ready: true,
+        _busy: false,
+        _mockResult: { killed: true, durationMs: 10 },
+        on: vi.fn(),
+        once: vi.fn(),
+        isReady: vi.fn(() => worker._ready),
+        isBusy: vi.fn(() => worker._busy),
+        start: vi.fn(async () => {
+            // Simulate worker startup
+        }),
+        run: vi.fn(async () => worker._mockResult),
+        shutdown: vi.fn(async () => { }),
+        kill: vi.fn(),
+        emit: vi.fn(),
+    };
+    return worker;
+}
+const dummyMutant = {
+    id: 'test#1',
+    name: 'flipEQ',
+    file: '/src/foo.ts',
+    code: 'mutated',
+    line: 1,
+    col: 0,
+};
+describe('JestPool', () => {
+    it('throws if run is called before init', async () => {
+        const pool = new JestPool({ cwd: '/tmp', concurrency: 1 });
+        await expect(pool.run(dummyMutant, ['test.ts'])).rejects.toThrow('Pool not initialised');
+    });
+    it('initialises with the specified concurrency', async () => {
+        const workers = [];
+        const pool = new JestPool({
+            cwd: '/tmp',
+            concurrency: 2,
+            createWorker: (id) => {
+                const w = makeMockWorker(id);
+                workers.push(w);
+                return w;
+            },
+        });
+        await pool.init();
+        expect(workers).toHaveLength(2);
+        expect(workers[0].start).toHaveBeenCalled();
+        expect(workers[1].start).toHaveBeenCalled();
+    });
+    it('does not re-initialise if already initialised', async () => {
+        const workers = [];
+        const pool = new JestPool({
+            cwd: '/tmp',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = makeMockWorker(id);
+                workers.push(w);
+                return w;
+            },
+        });
+        await pool.init();
+        await pool.init(); // second call should be no-op
+        expect(workers).toHaveLength(1);
+    });
+    it('runs a mutant via a worker', async () => {
+        const workers = [];
+        const pool = new JestPool({
+            cwd: '/tmp',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = makeMockWorker(id);
+                w._mockResult = { killed: true, durationMs: 50 };
+                workers.push(w);
+                return w;
+            },
+        });
+        await pool.init();
+        const result = await pool.run(dummyMutant, ['test.ts']);
+        expect(result.killed).toBe(true);
+        expect(result.durationMs).toBe(50);
+    });
+    it('shuts down all workers', async () => {
+        const workers = [];
+        const pool = new JestPool({
+            cwd: '/tmp',
+            concurrency: 2,
+            createWorker: (id) => {
+                const w = makeMockWorker(id);
+                workers.push(w);
+                return w;
+            },
+        });
+        await pool.init();
+        await pool.shutdown();
+        for (const w of workers) {
+            expect(w.shutdown).toHaveBeenCalled();
+        }
+    });
+    it('throws if run is called after shutdown', async () => {
+        const pool = new JestPool({
+            cwd: '/tmp',
+            concurrency: 1,
+            createWorker: (id) => makeMockWorker(id),
+        });
+        await pool.init();
+        await pool.shutdown();
+        // After shutdown, initialised is set to false, so "not initialised" check fires first
+        await expect(pool.run(dummyMutant, ['test.ts'])).rejects.toThrow('Pool not initialised');
+    });
+    it('does not double-shutdown', async () => {
+        const workers = [];
+        const pool = new JestPool({
+            cwd: '/tmp',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = makeMockWorker(id);
+                workers.push(w);
+                return w;
+            },
+        });
+        await pool.init();
+        await pool.shutdown();
+        await pool.shutdown(); // should not throw
+        expect(workers[0].shutdown).toHaveBeenCalledTimes(1);
+    });
+});
+describe('runWithJestPool', () => {
+    it('maps killed result correctly', async () => {
+        const pool = new JestPool({
+            cwd: '/tmp',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = makeMockWorker(id);
+                w._mockResult = { killed: true, durationMs: 10 };
+                return w;
+            },
+        });
+        await pool.init();
+        const result = await runWithJestPool(pool, dummyMutant, ['test.ts']);
+        expect(result.status).toBe('killed');
+        expect(result.durationMs).toBe(10);
+        await pool.shutdown();
+    });
+    it('maps escaped result correctly', async () => {
+        const pool = new JestPool({
+            cwd: '/tmp',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = makeMockWorker(id);
+                w._mockResult = { killed: false, durationMs: 20 };
+                return w;
+            },
+        });
+        await pool.init();
+        const result = await runWithJestPool(pool, dummyMutant, ['test.ts']);
+        expect(result.status).toBe('escaped');
+        await pool.shutdown();
+    });
+    it('maps timeout error correctly', async () => {
+        const pool = new JestPool({
+            cwd: '/tmp',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = makeMockWorker(id);
+                w._mockResult = { killed: true, durationMs: 5000, error: 'timeout' };
+                return w;
+            },
+        });
+        await pool.init();
+        const result = await runWithJestPool(pool, dummyMutant, ['test.ts']);
+        expect(result.status).toBe('timeout');
+        expect(result.error).toBe('timeout');
+        await pool.shutdown();
+    });
+    it('maps non-timeout error with !killed to error status', async () => {
+        const pool = new JestPool({
+            cwd: '/tmp',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = makeMockWorker(id);
+                w._mockResult = { killed: false, durationMs: 10, error: 'crash' };
+                return w;
+            },
+        });
+        await pool.init();
+        const result = await runWithJestPool(pool, dummyMutant, ['test.ts']);
+        expect(result.status).toBe('error');
+        expect(result.error).toBe('crash');
+        await pool.shutdown();
+    });
+    it('handles pool.run throwing an error', async () => {
+        const pool = new JestPool({
+            cwd: '/tmp',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = makeMockWorker(id);
+                w.run = vi.fn().mockRejectedValue(new Error('pool exploded'));
+                return w;
+            },
+        });
+        await pool.init();
+        const result = await runWithJestPool(pool, dummyMutant, ['test.ts']);
+        expect(result.status).toBe('error');
+        expect(result.error).toBe('pool exploded');
+        expect(result.durationMs).toBe(0);
+        await pool.shutdown();
+    });
+});

package/dist/runner/jest/__tests__/worker-runtime.spec.d.ts

@@ -0,0 +1 @@
+export {};

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((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/jest/adapter.js

@@ -121,7 +121,7 @@ export class JestAdapter {
     }
     async runMutant(mutant, tests) {
         if (!this.pool) {
-            throw new Error('JestAdapter not initialized. Call init() first.');
+            throw new Error('JestAdapter not initialised. Call init() first.');
         }
         try {
             const result = await this.pool.run(mutant, [...tests]);

package/dist/runner/jest/pool.d.ts

@@ -33,7 +33,7 @@ export declare class JestPool {
     private availableWorkers;
     private waitingTasks;
     private readonly options;
-    private initialized;
+    private initialised;
     private shuttingDown;
     constructor(options: JestPoolOptions);
     init(): Promise<void>;

package/dist/runner/jest/pool.js

@@ -170,7 +170,7 @@ export class JestPool {
         this.workers = [];
         this.availableWorkers = [];
         this.waitingTasks = [];
-        this.initialized = false;
+        this.initialised = false;
         this.shuttingDown = false;
         this.options = {
             cwd: options.cwd,
@@ -181,7 +181,7 @@ export class JestPool {
         };
     }
     async init() {
-        if (this.initialized)
+        if (this.initialised)
             return;
         const startPromises = [];
         for (let i = 0; i < this.options.concurrency; i++) {
@@ -200,7 +200,7 @@ export class JestPool {
             }));
         }
         await Promise.all(startPromises);
-        this.initialized = true;
+        this.initialised = true;
     }
     handleWorkerExit(worker) {
         const availIdx = this.availableWorkers.indexOf(worker);
@@ -249,8 +249,8 @@ export class JestPool {
         }
     }
     async run(mutant, tests) {
-        if (!this.initialized) {
-            throw new Error('Pool not initialized. Call init() first.');
+        if (!this.initialised) {
+            throw new Error('Pool not initialised. Call init() first.');
         }
         if (this.shuttingDown) {
             throw new Error('Pool is shutting down');
@@ -272,7 +272,7 @@ export class JestPool {
         await Promise.all(this.workers.map((w) => w.shutdown()));
         this.workers = [];
         this.availableWorkers = [];
-        this.initialized = false;
+        this.initialised = false;
     }
 }
 export async function runWithJestPool(pool, mutant, tests) {

package/dist/runner/jest/worker.mjs

@@ -16,7 +16,7 @@ async function main() {
         await runtime.init();
     }
     catch (err) {
-        log.error(`Failed to initialize: ${err}`);
+        log.error(`Failed to initialise: ${err}`);
         process.exit(1);
     }
     process.send?.({ type: 'ready', workerId });