@dommaker/harness 0.13.0 → 0.13.2

package/src/cli/commands/__tests__/command.test.ts

@@ -0,0 +1,149 @@
+/**
+ * command 命令测试
+ */
+
+import { executeCommand } from '../command';
+import { createCommandGate, getCommandRiskLevel, DEFAULT_COMMAND_BLACKLIST } from '../../../gates';
+
+jest.mock('../../../gates', () => ({
+  createCommandGate: jest.fn(),
+  getCommandRiskLevel: jest.fn(),
+  DEFAULT_COMMAND_BLACKLIST: [
+    { id: 'rule-1', level: 'block', message: 'No rm -rf', category: 'destructive', pattern: 'rm -rf' },
+    { id: 'rule-2', level: 'warn', message: 'No DROP TABLE', category: 'database', pattern: 'DROP TABLE' },
+  ],
+}));
+
+jest.mock('chalk', () => ({
+  blue: jest.fn((s: string) => s),
+  green: jest.fn((s: string) => s),
+  red: jest.fn((s: string) => s),
+  yellow: jest.fn((s: string) => s),
+  gray: jest.fn((s: string) => s),
+}));
+
+const mockCreateGate = createCommandGate as jest.MockedFunction<typeof createCommandGate>;
+const mockGetRisk = getCommandRiskLevel as jest.MockedFunction<typeof getCommandRiskLevel>;
+
+describe('command command', () => {
+  let consoleSpy: jest.SpyInstance;
+  let errorSpy: jest.SpyInstance;
+  let exitSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    errorSpy = jest.spyOn(console, 'error').mockImplementation();
+    exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+    process.exitCode = 0;
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    errorSpy.mockRestore();
+    exitSpy.mockRestore();
+    process.exitCode = 0;
+  });
+
+  describe('--list', () => {
+    it('should list rules grouped by category', async () => {
+      await executeCommand(undefined, { list: true });
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('命令黑名单规则'));
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[destructive]'));
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[database]'));
+    });
+
+    it('should list rules as JSON when --json', async () => {
+      await executeCommand(undefined, { list: true, json: true });
+
+      const jsonCall = consoleSpy.mock.calls.find((c: any[]) => {
+        try { return Array.isArray(JSON.parse(c[0])); } catch { return false; }
+      });
+      expect(jsonCall).toBeTruthy();
+      const parsed = JSON.parse(jsonCall[0]);
+      expect(parsed).toHaveLength(2);
+    });
+  });
+
+  describe('no command', () => {
+    it('should print error and exit 1 when no command provided', async () => {
+      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'OK' });
+      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+
+      await executeCommand(undefined, {});
+
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('请提供要检查的命令'));
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('default mode', () => {
+    it('should print pass when result passes', async () => {
+      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'OK' });
+      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+
+      await executeCommand('safe-cmd', {});
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('✓'));
+    });
+
+    it('should print fail and exit 1 when result fails', async () => {
+      const mockCheck = jest.fn().mockResolvedValue({ passed: false, message: 'Blocked' });
+      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+
+      await executeCommand('rm -rf /', {});
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('✗'));
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should output JSON when --json', async () => {
+      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'OK', details: {} });
+      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+
+      await executeCommand('cmd', { json: true });
+
+      const jsonCall = consoleSpy.mock.calls.find((c: any[]) => {
+        try { const p = JSON.parse(c[0]); return p.command !== undefined; } catch { return false; }
+      });
+      expect(jsonCall).toBeTruthy();
+    });
+  });
+
+  describe('--level', () => {
+    it('should print risk level', async () => {
+      mockGetRisk.mockReturnValue('low');
+      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'OK' });
+      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+
+      await executeCommand('safe-cmd', { level: true });
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('low'));
+      expect(exitSpy).toHaveBeenCalledWith(0);
+    });
+
+    it('should exit 1 for high risk', async () => {
+      mockGetRisk.mockReturnValue('high');
+      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'OK' });
+      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+
+      await executeCommand('rm -rf /', { level: true });
+
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should output JSON when --json', async () => {
+      mockGetRisk.mockReturnValue('medium');
+      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'OK' });
+      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+
+      await executeCommand('cmd', { level: true, json: true });
+
+      const jsonCall = consoleSpy.mock.calls.find((c: any[]) => {
+        try { const p = JSON.parse(c[0]); return p.level !== undefined; } catch { return false; }
+      });
+      expect(jsonCall).toBeTruthy();
+    });
+  });
+});

package/src/cli/commands/__tests__/contract.test.ts

