@mutineerjs/mutineer 0.2.2 → 0.2.4

package/README.md

@@ -64,12 +64,27 @@ npm i @mutineerjs/mutineer
 
 ### Quick Start
 
+Try it immediately with `npx`:
+
 ```bash
-# Scaffold a config file
-mutineer init
+npx @mutineerjs/mutineer init
+npx @mutineerjs/mutineer run
+```
+
+Or add scripts to your `package.json` (recommended for team projects):
+
+```json
+{
+  "scripts": {
+    "mutineer": "mutineer run",
+    "mutineer:init": "mutineer init"
+  }
+}
+```
 
-# Run mutation testing
-mutineer run
+```bash
+npm run mutineer:init
+npm run mutineer
 ```
 
 ### CLI Options (for `mutineer run`)
@@ -92,19 +107,19 @@ mutineer run
 Run mutations on only the files you changed:
 
 ```bash
-mutineer run --changed
+npm run mutineer -- --changed
 ```
 
 Run with Jest and a minimum kill rate:
 
 ```bash
-mutineer run --runner jest --min-kill-percent 80
+npm run mutineer -- --runner jest --min-kill-percent 80
 ```
 
 Focus on covered code with 2 parallel workers:
 
 ```bash
-mutineer run --only-covered-lines --concurrency 2
+npm run mutineer -- --only-covered-lines --concurrency 2
 ```
 
 ## Configuration

package/dist/core/__tests__/module.spec.js

@@ -1,6 +1,69 @@
 import { describe, it, expect } from 'vitest';
