@mutineerjs/mutineer 0.2.2 → 0.2.4

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

@@ -0,0 +1,180 @@
+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 { clearCacheOnStart, saveCacheAtomic, decodeCacheKey, keyForTests, hash, readMutantCache, } from '../cache.js';
+let tmpDir;
+beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-cache-'));
+});
+afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+});
+describe('clearCacheOnStart', () => {
+    it('removes the cache file if it exists', async () => {
+        const cacheFile = path.join(tmpDir, '.mutate-cache.json');
+        await fs.writeFile(cacheFile, '{}');
+        await clearCacheOnStart(tmpDir);
+        await expect(fs.access(cacheFile)).rejects.toThrow();
+    });
+    it('does not throw if cache file does not exist', async () => {
+        await expect(clearCacheOnStart(tmpDir)).resolves.toBeUndefined();
+    });
+});
+describe('saveCacheAtomic', () => {
+    it('writes cache data to the file', async () => {
+        const cache = {
+            key1: {
+                status: 'killed',
+                file: 'foo.ts',
+                line: 1,
+                col: 0,
+                mutator: 'flipEQ',
+            },
+        };
+        await saveCacheAtomic(tmpDir, cache);
+        const content = await fs.readFile(path.join(tmpDir, '.mutate-cache.json'), 'utf8');
+        expect(JSON.parse(content)).toEqual(cache);
+    });
+    it('overwrites existing cache', async () => {
+        await saveCacheAtomic(tmpDir, { old: {} });
+        const newCache = {
+            new: {
+                status: 'escaped',
+                file: 'bar.ts',
+                line: 2,
+                col: 3,
+                mutator: 'andToOr',
+            },
+        };
+        await saveCacheAtomic(tmpDir, newCache);
+        const content = await fs.readFile(path.join(tmpDir, '.mutate-cache.json'), 'utf8');
+        expect(JSON.parse(content)).toEqual(newCache);
+    });
+});
+describe('decodeCacheKey', () => {
+    it('decodes a full cache key', () => {
+        const key = 'testsig:codesig:src/foo.ts:10,5:flipEQ';
+        const decoded = decodeCacheKey(key);
+        expect(decoded.file).toBe('src/foo.ts');
+        expect(decoded.line).toBe(10);
+        expect(decoded.col).toBe(5);
+        expect(decoded.mutator).toBe('flipEQ');
+    });
+    it('handles key with no colons', () => {
+        const decoded = decodeCacheKey('nodelimiters');
+        expect(decoded.mutator).toBe('unknown');
+    });
+    it('handles key with only one colon', () => {
+        const decoded = decodeCacheKey('only:one');
+        expect(decoded.mutator).toBe('one');
+    });
+    it('handles malformed position', () => {
+        const key = 'a:b:file:badpos:mutator';
+        const decoded = decodeCacheKey(key);
+        expect(decoded.mutator).toBe('mutator');
+    });
+    it('handles key with exactly two colons (no firstColon in rest)', () => {
+        // Key: "pos:mutator" after splitting last colon → rest = "pos", no colon in rest
+        // Full key: "10,5:mutator" → lastColon splits mutator, positionColon splits pos
+        // rest becomes empty string before positionColon
+        const decoded = decodeCacheKey('10,5:mutator');
+        expect(decoded.mutator).toBe('mutator');
+        expect(decoded.line).toBe(0); // positionColon = -1, returns early
+    });
+    it('handles key with exactly three colons (firstColon but no secondColon)', () => {
+        // "sig:10,5:mutator" → mutator='mutator', posRaw='10,5', rest='sig'
+        // firstColon in 'sig' = -1, returns early at line 70
+        const decoded = decodeCacheKey('sig:10,5:mutator');
+        expect(decoded.mutator).toBe('mutator');
+        expect(decoded.line).toBe(10);
+        expect(decoded.col).toBe(5);
+    });
+    it('handles key with four colons (firstColon but no secondColon in restAfterFirst)', () => {
+        // "tsig:csig:10,5:mutator" → mutator='mutator', posRaw='10,5', rest='tsig:csig'
+        // firstColon=4, restAfterFirst='csig', secondColon in 'csig' = -1, returns at line 73
+        const decoded = decodeCacheKey('tsig:csig:10,5:mutator');
+        expect(decoded.mutator).toBe('mutator');
+        expect(decoded.line).toBe(10);
+        expect(decoded.col).toBe(5);
+    });
+});
+describe('keyForTests', () => {
+    it('produces deterministic keys regardless of input order', () => {
+        const key1 = keyForTests(['b.test.ts', 'a.test.ts']);
+        const key2 = keyForTests(['a.test.ts', 'b.test.ts']);
+        expect(key1).toBe(key2);
+    });
+    it('produces different keys for different test sets', () => {
+        const key1 = keyForTests(['a.test.ts']);
+        const key2 = keyForTests(['b.test.ts']);
+        expect(key1).not.toBe(key2);
+    });
+});
+describe('hash', () => {
+    it('returns a 12 character hex string', () => {
+        const h = hash('test');
+        expect(h).toMatch(/^[0-9a-f]{12}$/);
+    });
+    it('returns the same hash for the same input', () => {
+        expect(hash('hello')).toBe(hash('hello'));
+    });
+    it('returns different hashes for different inputs', () => {
+        expect(hash('a')).not.toBe(hash('b'));
+    });
+});
+describe('readMutantCache', () => {
+    it('returns empty object when no cache file exists', async () => {
+        const result = await readMutantCache(tmpDir);
+        expect(result).toEqual({});
+    });
+    it('reads and normalizes object-format cache entries', async () => {
+        const cache = {
+            'testsig:codesig:file.ts:1,0:flip': {
+                status: 'killed',
+                file: 'file.ts',
+                line: 1,
+                col: 0,
+                mutator: 'flip',
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), JSON.stringify(cache));
+        const result = await readMutantCache(tmpDir);
+        expect(result['testsig:codesig:file.ts:1,0:flip']).toEqual({
+            status: 'killed',
+            file: 'file.ts',
+            line: 1,
+            col: 0,
+            mutator: 'flip',
+        });
+    });
+    it('reads and normalizes old string-format cache entries', async () => {
+        const cache = {
+            'testsig:codesig:file.ts:1,0:flip': 'killed',
+        };
+        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), JSON.stringify(cache));
+        const result = await readMutantCache(tmpDir);
+        const entry = result['testsig:codesig:file.ts:1,0:flip'];
+        expect(entry.status).toBe('killed');
+        expect(entry.mutator).toBe('flip');
+    });
+    it('returns empty object for invalid JSON', async () => {
+        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), 'not json');
+        const result = await readMutantCache(tmpDir);
+        expect(result).toEqual({});
+    });
+    it('normalizes partial object entries with decoded fallbacks', async () => {
+        const cache = {
+            'testsig:codesig:file.ts:5,3:mut': {
+                status: 'escaped',
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), JSON.stringify(cache));
+        const result = await readMutantCache(tmpDir);
+        const entry = result['testsig:codesig:file.ts:5,3:mut'];
+        expect(entry.status).toBe('escaped');
+        expect(entry.line).toBe(5);
+        expect(entry.col).toBe(3);
+        expect(entry.mutator).toBe('mut');
+    });
+});

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

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

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