@mutineerjs/mutineer 0.2.3 → 0.2.4

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

@@ -0,0 +1,227 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { listChangedFiles } from '../changed.js';
+// Mock child_process.spawnSync
+const spawnSyncMock = vi.fn();
+vi.mock('node:child_process', () => ({
+    spawnSync: (...args) => spawnSyncMock(...args),
+}));
+// Mock fs functions
+const existsSyncMock = vi.fn();
+const readFileSyncMock = vi.fn();
+vi.mock('node:fs', () => ({
+    default: {
+        existsSync: (...args) => existsSyncMock(...args),
+        readFileSync: (...args) => readFileSyncMock(...args),
+    },
+    existsSync: (...args) => existsSyncMock(...args),
+    readFileSync: (...args) => readFileSyncMock(...args),
+}));
+describe('listChangedFiles', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Default: files exist
+        existsSyncMock.mockReturnValue(true);
+    });
+    it('returns empty array when no git repo is found', () => {
+        spawnSyncMock.mockReturnValue({ status: 1, stdout: '' });
+        const result = listChangedFiles('/not-a-repo', { quiet: true });
+        expect(result).toEqual([]);
+    });
+    it('returns changed files from git diff', () => {
+        // First call: rev-parse --show-toplevel (find repo root)
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            if (args.includes('--name-only') && args.includes('main...HEAD')) {
+                return { status: 0, stdout: 'src/foo.ts\0src/bar.ts\0' };
+            }
+            if (args.includes('--name-only') && args.includes('HEAD')) {
+                return { status: 0, stdout: '' };
+            }
+            if (args.includes('--others')) {
+                return { status: 0, stdout: '' };
+            }
+            return { status: 1, stdout: '' };
+        });
+        const result = listChangedFiles('/repo');
+        expect(result).toHaveLength(2);
+        expect(result).toContain('/repo/src/foo.ts');
+        expect(result).toContain('/repo/src/bar.ts');
+    });
+    it('deduplicates files from multiple git sources', () => {
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            if (args.includes('main...HEAD')) {
+                return { status: 0, stdout: 'src/foo.ts\0' };
+            }
+            if (args.includes('HEAD') && !args.includes('main...HEAD')) {
+                return { status: 0, stdout: 'src/foo.ts\0' }; // same file
+            }
+            if (args.includes('--others')) {
+                return { status: 0, stdout: '' };
+            }
+            return { status: 1, stdout: '' };
+        });
+        const result = listChangedFiles('/repo');
+        expect(result).toHaveLength(1);
+    });
+    it('skips deleted/missing files', () => {
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            if (args.includes('main...HEAD')) {
+                return { status: 0, stdout: 'deleted.ts\0' };
+            }
+            return { status: 0, stdout: '' };
+        });
+        existsSyncMock.mockReturnValue(false);
+        const result = listChangedFiles('/repo');
+        expect(result).toEqual([]);
+    });
+    it('includes untracked files', () => {
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            if (args.includes('--others')) {
+                return { status: 0, stdout: 'new-file.ts\0' };
+            }
+            return { status: 0, stdout: '' };
+        });
+        const result = listChangedFiles('/repo');
+        expect(result).toContain('/repo/new-file.ts');
+    });
+    it('returns empty when all git commands fail', () => {
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            return { status: 1, stdout: '' };
+        });
+        const result = listChangedFiles('/repo');
+        expect(result).toEqual([]);
+    });
+    it('uses custom baseRef', () => {
+        const gitArgs = [];
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            gitArgs.push(args);
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            return { status: 0, stdout: '' };
+        });
+        listChangedFiles('/repo', { baseRef: 'develop' });
+        const diffCall = gitArgs.find((a) => a.some((x) => x.includes('...')));
+        expect(diffCall).toBeDefined();
+        expect(diffCall.some((a) => a.includes('develop...HEAD'))).toBe(true);
+    });
+    it('resolves dependencies when includeDeps is true', () => {
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            if (args.includes('main...HEAD')) {
+                return { status: 0, stdout: 'src/foo.ts\0' };
+            }
+            return { status: 0, stdout: '' };
+        });
+        // When reading the changed file to resolve deps
+        readFileSyncMock.mockReturnValue('// no imports');
+        const result = listChangedFiles('/repo', { includeDeps: true });
+        // Should at least contain the original file
+        expect(result).toContain('/repo/src/foo.ts');
+    });
+    it('resolves dependencies with import statements', () => {
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            if (args.includes('main...HEAD')) {
+                return { status: 0, stdout: 'src/foo.ts\0' };
+            }
+            return { status: 0, stdout: '' };
+        });
+        // File with imports - the import resolution will fail (no real files)
+        // but it exercises the parsing code paths
+        readFileSyncMock.mockReturnValue('import { bar } from "./bar"\nexport { baz } from "./baz"\nconst x = require("./qux")');
+        const result = listChangedFiles('/repo', { includeDeps: true });
+        expect(result).toContain('/repo/src/foo.ts');
+    });
+    it('skips non-local imports in dependency resolution', () => {
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            if (args.includes('main...HEAD')) {
+                return { status: 0, stdout: 'src/foo.ts\0' };
+            }
+            return { status: 0, stdout: '' };
+        });
+        // Non-local imports (no './' prefix) should be skipped
+        readFileSyncMock.mockReturnValue('import lodash from "lodash"');
+        const result = listChangedFiles('/repo', { includeDeps: true });
+        expect(result).toHaveLength(1);
+        expect(result).toContain('/repo/src/foo.ts');
+    });
+    it('handles file that no longer exists during dep resolution', () => {
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            if (args.includes('main...HEAD')) {
+                return { status: 0, stdout: 'src/foo.ts\0' };
+            }
+            return { status: 0, stdout: '' };
+        });
+        // First existsSync for changed file check = true
+        // Then existsSync for dep resolution: file exists check, then readFile fails
+        let callCount = 0;
+        existsSyncMock.mockImplementation(() => {
+            callCount++;
+            // First call is for the changed file in the main loop
+            return callCount <= 1;
+        });
+        readFileSyncMock.mockImplementation(() => {
+            throw new Error('ENOENT');
+        });
+        const result = listChangedFiles('/repo', { includeDeps: true });
+        expect(result).toContain('/repo/src/foo.ts');
+    });
+    it('respects maxDepth option', () => {
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            if (args.includes('main...HEAD')) {
+                return { status: 0, stdout: 'src/foo.ts\0' };
+            }
+            return { status: 0, stdout: '' };
+        });
+        readFileSyncMock.mockReturnValue('import { x } from "./bar"');
+        const result = listChangedFiles('/repo', {
+            includeDeps: true,
+            maxDepth: 0,
+        });
+        // maxDepth=0 means no recursion into deps
+        expect(result).toContain('/repo/src/foo.ts');
+    });
+    it('only processes source files for dependency resolution', () => {
+        spawnSyncMock.mockImplementation((_cmd, args) => {
+            if (args.includes('--show-toplevel')) {
+                return { status: 0, stdout: '/repo\n' };
+            }
+            if (args.includes('main...HEAD')) {
+                return { status: 0, stdout: 'README.md\0' }; // non-source file
+            }
+            return { status: 0, stdout: '' };
+        });
+        const result = listChangedFiles('/repo', { includeDeps: true });
+        // README.md doesn't match /\.(js|ts|vue|mjs|cjs)$/, so no deps resolved
+        expect(result).toContain('/repo/README.md');
+        expect(readFileSyncMock).not.toHaveBeenCalled();
+    });
+});

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

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

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