-describe('Module', () => {
-    it('should pass a basic test', () => {
-        expect(true).toBe(true);
+import { mutateModuleSource } from '../module.js';
+describe('mutateModuleSource', () => {
+    it('returns empty array for code with no mutable patterns', () => {
+        const result = mutateModuleSource('const x = 1');
+        expect(result).toEqual([]);
+    });
+    it('generates mutations for equality operators', () => {
+        const code = 'if (a === b) {}';
+        const result = mutateModuleSource(code);
+        expect(result.length).toBeGreaterThan(0);
+        expect(result.some((v) => v.name === 'flipStrictEQ')).toBe(true);
+    });
+    it('generates mutations for logical operators', () => {
+        const code = 'const x = a && b';
+        const result = mutateModuleSource(code);
+        expect(result.some((v) => v.name === 'andToOr')).toBe(true);
+    });
+    it('generates mutations for arithmetic operators', () => {
+        const code = 'const x = a + b';
+        const result = mutateModuleSource(code);
+        expect(result.some((v) => v.name === 'addToSub')).toBe(true);
+    });
+    it('deduplicates identical mutations', () => {
+        const code = 'if (a === b) {}';
+        const result = mutateModuleSource(code);
+        const codes = result.map((v) => v.code);
+        expect(new Set(codes).size).toBe(codes.length);
+    });
+    it('respects include filter', () => {
+        const code = 'if (a === b && c || d) {}';
+        const result = mutateModuleSource(code, ['andToOr']);
+        expect(result.every((v) => v.name === 'andToOr')).toBe(true);
+    });
+    it('respects exclude filter', () => {
+        const code = 'if (a === b && c || d) {}';
+        const result = mutateModuleSource(code, undefined, ['flipStrictEQ']);
+        expect(result.every((v) => v.name !== 'flipStrictEQ')).toBe(true);
+    });
+    it('respects max limit', () => {
+        const code = 'if (a === b && c || d) {}';
+        const all = mutateModuleSource(code);
+        expect(all.length).toBeGreaterThan(1);
+        const limited = mutateModuleSource(code, undefined, undefined, 1);
+        expect(limited).toHaveLength(1);
+    });
+    it('throws when max is 0', () => {
+        expect(() => mutateModuleSource('code', undefined, undefined, 0)).toThrow('max must be a positive number');
+    });
+    it('throws when max is negative', () => {
+        expect(() => mutateModuleSource('code', undefined, undefined, -1)).toThrow('max must be a positive number');
+    });
+    it('includes line and col in variants', () => {
+        const code = 'const x = a + b';
+        const result = mutateModuleSource(code);
+        for (const v of result) {
+            expect(typeof v.line).toBe('number');
+            expect(typeof v.col).toBe('number');
+        }
+    });
+    it('produces valid mutated code strings', () => {
+        const code = 'const x = a <= b';
+        const result = mutateModuleSource(code);
+        for (const v of result) {
+            expect(typeof v.code).toBe('string');
+            expect(v.code).not.toBe(code);
+        }
     });
 });

package/dist/core/__tests__/sfc.spec.d.ts

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

package/dist/core/__tests__/sfc.spec.js

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi } from 'vitest';
+import { mutateVueSfcScriptSetup } from '../sfc.js';
+// Mock @vue/compiler-sfc
+vi.mock('@vue/compiler-sfc', () => ({
+    parse: (code, _opts) => {
+        // Simple mock that extracts content between <script setup> tags
+        const startTag = '<script setup>';
+        const endTag = '</script>';
+        const startIdx = code.indexOf(startTag);
+        if (startIdx === -1) {
+            return { descriptor: { scriptSetup: null } };
+        }
+        const contentStart = startIdx + startTag.length;
+        const contentEnd = code.indexOf(endTag, contentStart);
+        return {
+            descriptor: {
+                scriptSetup: {
+                    loc: {
+                        start: { offset: contentStart },
+                        end: { offset: contentEnd },
+                    },
+                },
+            },
+        };
+    },
+}));
+describe('mutateVueSfcScriptSetup', () => {
+    it('returns empty array when there is no script setup block', async () => {
+        const code = '<template><div>hello</div></template>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code);
+        expect(result).toEqual([]);
+    });
+    it('throws when max is 0', async () => {
+        await expect(mutateVueSfcScriptSetup('test.vue', '<script setup></script>', [], [], 0)).rejects.toThrow('max must be a positive number, got: 0');
+    });
+    it('throws when max is negative', async () => {
+        await expect(mutateVueSfcScriptSetup('test.vue', '<script setup></script>', [], [], -1)).rejects.toThrow('max must be a positive number, got: -1');
+    });
+    it('generates mutations for script setup content', async () => {
+        const code = '<script setup>\nconst x = a && b\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code);
+        // Should find at least the andToOr mutation
+        expect(result.length).toBeGreaterThan(0);
+        // Every result should have the full SFC code (containing template tags)
+        for (const v of result) {
+            expect(v.code).toContain('<script setup>');
+            expect(v.code).toContain('</script>');
+        }
+    });
+    it('deduplicates identical mutations', async () => {
+        const code = '<script setup>\nconst x = a && b\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code);
+        const outputs = result.map((v) => v.code);
+        const unique = new Set(outputs);
+        expect(outputs.length).toBe(unique.size);
+    });
+    it('respects max limit', async () => {
+        const code = '<script setup>\nconst x = a && b\nconst y = c || d\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code, undefined, undefined, 1);
+        expect(result.length).toBeLessThanOrEqual(1);
+    });
+    it('filters mutators with include', async () => {
+        const code = '<script setup>\nconst x = a && b\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code, ['andToOr']);
+        for (const v of result) {
+            expect(v.name).toBe('andToOr');
+        }
+    });
+    it('filters mutators with exclude', async () => {
+        const code = '<script setup>\nconst x = a && b\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code, undefined, ['andToOr']);
+        for (const v of result) {
+            expect(v.name).not.toBe('andToOr');
+        }
+    });
+});

package/dist/core/__tests__/variant-utils.spec.d.ts

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

package/dist/core/__tests__/variant-utils.spec.js

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest';
+import { generateMutationVariants, getFilteredRegistry } from '../variant-utils.js';
+function makeMutator(name, mutations) {
+    return {
+        name,
+        description: name,
+        apply: () => mutations,
+    };
+}
+describe('generateMutationVariants', () => {
+    it('returns empty array for empty registry', () => {
+        expect(generateMutationVariants([], 'const x = 1')).toEqual([]);
+    });
+    it('generates variants from a single mutator', () => {
+        const mutator = makeMutator('flip', [
+            { code: 'const x = 2', line: 1, col: 0 },
+        ]);
+        const result = generateMutationVariants([mutator], 'const x = 1');
+        expect(result).toEqual([
+            { name: 'flip', code: 'const x = 2', line: 1, col: 0 },
+        ]);
+    });
+    it('generates variants from multiple mutators', () => {
+        const m1 = makeMutator('a', [{ code: 'code_a', line: 1, col: 0 }]);
+        const m2 = makeMutator('b', [{ code: 'code_b', line: 2, col: 5 }]);
+        const result = generateMutationVariants([m1, m2], 'original');
+        expect(result).toHaveLength(2);
+        expect(result[0].name).toBe('a');
+        expect(result[1].name).toBe('b');
+    });
+    it('deduplicates identical mutation outputs', () => {
+        const m1 = makeMutator('a', [{ code: 'same', line: 1, col: 0 }]);
+        const m2 = makeMutator('b', [{ code: 'same', line: 2, col: 0 }]);
+        const result = generateMutationVariants([m1, m2], 'original');
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe('a');
+    });
+    it('throws when max is 0', () => {
+        expect(() => generateMutationVariants([], 'code', { max: 0 })).toThrow('max must be a positive number, got: 0');
+    });
+    it('throws when max is negative', () => {
+        expect(() => generateMutationVariants([], 'code', { max: -5 })).toThrow('max must be a positive number, got: -5');
+    });
+    it('respects max limit', () => {
+        const mutator = makeMutator('m', [
+            { code: 'v1', line: 1, col: 0 },
+            { code: 'v2', line: 2, col: 0 },
+            { code: 'v3', line: 3, col: 0 },
+        ]);
+        const result = generateMutationVariants([mutator], 'code', { max: 2 });
+        expect(result).toHaveLength(2);
+    });
+    it('stops iterating mutators once max is reached via inner return', () => {
+        const m1 = makeMutator('a', [
+            { code: 'v1', line: 1, col: 0 },
+            { code: 'v2', line: 2, col: 0 },
+        ]);
+        const m2 = makeMutator('b', [{ code: 'v3', line: 3, col: 0 }]);
+        const result = generateMutationVariants([m1, m2], 'code', { max: 2 });
+        expect(result).toHaveLength(2);
+        expect(result.every((v) => v.name === 'a')).toBe(true);
+    });
+    // NOTE: The outer loop `break` (variant-utils.ts line 42) is dead code.
+    // The inner loop always `return`s immediately when max is reached after adding
+    // a new unique variant, so the outer loop check can never fire.
+    // Same applies to sfc.ts line 43.
+    it('works with undefined max', () => {
+        const mutator = makeMutator('m', [
+            { code: 'v1', line: 1, col: 0 },
+            { code: 'v2', line: 2, col: 0 },
+        ]);
+        const result = generateMutationVariants([mutator], 'code', {});
+        expect(result).toHaveLength(2);
+    });
+});
+describe('getFilteredRegistry', () => {
+    it('returns the full registry when no filters', () => {
+        const result = getFilteredRegistry();
+        expect(result.length).toBeGreaterThan(0);
+        expect(result[0]).toHaveProperty('name');
+        expect(result[0]).toHaveProperty('apply');
+    });
+    it('filters by include', () => {
+        const result = getFilteredRegistry(['flipEQ', 'andToOr']);
+        expect(result.map((r) => r.name)).toEqual(['andToOr', 'flipEQ']);
+    });
+    it('filters by exclude', () => {
+        const all = getFilteredRegistry();
+        const result = getFilteredRegistry(undefined, ['flipEQ']);
+        expect(result.length).toBe(all.length - 1);
+        expect(result.find((r) => r.name === 'flipEQ')).toBeUndefined();
+    });
+});

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

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

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

@@ -0,0 +1,225 @@
+import { describe, it, expect } from 'vitest';
+import { parseFlagNumber, readNumberFlag, readStringFlag, validatePercent, parseConcurrency, parseProgressMode, parseCliOptions, extractConfigPath, } from '../args.js';
+describe('parseFlagNumber', () => {
+    it('parses valid integers', () => {
+        expect(parseFlagNumber('42', '--flag')).toBe(42);
+    });
+    it('parses valid floats', () => {
+        expect(parseFlagNumber('3.14', '--flag')).toBe(3.14);
+    });
+    it('parses zero', () => {
+        expect(parseFlagNumber('0', '--flag')).toBe(0);
+    });
+    it('parses negative numbers', () => {
+        expect(parseFlagNumber('-5', '--flag')).toBe(-5);
+    });
+    it('throws on non-numeric strings', () => {
+        expect(() => parseFlagNumber('abc', '--flag')).toThrow('Invalid value for --flag: abc');
+    });
+    it('parses empty string as 0', () => {
+        // Number('') === 0, which is finite
+        expect(parseFlagNumber('', '--flag')).toBe(0);
+    });
+    it('throws on NaN-producing values', () => {
+        expect(() => parseFlagNumber('not-a-number', '--flag')).toThrow('Invalid value for --flag: not-a-number');
+    });
+    it('throws on Infinity', () => {
+        expect(() => parseFlagNumber('Infinity', '--flag')).toThrow('Invalid value for --flag: Infinity');
+    });
+});
+describe('readNumberFlag', () => {
+    it('reads flag with separate value', () => {
+        expect(readNumberFlag(['--count', '5'], '--count')).toBe(5);
+    });
+    it('reads flag with = syntax', () => {
+        expect(readNumberFlag(['--count=10'], '--count')).toBe(10);
+    });
+    it('returns undefined when flag is not present', () => {
+        expect(readNumberFlag(['--other', '5'], '--count')).toBeUndefined();
+    });
+    it('throws when no value follows flag', () => {
+        expect(() => readNumberFlag(['--count'], '--count')).toThrow('Expected a numeric value after --count');
+    });
+    it('throws when value is not a number', () => {
+        expect(() => readNumberFlag(['--count', 'abc'], '--count')).toThrow('Invalid value for --count: abc');
+    });
+});
+describe('readStringFlag', () => {
+    it('reads flag with separate value', () => {
+        expect(readStringFlag(['--config', 'path.ts'], '--config')).toBe('path.ts');
+    });
+    it('reads flag with = syntax', () => {
+        expect(readStringFlag(['--config=path.ts'], '--config')).toBe('path.ts');
+    });
+    it('reads alias', () => {
+        expect(readStringFlag(['-c', 'path.ts'], '--config', '-c')).toBe('path.ts');
+    });
+    it('reads alias with = syntax', () => {
+        expect(readStringFlag(['-c=path.ts'], '--config', '-c')).toBe('path.ts');
+    });
+    it('returns undefined when flag is not present', () => {
+        expect(readStringFlag(['--other', 'val'], '--config')).toBeUndefined();
+    });
+    it('throws when no value follows flag', () => {
+        expect(() => readStringFlag(['--config'], '--config')).toThrow('Expected a value after --config');
+    });
+    it('throws when no value follows alias', () => {
+        expect(() => readStringFlag(['-c'], '--config', '-c')).toThrow('Expected a value after -c');
+    });
+});
+describe('validatePercent', () => {
+    it('returns undefined for undefined', () => {
+        expect(validatePercent(undefined, 'test')).toBeUndefined();
+    });
+    it('returns the value for valid percentages', () => {
+        expect(validatePercent(0, 'test')).toBe(0);
+        expect(validatePercent(50, 'test')).toBe(50);
+        expect(validatePercent(100, 'test')).toBe(100);
+    });
+    it('throws for negative values', () => {
+        expect(() => validatePercent(-1, 'test')).toThrow('Invalid test: expected value between 0 and 100 (received -1)');
+    });
+    it('throws for values over 100', () => {
+        expect(() => validatePercent(101, 'test')).toThrow('Invalid test: expected value between 0 and 100 (received 101)');
+    });
+    it('throws for non-finite values', () => {
+        expect(() => validatePercent(NaN, 'test')).toThrow('Invalid test: expected a number between 0 and 100');
+        expect(() => validatePercent(Infinity, 'test')).toThrow('Invalid test: expected a number between 0 and 100');
+    });
+});
+describe('parseConcurrency', () => {
+    it('returns default when flag not present', () => {
+        const result = parseConcurrency([]);
+        expect(result).toBeGreaterThanOrEqual(1);
+    });
+    it('parses explicit concurrency', () => {
+        expect(parseConcurrency(['--concurrency', '4'])).toBe(4);
+    });
+    it('clamps to minimum of 1', () => {
+        expect(parseConcurrency(['--concurrency', '0'])).toBeGreaterThanOrEqual(1);
+    });
+    it('handles invalid concurrency value gracefully', () => {
+        const result = parseConcurrency(['--concurrency', 'abc']);
+        expect(result).toBeGreaterThanOrEqual(1);
+    });
+});
+describe('parseProgressMode', () => {
+    it('returns bar by default', () => {
+        expect(parseProgressMode([])).toBe('bar');
+    });
+    it('returns list when specified', () => {
+        expect(parseProgressMode(['--progress', 'list'])).toBe('list');
+    });
+    it('returns quiet when specified', () => {
+        expect(parseProgressMode(['--progress', 'quiet'])).toBe('quiet');
+    });
+    it('returns bar for unknown values', () => {
+        expect(parseProgressMode(['--progress', 'unknown'])).toBe('bar');
+    });
+    it('defaults to bar when --progress has no following value', () => {
+        expect(parseProgressMode(['--progress'])).toBe('bar');
+    });
+});
+describe('parseCliOptions', () => {
+    const emptyCfg = {};
+    it('parses --changed flag', () => {
+        const opts = parseCliOptions(['--changed'], emptyCfg);
+        expect(opts.wantsChanged).toBe(true);
+        expect(opts.wantsChangedWithDeps).toBe(false);
+    });
+    it('parses --changed-with-deps flag', () => {
+        const opts = parseCliOptions(['--changed-with-deps'], emptyCfg);
+        expect(opts.wantsChangedWithDeps).toBe(true);
+    });
+    it('parses --only-covered-lines flag', () => {
+        const opts = parseCliOptions(['--only-covered-lines'], emptyCfg);
+        expect(opts.wantsOnlyCoveredLines).toBe(true);
+    });
+    it('reads onlyCoveredLines from config', () => {
+        const opts = parseCliOptions([], { onlyCoveredLines: true });
+        expect(opts.wantsOnlyCoveredLines).toBe(true);
+    });
+    it('parses --per-test-coverage flag', () => {
+        const opts = parseCliOptions(['--per-test-coverage'], emptyCfg);
+        expect(opts.wantsPerTestCoverage).toBe(true);
+    });
+    it('reads perTestCoverage from config', () => {
+        const opts = parseCliOptions([], { perTestCoverage: true });
+        expect(opts.wantsPerTestCoverage).toBe(true);
+    });
+    it('parses --coverage-file flag', () => {
+        const opts = parseCliOptions(['--coverage-file', 'coverage.json'], emptyCfg);
+        expect(opts.coverageFilePath).toBe('coverage.json');
+    });
+    it('reads coverageFile from config', () => {
+        const opts = parseCliOptions([], { coverageFile: 'cov.json' });
+        expect(opts.coverageFilePath).toBe('cov.json');
+    });
+    it('CLI coverage-file takes precedence over config', () => {
+        const opts = parseCliOptions(['--coverage-file', 'cli.json'], {
+            coverageFile: 'config.json',
+        });
+        expect(opts.coverageFilePath).toBe('cli.json');
+    });
+    it('parses --runner vitest', () => {
+        const opts = parseCliOptions(['--runner', 'vitest'], emptyCfg);
+        expect(opts.runner).toBe('vitest');
+    });
+    it('parses --runner jest', () => {
+        const opts = parseCliOptions(['--runner', 'jest'], emptyCfg);
+        expect(opts.runner).toBe('jest');
+    });
+    it('falls back to config runner', () => {
+        const opts = parseCliOptions([], { runner: 'jest' });
+        expect(opts.runner).toBe('jest');
+    });
+    it('defaults to vitest', () => {
+        const opts = parseCliOptions([], emptyCfg);
+        expect(opts.runner).toBe('vitest');
+    });
+    it('parses --config flag', () => {
+        const opts = parseCliOptions(['--config', 'my.config.ts'], emptyCfg);
+        expect(opts.configPath).toBe('my.config.ts');
+    });
+    it('parses -c alias', () => {
+        const opts = parseCliOptions(['-c', 'my.config.ts'], emptyCfg);
+        expect(opts.configPath).toBe('my.config.ts');
+    });
+    it('parses --min-kill-percent from CLI', () => {
+        const opts = parseCliOptions(['--min-kill-percent', '80'], emptyCfg);
+        expect(opts.minKillPercent).toBe(80);
+    });
+    it('reads minKillPercent from config', () => {
+        const opts = parseCliOptions([], { minKillPercent: 75 });
+        expect(opts.minKillPercent).toBe(75);
+    });
+    it('CLI min-kill-percent takes precedence over config', () => {
+        const opts = parseCliOptions(['--min-kill-percent', '90'], {
+            minKillPercent: 75,
+        });
+        expect(opts.minKillPercent).toBe(90);
+    });
+    it('rejects invalid --min-kill-percent', () => {
+        expect(() => parseCliOptions(['--min-kill-percent', '150'], emptyCfg)).toThrow('expected value between 0 and 100');
+    });
+});
+describe('extractConfigPath', () => {
+    it('extracts --config with separate value', () => {
+        expect(extractConfigPath(['--config', 'my.config.ts'])).toBe('my.config.ts');
+    });
+    it('extracts --config with = syntax', () => {
+        expect(extractConfigPath(['--config=my.config.ts'])).toBe('my.config.ts');
+    });
+    it('extracts -c alias with separate value', () => {
+        expect(extractConfigPath(['-c', 'my.config.ts'])).toBe('my.config.ts');
+    });
+    it('extracts -c alias with = syntax', () => {
+        expect(extractConfigPath(['-c=my.config.ts'])).toBe('my.config.ts');
+    });
+    it('returns undefined when no config flag is present', () => {
+        expect(extractConfigPath(['--changed', '--runner', 'vitest'])).toBeUndefined();
+    });
+    it('returns undefined for empty args', () => {
+        expect(extractConfigPath([])).toBeUndefined();
+    });
+});

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

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