@mutineerjs/mutineer 0.2.2 → 0.2.4

package/dist/runner/__tests__/coverage-resolver.spec.js

@@ -0,0 +1,171 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { resolveCoverageConfig, loadCoverageAfterBaseline, } from '../coverage-resolver.js';
+function makeOpts(overrides = {}) {
+    return {
+        configPath: undefined,
+        wantsChanged: false,
+        wantsChangedWithDeps: false,
+        wantsOnlyCoveredLines: false,
+        wantsPerTestCoverage: false,
+        coverageFilePath: undefined,
+        concurrency: 1,
+        progressMode: 'bar',
+        minKillPercent: undefined,
+        runner: 'vitest',
+        ...overrides,
+    };
+}
+function makeAdapter(overrides = {}) {
+    return {
+        name: 'vitest',
+        init: vi.fn().mockResolvedValue(undefined),
+        runBaseline: vi.fn().mockResolvedValue(true),
+        runMutant: vi.fn().mockResolvedValue({ status: 'killed', durationMs: 0 }),
+        shutdown: vi.fn().mockResolvedValue(undefined),
+        hasCoverageProvider: vi.fn().mockReturnValue(false),
+        detectCoverageConfig: vi
+            .fn()
+            .mockResolvedValue({ perTestEnabled: false, coverageEnabled: false }),
+        ...overrides,
+    };
+}
+describe('resolveCoverageConfig', () => {
+    beforeEach(() => {
+        process.exitCode = undefined;
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('returns baseline defaults when no coverage is requested', async () => {
+        const result = await resolveCoverageConfig(makeOpts(), {}, makeAdapter(), []);
+        expect(result.coverageData).toBeNull();
+        expect(result.perTestCoverage).toBeNull();
+        expect(result.enableCoverageForBaseline).toBe(false);
+        expect(result.wantsPerTestCoverage).toBe(false);
+        expect(result.needsCoverageFromBaseline).toBe(false);
+    });
+    it('enables coverage for baseline when config coverage is true', async () => {
+        const result = await resolveCoverageConfig(makeOpts(), { coverage: true }, makeAdapter(), []);
+        expect(result.enableCoverageForBaseline).toBe(true);
+    });
+    it('disables coverage for baseline when config coverage is false', async () => {
+        const adapter = makeAdapter({
+            detectCoverageConfig: vi
+                .fn()
+                .mockResolvedValue({ perTestEnabled: false, coverageEnabled: true }),
+        });
+        const result = await resolveCoverageConfig(makeOpts(), { coverage: false }, adapter, []);
+        expect(result.enableCoverageForBaseline).toBe(false);
+    });
+    it('sets exitCode when onlyCoveredLines is set but no coverage provider', async () => {
+        const opts = makeOpts({ wantsOnlyCoveredLines: true });
+        const adapter = makeAdapter({ hasCoverageProvider: vi.fn().mockReturnValue(false) });
+        await resolveCoverageConfig(opts, {}, adapter, []);
+        expect(process.exitCode).toBe(1);
+    });
+    it('does not set exitCode when onlyCoveredLines is set with coverage provider', async () => {
+        const opts = makeOpts({ wantsOnlyCoveredLines: true });
+        const adapter = makeAdapter({
+            hasCoverageProvider: vi.fn().mockReturnValue(true),
+        });
+        await resolveCoverageConfig(opts, {}, adapter, []);
+        expect(process.exitCode).toBeUndefined();
+    });
+    it('disables per-test coverage for jest runner', async () => {
+        const opts = makeOpts({ runner: 'jest', wantsPerTestCoverage: true });
+        const result = await resolveCoverageConfig(opts, {}, makeAdapter(), []);
+        expect(result.wantsPerTestCoverage).toBe(false);
+    });
+    it('enables per-test coverage for vitest runner', async () => {
+        const opts = makeOpts({ runner: 'vitest', wantsPerTestCoverage: true });
+        const result = await resolveCoverageConfig(opts, {}, makeAdapter(), []);
+        expect(result.wantsPerTestCoverage).toBe(true);
+        expect(result.enableCoverageForBaseline).toBe(true);
+    });
+    it('enables per-test coverage when adapter reports it enabled', async () => {
+        const adapter = makeAdapter({
+            detectCoverageConfig: vi
+                .fn()
+                .mockResolvedValue({ perTestEnabled: true, coverageEnabled: false }),
+        });
+        const result = await resolveCoverageConfig(makeOpts(), {}, adapter, []);
+        expect(result.wantsPerTestCoverage).toBe(true);
+    });
+    it('sets needsCoverageFromBaseline when onlyCoveredLines without coverageFile', async () => {
+        const opts = makeOpts({ wantsOnlyCoveredLines: true });
+        const adapter = makeAdapter({
+            hasCoverageProvider: vi.fn().mockReturnValue(true),
+        });
+        const result = await resolveCoverageConfig(opts, {}, adapter, []);
+        expect(result.needsCoverageFromBaseline).toBe(true);
+        expect(result.enableCoverageForBaseline).toBe(true);
+    });
+});
+describe('loadCoverageAfterBaseline', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-cov-resolver-'));
+    });
+    afterEach(async () => {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    it('returns resolution unchanged when no coverage needed from baseline', async () => {
+        const resolution = {
+            coverageData: null,
+            perTestCoverage: null,
+            enableCoverageForBaseline: false,
+            wantsPerTestCoverage: false,
+            needsCoverageFromBaseline: false,
+        };
+        const result = await loadCoverageAfterBaseline(resolution, tmpDir);
+        expect(result).toEqual(resolution);
+    });
+    it('loads coverage data from default path when needsCoverageFromBaseline', async () => {
+        const coverageDir = path.join(tmpDir, 'coverage');
+        await fs.mkdir(coverageDir, { recursive: true });
+        const coverageJson = {
+            '/src/foo.ts': {
+                path: '/src/foo.ts',
+                statementMap: { '0': { start: { line: 1, column: 0 }, end: { line: 1, column: 10 } } },
+                s: { '0': 1 },
+            },
+        };
+        await fs.writeFile(path.join(coverageDir, 'coverage-final.json'), JSON.stringify(coverageJson));
+        const resolution = {
+            coverageData: null,
+            perTestCoverage: null,
+            enableCoverageForBaseline: true,
+            wantsPerTestCoverage: false,
+            needsCoverageFromBaseline: true,
+        };
+        const result = await loadCoverageAfterBaseline(resolution, tmpDir);
+        expect(result.coverageData).not.toBeNull();
+        expect(result.coverageData.coveredLines.size).toBeGreaterThan(0);
+    });
+    it('continues gracefully when coverage file is missing', async () => {
+        const resolution = {
+            coverageData: null,
+            perTestCoverage: null,
+            enableCoverageForBaseline: true,
+            wantsPerTestCoverage: false,
+            needsCoverageFromBaseline: true,
+        };
+        const result = await loadCoverageAfterBaseline(resolution, tmpDir);
+        // Should not throw, coverageData stays null
+        expect(result.coverageData).toBeNull();
+    });
+    it('does not modify resolution when wantsPerTestCoverage is false', async () => {
+        const resolution = {
+            coverageData: null,
+            perTestCoverage: null,
+            enableCoverageForBaseline: false,
+            wantsPerTestCoverage: false,
+            needsCoverageFromBaseline: false,
+        };
+        const result = await loadCoverageAfterBaseline(resolution, tmpDir);
+        expect(result.perTestCoverage).toBeNull();
+    });
+});

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

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

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

@@ -0,0 +1,213 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { executePool } from '../pool-executor.js';
+function makeAdapter(overrides = {}) {
+    return {
+        name: 'vitest',
+        init: vi.fn().mockResolvedValue(undefined),
+        runBaseline: vi.fn().mockResolvedValue(true),
+        runMutant: vi
+            .fn()
+            .mockResolvedValue({ status: 'killed', durationMs: 10 }),
+        shutdown: vi.fn().mockResolvedValue(undefined),
+        hasCoverageProvider: vi.fn().mockReturnValue(false),
+        detectCoverageConfig: vi
+            .fn()
+            .mockResolvedValue({ perTestEnabled: false, coverageEnabled: false }),
+        ...overrides,
+    };
+}
+function makeTask(overrides = {}) {
+    return {
+        v: {
+            id: 'file.ts#0',
+            name: 'flipStrictEQ',
+            file: '/src/file.ts',
+            code: 'const x = a !== b',
+            line: 1,
+            col: 10,
+            tests: ['/tests/file.test.ts'],
+        },
+        tests: ['/tests/file.test.ts'],
+        key: 'test-key-1',
+        ...overrides,
+    };
+}
+describe('executePool', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-pool-'));
+        process.exitCode = undefined;
+    });
+    afterEach(async () => {
+        process.exitCode = undefined;
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    it('initializes adapter with correct worker count', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const tasks = [makeTask()];
+        await executePool({
+            tasks,
+            adapter,
+            cache,
+            concurrency: 4,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        // workerCount = min(concurrency, tasks.length) = min(4, 1) = 1
+        expect(adapter.init).toHaveBeenCalledWith(1);
+    });
+    it('runs mutants through the adapter and populates cache', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const task = makeTask({ key: 'unique-key' });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(adapter.runMutant).toHaveBeenCalledTimes(1);
+        expect(cache['unique-key']).toBeDefined();
+        expect(cache['unique-key'].status).toBe('killed');
+    });
+    it('skips cached tasks without calling runMutant', async () => {
+        const adapter = makeAdapter();
+        const cache = {
+            'cached-key': {
+                status: 'killed',
+                file: '/src/file.ts',
+                line: 1,
+                col: 10,
+                mutator: 'flipStrictEQ',
+            },
+        };
+        await executePool({
+            tasks: [makeTask({ key: 'cached-key' })],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(adapter.runMutant).not.toHaveBeenCalled();
+    });
+    it('marks tasks with no tests as skipped', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const task = makeTask({ tests: [], key: 'no-tests-key' });
+        await executePool({
+            tasks: [task],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(adapter.runMutant).not.toHaveBeenCalled();
+        expect(cache['no-tests-key'].status).toBe('skipped');
+    });
+    it('processes multiple tasks', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const tasks = [
+            makeTask({ key: 'key-1' }),
+            makeTask({ key: 'key-2' }),
+            makeTask({ key: 'key-3' }),
+        ];
+        await executePool({
+            tasks,
+            adapter,
+            cache,
+            concurrency: 2,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(adapter.runMutant).toHaveBeenCalledTimes(3);
+        expect(Object.keys(cache)).toHaveLength(3);
+    });
+    it('shuts down adapter after completion', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        await executePool({
+            tasks: [makeTask()],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        expect(adapter.shutdown).toHaveBeenCalledTimes(1);
+    });
+    it('sets exitCode when kill rate is below threshold', async () => {
+        const adapter = makeAdapter({
+            runMutant: vi
+                .fn()
+                .mockResolvedValue({ status: 'escaped', durationMs: 10 }),
+        });
+        const cache = {};
+        await executePool({
+            tasks: [makeTask()],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            minKillPercent: 80,
+            cwd: tmpDir,
+        });
+        expect(process.exitCode).toBe(1);
+    });
+    it('does not set exitCode when kill rate meets threshold', async () => {
+        const adapter = makeAdapter({
+            runMutant: vi
+                .fn()
+                .mockResolvedValue({ status: 'killed', durationMs: 10 }),
+        });
+        const cache = {};
+        await executePool({
+            tasks: [makeTask()],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            minKillPercent: 80,
+            cwd: tmpDir,
+        });
+        expect(process.exitCode).toBeUndefined();
+    });
+    it('saves cache to disk after completion', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        await executePool({
+            tasks: [makeTask({ key: 'persist-key' })],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        const cacheFile = path.join(tmpDir, '.mutate-cache.json');
+        const content = JSON.parse(await fs.readFile(cacheFile, 'utf8'));
+        expect(content['persist-key']).toBeDefined();
+    });
+    it('handles adapter errors gracefully and still shuts down', async () => {
+        const adapter = makeAdapter({
+            runMutant: vi.fn().mockRejectedValue(new Error('adapter failure')),
+        });
+        const cache = {};
+        await expect(executePool({
+            tasks: [makeTask()],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        })).rejects.toThrow('adapter failure');
+        expect(adapter.shutdown).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/runner/__tests__/tasks.spec.d.ts

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

package/dist/runner/__tests__/tasks.spec.js

@@ -0,0 +1,95 @@
+import { describe, it, expect } from 'vitest';
+import { prepareTasks } from '../tasks.js';
+import { hash, keyForTests } from '../cache.js';
+function makeVariant(overrides = {}) {
+    return {
+        id: 'file.ts#0',
+        name: 'flipStrictEQ',
+        file: '/src/file.ts',
+        code: 'const x = a !== b',
+        line: 1,
+        col: 10,
+        tests: ['/tests/file.test.ts'],
+        ...overrides,
+    };
+}
+describe('prepareTasks', () => {
+    it('creates tasks with sorted tests and computed cache keys', () => {
+        const v = makeVariant({
+            tests: ['/tests/b.test.ts', '/tests/a.test.ts'],
+        });
+        const tasks = prepareTasks([v], null);
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0].tests).toEqual(['/tests/a.test.ts', '/tests/b.test.ts']);
+        expect(tasks[0].v).toBe(v);
+        // Key should be testSig:codeSig
+        const expectedTestSig = hash(keyForTests(['/tests/a.test.ts', '/tests/b.test.ts']));
+        const expectedCodeSig = hash(v.code);
+        expect(tasks[0].key).toBe(`${expectedTestSig}:${expectedCodeSig}`);
+    });
+    it('produces deterministic keys regardless of test order', () => {
+        const v1 = makeVariant({
+            tests: ['/tests/b.test.ts', '/tests/a.test.ts'],
+        });
+        const v2 = makeVariant({
+            tests: ['/tests/a.test.ts', '/tests/b.test.ts'],
+        });
+        const tasks1 = prepareTasks([v1], null);
+        const tasks2 = prepareTasks([v2], null);
+        expect(tasks1[0].key).toBe(tasks2[0].key);
+    });
+    it('produces different keys for different code', () => {
+        const v1 = makeVariant({ code: 'const x = a !== b' });
+        const v2 = makeVariant({ code: 'const x = a === b' });
+        const tasks = prepareTasks([v1, v2], null);
+        expect(tasks[0].key).not.toBe(tasks[1].key);
+    });
+    it('produces different keys for different test sets', () => {
+        const v1 = makeVariant({ tests: ['/tests/a.test.ts'] });
+        const v2 = makeVariant({ tests: ['/tests/b.test.ts'] });
+        const tasks = prepareTasks([v1, v2], null);
+        expect(tasks[0].key).not.toBe(tasks[1].key);
+    });
+    it('handles variants with no tests', () => {
+        const v = makeVariant({ tests: [] });
+        const tasks = prepareTasks([v], null);
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0].tests).toEqual([]);
+    });
+    it('prunes tests via per-test coverage', () => {
+        const v = makeVariant({
+            file: '/src/file.ts',
+            line: 5,
+            tests: ['/tests/a.test.ts', '/tests/b.test.ts'],
+        });
+        // Only test-a covers line 5 of /src/file.ts
+        const perTestCoverage = new Map();
+        const aCoverage = new Map();
+        aCoverage.set('/src/file.ts', new Set([5, 6, 7]));
+        perTestCoverage.set('/tests/a.test.ts', aCoverage);
+        const bCoverage = new Map();
+        bCoverage.set('/src/file.ts', new Set([10, 11]));
+        perTestCoverage.set('/tests/b.test.ts', bCoverage);
+        const tasks = prepareTasks([v], perTestCoverage);
+        expect(tasks[0].tests).toEqual(['/tests/a.test.ts']);
+    });
+    it('does not prune when perTestCoverage is null', () => {
+        const v = makeVariant({
+            tests: ['/tests/a.test.ts', '/tests/b.test.ts'],
+        });
+        const tasks = prepareTasks([v], null);
+        expect(tasks[0].tests).toHaveLength(2);
+    });
+    it('handles multiple variants', () => {
+        const variants = [
+            makeVariant({ id: 'file.ts#0', code: 'code1' }),
+            makeVariant({ id: 'file.ts#1', code: 'code2' }),
+            makeVariant({ id: 'file.ts#2', code: 'code3' }),
+        ];
+        const tasks = prepareTasks(variants, null);
+        expect(tasks).toHaveLength(3);
+        expect(tasks[0].v.id).toBe('file.ts#0');
+        expect(tasks[1].v.id).toBe('file.ts#1');
+        expect(tasks[2].v.id).toBe('file.ts#2');
+    });
+});

package/dist/runner/__tests__/variants.spec.d.ts

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