@@ -0,0 +1,41 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { cleanupMutineerDirs } from '../cleanup.js';
+let tmpDir;
+beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-cleanup-'));
+});
+afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+});
+describe('cleanupMutineerDirs', () => {
+    it('removes __mutineer__ directories', async () => {
+        const mutDir = path.join(tmpDir, 'src', '__mutineer__');
+        await fs.mkdir(mutDir, { recursive: true });
+        await fs.writeFile(path.join(mutDir, 'mutant.ts'), 'code');
+        await cleanupMutineerDirs(tmpDir);
+        await expect(fs.access(mutDir)).rejects.toThrow();
+    });
+    it('removes nested __mutineer__ directories', async () => {
+        const dir1 = path.join(tmpDir, 'src', 'a', '__mutineer__');
+        const dir2 = path.join(tmpDir, 'src', 'b', '__mutineer__');
+        await fs.mkdir(dir1, { recursive: true });
+        await fs.mkdir(dir2, { recursive: true });
+        await cleanupMutineerDirs(tmpDir);
+        await expect(fs.access(dir1)).rejects.toThrow();
+        await expect(fs.access(dir2)).rejects.toThrow();
+    });
+    it('does not throw when no __mutineer__ dirs exist', async () => {
+        await expect(cleanupMutineerDirs(tmpDir)).resolves.toBeUndefined();
+    });
+    it('preserves non-mutineer directories', async () => {
+        const srcDir = path.join(tmpDir, 'src');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(path.join(srcDir, 'file.ts'), 'code');
+        await cleanupMutineerDirs(tmpDir);
+        const stat = await fs.stat(srcDir);
+        expect(stat.isDirectory()).toBe(true);
+    });
+});

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

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

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

