@mutineerjs/mutineer 0.2.3 → 0.2.4

package/dist/runner/shared/__tests__/redirect-state.spec.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { initializeRedirectState, setRedirect, getRedirect, clearRedirect, } from '../redirect-state.js';
+describe('redirect-state', () => {
+    beforeEach(() => {
+        initializeRedirectState();
+    });
+    describe('initializeRedirectState', () => {
+        it('sets global redirect to null/null', () => {
+            expect(globalThis.__mutineer_redirect__).toEqual({
+                from: null,
+                to: null,
+            });
+        });
+    });
+    describe('setRedirect', () => {
+        it('sets the redirect config', () => {
+            setRedirect({ from: '/src/foo.ts', to: '/tmp/mutant.ts' });
+            expect(globalThis.__mutineer_redirect__).toEqual({
+                from: '/src/foo.ts',
+                to: '/tmp/mutant.ts',
+            });
+        });
+    });
+    describe('getRedirect', () => {
+        it('returns null when no redirect is set', () => {
+            expect(getRedirect()).toBeNull();
+        });
+        it('returns the redirect config when set', () => {
+            setRedirect({ from: '/src/foo.ts', to: '/tmp/mutant.ts' });
+            const redirect = getRedirect();
+            expect(redirect).toEqual({
+                from: '/src/foo.ts',
+                to: '/tmp/mutant.ts',
+            });
+        });
+        it('returns null when from is null', () => {
+            globalThis.__mutineer_redirect__ = { from: null, to: '/tmp/mutant.ts' };
+            expect(getRedirect()).toBeNull();
+        });
+        it('returns null when to is null', () => {
+            globalThis.__mutineer_redirect__ = { from: '/src/foo.ts', to: null };
+            expect(getRedirect()).toBeNull();
+        });
+    });
+    describe('clearRedirect', () => {
+        it('resets the redirect to null/null', () => {
+            setRedirect({ from: '/src/foo.ts', to: '/tmp/mutant.ts' });
+            clearRedirect();
+            expect(getRedirect()).toBeNull();
+            expect(globalThis.__mutineer_redirect__).toEqual({
+                from: null,
+                to: null,
+            });
+        });
+    });
+});

package/dist/runner/tasks.d.ts

@@ -0,0 +1,12 @@
+import type { Variant } from '../types/mutant.js';
+import type { PerTestCoverageMap } from '../utils/coverage.js';
+export interface MutantTask {
+    v: Variant;
+    tests: string[];
+    key: string;
+}
+/**
+ * Prepare mutant tasks from variants by pruning tests via per-test coverage,
+ * sorting tests deterministically, and computing cache keys.
+ */
+export declare function prepareTasks(variants: readonly Variant[], perTestCoverage: PerTestCoverageMap | null): MutantTask[];

package/dist/runner/tasks.js

@@ -0,0 +1,25 @@
+import { filterTestsByCoverage } from './variants.js';
+import { hash, keyForTests } from './cache.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('tasks');
+/**
+ * Prepare mutant tasks from variants by pruning tests via per-test coverage,
+ * sorting tests deterministically, and computing cache keys.
+ */
+export function prepareTasks(variants, perTestCoverage) {
+    return variants.map((v) => {
+        let tests = Array.from(v.tests);
+        if (perTestCoverage && tests.length) {
+            const before = tests.length;
+            tests = filterTestsByCoverage(perTestCoverage, tests, v.file, v.line);
+            if (tests.length !== before) {
+                log.debug(`Pruned tests ${before} -> ${tests.length} for mutant ${v.name} via per-test coverage`);
+            }
+        }
+        tests.sort();
+        const testSig = hash(keyForTests(tests));
+        const codeSig = hash(v.code);
+        const key = `${testSig}:${codeSig}`;
+        return { v, tests, key };
+    });
+}

package/dist/runner/variants.d.ts

@@ -4,8 +4,10 @@
  * Functions for enumerating mutation variants from source files.
  * Handles both regular modules and Vue SFC files.
  */
-import type { MutateTarget } from '../types/config.js';
-import type { MutantPayload } from '../types/mutant.js';
+import type { MutateTarget, MutineerConfig } from '../types/config.js';
+import type { MutantPayload, Variant } from '../types/mutant.js';
+import { type CoverageData } from '../utils/coverage.js';
+import type { TestMap } from './discover.js';
 /**
  * Get file path from target (handles both string and object forms).
  */
