@mutineerjs/mutineer 0.6.0 → 0.8.0

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

@@ -2,7 +2,7 @@ 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';
+import { clearCacheOnStart, saveCacheAtomic, decodeCacheKey, keyForTests, hash, readMutantCache, getCacheFilename, } from '../cache.js';
 let tmpDir;
 beforeEach(async () => {
     tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-cache-'));
@@ -10,9 +10,19 @@ beforeEach(async () => {
 afterEach(async () => {
     await fs.rm(tmpDir, { recursive: true, force: true });
 });
+describe('getCacheFilename', () => {
+    it('returns default filename when no shard', () => {
+        expect(getCacheFilename()).toBe('.mutineer-cache.json');
+        expect(getCacheFilename(undefined)).toBe('.mutineer-cache.json');
+    });
+    it('returns shard-namespaced filename when shard provided', () => {
+        expect(getCacheFilename({ index: 1, total: 2 })).toBe('.mutineer-cache-shard-1-of-2.json');
+        expect(getCacheFilename({ index: 3, total: 4 })).toBe('.mutineer-cache-shard-3-of-4.json');
+    });
+});
 describe('clearCacheOnStart', () => {
     it('removes the cache file if it exists', async () => {
-        const cacheFile = path.join(tmpDir, '.mutate-cache.json');
+        const cacheFile = path.join(tmpDir, '.mutineer-cache.json');
         await fs.writeFile(cacheFile, '{}');
         await clearCacheOnStart(tmpDir);
         await expect(fs.access(cacheFile)).rejects.toThrow();
@@ -20,6 +30,19 @@ describe('clearCacheOnStart', () => {
     it('does not throw if cache file does not exist', async () => {
         await expect(clearCacheOnStart(tmpDir)).resolves.toBeUndefined();
     });
+    it('removes shard-specific cache file', async () => {
+        const shardFile = path.join(tmpDir, '.mutineer-cache-shard-1-of-2.json');
+        await fs.writeFile(shardFile, '{}');
+        await clearCacheOnStart(tmpDir, { index: 1, total: 2 });
+        await expect(fs.access(shardFile)).rejects.toThrow();
+    });
+    it('does not remove default cache when shard is specified', async () => {
+        const defaultFile = path.join(tmpDir, '.mutineer-cache.json');
+        await fs.writeFile(defaultFile, '{}');
+        await clearCacheOnStart(tmpDir, { index: 1, total: 2 });
+        // default file should still exist
+        await expect(fs.access(defaultFile)).resolves.toBeUndefined();
+    });
 });
 describe('saveCacheAtomic', () => {
     it('writes cache data to the file', async () => {
@@ -33,7 +56,7 @@ describe('saveCacheAtomic', () => {
             },
         };
         await saveCacheAtomic(tmpDir, cache);
-        const content = await fs.readFile(path.join(tmpDir, '.mutate-cache.json'), 'utf8');
+        const content = await fs.readFile(path.join(tmpDir, '.mutineer-cache.json'), 'utf8');
         expect(JSON.parse(content)).toEqual(cache);
     });
     it('overwrites existing cache', async () => {
@@ -48,9 +71,25 @@ describe('saveCacheAtomic', () => {
             },
         };
         await saveCacheAtomic(tmpDir, newCache);
-        const content = await fs.readFile(path.join(tmpDir, '.mutate-cache.json'), 'utf8');
+        const content = await fs.readFile(path.join(tmpDir, '.mutineer-cache.json'), 'utf8');
         expect(JSON.parse(content)).toEqual(newCache);
     });
+    it('writes to shard-named file when shard is provided', async () => {
+        const cache = {
+            k: {
+                status: 'killed',
+                file: 'x.ts',
+                line: 1,
+                col: 0,
+                mutator: 'm',
+            },
+        };
+        await saveCacheAtomic(tmpDir, cache, { index: 2, total: 3 });
+        const content = await fs.readFile(path.join(tmpDir, '.mutineer-cache-shard-2-of-3.json'), 'utf8');
+        expect(JSON.parse(content)).toEqual(cache);
+        // default file should NOT exist
+        await expect(fs.access(path.join(tmpDir, '.mutineer-cache.json'))).rejects.toThrow();
+    });
 });
 describe('decodeCacheKey', () => {
     it('decodes a full cache key', () => {
@@ -128,6 +167,24 @@ describe('readMutantCache', () => {
         const result = await readMutantCache(tmpDir);
         expect(result).toEqual({});
     });
+    it('reads from shard-named file when shard is provided', async () => {
+        const cache = {
+            'k:v:f.ts:1,0:m': {
+                status: 'killed',
+                file: 'f.ts',
+                line: 1,
+                col: 0,
+                mutator: 'm',
+            },
+        };
+        await fs.writeFile(path.join(tmpDir, '.mutineer-cache-shard-1-of-2.json'), JSON.stringify(cache));
+        const result = await readMutantCache(tmpDir, { index: 1, total: 2 });
+        expect(result['k:v:f.ts:1,0:m'].status).toBe('killed');
+    });
+    it('returns empty object when shard file does not exist', async () => {
+        const result = await readMutantCache(tmpDir, { index: 2, total: 4 });
+        expect(result).toEqual({});
+    });
     it('reads and normalizes object-format cache entries', async () => {
         const cache = {
             'testsig:codesig:file.ts:1,0:flip': {
@@ -138,7 +195,7 @@ describe('readMutantCache', () => {
                 mutator: 'flip',
             },
         };
-        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), JSON.stringify(cache));
+        await fs.writeFile(path.join(tmpDir, '.mutineer-cache.json'), JSON.stringify(cache));
         const result = await readMutantCache(tmpDir);
         expect(result['testsig:codesig:file.ts:1,0:flip']).toEqual({
             status: 'killed',
@@ -152,14 +209,14 @@ describe('readMutantCache', () => {
         const cache = {
             'testsig:codesig:file.ts:1,0:flip': 'killed',
         };
-        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), JSON.stringify(cache));
+        await fs.writeFile(path.join(tmpDir, '.mutineer-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');
+        await fs.writeFile(path.join(tmpDir, '.mutineer-cache.json'), 'not json');
         const result = await readMutantCache(tmpDir);
         expect(result).toEqual({});
     });
@@ -169,7 +226,7 @@ describe('readMutantCache', () => {
                 status: 'escaped',
             },
         };
-        await fs.writeFile(path.join(tmpDir, '.mutate-cache.json'), JSON.stringify(cache));
+        await fs.writeFile(path.join(tmpDir, '.mutineer-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');

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

@@ -18,6 +18,13 @@ describe('cleanupMutineerDirs', () => {
         await cleanupMutineerDirs(tmpDir);
         await expect(fs.access(mutDir)).rejects.toThrow();
     });
+    it('removes root-level __mutineer__ directory', async () => {
+        const rootMutDir = path.join(tmpDir, '__mutineer__');
+        await fs.mkdir(rootMutDir, { recursive: true });
+        await fs.writeFile(path.join(rootMutDir, 'setup.mjs'), 'content');
+        await cleanupMutineerDirs(tmpDir);
+        await expect(fs.access(rootMutDir)).rejects.toThrow();
+    });
     it('removes nested __mutineer__ directories', async () => {
         const dir1 = path.join(tmpDir, 'src', 'a', '__mutineer__');
         const dir2 = path.join(tmpDir, 'src', 'b', '__mutineer__');
@@ -38,4 +45,34 @@ describe('cleanupMutineerDirs', () => {
         const stat = await fs.stat(srcDir);
         expect(stat.isDirectory()).toBe(true);
     });
+    it('does not remove cache files by default', async () => {
+        const cacheFile = path.join(tmpDir, '.mutineer-cache.json');
+        await fs.writeFile(cacheFile, '{}');
+        await cleanupMutineerDirs(tmpDir);
+        await expect(fs.access(cacheFile)).resolves.toBeUndefined();
+    });
+    it('removes .mutineer-cache*.json files when includeCacheFiles is true', async () => {
+        const cacheFile = path.join(tmpDir, '.mutineer-cache.json');
+        const shardFile = path.join(tmpDir, '.mutineer-cache-shard-1-of-2.json');
+        await fs.writeFile(cacheFile, '{}');
+        await fs.writeFile(shardFile, '{}');
+        await cleanupMutineerDirs(tmpDir, { includeCacheFiles: true });
+        await expect(fs.access(cacheFile)).rejects.toThrow();
+        await expect(fs.access(shardFile)).rejects.toThrow();
+    });
+    it('removes legacy .mutate-cache*.json files for migration when includeCacheFiles is true', async () => {
+        const legacyCache = path.join(tmpDir, '.mutate-cache.json');
+        const legacyShard = path.join(tmpDir, '.mutate-cache-shard-2-of-4.json');
+        await fs.writeFile(legacyCache, '{}');
+        await fs.writeFile(legacyShard, '{}');
+        await cleanupMutineerDirs(tmpDir, { includeCacheFiles: true });
+        await expect(fs.access(legacyCache)).rejects.toThrow();
+        await expect(fs.access(legacyShard)).rejects.toThrow();
+    });
+    it('removes .mutineer-cache*.json.tmp temp files when includeCacheFiles is true', async () => {
+        const tmpFile = path.join(tmpDir, '.mutineer-cache.json.tmp');
+        await fs.writeFile(tmpFile, '{}');
+        await cleanupMutineerDirs(tmpDir, { includeCacheFiles: true });
+        await expect(fs.access(tmpFile)).rejects.toThrow();
+    });
 });

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

@@ -16,6 +16,11 @@ function makeOpts(overrides = {}) {
         minKillPercent: undefined,
         runner: 'vitest',
         timeout: undefined,
+        reportFormat: 'text',
+        shard: undefined,
+        typescriptCheck: undefined,
+        vitestProject: undefined,
+        skipBaseline: false,
         ...overrides,
     };
 }

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

@@ -114,6 +114,134 @@ describe('autoDiscoverTargetsAndTests', () => {
             await fs.rm(tmpDir, { recursive: true, force: true });
         }
     });
+    it('calls onProgress at least twice with informational messages', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-progress-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const moduleFile = path.join(srcDir, 'foo.ts');
+        const testFile = path.join(srcDir, 'foo.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(moduleFile, 'export const foo = 1\n', 'utf8');
+        const importLine = ['im', 'port { foo } from "./foo"'].join('');
+        await fs.writeFile(testFile, `${importLine}\nconsole.log(foo)\n`, 'utf8');
+        const messages = [];
+        try {
+            await autoDiscoverTargetsAndTests(tmpDir, { testPatterns: ['**/*.test.ts'] }, (msg) => messages.push(msg));
+            expect(messages.length).toBeGreaterThanOrEqual(2);
+            expect(messages.some((m) => m.includes('test file'))).toBe(true);
+            expect(messages.some((m) => m.includes('Discovery complete'))).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('shared dep imported by 2 tests appears in testMap for both', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-shared-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const sharedDep = path.join(srcDir, 'shared.ts');
+        const test1 = path.join(srcDir, 'a.test.ts');
+        const test2 = path.join(srcDir, 'b.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(sharedDep, 'export const shared = 1\n', 'utf8');
+        const importShared = ['im', 'port { shared } from "./shared"'].join('');
+        await fs.writeFile(test1, `${importShared}\n`, 'utf8');
+        await fs.writeFile(test2, `${importShared}\n`, 'utf8');
+        try {
+            const { testMap } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const sharedAbs = normalizePath(sharedDep);
+            const test1Abs = normalizePath(test1);
+            const test2Abs = normalizePath(test2);
+            expect(testMap.get(sharedAbs)?.has(test1Abs)).toBe(true);
+            expect(testMap.get(sharedAbs)?.has(test2Abs)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('diamond graph: shared grandchild discovered with no duplicates', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-diamond-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const fileA = path.join(srcDir, 'A.ts');
+        const fileB = path.join(srcDir, 'B.ts');
+        const fileC = path.join(srcDir, 'C.ts');
+        const fileD = path.join(srcDir, 'D.ts');
+        const testFile = path.join(srcDir, 'test.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(fileD, 'export const d = 4\n', 'utf8');
+        const importD = ['im', 'port { d } from "./D"'].join('');
+        await fs.writeFile(fileB, `${importD}\nexport const b = 2\n`, 'utf8');
+        await fs.writeFile(fileC, `${importD}\nexport const c = 3\n`, 'utf8');
+        const importB = ['im', 'port { b } from "./B"'].join('');
+        const importC = ['im', 'port { c } from "./C"'].join('');
+        await fs.writeFile(fileA, `${importB}\n${importC}\nexport const a = 1\n`, 'utf8');
+        const importA = ['im', 'port { a } from "./A"'].join('');
+        await fs.writeFile(testFile, `${importA}\n`, 'utf8');
+        try {
+            const { testMap } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const dAbs = normalizePath(fileD);
+            const testAbs = normalizePath(testFile);
+            expect(testMap.get(dAbs)?.has(testAbs)).toBe(true);
+            // D should only be in testMap once (Set ensures no duplicates)
+            expect(testMap.get(dAbs)?.size).toBe(1);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('deep chain: deepest file is discovered correctly', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-deep-'));
+        const srcDir = path.join(tmpDir, 'src');
+        await fs.mkdir(srcDir, { recursive: true });
+        // chain: test -> f1 -> f2 -> f3 -> f4 -> f5
+        const files = Array.from({ length: 5 }, (_, i) => path.join(srcDir, `f${i + 1}.ts`));
+        const testFile = path.join(srcDir, 'chain.test.ts');
+        await fs.writeFile(files[4], 'export const f5 = 5\n', 'utf8');
+        for (let i = 3; i >= 0; i--) {
+            const importNext = ['im', `port { f${i + 2} } from "./f${i + 2}"`].join('');
+            await fs.writeFile(files[i], `${importNext}\nexport const f${i + 1} = ${i + 1}\n`, 'utf8');
+        }
+        const importF1 = ['im', 'port { f1 } from "./f1"'].join('');
+        await fs.writeFile(testFile, `${importF1}\n`, 'utf8');
+        try {
+            const { testMap } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const f5Abs = normalizePath(files[4]);
+            const testAbs = normalizePath(testFile);
+            expect(testMap.get(f5Abs)?.has(testAbs)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('2 tests directly importing same file both appear in directTestMap', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-direct2-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const sharedDep = path.join(srcDir, 'shared.ts');
+        const test1 = path.join(srcDir, 'a.test.ts');
+        const test2 = path.join(srcDir, 'b.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(sharedDep, 'export const shared = 1\n', 'utf8');
+        const importShared = ['im', 'port { shared } from "./shared"'].join('');
+        await fs.writeFile(test1, `${importShared}\n`, 'utf8');
+        await fs.writeFile(test2, `${importShared}\n`, 'utf8');
+        try {
+            const { directTestMap } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const sharedAbs = normalizePath(sharedDep);
+            const test1Abs = normalizePath(test1);
+            const test2Abs = normalizePath(test2);
+            expect(directTestMap.get(sharedAbs)?.has(test1Abs)).toBe(true);
+            expect(directTestMap.get(sharedAbs)?.has(test2Abs)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
     it('ignores test files when collecting mutate targets', async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-'));
         const srcDir = path.join(tmpDir, 'src');