@dommaker/harness 0.13.0 → 0.13.2

package/src/monitoring/__tests__/performance-analyzer.test.ts

@@ -0,0 +1,137 @@
+/**
+ * PerformanceAnalyzer 测试
+ */
+
+import { PerformanceAnalyzer } from '../performance-analyzer';
+import { PerformanceCollector } from '../performance-collector';
+import type { PerformanceTrace } from '../../types/performance';
+
+// Mock PerformanceCollector
+jest.mock('../performance-collector');
+
+// Mock fs
+jest.mock('fs', () => ({
+  existsSync: jest.fn(),
+  mkdirSync: jest.fn(),
+  readFileSync: jest.fn(),
+  writeFileSync: jest.fn(),
+}));
+
+const MockPerformanceCollector = PerformanceCollector as jest.MockedClass<typeof PerformanceCollector>;
+
+describe('PerformanceAnalyzer', () => {
+  let analyzer: PerformanceAnalyzer;
+  let mockCollector: PerformanceCollector;
+
+  const mockTraces: PerformanceTrace[] = [
+    { operation: 'test', timestamp: Date.now(), duration: 100, result: 'ok' },
+    { operation: 'test', timestamp: Date.now() + 1000, duration: 200, result: 'ok' },
+    { operation: 'test', timestamp: Date.now() + 2000, duration: 35000, result: 'exceeded', threshold: 30000 },
+    { operation: 'test2', timestamp: Date.now(), duration: 500, result: 'ok' },
+  ];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockCollector = new MockPerformanceCollector();
+    analyzer = new PerformanceAnalyzer(mockCollector);
+  });
+
+  describe('constructor', () => {
+    it('should create with default config', () => {
+      expect(analyzer).toBeDefined();
+    });
+
+    it('should accept custom config', () => {
+      const customAnalyzer = new PerformanceAnalyzer(mockCollector, {
+        periodMs: 7200 * 1000,
+      });
+      expect(customAnalyzer).toBeDefined();
+    });
+  });
+
+  describe('summarize()', () => {
+    it('should group by operation', () => {
+      const summaries = analyzer.summarize(mockTraces);
+      expect(summaries.length).toBeGreaterThan(0);
+    });
+
+    it('should calculate total calls', () => {
+      const summaries = analyzer.summarize(mockTraces);
+      const testSummary = summaries.find(s => s.operation === 'test');
+      expect(testSummary).toBeDefined();
+      expect(testSummary!.totalCalls).toBe(3);
+    });
+
+    it('should calculate ok rate', () => {
+      const summaries = analyzer.summarize(mockTraces);
+      const testSummary = summaries.find(s => s.operation === 'test');
+      expect(testSummary).toBeDefined();
+    });
+
+    it('should handle empty traces', () => {
+      const summaries = analyzer.summarize([]);
+      expect(summaries).toEqual([]);
+    });
+
+    it('should handle single trace', () => {
+      const summaries = analyzer.summarize([
+        { operation: 'single', timestamp: Date.now(), duration: 100, result: 'ok' },
+      ]);
+      expect(summaries.length).toBe(1);
+    });
+  });
+
+  describe('detectAnomalies()', () => {
+    it('should detect high exceeded rate', () => {
+      const highExceededTraces: PerformanceTrace[] = [
+        { operation: 'test', timestamp: Date.now(), duration: 35000, result: 'exceeded', threshold: 30000 },
+        { operation: 'test', timestamp: Date.now() + 1000, duration: 40000, result: 'exceeded', threshold: 30000 },
+        { operation: 'test', timestamp: Date.now() + 2000, duration: 100, result: 'ok' },
+      ];
+      
+      const summaries = analyzer.summarize(highExceededTraces);
+      const anomalies = analyzer.detectAnomalies(summaries);
+      expect(anomalies.length).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should return empty array for normal traces', () => {
+      const normalTraces: PerformanceTrace[] = [
+        { operation: 'test', timestamp: Date.now(), duration: 100, result: 'ok' },
+        { operation: 'test', timestamp: Date.now() + 1000, duration: 150, result: 'ok' },
+      ];
+      
+      const summaries = analyzer.summarize(normalTraces);
+      const anomalies = analyzer.detectAnomalies(summaries);
+      expect(Array.isArray(anomalies)).toBe(true);
+    });
+  });
+
+  describe('compareWithPrevious()', () => {
+    it('should compare two summaries', () => {
+      const current = analyzer.summarize(mockTraces);
+      const previous = [...current];
+      
+      const compared = analyzer.compareWithPrevious(current, previous);
+      expect(Array.isArray(compared)).toBe(true);
+    });
+
+    it('should handle empty comparison', () => {
+      const compared = analyzer.compareWithPrevious([], []);
+      expect(compared).toEqual([]);
+    });
+  });
+
+  describe('runHourlySummary()', () => {
+    it('should run hourly summary', () => {
+      // Verify method exists - actual execution depends on collector state
+      expect(typeof analyzer.runHourlySummary).toBe('function');
+    });
+  });
+
+  describe('runDailyAnomalyCheck()', () => {
+    it('should have method', () => {
+      // Verify method exists
+      expect(typeof analyzer.runDailyAnomalyCheck).toBe('function');
+    });
+  });
+});

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

