@mutineerjs/mutineer 0.2.4 → 0.4.0

package/dist/runner/adapters/vitest.js

@@ -1,267 +0,0 @@
-/**
- * Vitest Test Runner Adapter
- *
- * Implements the TestRunnerAdapter interface for Vitest.
- * Handles baseline test runs, mutant execution via worker pool,
- * and coverage configuration detection.
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { createRequire } from 'node:module';
-import { VitestPool } from '../pool/index.js';
-const require = createRequire(import.meta.url);
-/**
- * Resolve the Vitest CLI entry point.
- */
-function resolveVitestPath() {
-    try {
-        return require.resolve('vitest/vitest.mjs');
-    }
-    catch {
-        const pkgJson = require.resolve('vitest/package.json');
-        return path.join(path.dirname(pkgJson), 'vitest.mjs');
-    }
-}
-/**
- * Strip mutineer-specific CLI args that shouldn't be passed to Vitest.
- */
-function stripMutineerArgs(args) {
-    const out = [];
-    const consumeNext = new Set([
-        '--concurrency',
-        '--progress',
-        '--min-kill-percent',
-        '--config',
-        '-c',
-        '--coverage-file',
-    ]);
-    const dropExact = new Set([
-        '-m',
-        '--mutate',
-        '--changed',
-        '--changed-with-deps',
-        '--only-covered-lines',
-        '--per-test-coverage',
-        '--perTestCoverage',
-    ]);
-    for (let i = 0; i < args.length; i++) {
-        const a = args[i];
-        if (dropExact.has(a))
-            continue;
-        if (consumeNext.has(a)) {
-            i++;
-            continue;
-        }
-        if (a.startsWith('--min-kill-percent='))
-            continue;
-        if (a.startsWith('--config=') || a.startsWith('-c='))
-            continue;
-        out.push(a);
-    }
-    return out;
-}
-/**
- * Ensure the Vitest config arg is included if specified.
- */
-function ensureConfigArg(args, vitestConfig, cwd) {
-    if (!vitestConfig)
-        return args;
-    if (args.some((a) => a === '--config' || a === '-c' || a.startsWith('--config=') || a.startsWith('-c='))) {
-        return args;
-    }
-    const resolved = cwd ? path.resolve(cwd, vitestConfig) : vitestConfig;
-    return [...args, '--config', resolved];
-}
-/**
- * Build Vitest CLI arguments for the given mode.
- */
-function buildVitestArgs(args, mode) {
-    const result = [...args];
-    if (!result.includes('run') && !result.includes('--run'))
-        result.unshift('run');
-    if (!result.some((a) => a.startsWith('--watch')))
-        result.push('--watch=false');
-    if (!result.some((a) => a.startsWith('--passWithNoTests')))
-        result.push('--passWithNoTests');
-    if (mode === 'baseline-with-coverage') {
-        if (!result.some((a) => a.startsWith('--coverage'))) {
-            result.push('--coverage.enabled=true', '--coverage.reporter=json');
-        }
-        if (!result.some((a) => a.startsWith('--coverage.perTest='))) {
-            result.push('--coverage.perTest=true');
-        }
-    }
-    return result;
-}
-/**
- * Vitest adapter implementation.
- */
-export class VitestAdapter {
-    constructor(options) {
-        this.name = 'vitest';
-        this.pool = null;
-        this.baseArgs = [];
-        this.options = options;
-        this.vitestPath = resolveVitestPath();
-        // Prepare base args by stripping mutineer-specific flags
-        const stripped = stripMutineerArgs(options.cliArgs);
-        this.baseArgs = ensureConfigArg(stripped, options.config.vitestConfig, options.cwd);
-    }
-    async init(concurrencyOverride) {
-        const workerCount = Math.max(1, concurrencyOverride ?? this.options.concurrency);
-        this.pool = new VitestPool({
-            cwd: this.options.cwd,
-            concurrency: workerCount,
-            vitestConfig: this.options.config.vitestConfig,
-            timeoutMs: this.options.timeoutMs,
-            debug: this.options.debug,
-        });
-        await this.pool.init();
-    }
-    async runBaseline(tests, options) {
-        const mode = options.collectCoverage ? 'baseline-with-coverage' : 'baseline';
-        const args = buildVitestArgs(this.baseArgs, mode);
-        return new Promise((resolve) => {
-            const env = { ...process.env };
-            env.VITEST_WATCH = 'false';
-            if (!env.CI)
-                env.CI = '1';
-            const child = spawn(process.execPath, [this.vitestPath, ...args, ...tests], {
-                cwd: this.options.cwd,
-                stdio: ['ignore', 'inherit', 'inherit'],
-                env,
-            });
-            child.on('error', (err) => {
-                if (this.options.debug)
-                    console.error('Failed to spawn vitest process', err);
-                resolve(false);
-            });
-            child.on('exit', (code) => {
-                resolve(code === 0);
-            });
-        });
-    }
-    async runMutant(mutant, tests) {
-        if (!this.pool) {
-            throw new Error('VitestAdapter not initialized. Call init() first.');
-        }
-        try {
-            const result = await this.pool.run(mutant, [...tests]);
-            if (result.error === 'timeout') {
-                return {
-                    status: 'timeout',
-                    durationMs: result.durationMs,
-                    error: result.error,
-                };
-            }
-            if (result.error) {
-                return {
-                    status: 'error',
-                    durationMs: result.durationMs,
-                    error: result.error,
-                };
-            }
-            return {
-                status: result.killed ? 'killed' : 'escaped',
-                durationMs: result.durationMs,
-                error: result.error,
-            };
-        }
-        catch (err) {
-            return {
-                status: 'error',
-                durationMs: 0,
-                error: err instanceof Error ? err.message : String(err),
-            };
-        }
-    }
-    async shutdown() {
-        if (this.pool) {
-            await this.pool.shutdown();
-            this.pool = null;
-        }
-    }
-    hasCoverageProvider() {
-        try {
-            require.resolve('@vitest/coverage-v8/package.json', { paths: [this.options.cwd] });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async detectCoverageConfig() {
-        const configPath = this.options.config.vitestConfig;
-        if (!configPath) {
-            return { perTestEnabled: false, coverageEnabled: false };
-        }
-        try {
-            const abs = path.isAbsolute(configPath) ? configPath : path.join(this.options.cwd, configPath);
-            const content = await fs.readFile(abs, 'utf8');
-            const perTestEnabled = /perTest\s*:\s*true/.test(content);
-            let coverageEnabled = false;
-            if (!/coverage\s*\.\s*enabled\s*:\s*false/.test(content) && !/coverage\s*:\s*false/.test(content)) {
-                coverageEnabled = /coverage\s*:/.test(content);
-            }
-            return { perTestEnabled, coverageEnabled };
-        }
-        catch {
-            return { perTestEnabled: false, coverageEnabled: false };
-        }
-    }
-}
-/**
- * Check if coverage is requested via CLI args.
- */
-export function isCoverageRequestedInArgs(args) {
-    let requested = false;
-    let disabled = false;
-    const isFalsey = (v) => typeof v === 'string' && /^(false|0|off)$/i.test(v);
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--no-coverage') {
-            disabled = true;
-            continue;
-        }
-        if (arg === '--coverage') {
-            requested = true;
-            continue;
-        }
-        if (arg === '--coverage.enabled') {
-            const next = args[i + 1];
-            if (isFalsey(next))
-                disabled = true;
-            else
-                requested = true;
-            continue;
-        }
-        if (arg.startsWith('--coverage.enabled=')) {
-            const val = arg.slice('--coverage.enabled='.length);
-            if (isFalsey(val))
-                disabled = true;
-            else
-                requested = true;
-            continue;
-        }
-        if (arg.startsWith('--coverage=')) {
-            const val = arg.slice('--coverage='.length);
-            if (isFalsey(val))
-                disabled = true;
-            else
-                requested = true;
-            continue;
-        }
-        if (arg.startsWith('--coverage.')) {
-            requested = true;
-            continue;
-        }
-    }
-    return requested && !disabled;
-}
-/**
- * Factory function for creating VitestAdapter instances.
- */
-export function createVitestAdapter(options) {
-    return new VitestAdapter(options);
-}

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

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

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

