@mutineerjs/mutineer 0.2.4 → 0.3.2

package/dist/runner/adapters/jest.js

@@ -1,216 +0,0 @@
-/**
- * Jest Test Runner Adapter
- *
- * Implements the TestRunnerAdapter interface for Jest using runCLI.
- * Baseline runs are executed directly via runCLI; mutant runs are delegated
- * to a pool of long-lived worker processes that also use runCLI with a
- * redirect resolver to swap in mutated code.
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { createRequire } from 'node:module';
-// import os from 'node:os'
-import { JestPool } from '../pool/jest/pool.js';
-const require = createRequire(import.meta.url);
-/**
- * Strip mutineer-specific CLI args that shouldn't be passed to Jest.
- */
-function stripMutineerArgs(args) {
-    const out = [];
-    const consumeNext = new Set([
-        '--concurrency',
-        '--progress',
-        '--min-kill-percent',
-        '--config',
-        '-c',
-        '--coverage-file',
-        '--runner',
-    ]);
-    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;
-}
-// function getMutantFilePath(originalFile: string, mutantId: string): string {
-// 	const dir = path.dirname(originalFile)
-// 	const ext = path.extname(originalFile)
-// 	const basename = path.basename(originalFile, ext)
-// 	const mutineerDir = path.join(dir, '__mutineer__')
-// 	return path.join(mutineerDir, `${basename}_${mutantId.replace(/[^a-zA-Z0-9]/g, '_').slice(0, 20)}${ext}`)
-// }
-// function ensureMutineerDir(file: string): void {
-// 	const dir = path.dirname(file)
-// 	if (!fs) return
-// }
-// function createResolverModule(workerId: string): string {
-// 	const resolverPath = path.join(os.tmpdir(), `mutineer-jest-resolver-${workerId}.cjs`)
-// 	const resolverCode = `
-// const path = require('path');
-// const { defaultResolver } = require('jest-resolve');
-// module.exports = (request, options) => {
-//   const from = process.env.MUTINEER_REDIRECT_FROM;
-//   const to = process.env.MUTINEER_REDIRECT_TO;
-//   if (!from || !to) {
-//     return defaultResolver(request, options);
-//   }
-//   const normalizedFrom = path.resolve(from);
-//   const baseDir = options?.basedir ?? process.cwd();
-//   const candidate = path.resolve(baseDir, request);
-//   if (candidate === normalizedFrom || request === normalizedFrom) {
-//     return defaultResolver(to, options);
-//   }
-//   return defaultResolver(request, options);
-// };
-// `
-// 	fs.writeFile(resolverPath, resolverCode, 'utf8')
-// 		.catch(() => {
-// 			/* ignore */
-// 		})
-// 	return resolverPath
-// }
-async function loadRunCLI(requireFromCwd) {
-    try {
-        return requireFromCwd('@jest/core');
-    }
-    catch {
-        return import('@jest/core');
-    }
-}
-/**
- * Build Jest runCLI options for the given mode.
- */
-function buildJestCliOptions(tests, mode, jestConfigPath) {
-    const opts = {
-        _: [...tests],
-        $0: 'mutineer',
-        runInBand: true,
-        runTestsByPath: true,
-        watch: false,
-        passWithNoTests: true,
-        testPathPattern: [...tests],
-    };
-    if (jestConfigPath) {
-        opts.config = jestConfigPath;
-    }
-    if (mode === 'baseline-with-coverage') {
-        opts.coverage = true;
-        opts.collectCoverage = true;
-        opts.coverageProvider = 'v8';
-    }
-    return opts;
-}
-export class JestAdapter {
-    constructor(options) {
-        this.name = 'jest';
-        this.pool = null;
-        this.options = options;
-        this.jestConfigPath = options.config.jestConfig;
-        stripMutineerArgs(options.cliArgs);
-        this.requireFromCwd = createRequire(path.join(options.cwd, 'package.json'));
-    }
-    async init(concurrencyOverride) {
-        const workerCount = Math.max(1, concurrencyOverride ?? this.options.concurrency);
-        this.pool = new JestPool({
-            cwd: this.options.cwd,
-            concurrency: workerCount,
-            jestConfig: this.options.config.jestConfig,
-            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 cliOptions = buildJestCliOptions(tests, mode, this.jestConfigPath);
-        try {
-            const { runCLI } = await loadRunCLI(this.requireFromCwd);
-            const { results } = await runCLI(cliOptions, [this.options.cwd]);
-            return results.success;
-        }
-        catch (err) {
-            if (this.options.debug) {
-                console.error('Failed to run Jest baseline', err);
-            }
-            return false;
-        }
-    }
-    async runMutant(mutant, tests) {
-        if (!this.pool) {
-            throw new Error('JestAdapter 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('jest/package.json', { paths: [this.options.cwd] });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async detectCoverageConfig() {
-        const configPath = this.options.config.jestConfig;
-        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 coverageEnabled = /collectCoverage\s*:\s*true/.test(content) || /coverageProvider\s*:/.test(content);
-            return { perTestEnabled: false, coverageEnabled };
-        }
-        catch {
-            return { perTestEnabled: false, coverageEnabled: false };
-        }
-    }
-}
-export function createJestAdapter(options) {
-    return new JestAdapter(options);
-}

package/dist/runner/adapters/types.d.ts

@@ -1,89 +0,0 @@
-/**
- * Test Runner Adapter Interface
- *
- * This module defines the interface that all test runner adapters must implement.
- * Adapters abstract test runner-specific details (Vitest, Jest, etc.) from the
- * mutation testing orchestrator.
- */
-import type { MutineerConfig } from '../../types/config.js';
-import type { MutantPayload, MutantRunResult } from '../../types/mutant.js';
-/**
- * Options for initializing a test runner adapter.
- */
-export interface TestRunnerAdapterOptions {
-    readonly cwd: string;
-    readonly concurrency: number;
-    readonly timeoutMs: number;
-    readonly debug: boolean;
-    readonly config: MutineerConfig;
-    readonly cliArgs: string[];
-}
-/**
- * Coverage-related configuration detected from the test runner.
- */
-export interface CoverageConfig {
-    /** Whether per-test coverage is enabled in the config */
-    readonly perTestEnabled: boolean;
-    /** Whether coverage is enabled in the config */
-    readonly coverageEnabled: boolean;
-}
-/**
- * Interface that all test runner adapters must implement.
- *
- * A test runner adapter handles:
- * - Running baseline tests before mutation testing
- * - Running mutant tests (with code substitution)
- * - Managing worker pools for parallel execution
- * - Detecting coverage configuration
- */
-export interface TestRunnerAdapter {
-    /**
-     * The name of the test runner (e.g., 'vitest', 'jest').
-     */
-    readonly name: string;
-    /**
-     * Initialize the adapter (start worker pools, etc.).
-     * Must be called before running tests.
-     */
-    init(concurrencyOverride?: number): Promise<void>;
-    /**
-     * Run baseline tests to ensure they pass before mutation testing.
-     * @param tests - Array of test file paths to run
-     * @param options - Options for the baseline run
-     * @returns true if all tests pass, false otherwise
-     */
-    runBaseline(tests: readonly string[], options: BaselineOptions): Promise<boolean>;
-    /**
-     * Run a single mutant against its associated tests.
-     * @param mutant - The mutation to test
-     * @param tests - Array of test file paths to run
-     * @returns Result indicating if the mutant was killed, escaped, or errored
-     */
-    runMutant(mutant: MutantPayload, tests: readonly string[]): Promise<MutantRunResult>;
-    /**
-     * Shutdown the adapter (stop worker pools, cleanup, etc.).
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Check if the coverage provider is installed.
-     */
-    hasCoverageProvider(): boolean;
-    /**
-     * Detect coverage configuration from the test runner config.
-     */
-    detectCoverageConfig(): Promise<CoverageConfig>;
-}
-/**
- * Options for running baseline tests.
- */
-export interface BaselineOptions {
-    /** Whether to collect coverage during baseline run */
-    readonly collectCoverage: boolean;
-    /** Whether to collect per-test coverage */
-    readonly perTestCoverage: boolean;
-}
-/**
- * Factory function type for creating test runner adapters.
- */
-export type TestRunnerAdapterFactory = (options: TestRunnerAdapterOptions) => TestRunnerAdapter;
-export type { MutantPayload, MutantRunResult, MutantRunStatus } from '../../types/mutant.js';

package/dist/runner/adapters/types.js

@@ -1,8 +0,0 @@
-/**
- * Test Runner Adapter Interface
- *
- * This module defines the interface that all test runner adapters must implement.
- * Adapters abstract test runner-specific details (Vitest, Jest, etc.) from the
- * mutation testing orchestrator.
- */
-export {};

package/dist/runner/adapters/vitest/__tests__/index.spec.d.ts

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

package/dist/runner/adapters/vitest/__tests__/index.spec.js

@@ -1,118 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import path from 'node:path';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import { createVitestAdapter, isCoverageRequestedInArgs } from '../index.js';
-// Mock VitestPool to avoid spinning processes
-var poolInstance = null;
-var poolCtorOpts = null;
-vi.mock('../../../pool/index.js', () => {
-    class MockPool {
-        constructor(opts) {
-            this.init = vi.fn();
-            this.run = vi.fn();
-            this.shutdown = vi.fn();
-            poolCtorOpts = opts;
-            poolInstance = this;
-        }
-    }
-    return { VitestPool: MockPool };
-});
-// Mock spawn for baseline runs
-var spawnMock;
-vi.mock('node:child_process', async () => {
-    const actual = await vi.importActual('node:child_process');
-    spawnMock = vi.fn();
-    return { ...actual, spawn: spawnMock };
-});
-function makeAdapter(opts = {}) {
-    return createVitestAdapter({
-        cwd: opts.cwd ?? process.cwd(),
-        concurrency: opts.concurrency ?? 2,
-        timeoutMs: opts.timeoutMs ?? 1000,
-        debug: opts.debug ?? false,
-        config: opts.config ?? { vitestConfig: undefined },
-        cliArgs: opts.cliArgs ?? ['--changed']
-    });
-}
-describe('Vitest adapter', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    it('initializes pool with override concurrency', async () => {
-        const adapter = makeAdapter();
-        await adapter.init(5);
-        expect(poolInstance?.init).toHaveBeenCalledTimes(1);
-        expect(poolCtorOpts.concurrency).toBe(5);
-    });
-    it('maps pool result to mutant status', async () => {
-        poolInstance = null;
-        poolCtorOpts = null;
-        const adapter = makeAdapter();
-        await adapter.init();
-        poolInstance.run.mockResolvedValueOnce({ killed: true, durationMs: 10 });
-        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
-        expect(res).toEqual({ status: 'killed', durationMs: 10, error: undefined });
-    });
-    it('maps pool timeout errors to timeout status', async () => {
-        const adapter = makeAdapter();
-        await adapter.init();
-        poolInstance.run.mockResolvedValueOnce({ killed: true, durationMs: 15, error: 'timeout' });
-        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
-        expect(res).toEqual({ status: 'timeout', durationMs: 15, error: 'timeout' });
-    });
-    it('maps pool errors to error status', async () => {
-        const adapter = makeAdapter();
-        await adapter.init();
-        poolInstance.run.mockResolvedValueOnce({ killed: true, durationMs: 12, error: 'crash' });
-        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
-        expect(res).toEqual({ status: 'error', durationMs: 12, error: 'crash' });
-    });
-    it('returns error status on pool throw', async () => {
-        const adapter = makeAdapter();
-        await adapter.init();
-        poolInstance.run.mockRejectedValueOnce(new Error('boom'));
-        const res = await adapter.runMutant({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
-        expect(res.status).toBe('error');
-    });
-    it('includes coverage args for baseline when requested', async () => {
-        const adapter = makeAdapter({ cliArgs: [] });
-        spawnMock.mockImplementationOnce(() => ({
-            on: (evt, cb) => {
-                if (evt === 'exit')
-                    cb(0);
-            }
-        }));
-        const ok = await adapter.runBaseline(['test-a'], { collectCoverage: true, perTestCoverage: true });
-        expect(ok).toBe(true);
-        const call = spawnMock.mock.calls[0];
-        const args = call[1];
-        expect(args.join(' ')).toContain('--coverage.enabled=true');
-        expect(args.join(' ')).toContain('--coverage.perTest=true');
-    });
-    it('detects coverage config from vitest config file', async () => {
-        const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-vitest-'));
-        const cfgPath = path.join(tmp, 'vitest.config.ts');
-        await fs.writeFile(cfgPath, 'export default { coverage: { enabled: true }, test: { coverage: { perTest: true } } }');
-        try {
-            const adapter = makeAdapter({ cwd: tmp, config: { vitestConfig: 'vitest.config.ts' } });
-            const coverage = await adapter.detectCoverageConfig();
-            expect(coverage.coverageEnabled).toBe(true);
-            expect(coverage.perTestEnabled).toBe(true);
-        }
-        finally {
-            await fs.rm(tmp, { recursive: true, force: true });
-        }
-    });
-});
-describe('isCoverageRequestedInArgs', () => {
-    it('detects enabled coverage flags', () => {
-        expect(isCoverageRequestedInArgs(['--coverage'])).toBe(true);
-        expect(isCoverageRequestedInArgs(['--coverage.enabled=true'])).toBe(true);
-        expect(isCoverageRequestedInArgs(['--coverage.enabled=false'])).toBe(false);
-        expect(isCoverageRequestedInArgs(['--no-coverage'])).toBe(false);
-    });
-});

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

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

package/dist/runner/adapters/vitest/__tests__/worker-runtime.spec.js

@@ -1,59 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { createVitestWorkerRuntime } from '../worker-runtime.js';
-const initFn = vi.fn();
-const closeFn = vi.fn();
-const runSpecsFn = vi.fn();
-const invalidateFn = vi.fn();
-const getProjectByNameFn = vi.fn();
-vi.mock('vitest/node', () => ({
-    createVitest: vi.fn(async () => ({
-        init: initFn,
-        close: closeFn,
-        runTestSpecifications: runSpecsFn,
-        invalidateFile: invalidateFn,
-        getProjectByName: getProjectByNameFn,
-    }))
-}));
-describe('VitestWorkerRuntime', () => {
-    const tmpFiles = [];
-    beforeEach(() => {
-        vi.clearAllMocks();
-        getProjectByNameFn.mockReturnValue({
-            createSpecification: (file) => ({ moduleId: file })
-        });
-        runSpecsFn.mockResolvedValue({ testModules: [{ moduleId: 'a', ok: () => false }] });
-    });
-    afterEach(() => {
-        for (const f of tmpFiles.splice(0)) {
-            try {
-                fs.rmSync(f, { recursive: true, force: true });
-            }
-            catch { }
-        }
-    });
-    it('runs specs and reports kill based on results', async () => {
-        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
-        tmpFiles.push(tmp);
-        const runtime = createVitestWorkerRuntime({ workerId: 'w1', cwd: tmp });
-        await runtime.init();
-        const result = await runtime.run({ id: 'mut#1', name: 'm', file: path.join(tmp, 'src.ts'), code: 'export const x=1', line: 1, col: 1 }, [path.join(tmp, 'test.ts')]);
-        expect(initFn).toHaveBeenCalled();
-        expect(runSpecsFn).toHaveBeenCalled();
-        expect(result.killed).toBe(true);
-        expect(fs.existsSync(path.join(tmp, 'src', '__mutineer__'))).toBe(false);
-        await runtime.shutdown();
-    });
-    it('returns escaped when no specs produced', async () => {
-        getProjectByNameFn.mockReturnValue({ createSpecification: () => null });
-        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
-        tmpFiles.push(tmp);
-        const runtime = createVitestWorkerRuntime({ workerId: 'w2', cwd: tmp });
-        await runtime.init();
-        const result = await runtime.run({ id: 'mut#2', name: 'm', file: path.join(tmp, 'src.ts'), code: 'export const x=1', line: 1, col: 1 }, [path.join(tmp, 'test.ts')]);
-        expect(result.killed).toBe(false);
-        await runtime.shutdown();
-    });
-});

package/dist/runner/adapters/vitest/index.d.ts

@@ -1,33 +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 type { TestRunnerAdapter, TestRunnerAdapterOptions, MutantPayload, MutantRunResult, BaselineOptions, CoverageConfig } from '../types.js';
-/**
- * Vitest adapter implementation.
- */
-export declare class VitestAdapter implements TestRunnerAdapter {
-    readonly name = "vitest";
-    private readonly options;
-    private readonly vitestPath;
-    private pool;
-    private baseArgs;
-    constructor(options: TestRunnerAdapterOptions);
-    init(concurrencyOverride?: number): Promise<void>;
-    runBaseline(tests: readonly string[], options: BaselineOptions): Promise<boolean>;
-    runMutant(mutant: MutantPayload, tests: readonly string[]): Promise<MutantRunResult>;
-    shutdown(): Promise<void>;
-    hasCoverageProvider(): boolean;
-    detectCoverageConfig(): Promise<CoverageConfig>;
-}
-/**
- * Check if coverage is requested via CLI args.
- */
-export declare function isCoverageRequestedInArgs(args: string[]): boolean;
-/**
- * Factory function for creating VitestAdapter instances.
- */
-export declare function createVitestAdapter(options: TestRunnerAdapterOptions): VitestAdapter;