@dommaker/harness 0.13.0 → 0.13.2

package/src/__tests__/performance-collector.test.ts

@@ -0,0 +1,276 @@
+/**
+ * PerformanceCollector 测试
+ */
+
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from '@jest/globals';
+import { PerformanceCollector } from '../monitoring/performance-collector';
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('PerformanceCollector', () => {
+  const tempDir = path.join(process.cwd(), 'temp-test-perf');
+  const logFile = path.join(tempDir, 'performance.log');
+  let collector: PerformanceCollector;
+
+  beforeAll(() => {
+    fs.mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  beforeEach(() => {
+    fs.writeFileSync(logFile, '');
+    collector = new PerformanceCollector({ logFile, enabled: true });
+  });
+
+  describe('record', () => {
+    it('应该记录性能数据', () => {
+      collector.record({
+        operation: 'test_op',
+        timestamp: Date.now(),
+        duration: 100,
+        result: 'ok',
+      });
+
+      const content = fs.readFileSync(logFile, 'utf-8');
+      expect(content).toContain('test_op');
+      expect(content).toContain('ok');
+    });
+
+    it('禁用时应该不记录', () => {
+      const disabledCollector = new PerformanceCollector({
+        logFile,
+        enabled: false,
+      });
+
+      disabledCollector.record({
+        operation: 'test',
+        timestamp: Date.now(),
+        duration: 100,
+        result: 'ok',
+      });
+
+      const content = fs.readFileSync(logFile, 'utf-8');
+      expect(content).toBe('');
+    });
+  });
+
+  describe('recordOk', () => {
+    it('应该记录正常执行', () => {
+      collector.recordOk('extract', 150);
+
+      const content = fs.readFileSync(logFile, 'utf-8');
+      expect(content).toContain('extract');
+      expect(content).toContain('150');
+      expect(content).toContain('ok');
+    });
+
+    it('应该支持元数据', () => {
+      collector.recordOk('extract', 150, { files: 10 });
+
+      const content = fs.readFileSync(logFile, 'utf-8');
+      expect(content).toContain('files');
+    });
+  });
+
+  describe('recordExceeded', () => {
+    it('应该记录超阈值执行', () => {
+      collector.recordExceeded('invokeAgent', 35000, 30000);
+
+      const content = fs.readFileSync(logFile, 'utf-8');
+      expect(content).toContain('invokeAgent');
+      expect(content).toContain('exceeded');
+      expect(content).toContain('35000');
+    });
+  });
+
+  describe('read', () => {
+    it('应该读取性能数据', () => {
+      collector.recordOk('op1', 100);
+      collector.recordOk('op2', 200);
+
+      const traces = collector.read();
+      expect(traces.length).toBe(2);
+    });
+
+    it('空文件应该返回空数组', () => {
+      fs.writeFileSync(logFile, '');
+      const traces = collector.read();
+      expect(traces).toEqual([]);
+    });
+  });
+
+  describe('getStats', () => {
+    it('应该返回统计信息', () => {
+      collector.recordOk('op1', 100);
+      collector.recordOk('op2', 200);
+      collector.recordExceeded('op3', 500, 400);
+
+      const stats = collector.getStats();
+
+      expect(stats.totalRecords).toBe(3);
+    });
+
+    it('应该正确读取数据', () => {
+      collector.recordOk('op1', 100);
+      collector.recordOk('op2', 200);
+
+      const traces = collector.read();
+
+      expect(traces.length).toBe(2);
+    });
+
+    it('文件不存在时应该返回空统计', () => {
+      fs.unlinkSync(logFile);
+      const tmpFile = path.join(require('os').tmpdir(), 'harness-test-nonexistent', 'perf.log');
+      const newCollector = new PerformanceCollector({ logFile: tmpFile });
+
+      const stats = newCollector.getStats();
+
+      expect(stats.fileExists).toBe(false);
+      expect(stats.totalRecords).toBe(0);
+    });
+  });
+
+  describe('recordError', () => {
+    it('应该记录错误', () => {
+      collector.recordError('failing-op', 100, 'Something went wrong');
+
+      const content = fs.readFileSync(logFile, 'utf-8');
+      expect(content).toContain('error');
+      expect(content).toContain('Something went wrong');
+    });
+
+    it('应该支持 Error 对象', () => {
+      collector.recordError('failing-op', 100, new Error('Test error'));
+
+      const content = fs.readFileSync(logFile, 'utf-8');
+      expect(content).toContain('Test error');
+    });
+
+    it('应该支持元数据', () => {
+      collector.recordError('failing-op', 100, 'Error', { retryCount: 3 });
+
+      const content = fs.readFileSync(logFile, 'utf-8');
+      expect(content).toContain('retryCount');
+    });
+  });
+
+  describe('readRecent', () => {
+    it('应该读取最近 N 小时的数据', () => {
+      collector.recordOk('recent-op', 100);
+
+      const traces = collector.readRecent(1);
+      expect(traces.length).toBe(1);
+    });
+  });
+
+  describe('readByOperation', () => {
+    it('应该过滤特定操作', () => {
+      collector.recordOk('op1', 100);
+      collector.recordOk('op2', 200);
+      collector.recordOk('op1', 150);
+
+      const traces = collector.readByOperation('op1');
+      expect(traces.length).toBe(2);
+    });
+  });
+
+  describe('过滤条件', () => {
+    it('应该按时间范围过滤', () => {
+      const now = Date.now();
+      collector.record({ operation: 'old', timestamp: now - 100000, duration: 100, result: 'ok' });
+      collector.record({ operation: 'new', timestamp: now, duration: 100, result: 'ok' });
+
+      const traces = collector.read({
+        timeRange: { start: now - 50000, end: now + 1000 },
+      });
+
+      expect(traces.length).toBe(1);
+      expect(traces[0]?.operation).toBe('new');
+    });
+
+    it('应该按结果类型过滤', () => {
+      collector.recordOk('ok-op', 100);
+      collector.recordError('err-op', 200, 'error');
+
+      const traces = collector.read({ result: 'error' });
+      expect(traces.length).toBe(1);
+      expect(traces[0]?.operation).toBe('err-op');
+    });
+
+    it('应该按项目路径过滤', () => {
+      collector.record({ operation: 'op1', timestamp: Date.now(), duration: 100, result: 'ok', projectPath: '/project1' });
+      collector.record({ operation: 'op2', timestamp: Date.now(), duration: 100, result: 'ok', projectPath: '/project2' });
+
+      const traces = collector.read({ projectPath: '/project1' });
+      expect(traces.length).toBe(1);
+    });
+
+    it('应该按会话 ID 过滤', () => {
+      collector.record({ operation: 'op1', timestamp: Date.now(), duration: 100, result: 'ok', sessionId: 'session-1' });
+      collector.record({ operation: 'op2', timestamp: Date.now(), duration: 100, result: 'ok', sessionId: 'session-2' });
+
+      const traces = collector.read({ sessionId: 'session-1' });
+      expect(traces.length).toBe(1);
+    });
+
+    it('应该按任务 ID 过滤', () => {
+      collector.record({ operation: 'op1', timestamp: Date.now(), duration: 100, result: 'ok', taskId: 'task-1' });
+      collector.record({ operation: 'op2', timestamp: Date.now(), duration: 100, result: 'ok', taskId: 'task-2' });
+
+      const traces = collector.read({ taskId: 'task-1' });
+      expect(traces.length).toBe(1);
+    });
+
+    it('应该按角色 ID 过滤', () => {
+      collector.record({ operation: 'op1', timestamp: Date.now(), duration: 100, result: 'ok', roleId: 'role-1' });
+      collector.record({ operation: 'op2', timestamp: Date.now(), duration: 100, result: 'ok', roleId: 'role-2' });
+
+      const traces = collector.read({ roleId: 'role-1' });
+      expect(traces.length).toBe(1);
+    });
+  });
+
+  describe('cleanupOldFiles', () => {
+    it('应该清理旧备份文件', () => {
+      // 创建一些备份文件（模拟滚动）
+      const backupFile = logFile.replace('.log', '-2026-01-01.log');
+      fs.writeFileSync(backupFile, 'old data');
+
+      // 由于文件是新建的，需要修改 mtime
+      // 简单验证函数运行不崩溃
+      const deleted = collector.cleanupOldFiles(0);
+      expect(deleted).toBeGreaterThanOrEqual(0);
+      
+      // 清理备份文件
+      try { fs.unlinkSync(backupFile); } catch {}
+    });
+
+    it('不存在目录时应该返回 0', () => {
+      // 创建新的 collector，使用临时目录
+      const nonexistentDir = path.join(process.cwd(), 'temp-nonexistent-perf');
+      const nonexistentLogFile = path.join(nonexistentDir, 'perf.log');
+      const newCollector = new PerformanceCollector({ logFile: nonexistentLogFile });
+
+      const deleted = newCollector.cleanupOldFiles(30);
+      expect(deleted).toBe(0);
+    });
+  });
+
+  describe('文件滚动', () => {
+    it('应该检查文件大小', () => {
+      // 创建大文件触发滚动检查
+      collector.recordOk('test', 100);
+      
+      // 文件应该存在
+      expect(fs.existsSync(logFile)).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,74 @@
+/**
+ * PerformanceGate 测试
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
+import { PerformanceGate } from '../gates/performance';
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('PerformanceGate', () => {
+  const tempDir = path.join(process.cwd(), 'temp-test-perf-gate');
+
+  beforeAll(() => {
+    fs.mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  describe('check', () => {
+    it('禁用时应该返回通过', async () => {
+      const gate = new PerformanceGate({ enabled: false });
+
+      const result = await gate.check({
+        projectId: 'test',
+        projectPath: tempDir,
+      });
+
+      expect(result.passed).toBe(true);
+    });
+
+    it('应该返回检查结果', async () => {
+      const gate = new PerformanceGate({
+        enabled: true,
+        thresholds: {
+          maxResponseTime: 1000,
+        },
+      });
+
+      const result = await gate.check({
+        projectId: 'test',
+        projectPath: tempDir,
+      });
+
+      expect(result.gate).toBe('performance');
+    });
+  });
+
+  describe('配置', () => {
+    it('应该支持自定义阈值', () => {
+      const gate = new PerformanceGate({
+        thresholds: {
+          maxResponseTime: 500,
+          maxMemoryUsage: 1000,
+        },
+      });
+
+      expect(gate).toBeDefined();
+    });
+
+    it('应该支持基准测试命令', () => {
+      const gate = new PerformanceGate({
+        benchmarkCommand: 'npm run benchmark',
+      });
+
+      expect(gate).toBeDefined();
+    });
+  });
+});

package/src/__tests__/presets.test.ts

@@ -0,0 +1,104 @@
+/**
+ * presets 测试
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { STRICT_PRESET, STANDARD_PRESET, RELAXED_PRESET, getPreset, getIronLawPreset, STANDARD_IRON_LAWS_CONFIG } from '../presets/standard';
+
+describe('Presets', () => {
+  describe('STRICT_PRESET', () => {
+    it('应该启用所有约束', () => {
+      expect(STRICT_PRESET.name).toBe('strict');
+      expect(STRICT_PRESET.ironLaws).toBeNull();
+      expect(STRICT_PRESET.guidelines).toBeNull();
+      expect(STRICT_PRESET.tips).toBeNull();
+    });
+  });
+
+  describe('STANDARD_PRESET', () => {
+    it('应该启用所有约束', () => {
+      expect(STANDARD_PRESET.name).toBe('standard');
+      expect(STANDARD_PRESET.ironLaws).toBeNull();
+      expect(STANDARD_PRESET.guidelines).toBeNull();
+      expect(STANDARD_PRESET.tips).toBeNull();
+    });
+  });
+
+  describe('RELAXED_PRESET', () => {
+    it('应该只启用核心约束', () => {
+      expect(RELAXED_PRESET.name).toBe('relaxed');
+      expect(RELAXED_PRESET.ironLaws).not.toBeNull();
+      expect(RELAXED_PRESET.guidelines).not.toBeNull();
+      expect(RELAXED_PRESET.tips).toEqual([]);
+    });
+
+    it('应该包含 no_bypass_checkpoint', () => {
+      expect(RELAXED_PRESET.ironLaws).toContain('no_bypass_checkpoint');
+    });
+
+    it('应该包含 no_self_approval', () => {
+      expect(RELAXED_PRESET.ironLaws).toContain('no_self_approval');
+    });
+  });
+
+  describe('getPreset', () => {
+    it('应该返回 strict 预设', () => {
+      const preset = getPreset('strict');
+      expect(preset.name).toBe('strict');
+    });
+
+    it('应该返回 standard 预设', () => {
+      const preset = getPreset('standard');
+      expect(preset.name).toBe('standard');
+    });
+
+    it('应该返回 relaxed 预设', () => {
+      const preset = getPreset('relaxed');
+      expect(preset.name).toBe('relaxed');
+    });
+
+    it('未知预设应该返回 standard', () => {
+      const preset = getPreset('unknown');
+      expect(preset.name).toBe('standard');
+    });
+  });
+
+  describe('getIronLawPreset (deprecated)', () => {
+    it('strict 应该返回所有 Iron Laws', () => {
+      const config = getIronLawPreset('strict');
+      expect(config.preset).toBe('strict');
+      expect(config.enabled).toBe(true);
+      expect(Array.isArray(config.ironLaws)).toBe(true);
+      expect(config.ironLaws.length).toBeGreaterThan(0);
+    });
+
+    it('standard 应该返回所有 Iron Laws', () => {
+      const config = getIronLawPreset('standard');
+      expect(config.preset).toBe('standard');
+      expect(config.enabled).toBe(true);
+      expect(Array.isArray(config.ironLaws)).toBe(true);
+      expect(config.ironLaws.length).toBeGreaterThan(0);
+    });
+
+    it('relaxed 应该返回过滤后的 Iron Laws', () => {
+      const config = getIronLawPreset('relaxed');
+      expect(config.preset).toBe('relaxed');
+      expect(config.enabled).toBe(true);
+      expect(Array.isArray(config.ironLaws)).toBe(true);
+      expect(config.ironLaws.length).toBe(3);
+    });
+
+    it('未知预设应该返回所有 Iron Laws', () => {
+      const config = getIronLawPreset('unknown');
+      expect(config.preset).toBe('unknown');
+      expect(config.enabled).toBe(true);
+      expect(config.ironLaws.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('STANDARD_IRON_LAWS_CONFIG (deprecated re-export)', () => {
+    it('应该等同于 STANDARD_PRESET', () => {
+      expect(STANDARD_IRON_LAWS_CONFIG).toBe(STANDARD_PRESET);
+    });
+  });
+});