@@ -0,0 +1,151 @@
+/**
+ * contract 命令测试
+ */
+
+import { contract, validateSchema } from '../contract';
+import * as fs from 'fs/promises';
+import { ContractGate } from '../../../gates/contract';
+
+jest.mock('fs/promises', () => ({
+  readFile: jest.fn(),
+  access: jest.fn(),
+}));
+
+jest.mock('../../../gates/contract', () => ({
+  ContractGate: jest.fn().mockImplementation(() => ({
+    check: jest.fn(),
+  })),
+}));
+
+jest.mock('js-yaml', () => ({
+  load: jest.fn(),
+}));
+
+jest.mock('chalk', () => ({
+  blue: jest.fn((s: string) => s),
+  green: jest.fn((s: string) => s),
+  red: jest.fn((s: string) => s),
+  yellow: jest.fn((s: string) => s),
+  gray: jest.fn((s: string) => s),
+}));
+
+const mockFs = fs as jest.Mocked<typeof fs>;
+const MockGate = ContractGate as jest.MockedClass<typeof ContractGate>;
+const yaml = require('js-yaml');
+
+describe('contract command', () => {
+  let consoleSpy: jest.SpyInstance;
+  let exitSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+    process.exitCode = 0;
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+    process.exitCode = 0;
+  });
+
+  describe('contract', () => {
+    it('should print success when check passes', async () => {
+      mockFs.access.mockResolvedValue(undefined);
+      const mockCheck = jest.fn().mockResolvedValue({
+        passed: true,
+        message: 'ok',
+        details: { endpoints: 10, breakingChanges: false },
+      });
+      MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+
+      await contract({});
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('契约门控检查通过'));
+      expect(exitSpy).not.toHaveBeenCalled();
+    });
+
+    it('should exit 1 when file does not exist', async () => {
+      mockFs.access.mockRejectedValue(new Error('ENOENT'));
+
+      await contract({});
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('契约文件不存在'));
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should print failure and exit 1 when check fails', async () => {
+      mockFs.access.mockResolvedValue(undefined);
+      const mockCheck = jest.fn().mockResolvedValue({
+        passed: false,
+        message: 'validation errors',
+        details: {
+          errors: ['missing field X', 'invalid type Y'],
+          breakingChanges: [{ type: 'removed', path: '/api/v1/users' }],
+        },
+      });
+      MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+
+      await contract({});
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('契约门控检查失败'));
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle thrown errors and exit 1', async () => {
+      mockFs.access.mockResolvedValue(undefined);
+      const mockCheck = jest.fn().mockRejectedValue(new Error('gate error'));
+      MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+
+      await contract({});
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('契约门控检查出错'));
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('validateSchema', () => {
+    it('should validate a valid schema', async () => {
+      mockFs.readFile.mockResolvedValue('yaml-content');
+      yaml.load.mockReturnValue({
+        openapi: '3.0.0',
+        info: { title: 'Test API', version: '1.0.0' },
+        paths: { '/users': {} },
+      });
+
+      await validateSchema({});
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Schema 验证通过'));
+    });
+
+    it('should report missing fields', async () => {
+      mockFs.readFile.mockResolvedValue('{}');
+      yaml.load.mockReturnValue({});
+
+      await validateSchema({});
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Schema 验证失败'));
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should report YAML parse errors', async () => {
+      mockFs.readFile.mockResolvedValue('invalid: yaml: content:');
+      yaml.load.mockImplementation(() => { throw new Error('parse error'); });
+
+      await validateSchema({});
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('YAML 解析错误'));
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle file read errors', async () => {
+      mockFs.readFile.mockRejectedValue(new Error('ENOENT'));
+
+      await validateSchema({});
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('验证失败'));
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+});

package/src/cli/commands/__tests__/failure.test.ts

