@dommaker/harness 0.13.0 → 0.13.2

package/src/__tests__/passes-gate-extra.test.ts

@@ -0,0 +1,238 @@
+/**
+ * PassesGate 补充测试 - 覆盖重试逻辑和 runTests
+ */
+
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from '@jest/globals';
+import { PassesGate, createPassesGate } from '../core/validators/passes-gate';
+import { mkdirSync, rmSync, writeFileSync, existsSync, mkdir } from 'fs';
+import { join } from 'path';
+
+describe('PassesGate - 补充覆盖', () => {
+  const tempDir = join(process.cwd(), 'temp-test-passes-extra');
+  let gate: PassesGate;
+
+  beforeAll(() => {
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  beforeEach(() => {
+    gate = createPassesGate({
+      enabled: true,
+      testCommand: 'npm test',
+      requireEvidence: false,
+      maxRetries: 1,
+      retryDelay: 100,
+    });
+  });
+
+  describe('runTests', () => {
+    // runTests 方法会实际执行测试命令，在测试环境中跳过
+    // 这些测试在 passes-gate.test.ts 中已经有类似覆盖
+    it.skip('应该返回测试结果统计', async () => {
+      // 这个测试会实际运行 npm test，在 CI 环境中可能超时
+    });
+  });
+
+  describe('setPasses 重试逻辑', () => {
+    it('测试失败应该返回不允许', async () => {
+      // 创建会失败的测试命令
+      writeFileSync(join(tempDir, 'package.json'), JSON.stringify({
+        name: 'fail-project',
+        scripts: { test: 'exit 1' },
+      }));
+
+      const failGate = createPassesGate({
+        enabled: true,
+        testCommand: 'npm test',
+        maxRetries: 0,
+        retryDelay: 10,
+      });
+
+      const result = await failGate.setPasses('fail-task', true, tempDir);
+      
+      expect(result.allowed).toBe(false);
+      expect(result.attempts).toBeGreaterThan(0);
+      expect(result.error).toBeDefined();
+    });
+
+    it('证据不存在应该返回不允许', async () => {
+      writeFileSync(join(tempDir, 'package.json'), JSON.stringify({
+        name: 'evidence-project',
+        scripts: { test: 'echo "1 passed"' },
+      }));
+
+      const evidenceGate = createPassesGate({
+        enabled: true,
+        testCommand: 'npm test',
+        requireEvidence: true,
+      });
+
+      const result = await evidenceGate.setPasses('evidence-task', true, tempDir);
+      
+      // 证据会自动生成在 .agent/evidence 目录
+      // requireEvidence=true 时需要验证证据存在
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('checkTestFileChanges', () => {
+    it('应该检测测试文件变更', async () => {
+      const changes = await gate.checkTestFileChanges(tempDir);
+      
+      expect(Array.isArray(changes)).toBe(true);
+    });
+  });
+
+  describe('getExtensionNames', () => {
+    it('初始应该为空数组', () => {
+      const names = gate.getExtensionNames();
+      expect(names).toEqual([]);
+    });
+
+    it('注册扩展后应该返回名称', () => {
+      gate.registerExtension('puppeteer', {
+        name: 'puppeteer',
+        run: async () => ({
+          passed: true,
+          command: 'puppeteer',
+          timestamp: new Date(),
+        }),
+      });
+
+      expect(gate.getExtensionNames()).toContain('puppeteer');
+      
+      gate.unregisterExtension('puppeteer');
+    });
+  });
+
+  describe('unregisterExtension', () => {
+    it('注销不存在扩展应该返回 false', () => {
+      expect(gate.unregisterExtension('nonexistent')).toBe(false);
+    });
+
+    it('注销已注册扩展应该返回 true', () => {
+      gate.registerExtension('temp', {
+        name: 'temp',
+        run: async () => ({ passed: true, command: 'temp', timestamp: new Date() }),
+      });
+
+      expect(gate.unregisterExtension('temp')).toBe(true);
+    });
+  });
+
+  describe('runAllTests', () => {
+    it('应该运行单元测试和扩展测试', async () => {
+      writeFileSync(join(tempDir, 'package.json'), JSON.stringify({
+        name: 'multi-test',
+        scripts: { test: 'echo "1 passed"' },
+      }));
+
+      gate.registerExtension('mock-ext', {
+        name: 'mock-ext',
+        run: async () => ({
+          passed: true,
+          command: 'mock-ext',
+          timestamp: new Date(),
+        }),
+      });
+
+      const results = await gate.runAllTests(tempDir);
+      
+      expect(results.length).toBeGreaterThan(0);
+      expect(results.some(r => r.type === 'mock-ext')).toBe(true);
+      
+      gate.unregisterExtension('mock-ext');
+    });
+
+    it('扩展失败应该返回失败结果', async () => {
+      writeFileSync(join(tempDir, 'package.json'), JSON.stringify({
+        name: 'ext-fail',
+        scripts: { test: 'echo "1 passed"' },
+      }));
+
+      gate.registerExtension('fail-ext', {
+        name: 'fail-ext',
+        run: async () => ({
+          passed: false,
+          command: 'fail-ext',
+          error: 'Extension failed',
+          timestamp: new Date(),
+        }),
+      });
+
+      const results = await gate.runAllTests(tempDir);
+      
+      expect(results.some(r => !r.passed)).toBe(true);
+      
+      gate.unregisterExtension('fail-ext');
+    });
+
+    it('扩展抛异常应该捕获', async () => {
+      writeFileSync(join(tempDir, 'package.json'), JSON.stringify({
+        name: 'ext-error',
+        scripts: { test: 'echo "1 passed"' },
+      }));
+
+      gate.registerExtension('error-ext', {
+        name: 'error-ext',
+        run: async () => {
+          throw new Error('Extension error');
+        },
+      });
+
+      const results = await gate.runAllTests(tempDir);
+      
+      expect(results.some(r => r.type === 'error-ext' && !r.passed)).toBe(true);
+      
+      gate.unregisterExtension('error-ext');
+    });
+  });
+
+  describe('checkAllPasses', () => {
+    it('所有测试通过应该返回 passed=true', async () => {
+      writeFileSync(join(tempDir, 'package.json'), JSON.stringify({
+        name: 'all-pass',
+        scripts: { test: 'echo "1 passed"' },
+      }));
+
+      gate.registerExtension('pass-ext', {
+        name: 'pass-ext',
+        run: async () => ({ passed: true, command: 'pass-ext', timestamp: new Date() }),
+      });
+
+      const { passed, failedTypes } = await gate.checkAllPasses(tempDir);
+      
+      expect(passed).toBe(true);
+      expect(failedTypes.length).toBe(0);
+      
+      gate.unregisterExtension('pass-ext');
+    });
+
+    it('有失败测试应该返回 passed=false', async () => {
+      writeFileSync(join(tempDir, 'package.json'), JSON.stringify({
+        name: 'some-fail',
+        scripts: { test: 'echo "1 passed"' },
+      }));
+
+      gate.registerExtension('fail-ext', {
+        name: 'fail-ext',
+        run: async () => ({ passed: false, command: 'fail-ext', timestamp: new Date() }),
+      });
+
+      const { passed, failedTypes } = await gate.checkAllPasses(tempDir);
+      
+      expect(passed).toBe(false);
+      expect(failedTypes).toContain('fail-ext');
+      
+      gate.unregisterExtension('fail-ext');
+    });
+  });
+});

package/src/__tests__/passes-gate.test.ts

@@ -0,0 +1,231 @@
+/**
+ * PassesGate 测试
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
+import { PassesGate, createPassesGate } from '../core/validators/passes-gate';
+import { mkdirSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+describe('PassesGate', () => {
+  const tempDir = join(process.cwd(), 'temp-test-passes-gate');
+  let gate: PassesGate;
+
+  beforeAll(() => {
+    mkdirSync(tempDir, { recursive: true });
+    
+    // 创建简单的 package.json
+    writeFileSync(join(tempDir, 'package.json'), JSON.stringify({
+      name: 'test-project',
+      scripts: { test: 'echo "1 passed"' },
+    }));
+    
+    gate = createPassesGate({ enabled: true });
+  });
+
+  afterAll(() => {
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  describe('setPasses', () => {
+    it('设置为 false 应该直接允许', async () => {
+      const result = await gate.setPasses('task-1', false, tempDir);
+      
+      expect(result.allowed).toBe(true);
+      expect(result.testResult?.passed).toBe(false);
+    });
+
+    it('设置为 true 应该运行测试', async () => {
+      const result = await gate.setPasses('task-2', true, tempDir, {
+        id: 'task-2',
+      });
+      
+      // 测试命令是 echo "1 passed"，所以应该通过
+      expect(result.allowed).toBe(true);
+      expect(result.testResult?.command).toContain('npm test');
+    });
+
+    it('禁用时应该允许所有设置', async () => {
+      const disabledGate = createPassesGate({ enabled: false });
+      
+      const result = await disabledGate.setPasses('task-3', true, tempDir);
+      
+      expect(result.allowed).toBe(true);
+      expect(result.attempts).toBe(0);
+    });
+  });
+
+  describe('runTests', () => {
+    // 跳过：会调用真实测试套件，需要 mock 重构
+    it.skip('应该返回测试结果', async () => {
+      const result = await gate.runTests();
+      
+      expect(result).toBeDefined();
+      expect(result.passed).toBeDefined();
+      expect(result.duration).toBeGreaterThan(0);
+    });
+  });
+
+  describe('detectTestCommand', () => {
+    it('应该检测 npm test', async () => {
+      // package.json 有 test script
+      const result = await gate.setPasses('task-4', true, tempDir);
+      
+      expect(result.testResult?.command).toContain('npm');
+    });
+  });
+
+  describe('checkTestFileChanges', () => {
+    it('应该检测测试文件变更', async () => {
+      // 无 git 变更时返回空数组
+      const changes = await gate.checkTestFileChanges(tempDir);
+      
+      expect(Array.isArray(changes)).toBe(true);
+    });
+  });
+
+  describe('扩展点支持', () => {
+    it('应该能注册扩展', () => {
+      gate.registerExtension('custom', {
+        name: 'custom',
+        run: async () => ({
+          passed: true,
+          command: 'custom-test',
+          timestamp: new Date(),
+        }),
+      });
+      
+      const names = gate.getExtensionNames();
+      expect(names).toContain('custom');
+    });
+
+    it('应该能注销扩展', () => {
+      gate.registerExtension('temp', {
+        name: 'temp',
+        run: async () => ({
+          passed: true,
+          command: 'temp-test',
+          timestamp: new Date(),
+        }),
+      });
+      
+      const removed = gate.unregisterExtension('temp');
+      expect(removed).toBe(true);
+      
+      const names = gate.getExtensionNames();
+      expect(names).not.toContain('temp');
+    });
+
+    it('runAllTests 应该运行所有测试包括扩展', async () => {
+      gate.registerExtension('puppeteer', {
+        name: 'puppeteer',
+        run: async () => ({
+          passed: true,
+          command: 'puppeteer-test',
+          timestamp: new Date(),
+        }),
+      });
+      
+      const results = await gate.runAllTests(tempDir);
+      
+      expect(results.length).toBeGreaterThan(1);  // 单元测试 + puppeteer
+      expect(results.some(r => r.type === 'puppeteer')).toBe(true);
+    });
+
+    it('checkAllPasses 应该返回综合结果', async () => {
+      gate.registerExtension('passing-ext', {
+        name: 'passing-ext',
+        run: async () => ({
+          passed: true,
+          command: 'passing-test',
+          timestamp: new Date(),
+        }),
+      });
+      
+      const result = await gate.checkAllPasses(tempDir);
+      
+      expect(result.passed).toBeDefined();
+      expect(result.results).toBeDefined();
+      expect(Array.isArray(result.failedTypes)).toBe(true);
+    });
+
+    it('checkAllPasses 应该返回失败类型', async () => {
+      const failingGate = createPassesGate({ enabled: true });
+      failingGate.registerExtension('failing-ext', {
+        name: 'failing-ext',
+        run: async () => ({
+          passed: false,
+          command: 'failing-test',
+          timestamp: new Date(),
+        }),
+      });
+      
+      const result = await failingGate.checkAllPasses(tempDir);
+      
+      expect(result.failedTypes).toContain('failing-ext');
+    });
+
+    it('扩展抛错应返回失败结果', async () => {
+      const errorGate = createPassesGate({ enabled: true });
+      errorGate.registerExtension('error-ext', {
+        name: 'error-ext',
+        run: async () => {
+          throw new Error('Extension error');
+        },
+      });
+      
+      const results = await errorGate.runAllTests(tempDir);
+      
+      const errorResult = results.find(r => r.type === 'error-ext');
+      expect(errorResult?.passed).toBe(false);
+      expect(errorResult?.error).toContain('Extension error');
+    });
+  });
+
+  describe('getTestResult', () => {
+    it('应该返回已存储的测试结果', async () => {
+      const result = await gate.setPasses('stored-task', true, tempDir);
+      
+      if (result.allowed && result.testResult) {
+        const stored = gate.getTestResult('stored-task');
+        expect(stored).toBeDefined();
+        expect(stored?.command).toContain('npm');
+      }
+    });
+
+    it('未存储任务应返回 undefined', () => {
+      const stored = gate.getTestResult('nonexistent-task');
+      expect(stored).toBeUndefined();
+    });
+  });
+
+  describe('测试失败重试', () => {
+    it('测试失败后应重试', async () => {
+      const retryDir = join(process.cwd(), 'temp-test-retry');
+      mkdirSync(retryDir, { recursive: true });
+      
+      writeFileSync(join(retryDir, 'package.json'), JSON.stringify({
+        name: 'retry-project',
+        scripts: { test: 'exit 1' },  // 总是失败
+      }));
+      
+      const retryGate = createPassesGate({
+        enabled: true,
+        maxRetries: 1,
+        retryDelay: 100,
+      });
+      
+      const result = await retryGate.setPasses('retry-task', true, retryDir);
+      
+      expect(result.allowed).toBe(false);
+      expect(result.attempts).toBeGreaterThan(1);
+      expect(result.error).toBeDefined();
+      
+      rmSync(retryDir, { recursive: true, force: true });
+    });
+  });
+});