@@ -0,0 +1,332 @@
+/**
+ * PerformanceCollector 测试
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { PerformanceCollector } from '../performance-collector';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Mock fs
+jest.mock('fs', () => ({
+  existsSync: jest.fn(),
+  mkdirSync: jest.fn(),
+  appendFileSync: jest.fn(),
+  statSync: jest.fn().mockReturnValue({ size: 100 }),
+  renameSync: jest.fn(),
+  writeFileSync: jest.fn(),
+  readdirSync: jest.fn().mockReturnValue([]),
+  readFileSync: jest.fn().mockReturnValue(''),
+}));
+
+const mockFs = fs as jest.Mocked<typeof fs>;
+
+describe('PerformanceCollector', () => {
+  let collector: PerformanceCollector;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.statSync.mockReturnValue({ size: 100 } as any);
+    collector = new PerformanceCollector();
+  });
+
+  describe('constructor', () => {
+    it('should create log directory if not exists', () => {
+      mockFs.existsSync.mockReturnValueOnce(false);
+      new PerformanceCollector();
+      expect(mockFs.mkdirSync).toHaveBeenCalled();
+    });
+
+    it('should be disabled when enabled=false', () => {
+      const disabledCollector = new PerformanceCollector({ enabled: false });
+      disabledCollector.recordOk('test', 100);
+      expect(mockFs.appendFileSync).not.toHaveBeenCalled();
+    });
+
+    it('should accept custom config', () => {
+      const customCollector = new PerformanceCollector({
+        enabled: true,
+        logFile: '.harness/perf.log',
+        maxFileSize: 5 * 1024 * 1024,
+      });
+      expect(customCollector).toBeDefined();
+    });
+
+    it('should use default config', () => {
+      const defaultCollector = new PerformanceCollector();
+      expect(defaultCollector).toBeDefined();
+    });
+  });
+
+  describe('record()', () => {
+    it('should append trace to file', () => {
+      collector.record({
+        operation: 'test',
+        timestamp: Date.now(),
+        duration: 100,
+        result: 'ok',
+      });
+      expect(mockFs.appendFileSync).toHaveBeenCalled();
+    });
+
+    it('should not record when disabled', () => {
+      const disabledCollector = new PerformanceCollector({ enabled: false });
+      disabledCollector.record({
+        operation: 'test',
+        timestamp: Date.now(),
+        duration: 100,
+        result: 'ok',
+      });
+      expect(mockFs.appendFileSync).not.toHaveBeenCalled();
+    });
+
+    it('should record with all fields', () => {
+      collector.record({
+        operation: 'full-test',
+        timestamp: 1234567890,
+        duration: 500,
+        result: 'exceeded',
+        threshold: 300,
+        metadata: { key: 'value' },
+      });
+      expect(mockFs.appendFileSync).toHaveBeenCalled();
+      const call = mockFs.appendFileSync.mock.calls[0];
+      const content = call[1] as string;
+      expect(content).toContain('full-test');
+      expect(content).toContain('exceeded');
+    });
+  });
+
+  describe('recordOk()', () => {
+    it('should record ok trace', () => {
+      collector.recordOk('test', 150);
+      const call = mockFs.appendFileSync.mock.calls[0];
+      const content = call[1] as string;
+      const trace = JSON.parse(content.trim());
+      expect(trace.result).toBe('ok');
+      expect(trace.operation).toBe('test');
+      expect(trace.duration).toBe(150);
+    });
+
+    it('should record with metadata', () => {
+      collector.recordOk('test', 100, { key: 'value' });
+      const call = mockFs.appendFileSync.mock.calls[0];
+      const content = call[1] as string;
+      const trace = JSON.parse(content.trim());
+      expect(trace.metadata).toEqual({ key: 'value' });
+    });
+
+    it('should auto-generate timestamp', () => {
+      collector.recordOk('test', 100);
+      const call = mockFs.appendFileSync.mock.calls[0];
+      const content = call[1] as string;
+      const trace = JSON.parse(content.trim());
+      expect(trace.timestamp).toBeDefined();
+      expect(typeof trace.timestamp).toBe('number');
+    });
+
+    it('should not record when disabled', () => {
+      const disabledCollector = new PerformanceCollector({ enabled: false });
+      disabledCollector.recordOk('test', 100);
+      expect(mockFs.appendFileSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('recordExceeded()', () => {
+    it('should record exceeded trace', () => {
+      collector.recordExceeded('test', 35000, 30000);
+      const call = mockFs.appendFileSync.mock.calls[0];
+      const content = call[1] as string;
+      const trace = JSON.parse(content.trim());
+      expect(trace.result).toBe('exceeded');
+      expect(trace.threshold).toBe(30000);
+    });
+
+    it('should include duration', () => {
+      collector.recordExceeded('test', 35000, 30000);
+      const call = mockFs.appendFileSync.mock.calls[0];
+      const content = call[1] as string;
+      const trace = JSON.parse(content.trim());
+      expect(trace.duration).toBe(35000);
+    });
+
+    it('should not record when disabled', () => {
+      const disabledCollector = new PerformanceCollector({ enabled: false });
+      disabledCollector.recordExceeded('test', 35000, 30000);
+      expect(mockFs.appendFileSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('recordError()', () => {
+    it('should record error trace', () => {
+      collector.recordError('test', 100, 'Test error');
+      const call = mockFs.appendFileSync.mock.calls[0];
+      const content = call[1] as string;
+      const trace = JSON.parse(content.trim());
+      expect(trace.result).toBe('error');
+      expect(trace.metadata.error).toBe('Test error');
+    });
+
+    it('should include duration', () => {
+      collector.recordError('test', 100, 'Test error');
+      const call = mockFs.appendFileSync.mock.calls[0];
+      const content = call[1] as string;
+      const trace = JSON.parse(content.trim());
+      expect(trace.duration).toBe(100);
+    });
+
+    it('should not record when disabled', () => {
+      const disabledCollector = new PerformanceCollector({ enabled: false });
+      disabledCollector.recordError('test', 100, 'Test error');
+      expect(mockFs.appendFileSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('read()', () => {
+    it('should return empty array if file not exists', () => {
+      mockFs.existsSync.mockReturnValueOnce(false);
+      const c = new PerformanceCollector();
+      const traces = c.read();
+      expect(traces).toEqual([]);
+    });
+
+    it('should return traces from file', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValueOnce(
+        JSON.stringify({ operation: 'test1', duration: 100, result: 'ok', timestamp: 1 }) + '\n' +
+        JSON.stringify({ operation: 'test2', duration: 200, result: 'ok', timestamp: 2 }) + '\n'
+      );
+      
+      const c = new PerformanceCollector();
+      const traces = c.read();
+      expect(traces.length).toBe(2);
+      expect(traces[0].operation).toBe('test1');
+      expect(traces[1].operation).toBe('test2');
+    });
+
+    it('should handle empty file', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValueOnce('');
+      
+      const c = new PerformanceCollector();
+      const traces = c.read();
+      expect(traces).toEqual([]);
+    });
+
+    it('should filter by period', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValueOnce(
+        JSON.stringify({ operation: 'test1', duration: 100, result: 'ok', timestamp: Date.now() - 100000 }) + '\n' +
+        JSON.stringify({ operation: 'test2', duration: 200, result: 'ok', timestamp: Date.now() }) + '\n'
+      );
+      
+      const c = new PerformanceCollector();
+      const traces = c.read({ timeRange: { start: Date.now() - 50000, end: Date.now() } });
+      expect(traces.length).toBe(1);
+      expect(traces[0].operation).toBe('test2');
+    });
+
+    it('should filter by operation', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValueOnce(
+        JSON.stringify({ operation: 'test1', duration: 100, result: 'ok', timestamp: Date.now() }) + '\n' +
+        JSON.stringify({ operation: 'test2', duration: 200, result: 'ok', timestamp: Date.now() }) + '\n'
+      );
+      
+      const c = new PerformanceCollector();
+      const traces = c.read({ operation: 'test1' });
+      expect(traces.length).toBe(1);
+      expect(traces[0].operation).toBe('test1');
+    });
+
+    it('should filter by result', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValueOnce(
+        JSON.stringify({ operation: 'test1', duration: 100, result: 'ok', timestamp: Date.now() }) + '\n' +
+        JSON.stringify({ operation: 'test2', duration: 200, result: 'exceeded', timestamp: Date.now() }) + '\n'
+      );
+      
+      const c = new PerformanceCollector();
+      const traces = c.read({ result: 'exceeded' });
+      expect(traces.length).toBe(1);
+      expect(traces[0].result).toBe('exceeded');
+    });
+  });
+
+  describe('getStats()', () => {
+    it('should return stats', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.statSync.mockReturnValue({ size: 1024 } as any);
+      
+      const stats = collector.getStats();
+      expect(stats).toHaveProperty('fileExists');
+    });
+
+    it('should return stats when file not exists', () => {
+      // 先让目录检查通过，再让文件检查失败
+      mockFs.existsSync
+        .mockReturnValueOnce(true) // 目录检查
+        .mockReturnValueOnce(false); // 文件检查
+      
+      const c = new PerformanceCollector();
+      mockFs.existsSync.mockReturnValue(false); // getStats 检查
+      const stats = c.getStats();
+      expect(stats.fileExists).toBe(false);
+    });
+
+    it('should include file size', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.statSync.mockReturnValue({ size: 2048 } as any);
+      
+      const stats = collector.getStats();
+      expect(stats.fileSize).toBe(2048);
+    });
+  });
+
+  describe('file rolling', () => {
+    it('should roll file when size exceeds limit', () => {
+      mockFs.statSync.mockReturnValue({ size: 15 * 1024 * 1024 } as any); // 15MB
+      
+      collector.recordOk('test', 100);
+      expect(mockFs.renameSync).toHaveBeenCalled();
+    });
+
+    it('should not roll when under limit', () => {
+      mockFs.statSync.mockReturnValue({ size: 5 * 1024 * 1024 } as any); // 5MB
+      
+      collector.recordOk('test', 100);
+      expect(mockFs.renameSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('clear()', () => {
+    it('should exist if implemented', () => {
+      // Check if method exists
+      const hasClear = typeof (collector as any).clear === 'function';
+      if (hasClear) {
+        mockFs.existsSync.mockReturnValue(true);
+        (collector as any).clear();
+        expect(mockFs.writeFileSync).toHaveBeenCalled();
+      }
+    });
+  });
+
+  describe('getRecentTraces()', () => {
+    it('should return recent traces', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValueOnce(
+        JSON.stringify({ operation: 'test1', duration: 100, result: 'ok', timestamp: Date.now() }) + '\n' +
+        JSON.stringify({ operation: 'test2', duration: 200, result: 'ok', timestamp: Date.now() }) + '\n' +
+        JSON.stringify({ operation: 'test3', duration: 300, result: 'ok', timestamp: Date.now() }) + '\n'
+      );
+      
+      // Check if method exists
+      const hasRecent = typeof (collector as any).getRecentTraces === 'function';
+      if (hasRecent) {
+        const traces = (collector as any).getRecentTraces(2);
+        expect(traces.length).toBe(2);
+      }
+    });
+  });
+});

package/src/monitoring/__tests__/traces.test.ts

@@ -0,0 +1,190 @@
+/**
+ * TraceCollector 测试（简化版）
+ */
+
+import { TraceCollector, getTraceCollector, configureTraceCollector } from '../traces';
+import * as fs from 'fs';
+
+// Mock fs
+jest.mock('fs', () => ({
+  existsSync: jest.fn().mockReturnValue(true),
+  mkdirSync: jest.fn(),
+  appendFileSync: jest.fn(),
+  readFileSync: jest.fn(),
+  statSync: jest.fn().mockReturnValue({ size: 100 }),
+  renameSync: jest.fn(),
+  writeFileSync: jest.fn(),
+  readdirSync: jest.fn().mockReturnValue([]),
+  unlinkSync: jest.fn(),
+}));
+
+const mockFs = fs as jest.Mocked<typeof fs>;
+
+describe('TraceCollector', () => {
+  let collector: TraceCollector;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.statSync.mockReturnValue({ size: 100 } as any);
+    collector = new TraceCollector();
+  });
+
+  describe('constructor', () => {
+    it('should create trace directory if not exists', () => {
+      mockFs.existsSync.mockReturnValueOnce(false);
+      new TraceCollector();
+      expect(mockFs.mkdirSync).toHaveBeenCalled();
+    });
+
+    it('should be disabled when enabled=false', () => {
+      const disabledCollector = new TraceCollector({ enabled: false });
+      disabledCollector.record({
+        constraintId: 'test',
+        level: 'iron_law',
+        timestamp: Date.now(),
+        result: 'pass',
+      });
+      expect(mockFs.appendFileSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('record()', () => {
+    it('should append trace to file', () => {
+      collector.record({
+        constraintId: 'test',
+        level: 'iron_law',
+        timestamp: Date.now(),
+        result: 'pass',
+      });
+      expect(mockFs.appendFileSync).toHaveBeenCalled();
+    });
+  });
+
+  describe('recordPass()', () => {
+    it('should record pass trace', () => {
+      collector.recordPass('test_constraint', 'iron_law');
+      const call = mockFs.appendFileSync.mock.calls[0];
+      const content = JSON.parse(call[1] as string);
+      expect(content.result).toBe('pass');
+    });
+  });
+
+  describe('recordFail()', () => {
+    it('should record fail trace', () => {
+      collector.recordFail('test_constraint', 'iron_law');
+      const call = mockFs.appendFileSync.mock.calls[0];
+      const content = JSON.parse(call[1] as string);
+      expect(content.result).toBe('fail');
+    });
+  });
+
+  describe('recordBypass()', () => {
+    it('should record bypass trace', () => {
+      collector.recordBypass('test', 'guideline', 'Emergency');
+      const call = mockFs.appendFileSync.mock.calls[0];
+      const content = JSON.parse(call[1] as string);
+      expect(content.result).toBe('bypassed');
+      expect(content.bypassReason).toBe('Emergency');
+    });
+  });
+
+  describe('read()', () => {
+    it('should return empty array if file not exists', () => {
+      mockFs.existsSync.mockReturnValueOnce(true);
+      mockFs.existsSync.mockReturnValueOnce(false);
+      const c = new TraceCollector();
+      const traces = c.read();
+      expect(traces).toEqual([]);
+    });
+
+    it('should parse all traces from file', () => {
+      mockFs.readFileSync.mockReturnValueOnce(
+        '{"constraintId":"a","level":"iron_law","timestamp":100,"result":"pass"}\n' +
+        '{"constraintId":"b","level":"guideline","timestamp":200,"result":"fail"}\n'
+      );
+      const traces = collector.read();
+      expect(traces.length).toBe(2);
+    });
+
+    it('should apply constraintId filter', () => {
+      mockFs.readFileSync.mockReturnValueOnce(
+        '{"constraintId":"a","level":"iron_law","timestamp":100,"result":"pass"}\n' +
+        '{"constraintId":"b","level":"guideline","timestamp":200,"result":"fail"}\n'
+      );
+      const traces = collector.read({ constraintId: 'a' });
+      expect(traces.length).toBe(1);
+    });
+
+    it('should apply level filter', () => {
+      mockFs.readFileSync.mockReturnValueOnce(
+        '{"constraintId":"a","level":"iron_law","timestamp":100,"result":"pass"}\n' +
+        '{"constraintId":"b","level":"guideline","timestamp":200,"result":"fail"}\n'
+      );
+      const traces = collector.read({ level: 'guideline' });
+      expect(traces.length).toBe(1);
+    });
+  });
+
+  describe('readRecent()', () => {
+    it('should read recent traces', () => {
+      const now = Date.now();
+      mockFs.readFileSync.mockReturnValueOnce(
+        `{"constraintId":"new","level":"iron_law","timestamp":${now - 1000},"result":"pass"}\n`
+      );
+      const traces = collector.readRecent(1);
+      expect(traces.length).toBe(1);
+    });
+  });
+
+  describe('readByConstraint()', () => {
+    it('should read by constraint', () => {
+      mockFs.readFileSync.mockReturnValueOnce(
+        '{"constraintId":"a","level":"iron_law","timestamp":100,"result":"pass"}\n'
+      );
+      const traces = collector.readByConstraint('a');
+      expect(traces.length).toBe(1);
+    });
+  });
+
+  describe('rotateFile()', () => {
+    it('should rotate when size exceeded', () => {
+      mockFs.statSync.mockReturnValueOnce({ size: 11 * 1024 * 1024 } as any);
+      collector.record({
+        constraintId: 'test',
+        level: 'iron_law',
+        timestamp: Date.now(),
+        result: 'pass',
+      });
+      expect(mockFs.renameSync).toHaveBeenCalled();
+    });
+  });
+
+  describe('getStats()', () => {
+    it('should return stats', () => {
+      mockFs.existsSync.mockReturnValueOnce(true);
+      mockFs.readFileSync.mockReturnValueOnce(
+        '{"constraintId":"a","level":"iron_law","timestamp":100,"result":"pass"}\n'
+      );
+      mockFs.statSync.mockReturnValueOnce({ size: 1024 } as any);
+      const stats = collector.getStats();
+      expect(stats.fileExists).toBe(true);
+    });
+  });
+});
+
+describe('getTraceCollector()', () => {
+  it('should return global collector', () => {
+    const c1 = getTraceCollector();
+    const c2 = getTraceCollector();
+    expect(c1).toBe(c2);
+  });
+});
+
+describe('configureTraceCollector()', () => {
+  it('should create new global collector', () => {
+    configureTraceCollector({ traceFile: '/custom/traces.log' });
+    const c = getTraceCollector();
+    expect(c).toBeDefined();
+  });
+});