@@ -18,4 +20,17 @@ export declare function enumerateVariantsForTarget(root: string, t: MutateTarget
  * Filter tests to only those that cover a specific line in a file.
  */
 export declare function filterTestsByCoverage(perTest: Map<string, Map<string, Set<number>>>, tests: readonly string[], filePath: string, line: number): string[];
+export interface EnumerateAllParams {
+    cwd: string;
+    targets: readonly MutateTarget[];
+    testMap: TestMap;
+    changedFiles: Set<string> | null;
+    coverageData: CoverageData | null;
+    config: MutineerConfig;
+}
+/**
+ * Enumerate variants for all targets, filtering by changed files and coverage.
+ * Links each variant to its relevant test files via the testMap.
+ */
+export declare function enumerateAllVariants(params: EnumerateAllParams): Promise<Variant[]>;
 export type { Variant } from '../types/mutant.js';

package/dist/runner/variants.js

@@ -8,6 +8,8 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { mutateVueSfcScriptSetup } from '../core/sfc.js';
 import { mutateModuleSource } from '../core/module.js';
+import { normalizePath } from '../utils/normalizePath.js';
+import { isLineCovered } from '../utils/coverage.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('variants');
 /**
@@ -64,3 +66,34 @@ export function filterTestsByCoverage(perTest, tests, filePath, line) {
         return lines.has(line);
     });
 }
+/**
+ * Enumerate variants for all targets, filtering by changed files and coverage.
+ * Links each variant to its relevant test files via the testMap.
+ */
+export async function enumerateAllVariants(params) {
+    const { cwd, targets, testMap, changedFiles, coverageData, config } = params;
+    const enumerated = await Promise.all(targets.map(async (target) => {
+        const file = getTargetFile(target);
+        const absFile = normalizePath(path.isAbsolute(file) ? file : path.join(cwd, file));
+        if (changedFiles && !changedFiles.has(absFile))
+            return [];
+        log.debug('Target file: ' + absFile);
+        const files = await enumerateVariantsForTarget(cwd, target, config.include, config.exclude, config.maxMutantsPerFile);
+        const testsAbs = testMap.get(normalizePath(absFile));
+        const tests = testsAbs ? Array.from(testsAbs) : [];
+        log.debug(`  found ${files.length} variants, linked to ${tests.length} tests`);
+        // Filter by coverage if enabled
+        let filtered = files;
+        if (coverageData) {
+            filtered = files.filter((v) => isLineCovered(coverageData, absFile, v.line));
+            if (filtered.length !== files.length) {
+                log.debug(`  filtered ${files.length} -> ${filtered.length} variants by coverage`);
+            }
+        }
+        return filtered.map((v) => ({ ...v, tests }));
+    }));
+    const variants = [];
+    for (const list of enumerated)
+        variants.push(...list);
+    return variants;
+}

package/dist/runner/vitest/__tests__/redirect-loader.spec.js

@@ -3,6 +3,10 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import { pathToFileURL } from 'node:url';
+vi.mock('node:module', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, register: vi.fn() };
+});
 import { resolve as poolResolve } from '../redirect-loader.js';
 describe('pool-redirect-loader resolve', () => {
     afterEach(() => {

package/dist/utils/__tests__/logger.spec.d.ts

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

package/dist/utils/__tests__/logger.spec.js

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// We need to test with different DEBUG values, so we mock the module dynamically
+describe('logger', () => {
+    let originalDebug;
+    beforeEach(() => {
+        originalDebug = process.env.MUTINEER_DEBUG;
+        vi.restoreAllMocks();
+    });
+    afterEach(() => {
+        if (originalDebug === undefined) {
+            delete process.env.MUTINEER_DEBUG;
+        }
+        else {
+            process.env.MUTINEER_DEBUG = originalDebug;
+        }
+    });
+    it('info logs to console.log', async () => {
+        const spy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const { createLogger } = await import('../logger.js');
+        const log = createLogger('test');
+        log.info('hello %s', 'world');
+        expect(spy).toHaveBeenCalledWith('hello %s', 'world');
+    });
+    it('warn logs to console.warn', async () => {
+        const spy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const { createLogger } = await import('../logger.js');
+        const log = createLogger('test');
+        log.warn('warning message');
+        expect(spy).toHaveBeenCalledWith('warning message');
+    });
+    it('error logs to console.error', async () => {
+        const spy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const { createLogger } = await import('../logger.js');
+        const log = createLogger('test');
+        log.error('error message');
+        expect(spy).toHaveBeenCalledWith('error message');
+    });
+    it('debug logs to console.error when DEBUG is enabled', async () => {
+        const spy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        // DEBUG is a module-level constant, so we check the tag prefix behavior
+        const { createLogger, DEBUG } = await import('../logger.js');
+        const log = createLogger('mytag');
+        log.debug('debug message');
+        if (DEBUG) {
+            expect(spy).toHaveBeenCalledWith('[mytag] debug message');
+        }
+        else {
+            // When DEBUG is false, debug should be a no-op
+            expect(spy).not.toHaveBeenCalled();
+        }
+    });
+    it('debug includes the tag prefix', async () => {
+        const spy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const { createLogger, DEBUG } = await import('../logger.js');
+        const log = createLogger('custom-tag');
+        log.debug('test');
+        if (DEBUG) {
+            expect(spy).toHaveBeenCalledWith(expect.stringContaining('[custom-tag]'));
+        }
+    });
+});

package/dist/utils/__tests__/normalizePath.spec.d.ts

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

package/dist/utils/__tests__/normalizePath.spec.js

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import { normalizePath } from '../normalizePath.js';
+describe('normalizePath', () => {
+    it('replaces backslashes with forward slashes', () => {
+        expect(normalizePath('src\\utils\\file.ts')).toBe('src/utils/file.ts');
+    });
+    it('handles multiple consecutive backslashes', () => {
+        expect(normalizePath('src\\\\file.ts')).toBe('src//file.ts');
+    });
+    it('leaves forward slashes unchanged', () => {
+        expect(normalizePath('src/utils/file.ts')).toBe('src/utils/file.ts');
+    });
+    it('handles empty string', () => {
+        expect(normalizePath('')).toBe('');
+    });
+    it('handles mixed slashes', () => {
+        expect(normalizePath('src\\utils/file.ts')).toBe('src/utils/file.ts');
+    });
+    it('handles Windows-style absolute paths', () => {
+        expect(normalizePath('C:\\Users\\dev\\project')).toBe('C:/Users/dev/project');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutineerjs/mutineer",
-  "version": "v0.2.3",
+  "version": "v0.2.4",
   "type": "module",
   "private": false,
   "bin": {