@@ -1,83 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { EventEmitter } from 'node:events';
-import * as childProcess from 'node:child_process';
-import * as readline from 'node:readline';
-import { VitestPool, runWithPool } from '../index.js';
-vi.mock('node:child_process', () => ({ spawn: vi.fn() }));
-vi.mock('node:readline', () => ({ createInterface: vi.fn() }));
-describe('VitestPool', () => {
-    const mockProcesses = [];
-    const rlEmitters = [];
-    const fakeWorkers = [];
-    beforeEach(() => {
-        mockProcesses.length = 0;
-        rlEmitters.length = 0;
-        vi.mocked(childProcess.spawn).mockImplementation(() => {
-            const proc = new EventEmitter();
-            proc.stdout = new EventEmitter();
-            proc.stderr = new EventEmitter();
-            proc.stdin = {
-                writes: [],
-                write: (chunk) => {
-                    proc.stdin.writes.push(chunk);
-                }
-            };
-            proc.kill = vi.fn();
-            mockProcesses.push(proc);
-            return proc;
-        });
-        vi.mocked(readline.createInterface).mockImplementation(() => {
-            const rl = new EventEmitter();
-            rlEmitters.push(rl);
-            return rl;
-        });
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('runs a mutant through a worker and returns result', async () => {
-        const pool = new VitestPool({
-            cwd: process.cwd(),
-            concurrency: 1,
-            timeoutMs: 5000,
-            createWorker: (id, opts) => {
-                const worker = new EventEmitter();
-                worker.id = id;
-                worker.start = vi.fn().mockResolvedValue(undefined);
-                worker.isReady = vi.fn().mockReturnValue(true);
-                worker.isBusy = vi.fn().mockReturnValue(false);
-                worker.run = vi.fn().mockImplementation(async () => ({ killed: true, durationMs: 42 }));
-                worker.shutdown = vi.fn().mockResolvedValue(undefined);
-                worker.kill = vi.fn();
-                fakeWorkers.push(worker);
-                return worker;
-            }
-        });
-        await pool.init();
-        const mutant = { id: '1', name: 'mutant', file: 'foo.ts', code: 'x', line: 1, col: 1 };
-        const tests = ['foo.spec.ts'];
-        const runPromise = pool.run(mutant, tests);
-        const result = await runPromise;
-        expect(result).toEqual({ killed: true, durationMs: 42, error: undefined });
-        expect(fakeWorkers[0].run).toHaveBeenCalledWith(mutant, tests, 5000);
-        await pool.shutdown();
-    });
-    it('maps runWithPool results to escaped when not killed', async () => {
-        const mockPool = {
-            run: vi.fn().mockResolvedValue({ killed: false, durationMs: 7 })
-        };
-        const mutant = { id: '2', name: 'm', file: 'bar.ts', code: 'y', line: 2, col: 3 };
-        const tests = ['bar.spec.ts'];
-        const result = await runWithPool(mockPool, mutant, tests);
-        expect(result).toEqual({ status: 'escaped', durationMs: 7 });
-        expect(mockPool.run).toHaveBeenCalledWith(mutant, ['bar.spec.ts']);
-    });
-    it('maps runWithPool errors to error status', async () => {
-        const mockPool = {
-            run: vi.fn().mockRejectedValue(new Error('boom'))
-        };
-        const mutant = { id: '3', name: 'err', file: 'baz.ts', code: 'z', line: 3, col: 4 };
-        const result = await runWithPool(mockPool, mutant, []);
-        expect(result.status).toBe('error');
-    });
-});

package/dist/runner/pool/__tests__/pool-plugin.spec.d.ts

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

package/dist/runner/pool/__tests__/pool-plugin.spec.js

@@ -1,59 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-import { poolMutineerPlugin } from '../plugin.js';
-function getLoadFn() {
-    const plugin = poolMutineerPlugin();
-    if (Array.isArray(plugin)) {
-        return plugin[0]?.load;
-    }
-    if (plugin && typeof plugin === 'object' && 'load' in plugin) {
-        return plugin.load;
-    }
-    return undefined;
-}
-describe('poolMutineerPlugin', () => {
-    afterEach(() => {
-        ;
-        globalThis.__mutineer_redirect__ = undefined;
-    });
-    it('returns null when no redirect is configured', () => {
-        const load = getLoadFn();
-        const result = load?.('/some/file.ts');
-        expect(result).toBeNull();
-    });
-    it('returns the mutated file when the id matches the redirect target', async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-plugin-'));
-        const fromPath = path.join(tmpDir, 'source.ts');
-        const mutatedPath = path.join(tmpDir, 'mutated.ts');
-        await fs.writeFile(fromPath, 'export const original = true\n', 'utf8');
-        await fs.writeFile(mutatedPath, 'export const mutated = true\n', 'utf8');
-        try {
-            ;
-            globalThis.__mutineer_redirect__ = { from: fromPath, to: mutatedPath };
-            const load = getLoadFn();
-            const result = load?.(fromPath);
-            expect(result).toBe('export const mutated = true\n');
-        }
-        finally {
-            await fs.rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-    it('ignores modules that do not match the redirect', async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-plugin-'));
-        const fromPath = path.join(tmpDir, 'source.ts');
-        const mutatedPath = path.join(tmpDir, 'mutated.ts');
-        await fs.writeFile(mutatedPath, 'export const mutated = true\n', 'utf8');
-        try {
-            ;
-            globalThis.__mutineer_redirect__ = { from: fromPath, to: mutatedPath };
-            const load = getLoadFn();
-            const result = load?.(path.join(tmpDir, 'other.ts?import'));
-            expect(result).toBeNull();
-        }
-        finally {
-            await fs.rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-});

package/dist/runner/pool/__tests__/pool-redirect-loader.spec.d.ts

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

package/dist/runner/pool/__tests__/pool-redirect-loader.spec.js

@@ -1,78 +0,0 @@
-import { describe, it, expect, vi, afterEach } from 'vitest';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-import { pathToFileURL } from 'node:url';
-import { resolve as poolResolve } from '../redirect-loader.js';
-describe('pool-redirect-loader resolve', () => {
-    afterEach(() => {
-        ;
-        globalThis.__mutineer_redirect__ = undefined;
-        vi.restoreAllMocks();
-    });
-    it('resolves .js to .ts in the same directory', async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
-        const parentFile = path.join(tmpDir, 'src', 'index.ts');
-        const tsFile = path.join(tmpDir, 'src', 'foo.ts');
-        await fs.mkdir(path.dirname(parentFile), { recursive: true });
-        await fs.writeFile(parentFile, 'export {}', 'utf8');
-        await fs.writeFile(tsFile, 'export const foo = 1', 'utf8');
-        try {
-            const nextResolve = vi.fn();
-            const result = await poolResolve('./foo.js', { parentURL: pathToFileURL(parentFile).href }, nextResolve);
-            expect(nextResolve).not.toHaveBeenCalled();
-            expect(result.shortCircuit).toBe(true);
-            expect(result.url).toBe(pathToFileURL(tsFile).href);
-        }
-        finally {
-            await fs.rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-    it('redirects to mutated file when target matches', async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
-        const parentFile = path.join(tmpDir, 'src', 'index.ts');
-        const fromPath = path.join(tmpDir, 'src', 'target.ts');
-        const mutatedPath = path.join(tmpDir, 'mutated.ts');
-        await fs.mkdir(path.dirname(parentFile), { recursive: true });
-        await fs.writeFile(parentFile, 'export {}', 'utf8');
-        await fs.writeFile(fromPath, 'export const target = true', 'utf8');
-        await fs.writeFile(mutatedPath, 'export const mutated = true', 'utf8');
-        try {
-            ;
-            globalThis.__mutineer_redirect__ = { from: fromPath, to: mutatedPath };
-            const nextResolve = vi.fn();
-            const result = await poolResolve('./target.js', { parentURL: pathToFileURL(parentFile).href }, nextResolve);
-            expect(nextResolve).not.toHaveBeenCalled();
-            expect(result.shortCircuit).toBe(true);
-            expect(result.url).toBe(pathToFileURL(mutatedPath).href);
-        }
-        finally {
-            await fs.rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-    it('redirects after delegated resolution', async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-loader-'));
-        const parentFile = path.join(tmpDir, 'src', 'index.ts');
-        const fromPath = path.join(tmpDir, 'src', 'delegated.ts');
-        const mutatedPath = path.join(tmpDir, 'mutated.ts');
-        await fs.mkdir(path.dirname(parentFile), { recursive: true });
-        await fs.writeFile(parentFile, 'export {}', 'utf8');
-        await fs.writeFile(fromPath, 'export const delegated = true', 'utf8');
-        await fs.writeFile(mutatedPath, 'export const mutated = true', 'utf8');
-        try {
-            ;
-            globalThis.__mutineer_redirect__ = { from: fromPath, to: mutatedPath };
-            const nextResolve = vi.fn().mockResolvedValue({
-                url: pathToFileURL(fromPath).href,
-                shortCircuit: false
-            });
-            const result = await poolResolve('./delegated', { parentURL: pathToFileURL(parentFile).href }, nextResolve);
-            expect(nextResolve).toHaveBeenCalledOnce();
-            expect(result.shortCircuit).toBe(true);
-            expect(result.url).toBe(pathToFileURL(mutatedPath).href);
-        }
-        finally {
-            await fs.rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-});

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

@@ -1,8 +0,0 @@
-/**
- * Test Runner Worker Pools
- *
- * Exports worker pool implementations for different test runners.
- */
-export { VitestPool, runWithPool, type VitestPoolOptions } from './vitest/pool.js';
-export { JestPool, runWithJestPool, type JestPoolOptions } from './jest/pool.js';
-export type { MutantPayload, MutantRunResult, MutantRunSummary } from '../../types/mutant.js';

package/dist/runner/pool/index.js

@@ -1,9 +0,0 @@
-/**
- * Test Runner Worker Pools
- *
- * Exports worker pool implementations for different test runners.
- */
-// Vitest pool
-export { VitestPool, runWithPool } from './vitest/pool.js';
-// Jest pool
-export { JestPool, runWithJestPool } from './jest/pool.js';

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

@@ -1,52 +0,0 @@
-import { EventEmitter } from 'node:events';
-import type { MutantPayload, MutantRunResult, MutantRunSummary } from '../../../types/mutant.js';
-declare class JestWorker extends EventEmitter {
-    private readonly cwd;
-    private readonly jestConfig?;
-    private readonly debug;
-    readonly id: string;
-    private process;
-    private pendingTask;
-    private ready;
-    private shuttingDown;
-    constructor(id: string, cwd: string, jestConfig?: string | undefined, debug?: boolean);
-    start(): Promise<void>;
-    private handleMessage;
-    private handleExit;
-    isReady(): boolean;
-    isBusy(): boolean;
-    run(mutant: MutantPayload, tests: string[], timeoutMs?: number): Promise<MutantRunSummary>;
-    shutdown(): Promise<void>;
-    kill(): void;
-    private log;
-}
-export interface JestPoolOptions {
-    cwd: string;
-    concurrency: number;
-    jestConfig?: string;
-    timeoutMs?: number;
-    debug?: boolean;
-    createWorker?: (id: string, opts: {
-        cwd: string;
-        jestConfig?: string;
-        debug: boolean;
-    }) => JestWorker;
-}
-export declare class JestPool {
-    private workers;
-    private availableWorkers;
-    private waitingTasks;
-    private readonly options;
-    private initialized;
-    private shuttingDown;
-    constructor(options: JestPoolOptions);
-    init(): Promise<void>;
-    private handleWorkerExit;
-    private acquireWorker;
-    private releaseWorker;
-    run(mutant: MutantPayload, tests: string[]): Promise<MutantRunSummary>;
-    shutdown(): Promise<void>;
-    private log;
-}
-export declare function runWithJestPool(pool: JestPool, mutant: MutantPayload, tests: readonly string[]): Promise<MutantRunResult>;
-export type { MutantPayload, MutantRunResult, MutantRunSummary } from '../../../types/mutant.js';