@boyingliu01/xp-gate 0.14.7 → 0.14.9

package/mutation/__tests__/init-baseline.test.ts

@@ -0,0 +1,347 @@
+/**
+ * @test init-baseline.ts - Mutation Baseline Initialization
+ * @intent Verify argument parsing, score calculation, baseline construction,
+ *         and source file filtering logic used by the init-baseline CLI script.
+ * @covers REQ-MUT-002 AC-001, AC-002, AC-003, AC-004
+ */
+
+import { describe, it, expect } from 'vitest';
+
+// ─── Inline copies of pure functions from init-baseline.ts ───────────────────
+// The module runs main() on import, so we cannot import it directly.
+// These are faithful copies of the pure logic for unit testing.
+// See gate-m.test.ts for the same pattern used in this project.
+
+interface MutantStatus {
+  id: string;
+  mutatorName: string;
+  replacement: string;
+  location: {
+    start: { line: number; column: number };
+    end: { line: number; column: number };
+  };
+  status: string;
+}
+
+interface StrykerFileReport {
+  source: string;
+  mutants: MutantStatus[];
+}
+
+interface StrykerReport {
+  schemaVersion: string;
+  thresholds: {
+    high: number;
+    low: number;
+    break: number | null;
+  };
+  files: Record<string, StrykerFileReport>;
+}
+
+interface MutationScoreEntry {
+  score: number;
+  mutants: number;
+  killed: number;
+  survived: number;
+}
+
+interface MutationBaseline {
+  version: string;
+  generatedAt: string;
+  source: 'local' | 'ci';
+  scores: Record<string, MutationScoreEntry>;
+}
+
+function parseArgs(args: string[]): { filesPattern: string; source: 'local' | 'ci' } {
+  let filesPattern = 'src/**/*.ts';
+  let source: 'local' | 'ci' = 'local';
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--files' && args[i + 1]) {
+      filesPattern = args[i + 1];
+      i++;
+    }
+    if (args[i] === '--source' && args[i + 1]) {
+      source = args[i + 1] as 'local' | 'ci';
+      i++;
+    }
+  }
+
+  return { filesPattern, source };
+}
+
+function calculateScore(entry: StrykerFileReport): MutationScoreEntry {
+  const total = entry.mutants.length;
+  const killed = entry.mutants.filter(m => m.status === 'Killed').length;
+  const survived = entry.mutants.filter(m => m.status === 'Survived').length;
+
+  return {
+    score: total > 0 ? parseFloat(((killed / total) * 100).toFixed(1)) : 100,
+    mutants: total,
+    killed,
+    survived
+  };
+}
+
+function buildBaseline(
+  report: StrykerReport,
+  sourceFiles: string[],
+  source: 'local' | 'ci'
+): MutationBaseline {
+  const scores: Record<string, MutationScoreEntry> = {};
+
+  for (const [filePath, fileReport] of Object.entries(report.files)) {
+    const relativePath = filePath.replace(/^\//, '');
+    if (sourceFiles.includes(relativePath) || sourceFiles.some(sf => relativePath.endsWith(sf))) {
+      scores[relativePath] = calculateScore(fileReport);
+    }
+  }
+
+  return {
+    version: '1.0',
+    generatedAt: new Date().toISOString(),
+    source,
+    scores
+  };
+}
+
+function isSourceFile(file: string): boolean {
+  return (
+    file.endsWith('.ts') &&
+    !file.endsWith('.d.ts') &&
+    !file.endsWith('.test.ts') &&
+    !file.includes('/__tests__/') &&
+    !file.includes('/adapters/')
+  );
+}
+
+// ─── Helper factories ────────────────────────────────────────────────────────
+
+function makeMutant(status: string, id = '0'): MutantStatus {
+  return {
+    id,
+    mutatorName: 'BlockMutator',
+    replacement: '{}',
+    location: {
+      start: { line: 1, column: 0 },
+      end: { line: 1, column: 10 }
+    },
+    status
+  };
+}
+
+function makeFileReport(mutants: MutantStatus[]): StrykerFileReport {
+  return { source: 'const x = 1;', mutants };
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe('parseArgs', () => {
+  it('returns defaults when no arguments provided', () => {
+    const result = parseArgs([]);
+    expect(result.filesPattern).toBe('src/**/*.ts');
+    expect(result.source).toBe('local');
+  });
+
+  it('parses --files flag', () => {
+    const result = parseArgs(['--files', 'lib/**/*.ts']);
+    expect(result.filesPattern).toBe('lib/**/*.ts');
+    expect(result.source).toBe('local');
+  });
+
+  it('parses --source flag', () => {
+    const result = parseArgs(['--source', 'ci']);
+    expect(result.filesPattern).toBe('src/**/*.ts');
+    expect(result.source).toBe('ci');
+  });
+
+  it('parses both --files and --source flags', () => {
+    const result = parseArgs(['--files', 'app/**/*.ts', '--source', 'ci']);
+    expect(result.filesPattern).toBe('app/**/*.ts');
+    expect(result.source).toBe('ci');
+  });
+
+  it('ignores --files without a following value', () => {
+    const result = parseArgs(['--files']);
+    expect(result.filesPattern).toBe('src/**/*.ts');
+  });
+
+  it('ignores unknown flags', () => {
+    const result = parseArgs(['--verbose', '--dry-run']);
+    expect(result.filesPattern).toBe('src/**/*.ts');
+    expect(result.source).toBe('local');
+  });
+});
+
+describe('calculateScore', () => {
+  it('returns 100 score when no mutants exist', () => {
+    const entry = makeFileReport([]);
+    const result = calculateScore(entry);
+    expect(result.score).toBe(100);
+    expect(result.mutants).toBe(0);
+    expect(result.killed).toBe(0);
+    expect(result.survived).toBe(0);
+  });
+
+  it('calculates score from killed and total mutants', () => {
+    const entry = makeFileReport([
+      makeMutant('Killed', '0'),
+      makeMutant('Killed', '1'),
+      makeMutant('Survived', '2'),
+      makeMutant('Survived', '3')
+    ]);
+    const result = calculateScore(entry);
+    expect(result.mutants).toBe(4);
+    expect(result.killed).toBe(2);
+    expect(result.survived).toBe(2);
+    expect(result.score).toBe(50);
+  });
+
+  it('returns 100 score when all mutants are killed', () => {
+    const entry = makeFileReport([
+      makeMutant('Killed', '0'),
+      makeMutant('Killed', '1'),
+      makeMutant('Killed', '2')
+    ]);
+    const result = calculateScore(entry);
+    expect(result.score).toBe(100);
+    expect(result.killed).toBe(3);
+    expect(result.survived).toBe(0);
+  });
+
+  it('returns 0 score when all mutants survived', () => {
+    const entry = makeFileReport([
+      makeMutant('Survived', '0'),
+      makeMutant('Survived', '1')
+    ]);
+    const result = calculateScore(entry);
+    expect(result.score).toBe(0);
+    expect(result.killed).toBe(0);
+    expect(result.survived).toBe(2);
+  });
+
+  it('ignores non-Killed/Survived statuses in killed/survived counts', () => {
+    const entry = makeFileReport([
+      makeMutant('Killed', '0'),
+      makeMutant('NoCoverage', '1'),
+      makeMutant('RuntimeError', '2'),
+      makeMutant('Survived', '3')
+    ]);
+    const result = calculateScore(entry);
+    expect(result.mutants).toBe(4);
+    expect(result.killed).toBe(1);
+    expect(result.survived).toBe(1);
+    expect(result.score).toBe(25);
+  });
+
+  it('rounds score to one decimal place', () => {
+    const entry = makeFileReport([
+      makeMutant('Killed', '0'),
+      makeMutant('Killed', '1'),
+      makeMutant('Survived', '2')
+    ]);
+    const result = calculateScore(entry);
+    // 2/3 * 100 = 66.666... → 66.7
+    expect(result.score).toBe(66.7);
+  });
+});
+
+describe('buildBaseline', () => {
+  const emptyReport: StrykerReport = {
+    schemaVersion: '1.0',
+    thresholds: { high: 80, low: 60, break: null },
+    files: {}
+  };
+
+  it('returns empty scores when report has no files', () => {
+    const baseline = buildBaseline(emptyReport, [], 'local');
+    expect(baseline.version).toBe('1.0');
+    expect(baseline.source).toBe('local');
+    expect(baseline.scores).toEqual({});
+    expect(baseline.generatedAt).toBeDefined();
+  });
+
+  it('includes only source files in baseline scores', () => {
+    const report: StrykerReport = {
+      schemaVersion: '1.0',
+      thresholds: { high: 80, low: 60, break: null },
+      files: {
+        'src/auth.ts': makeFileReport([makeMutant('Killed', '0')]),
+        'src/utils.ts': makeFileReport([makeMutant('Survived', '0')]),
+        'dist/bundle.js': makeFileReport([makeMutant('Killed', '0')])
+      }
+    };
+    const sourceFiles = ['src/auth.ts', 'src/utils.ts'];
+    const baseline = buildBaseline(report, sourceFiles, 'ci');
+    expect(Object.keys(baseline.scores)).toHaveLength(2);
+    expect(baseline.scores['src/auth.ts']).toBeDefined();
+    expect(baseline.scores['src/utils.ts']).toBeDefined();
+    expect(baseline.scores['dist/bundle.js']).toBeUndefined();
+    expect(baseline.source).toBe('ci');
+  });
+
+  it('strips leading slash from file paths', () => {
+    const report: StrykerReport = {
+      schemaVersion: '1.0',
+      thresholds: { high: 80, low: 60, break: null },
+      files: {
+        '/src/auth.ts': makeFileReport([makeMutant('Killed', '0')])
+      }
+    };
+    const sourceFiles = ['src/auth.ts'];
+    const baseline = buildBaseline(report, sourceFiles, 'local');
+    expect(baseline.scores['src/auth.ts']).toBeDefined();
+  });
+
+  it('matches files by suffix when exact match fails', () => {
+    const report: StrykerReport = {
+      schemaVersion: '1.0',
+      thresholds: { high: 80, low: 60, break: null },
+      files: {
+        'packages/core/src/auth.ts': makeFileReport([makeMutant('Killed', '0')])
+      }
+    };
+    const sourceFiles = ['src/auth.ts'];
+    const baseline = buildBaseline(report, sourceFiles, 'local');
+    expect(baseline.scores['packages/core/src/auth.ts']).toBeDefined();
+  });
+
+  it('sets generatedAt to a valid ISO date string', () => {
+    const baseline = buildBaseline(emptyReport, [], 'local');
+    const parsed = new Date(baseline.generatedAt);
+    expect(parsed.toISOString()).toBe(baseline.generatedAt);
+  });
+});
+
+describe('isSourceFile (getSourceFiles filter predicate)', () => {
+  it('accepts regular .ts files', () => {
+    expect(isSourceFile('src/auth.ts')).toBe(true);
+    expect(isSourceFile('src/utils/helper.ts')).toBe(true);
+  });
+
+  it('rejects .d.ts declaration files', () => {
+    expect(isSourceFile('src/types.d.ts')).toBe(false);
+    expect(isSourceFile('src/global.d.ts')).toBe(false);
+  });
+
+  it('rejects .test.ts files', () => {
+    expect(isSourceFile('src/auth.test.ts')).toBe(false);
+    expect(isSourceFile('src/utils/helper.test.ts')).toBe(false);
+  });
+
+  it('rejects files in __tests__ directories', () => {
+    expect(isSourceFile('src/__tests__/auth.test.ts')).toBe(false);
+    expect(isSourceFile('src/__tests__/helpers.ts')).toBe(false);
+  });
+
+  it('rejects files in adapters directories', () => {
+    expect(isSourceFile('githooks/adapters/typescript.sh')).toBe(false);
+    expect(isSourceFile('src/adapters/go.ts')).toBe(false);
+  });
+
+  it('rejects non-.ts files', () => {
+    expect(isSourceFile('src/index.js')).toBe(false);
+    expect(isSourceFile('src/style.css')).toBe(false);
+    expect(isSourceFile('README.md')).toBe(false);
+  });
+});