@boyingliu01/xp-gate 0.11.2 → 0.11.4

package/mutation/__tests__/pitest-runner.test.ts

@@ -0,0 +1,574 @@
+/**
+ * @test REQ-MUT-006 PITest mutation runner
+ * @intent Verify PitestRunner registration, availability checks, Maven/Gradle branch routing, and JSON report parsing
+ * @covers AC-MUT-006, AC-MUT-007
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { execSync, spawn, type ChildProcess } from 'child_process';
+import { mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+vi.mock('child_process', () => ({
+  execSync: vi.fn(),
+  spawn: vi.fn(),
+  spawnSync: vi.fn(),
+}));
+
+vi.mock('fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('fs')>();
+  return {
+    ...actual,
+    readFileSync: vi.fn((_path: string, _encoding?: string) => {
+      return '';
+    }),
+    existsSync: vi.fn((_path: string) => {
+      return false;
+    }),
+    readdirSync: vi.fn(() => []),
+    mkdirSync: vi.fn(),
+  };
+});
+
+describe('PitestRunner', () => {
+  let PitestRunner: typeof import('../runners/pitest-runner').PitestRunner;
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    tmpDir = join(tmpdir(), `xp-gate-pitest-test-${Date.now()}`);
+    mkdirSync(tmpDir, { recursive: true });
+    PitestRunner = (await import('../runners/pitest-runner')).PitestRunner;
+  });
+
+  afterEach(() => {
+    try { process.kill(process.pid, 0); } catch { /* noop */ }
+  });
+
+  describe('name and extensions', () => {
+    it('should have name "pitest"', () => {
+      const runner = new PitestRunner();
+      expect(runner.name).toBe('pitest');
+    });
+
+    it('should handle .java, .kt, and .kts extensions', () => {
+      const runner = new PitestRunner();
+      expect(runner.extensions).toContain('java');
+      expect(runner.extensions).toContain('kt');
+      expect(runner.extensions).toContain('kts');
+      expect(runner.extensions).not.toContain('ts');
+      expect(runner.extensions).not.toContain('py');
+    });
+  });
+
+  describe('isAvailable', () => {
+    it('should return false when neither Maven nor Gradle is available', async () => {
+      vi.mocked(execSync).mockImplementation(() => {
+        throw new Error('ENOENT');
+      });
+
+      const runner = new PitestRunner();
+      const result = await runner.isAvailable();
+      expect(result).toBe(false);
+    });
+
+    it('should return true when Maven is available and pom.xml has pitest-maven', async () => {
+      const { existsSync, readFileSync } = await import('fs');
+      vi.mocked(execSync).mockReturnValueOnce(Buffer.from('Apache Maven 3.9.0'));
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(readFileSync).mockReturnValue(
+        '<project><build><plugins><plugin><groupId>org.pitest</groupId><artifactId>pitest-maven</artifactId></plugin></plugins></build></project>',
+      );
+
+      const runner = new PitestRunner();
+      const result = await runner.isAvailable();
+      expect(result).toBe(true);
+      expect(execSync).toHaveBeenCalledWith('mvn --version', expect.any(Object));
+    });
+
+    it('should return false when Maven is available but pom.xml lacks pitest plugin', async () => {
+      const { existsSync, readFileSync } = await import('fs');
+      vi.mocked(execSync).mockReturnValueOnce(Buffer.from('Apache Maven 3.9.0'));
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(readFileSync).mockReturnValue(
+        '<project><build><plugins></plugins></build></project>',
+      );
+
+      const runner = new PitestRunner();
+      const result = await runner.isAvailable();
+      expect(result).toBe(false);
+    });
+
+    it('should return true when Gradle is available and build.gradle has pitest plugin', async () => {
+      const { existsSync, readFileSync } = await import('fs');
+      vi.mocked(execSync)
+        .mockImplementationOnce(() => {
+          throw new Error('mvn not found');
+        })
+        .mockReturnValueOnce(Buffer.from('Gradle 8.5'));
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(readFileSync).mockReturnValue(
+        'plugins { id("info.solidsoft.pitest") version "1.15.0" }',
+      );
+
+      const runner = new PitestRunner();
+      const result = await runner.isAvailable();
+      expect(result).toBe(true);
+    });
+
+    it('should return true when ./gradlew exists with build.gradle.kts containing pitest plugin', async () => {
+      const { existsSync, readFileSync } = await import('fs');
+      vi.mocked(execSync)
+        .mockImplementationOnce(() => {
+          throw new Error('mvn not found');
+        });
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(readFileSync).mockReturnValue(
+        'plugins { id("info.solidsoft.gradle.pitest") version "1.15.0" }',
+      );
+
+      const runner = new PitestRunner();
+      const result = await runner.isAvailable();
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('run - Maven branch', () => {
+    it('should run PITest via Maven and parse JSON output', async () => {
+      const { existsSync, readFileSync, readdirSync } = await import('fs');
+
+      vi.mocked(execSync).mockReset();
+      vi.mocked(spawn).mockReset();
+      vi.mocked(existsSync).mockReset();
+      vi.mocked(readFileSync).mockReset();
+      vi.mocked(readdirSync).mockReset();
+
+      vi.mocked(execSync).mockImplementation(() => Buffer.from('Apache Maven 3.9.0'));
+      vi.mocked(existsSync).mockImplementation((p) => {
+        const path = String(p);
+        if (path.endsWith('pom.xml')) return true;
+        if (path.includes('pit-reports')) return true;
+        if (path.endsWith('mutations.json')) return true;
+        return false;
+      });
+      vi.mocked(readdirSync).mockReturnValue(['202506300000'] as unknown as ReturnType<typeof readdirSync>);
+      vi.mocked(readFileSync).mockReturnValue(JSON.stringify({
+        mutations: [
+          { status: 'KILLED', mutatedClass: 'com.example.Foo', sourceFile: 'Foo.java' },
+          { status: 'KILLED', mutatedClass: 'com.example.Foo', sourceFile: 'Foo.java' },
+          { status: 'SURVIVED', mutatedClass: 'com.example.Foo', sourceFile: 'Foo.java' },
+          { status: 'SURVIVED', mutatedClass: 'com.example.Bar', sourceFile: 'Bar.java' },
+          { status: 'NO_COVERAGE', mutatedClass: 'com.example.Baz', sourceFile: 'Baz.java' },
+        ],
+      }));
+
+      let closeCb: ((code: number | null) => void) | null = null;
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn((event, cb) => {
+          if (event === 'close') closeCb = cb;
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      const runner = new PitestRunner();
+      const promise = runner.run({
+        files: ['src/main/java/com/example/Foo.java'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      closeCb!(0);
+      const result = await promise;
+
+      expect(spawn).toHaveBeenCalledWith('mvn', [
+        'test-compile',
+        'org.pitest:pitest-maven:mutationCoverage',
+        '-DoutputFormats=JSON',
+      ], expect.objectContaining({ cwd: tmpDir }));
+
+      expect(result.timedOut).toBe(false);
+      expect(result.report).not.toBeNull();
+      expect(result.report!.mutationScore).toBe(40);
+      expect(result.report!.nrOfMutants).toBe(5);
+      expect(result.report!.nrOfKilledMutants).toBe(2);
+      expect(result.report!.nrOfSurvivedMutants).toBe(3);
+    });
+  });
+
+  describe('run - Gradle branch', () => {
+    it('should run PITest via Gradle and parse JSON output', async () => {
+      const { existsSync, readFileSync } = await import('fs');
+
+      vi.mocked(existsSync).mockReset();
+      vi.mocked(readFileSync).mockReset();
+      vi.mocked(spawn).mockReset();
+      vi.mocked(execSync).mockReset();
+
+      vi.mocked(existsSync).mockImplementation((p) => {
+        const path = String(p);
+        if (path.includes('pom.xml')) return false;
+        if (path.includes('build.gradle')) return true;
+        if (path.includes('gradlew')) return true;
+        if (path.includes('mutations.json')) return true;
+        return false;
+      });
+
+      let closeCb: ((code: number | null) => void) | null = null;
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn((event, cb) => {
+          if (event === 'close') closeCb = cb;
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      vi.mocked(readFileSync).mockReturnValue(JSON.stringify({
+        mutations: [
+          { status: 'KILLED', mutatedClass: 'com.example.Foo', sourceFile: 'Foo.kt' },
+          { status: 'KILLED', mutatedClass: 'com.example.Foo', sourceFile: 'Foo.kt' },
+          { status: 'KILLED', mutatedClass: 'com.example.Foo', sourceFile: 'Foo.kt' },
+          { status: 'SURVIVED', mutatedClass: 'com.example.Foo', sourceFile: 'Foo.kt' },
+        ],
+      }));
+
+      const runner = new PitestRunner();
+      const promise = runner.run({
+        files: ['src/main/kotlin/com/example/Foo.kt'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      closeCb!(0);
+      const result = await promise;
+
+      expect(spawn).toHaveBeenCalledWith(join(tmpDir, 'gradlew'), ['pitest'], {
+        cwd: tmpDir,
+        stdio: 'pipe',
+        shell: false,
+      });
+      expect(result.timedOut).toBe(false);
+      expect(result.report).not.toBeNull();
+      expect(result.report!.mutationScore).toBe(75);
+    });
+
+    it('should use gradle (not ./gradlew) when gradlew does not exist', async () => {
+      const { existsSync, readFileSync } = await import('fs');
+
+      vi.mocked(execSync).mockReturnValueOnce(Buffer.from('Gradle 8.5'));
+      vi.mocked(existsSync).mockImplementation((p) => {
+        const path = String(p);
+        if (path.includes('pom.xml')) return false;
+        if (path.includes('build.gradle')) return true;
+        if (path.includes('gradlew')) return false;
+        if (path.includes('mutations.json')) return true;
+        return false;
+      });
+
+      let closeCb: ((code: number | null) => void) | null = null;
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn((event, cb) => {
+          if (event === 'close') closeCb = cb;
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      vi.mocked(readFileSync).mockReturnValue(JSON.stringify({
+        mutations: [
+          { status: 'KILLED', mutatedClass: 'com.example.Foo', sourceFile: 'Foo.java' },
+        ],
+      }));
+
+      const runner = new PitestRunner();
+      const promise = runner.run({
+        files: ['src/main/java/com/example/Foo.java'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      closeCb!(0);
+      const result = await promise;
+
+      expect(spawn).toHaveBeenCalledWith('gradle', ['pitest'], expect.objectContaining({ cwd: tmpDir }));
+      expect(result.report).not.toBeNull();
+      expect(result.report!.mutationScore).toBe(100);
+    });
+  });
+
+  describe('run - error handling', () => {
+    it('should return error when no build tool is available', async () => {
+      const { existsSync } = await import('fs');
+      vi.mocked(existsSync).mockReturnValue(false);
+      vi.mocked(execSync).mockImplementation(() => {
+        throw new Error('ENOENT');
+      });
+
+      const runner = new PitestRunner();
+      const result = await runner.run({
+        files: ['src/main/java/Foo.java'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      expect(result.report).toBeNull();
+      expect(result.timedOut).toBe(false);
+      expect(result.error).toBeTruthy();
+      expect(result.error).toContain('No supported build tool');
+    });
+
+    it('should return timedOut=true when child process is killed by timeout', async () => {
+      const { existsSync } = await import('fs');
+
+      vi.mocked(execSync).mockReturnValueOnce(Buffer.from('Apache Maven 3.9.0'));
+      vi.mocked(existsSync).mockImplementation((p) => {
+        const path = String(p);
+        if (path.includes('pom.xml')) return true;
+        return false;
+      });
+
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn((event, cb) => {
+          if (event === 'close') setTimeout(() => cb(null), 10);
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      const runner = new PitestRunner();
+      const result = await runner.run({
+        files: ['src/main/java/Foo.java'],
+        timeoutMs: 100,
+        cwd: tmpDir,
+      });
+
+      expect(result.timedOut).toBe(true);
+      expect(result.report).toBeNull();
+    });
+
+    it('should return error when spawn fails', async () => {
+      const { existsSync } = await import('fs');
+
+      vi.mocked(execSync).mockReturnValueOnce(Buffer.from('Apache Maven 3.9.0'));
+      vi.mocked(existsSync).mockImplementation((p) => {
+        const path = String(p);
+        if (path.includes('pom.xml')) return true;
+        return false;
+      });
+
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn((event, cb) => {
+          if (event === 'error') setTimeout(() => cb(new Error('spawn ENOENT')), 10);
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      const runner = new PitestRunner();
+      const result = await runner.run({
+        files: ['src/main/java/Foo.java'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      expect(result.report).toBeNull();
+      expect(result.timedOut).toBe(false);
+      expect(result.error).toBe('spawn ENOENT');
+    });
+
+    it('should return null report when mutations.json does not exist', async () => {
+      const { existsSync } = await import('fs');
+
+      vi.mocked(execSync).mockReturnValueOnce(Buffer.from('Apache Maven 3.9.0'));
+      vi.mocked(existsSync).mockImplementation((p) => {
+        const path = String(p);
+        if (path.includes('pom.xml')) return true;
+        if (path.includes('pit-reports') && !path.includes('mutations.json')) return true;
+        if (path.includes('mutations.json')) return false;
+        return false;
+      });
+
+      let closeCb: ((code: number | null) => void) | null = null;
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn((event, cb) => {
+          if (event === 'close') closeCb = cb;
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      const runner = new PitestRunner();
+      const promise = runner.run({
+        files: ['src/main/java/Foo.java'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      closeCb!(0);
+      const result = await promise;
+
+      expect(result.report).toBeNull();
+      expect(result.timedOut).toBe(false);
+    });
+
+    it('should return error string when Maven exits with non-zero code', async () => {
+      const { existsSync, readFileSync, readdirSync } = await import('fs');
+
+      vi.mocked(execSync).mockReturnValueOnce(Buffer.from('Apache Maven 3.9.0'));
+      vi.mocked(existsSync).mockImplementation((p) => {
+        const path = String(p);
+        if (path.includes('pom.xml')) return true;
+        if (path.includes('mutations.json')) return true;
+        if (path.includes('pit-reports')) return true;
+        return false;
+      });
+      vi.mocked(readdirSync).mockReturnValue(['202506300000'] as unknown as ReturnType<typeof readdirSync>);
+      vi.mocked(readFileSync).mockReturnValue(JSON.stringify({
+        mutations: [
+          { status: 'KILLED', mutatedClass: 'com.example.Foo', sourceFile: 'Foo.java' },
+        ],
+      }));
+
+      let stderrCalled = false;
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: {
+          on: vi.fn((_event: string, cb: (d: Buffer) => void) => {
+            if (!stderrCalled) {
+              stderrCalled = true;
+              cb(Buffer.from('Build failed: compilation error'));
+            }
+          }),
+        },
+        on: vi.fn((event, cb) => {
+          if (event === 'close') cb(1);
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      const runner = new PitestRunner();
+      const result = await runner.run({
+        files: ['src/main/java/Foo.java'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      expect(result.timedOut).toBe(false);
+      expect(result.report).not.toBeNull();
+      expect(result.error).toBeTruthy();
+      expect(result.error).toContain('Build failed');
+    });
+
+    it('should return null report when JSON is unparseable', async () => {
+      const { existsSync, readFileSync } = await import('fs');
+
+      vi.mocked(execSync).mockReturnValueOnce(Buffer.from('Apache Maven 3.9.0'));
+      vi.mocked(existsSync).mockImplementation((p) => {
+        const path = String(p);
+        if (path.includes('pom.xml')) return true;
+        if (path.includes('mutations.json')) return true;
+        if (path.includes('pit-reports')) return true;
+        return false;
+      });
+      vi.mocked(readFileSync).mockReturnValue('not valid json {{{');
+
+      let closeCb: ((code: number | null) => void) | null = null;
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn((event, cb) => {
+          if (event === 'close') closeCb = cb;
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      const runner = new PitestRunner();
+      const promise = runner.run({
+        files: ['src/main/java/Foo.java'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      closeCb!(0);
+      const result = await promise;
+
+      expect(result.report).toBeNull();
+      expect(result.timedOut).toBe(false);
+    });
+
+    it('should return null report when mutations array is empty', async () => {
+      const { existsSync, readFileSync } = await import('fs');
+
+      vi.mocked(execSync).mockReturnValueOnce(Buffer.from('Apache Maven 3.9.0'));
+      vi.mocked(existsSync).mockImplementation((p) => {
+        const path = String(p);
+        if (path.includes('pom.xml')) return true;
+        if (path.includes('mutations.json')) return true;
+        if (path.includes('pit-reports')) return true;
+        return false;
+      });
+      vi.mocked(readFileSync).mockReturnValue(JSON.stringify({
+        mutations: [],
+      }));
+
+      let closeCb: ((code: number | null) => void) | null = null;
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn((event, cb) => {
+          if (event === 'close') closeCb = cb;
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      const runner = new PitestRunner();
+      const promise = runner.run({
+        files: ['src/main/java/Foo.java'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      closeCb!(0);
+      const result = await promise;
+
+      expect(result.report).toBeNull();
+      expect(result.timedOut).toBe(false);
+    });
+  });
+
+  describe('registration', () => {
+    it('should register in runnerRegistry via registerAllRunners', async () => {
+      const { runnerRegistry, registerAllRunners } = await import('../runners');
+      registerAllRunners();
+      const runner = runnerRegistry.get('pitest');
+      expect(runner).toBeDefined();
+      expect(runner!.name).toBe('pitest');
+      expect(runner!.extensions).toContain('java');
+    });
+  });
+});