@@ -0,0 +1,199 @@
+/**
+ * failure CLI 命令测试
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { FailureRecorder } from '../../../failure/recorder';
+import { ErrorType, FailureLevel } from '../../../failure/types';
+import type { FailureRecord } from '../../../failure/types';
+
+// Mock FailureRecorder
+jest.mock('../../../failure/recorder');
+
+describe('failure CLI commands', () => {
+  const tempDir = path.join(process.cwd(), 'temp-test-failure-cli');
+  const logFilePath = path.join(tempDir, '.harness', 'failures', 'failures.log');
+  let consoleSpy: jest.SpyInstance;
+  let consoleErrorSpy: jest.SpyInstance;
+  let mockRecorderInstance: {
+    record: jest.Mock;
+    getHistory: jest.Mock;
+    getStats: jest.Mock;
+    clear: jest.Mock;
+  };
+
+  const sampleRecords: FailureRecord[] = [
+    { type: ErrorType.TEST_FAILED, level: FailureLevel.L1, message: 'Test 1 failed', timestamp: 1000 },
+    { type: ErrorType.NETWORK_ERROR, level: FailureLevel.L2, message: 'Network error', timestamp: 2000 },
+    { type: ErrorType.TEST_FAILED, level: FailureLevel.L3, message: 'Critical test fail', timestamp: 3000 },
+  ];
+
+  const sampleStats = {
+    total: 3,
+    byType: { TEST_FAILED: 2, NETWORK_ERROR: 1 },
+    byLevel: { L1: 1, L2: 1, L3: 1 },
+  };
+
+  beforeAll(() => {
+    fs.mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+
+    // Setup mock instance methods
+    mockRecorderInstance = {
+      record: jest.fn().mockResolvedValue(undefined),
+      getHistory: jest.fn().mockResolvedValue(sampleRecords),
+      getStats: jest.fn().mockResolvedValue(sampleStats),
+      clear: jest.fn().mockResolvedValue(undefined),
+    };
+
+    (FailureRecorder as jest.Mock).mockImplementation(() => mockRecorderInstance);
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  describe('failureList', () => {
+    it('应该列出所有记录', async () => {
+      const { failureList } = await import('../failure');
+      await failureList({ projectPath: tempDir });
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('失败记录'));
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('TEST_FAILED'));
+    });
+
+    it('应该按类型过滤', async () => {
+      const { failureList } = await import('../failure');
+      await failureList({ projectPath: tempDir, type: 'TEST_FAILED' });
+
+      expect(mockRecorderInstance.getHistory).toHaveBeenCalled();
+    });
+
+    it('应该按等级过滤', async () => {
+      const { failureList } = await import('../failure');
+      await failureList({ projectPath: tempDir, level: 'L1' });
+
+      expect(mockRecorderInstance.getHistory).toHaveBeenCalled();
+    });
+
+    it('应该限制返回数量', async () => {
+      const { failureList } = await import('../failure');
+      await failureList({ projectPath: tempDir, limit: 2 });
+
+      expect(mockRecorderInstance.getHistory).toHaveBeenCalled();
+    });
+
+    it('空记录应该输出提示', async () => {
+      mockRecorderInstance.getHistory.mockResolvedValue([]);
+      const { failureList } = await import('../failure');
+      await failureList({ projectPath: tempDir });
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('没有失败记录'));
+    });
+
+    it('--json 模式应该输出 JSON', async () => {
+      const { failureList } = await import('../failure');
+      await failureList({ projectPath: tempDir, json: true });
+
+      const jsonCall = consoleSpy.mock.calls.find(
+        (call: unknown[]) => typeof call[0] === 'string' && call[0].startsWith('{')
+      );
+      expect(jsonCall).toBeDefined();
+      const parsed = JSON.parse(jsonCall![0]);
+      expect(parsed.total).toBe(3);
+    });
+
+    it('--json 模式空记录应该输出 total:0', async () => {
+      mockRecorderInstance.getHistory.mockResolvedValue([]);
+      const { failureList } = await import('../failure');
+      await failureList({ projectPath: tempDir, json: true });
+
+      const jsonCall = consoleSpy.mock.calls.find(
+        (call: unknown[]) => typeof call[0] === 'string' && call[0].startsWith('{')
+      );
+      expect(jsonCall).toBeDefined();
+      const parsed = JSON.parse(jsonCall![0]);
+      expect(parsed.total).toBe(0);
+    });
+  });
+
+  describe('failureStats', () => {
+    it('应该输出统计信息', async () => {
+      const { failureStats } = await import('../failure');
+      await failureStats({ projectPath: tempDir });
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('失败统计'));
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('TEST_FAILED'));
+    });
+
+    it('--json 模式应该输出 JSON 统计', async () => {
+      const { failureStats } = await import('../failure');
+      await failureStats({ projectPath: tempDir, json: true });
+
+      const jsonCall = consoleSpy.mock.calls.find(
+        (call: unknown[]) => typeof call[0] === 'string' && call[0].startsWith('{')
+      );
+      expect(jsonCall).toBeDefined();
+      const parsed = JSON.parse(jsonCall![0]);
+      expect(parsed.total).toBe(3);
+    });
+
+    it('空记录应该输出绿色提示', async () => {
+      mockRecorderInstance.getStats.mockResolvedValue({ total: 0, byType: {}, byLevel: {} });
+      const { failureStats } = await import('../failure');
+      await failureStats({ projectPath: tempDir });
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('没有失败记录'));
+    });
+
+    it('--json 模式空记录应该输出空统计', async () => {
+      mockRecorderInstance.getStats.mockResolvedValue({ total: 0, byType: {}, byLevel: {} });
+      const { failureStats } = await import('../failure');
+      await failureStats({ projectPath: tempDir, json: true });
+
+      const jsonCall = consoleSpy.mock.calls.find(
+        (call: unknown[]) => typeof call[0] === 'string' && call[0].startsWith('{')
+      );
+      expect(jsonCall).toBeDefined();
+      const parsed = JSON.parse(jsonCall![0]);
+      expect(parsed.total).toBe(0);
+    });
+  });
+
+  describe('failureClear', () => {
+    it('应该清空记录并输出结果', async () => {
+      const { failureClear } = await import('../failure');
+      await failureClear({ projectPath: tempDir });
+
+      expect(mockRecorderInstance.clear).toHaveBeenCalled();
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('已清空'));
+    });
+
+    it('--json 模式应该输出清空的记录数', async () => {
+      const { failureClear } = await import('../failure');
+      await failureClear({ projectPath: tempDir, json: true });
+
+      const jsonCall = consoleSpy.mock.calls.find(
+        (call: unknown[]) => typeof call[0] === 'string' && call[0].startsWith('{')
+      );
+      expect(jsonCall).toBeDefined();
+      const parsed = JSON.parse(jsonCall![0]);
+      expect(parsed.cleared).toBe(3);
+    });
+  });
+});