@@ -0,0 +1,71 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { loadMutineerConfig } from '../config.js';
+let tmpDir;
+beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-config-'));
+});
+afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+});
+describe('loadMutineerConfig', () => {
+    it('throws when no config file is found', async () => {
+        await expect(loadMutineerConfig(tmpDir)).rejects.toThrow('No config found in');
+    });
+    it('throws when explicit config path does not exist', async () => {
+        await expect(loadMutineerConfig(tmpDir, 'nonexistent.js')).rejects.toThrow('No config found at nonexistent.js');
+    });
+    it('loads a .js config file', async () => {
+        const configFile = path.join(tmpDir, 'mutineer.config.js');
+        await fs.writeFile(configFile, 'export default { runner: "vitest" }');
+        const config = await loadMutineerConfig(tmpDir);
+        expect(config).toEqual({ runner: 'vitest' });
+    });
+    it('loads a .mjs config file', async () => {
+        const configFile = path.join(tmpDir, 'mutineer.config.mjs');
+        await fs.writeFile(configFile, 'export default { runner: "jest" }');
+        const config = await loadMutineerConfig(tmpDir);
+        expect(config).toEqual({ runner: 'jest' });
+    });
+    it('loads config from explicit path', async () => {
+        const configFile = path.join(tmpDir, 'custom.config.mjs');
+        await fs.writeFile(configFile, 'export default { maxMutantsPerFile: 10 }');
+        const config = await loadMutineerConfig(tmpDir, 'custom.config.mjs');
+        expect(config).toEqual({ maxMutantsPerFile: 10 });
+    });
+    it('prefers mutineer.config.ts over .js and .mjs', async () => {
+        // When a .ts config exists but we can't load it with Vite, it will fail.
+        // We just test the .js fallback works when no .ts exists.
+        const jsConfig = path.join(tmpDir, 'mutineer.config.js');
+        const mjsConfig = path.join(tmpDir, 'mutineer.config.mjs');
+        await fs.writeFile(jsConfig, 'export default { source: "js" }');
+        await fs.writeFile(mjsConfig, 'export default { source: "mjs" }');
+        const config = await loadMutineerConfig(tmpDir);
+        // .js comes before .mjs in the candidate order
+        expect(config).toEqual({ source: 'js' });
+    });
+    it('wraps load errors with config path info', async () => {
+        const configFile = path.join(tmpDir, 'mutineer.config.js');
+        // Write invalid JS that will fail to import
+        await fs.writeFile(configFile, '??? not valid javascript ???');
+        await expect(loadMutineerConfig(tmpDir)).rejects.toThrow(/Failed to load config from/);
+    });
+    // BUG: Two bugs compound here:
+    // 1. validateConfig uses `&&` instead of `||`: `typeof config !== 'object' && config === null`
+    //    Since typeof null === 'object', this condition is always false, so null passes validation.
+    // 2. loadModule uses `||` instead of `??`: `mod.default || mod`
+    //    When default export is null (falsy), it falls back to the module namespace object.
+    // Together: null configs pass validation AND get returned as the module namespace.
+    it('BUG: null config passes validation due to && vs || logic error', async () => {
+        const configFile = path.join(tmpDir, 'mutineer.config.mjs');
+        await fs.writeFile(configFile, 'export default null');
+        // This SHOULD throw but doesn't because of the validateConfig bug.
+        // Additionally, loadModule returns { default: null } instead of null
+        // because it uses || (which treats null as falsy) instead of ??
+        const config = await loadMutineerConfig(tmpDir);
+        // Bug: returns the module namespace object instead of throwing
+        expect(config).toHaveProperty('default', null);
+    });
+});

package/dist/runner/__tests__/coverage-resolver.spec.d.ts

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

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 {};