@dommaker/harness 1.6.0 → 1.8.0

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

@@ -6,15 +6,19 @@ import { describe, it, expect, beforeAll, afterAll, beforeEach } from '@jest/glo
 import { ContractGate } from '../gates/contract';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 
 describe('ContractGate', () => {
-  const tempDir = path.join(process.cwd(), 'temp-test-contract');
-  const contractFile = path.join(tempDir, 'openapi.yaml');
-  const oldContractFile = path.join(tempDir, 'openapi-old.yaml');
-  const jsonContractFile = path.join(tempDir, 'openapi.json');
+  let tempDir: string;
+  let contractFile: string;
+  let oldContractFile: string;
+  let jsonContractFile: string;
 
   beforeAll(() => {
-    fs.mkdirSync(tempDir, { recursive: true });
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'temp-test-contract-'));
+    contractFile = path.join(tempDir, 'openapi.yaml');
+    oldContractFile = path.join(tempDir, 'openapi-old.yaml');
+    jsonContractFile = path.join(tempDir, 'openapi.json');
   });
 
   afterAll(() => {
@@ -37,23 +41,10 @@ describe('ContractGate', () => {
   });
 
   describe('check', () => {
-    it('禁用时应该返回通过', async () => {
-      const gate = new ContractGate({ enabled: false });
-
-      const result = await gate.check({
-        projectId: 'test',
-        projectPath: tempDir,
-      });
-
-      expect(result.passed).toBe(true);
-      expect(result.message).toContain('禁用');
-    });
-
     it('无契约文件时应该通过', async () => {
-      const gate = new ContractGate({ enabled: true });
+      const gate = new ContractGate();
 
       const result = await gate.check({
-        projectId: 'test',
         projectPath: tempDir,
       });
 
@@ -76,10 +67,9 @@ paths:
       summary: Create user
 `);
 
-      const gate = new ContractGate({ enabled: true });
+      const gate = new ContractGate();
 
       const result = await gate.check({
-        projectId: 'test',
         projectPath: tempDir,
       });
 
@@ -98,10 +88,9 @@ paths:
       summary: Test
 `);
 
-      const gate = new ContractGate({ enabled: true });
+      const gate = new ContractGate();
 
       const result = await gate.check({
-        projectId: 'test',
         projectPath: tempDir,
       });
 
@@ -118,10 +107,9 @@ info:
 paths:
 `);
 
-      const gate = new ContractGate({ enabled: true });
+      const gate = new ContractGate();
 
       const result = await gate.check({
-        projectId: 'test',
         projectPath: tempDir,
       });
 
@@ -139,10 +127,9 @@ paths:
         },
       }));
 
-      const gate = new ContractGate({ enabled: true, contractPath: 'openapi.json' });
+      const gate = new ContractGate({contractPath: 'openapi.json' });
 
       const result = await gate.check({
-        projectId: 'test',
         projectPath: tempDir,
       });
 
@@ -172,10 +159,9 @@ paths:
       summary: Test
 `);
 
-      const gate = new ContractGate({ enabled: true, allowBreakingChanges: false });
+      const gate = new ContractGate({allowBreakingChanges: false });
 
       const result = await gate.check({
-        projectId: 'test',
         projectPath: tempDir,
         oldContractPath: oldContractFile,
       });
@@ -205,10 +191,9 @@ paths:
       summary: Test
 `);
 
-      const gate = new ContractGate({ enabled: true, allowBreakingChanges: true });
+      const gate = new ContractGate({allowBreakingChanges: true });
 
       const result = await gate.check({
-        projectId: 'test',
         projectPath: tempDir,
         oldContractPath: oldContractFile,
       });
@@ -237,10 +222,9 @@ paths:
       summary: New endpoint
 `);
 
-      const gate = new ContractGate({ enabled: true });
+      const gate = new ContractGate();
 
       const result = await gate.check({
-        projectId: 'test',
         projectPath: tempDir,
         oldContractPath: oldContractFile,
       });
@@ -258,10 +242,9 @@ paths:
       summary: Custom
 `);
 
-      const gate = new ContractGate({ enabled: true });
+      const gate = new ContractGate();
 
       const result = await gate.check({
-        projectId: 'test',
         projectPath: tempDir,
         newContractPath: customContract,
       });
@@ -272,10 +255,9 @@ paths:
     it('无效 YAML 应该返回解析失败', async () => {
       fs.writeFileSync(contractFile, 'invalid: yaml: content: [broken');
 
-      const gate = new ContractGate({ enabled: true });
+      const gate = new ContractGate();
 
       const result = await gate.check({
-        projectId: 'test',
         projectPath: tempDir,
       });
 
@@ -295,14 +277,12 @@ paths:
 
     it('getConfig 应该返回当前配置', () => {
       const gate = new ContractGate({
-        enabled: true,
         strict: false,
         allowBreakingChanges: true,
         contractPath: 'api.yaml',
       });
 
       const config = gate.getConfig();
-      expect(config.enabled).toBe(true);
       expect(config.strict).toBe(false);
       expect(config.allowBreakingChanges).toBe(true);
       expect(config.contractPath).toBe('api.yaml');
@@ -312,7 +292,6 @@ paths:
       const gate = new ContractGate();
       const config = gate.getConfig();
 
-      expect(config.enabled).toBe(true);
       expect(config.strict).toBe(true);
       expect(config.allowBreakingChanges).toBe(false);
       expect(config.contractPath).toBe('openapi.yaml');

package/src/__tests__/error-classifier.test.ts

@@ -4,7 +4,7 @@
 
 import { describe, it, expect } from '@jest/globals';
 import { ErrorClassifier } from '../failure/classifier';
-import { ErrorType, FailureLevel } from '../failure/types';
+import { ErrorType, FailureLevel } from '../types/failure';
 
 describe('ErrorClassifier', () => {
   const classifier = new ErrorClassifier();

package/src/__tests__/exec.test.ts

@@ -1,117 +1,55 @@
 /**
  * exec 工具测试
+ *
+ * 零消费者与跨 seam 谓词的收缩记录（harness#137 / #162，判据同 ADR-0022）：
+ * - `isCommandAvailable` / `delay` 双仓零生产消费者，已删（#137）；
+ * - `normalizeTriggers` / `matchesTrigger` 是约束域谓词（harness#105），已迁
+ *   `src/core/constraints/triggers.ts`，用例正本见 `core/constraints/__tests__/triggers.test.ts`；
+ * - `runCommand` 已删（#162）：#137 头注原记「`core/constraints/check-cache.ts`、`git-evidence.ts`
+ *   有生产消费者」，实测两处均为**注释**引用（示例用法与缓冲上限说明），非测试代码里
+ *   `runCommand(` 调用点为 0，且它不在包公共面（`src/index.ts` 与 `package.json` 五个
+ *   exports 入口均无）——与 `isCommandAvailable`/`delay` 同属「测试为假想消费者站岗」，
+ *   按 ADR-0022 同判据删除，外部不可达故零迁移成本。
+ * 下列 `@ts-expect-error` 与运行时键断言双向钉住：删多（指令失效即红）与复活（键重新出现即红）。
  */
 
 import { describe, it, expect } from '@jest/globals';
-import { runCommand, isCommandAvailable, normalizeTriggers, matchesTrigger, delay } from '../utils/exec';
+// @ts-expect-error isCommandAvailable 零生产消费者，随 harness#137 删除
+import { isCommandAvailable } from '../utils/exec';
+// @ts-expect-error delay 零生产消费者，随 harness#137 删除
+import { delay } from '../utils/exec';
+// @ts-expect-error normalizeTriggers 是约束域谓词，已迁 core/constraints/triggers（harness#137）
+import { normalizeTriggers } from '../utils/exec';
+// @ts-expect-error matchesTrigger 是约束域谓词，已迁 core/constraints/triggers（harness#137）
+import { matchesTrigger } from '../utils/exec';
+// @ts-expect-error runCommand 零生产消费者且不在包公共面，随 harness#162 删除（判据见头注）
+import { runCommand } from '../utils/exec';
 
 describe('exec utils', () => {
-  describe('runCommand', () => {
-    it('应该执行命令并返回 stdout', async () => {
-      const result = await runCommand('echo hello');
-      expect(result).toBe('hello');
-    });
-
-    it('不存在的命令应该返回空字符串', async () => {
-      const result = await runCommand('nonexistent_command_xyz');
-      expect(result).toBe('');
-    });
-
-    it('应该支持 cwd 参数', async () => {
-      const result = await runCommand('pwd', '/tmp');
-      expect(result).toContain('tmp');
-    });
-
-    it('多行输出应该保留换行', async () => {
-      const result = await runCommand('echo -e "line1\\nline2"');
-      expect(result).toContain('line1');
-      expect(result).toContain('line2');
-    });
-  });
-
-  describe('isCommandAvailable', () => {
-    it('存在的命令应该返回 true', async () => {
-      const result = await isCommandAvailable('ls');
-      expect(result).toBe(true);
-    });
-
-    it('不存在的命令应该返回 false', async () => {
-      const result = await isCommandAvailable('nonexistent_command_xyz');
-      expect(result).toBe(false);
-    });
-
-    it('常见命令应该可用', async () => {
-      expect(await isCommandAvailable('cat')).toBe(true);
-      expect(await isCommandAvailable('grep')).toBe(true);
-    });
-  });
-
-  describe('normalizeTriggers', () => {
-    it('应该返回 fallback 当值为 null', () => {
-      const result = normalizeTriggers(null, ['default']);
-      expect(result).toEqual(['default']);
-    });
-
-    it('应该返回 fallback 当值为 undefined', () => {
-      const result = normalizeTriggers(undefined, ['default']);
-      expect(result).toEqual(['default']);
-    });
-
-    it('应该将单值包装为数组', () => {
-      const result = normalizeTriggers('single');
-      expect(result).toEqual(['single']);
-    });
-
-    it('应该直接返回数组', () => {
-      const result = normalizeTriggers(['a', 'b']);
-      expect(result).toEqual(['a', 'b']);
-    });
-
-    it('应该使用空数组作为默认 fallback', () => {
-      const result = normalizeTriggers(undefined);
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('matchesTrigger', () => {
-    it('单值 trigger 命中操作返回 true', () => {
-      expect(matchesTrigger({ trigger: 'a' }, ['a'])).toBe(true);
-    });
-
-    it('单值 trigger 未命中返回 false', () => {
-      expect(matchesTrigger({ trigger: 'a' }, ['b'])).toBe(false);
-    });
-
-    it('数组 trigger 任一命中即返回 true', () => {
-      expect(matchesTrigger({ trigger: ['a', 'b'] }, ['b'])).toBe(true);
-    });
-
-    it('数组 trigger 全部未命中返回 false', () => {
-      expect(matchesTrigger({ trigger: ['a', 'b'] }, ['c', 'd'])).toBe(false);
-    });
-
-    it('operations 中任一命中即返回 true', () => {
-      expect(matchesTrigger({ trigger: 'a' }, ['x', 'a'])).toBe(true);
-    });
-
-    it('trigger 为 undefined 时不匹配任何操作', () => {
-      expect(matchesTrigger({ trigger: undefined }, ['a'])).toBe(false);
-    });
-
-    it('trigger 为空数组时不匹配任何操作', () => {
-      expect(matchesTrigger({ trigger: [] }, ['a'])).toBe(false);
-    });
-
-    it('operations 为空数组时返回 false', () => {
-      expect(matchesTrigger({ trigger: 'a' }, [])).toBe(false);
-    });
-  });
-
-  describe('delay', () => {
-    it('应该延迟指定时间', async () => {
-      const start = Date.now();
-      await delay(10);
-      expect(Date.now() - start).toBeGreaterThanOrEqual(8);
+  describe('零消费者与跨 seam 收缩（harness#137 / #162）', () => {
+    it('已删/已迁的五个名字在模块运行时键里都不存在', async () => {
+      const mod = await import('../utils/exec');
+      expect(Object.keys(mod).sort()).toEqual(['execAsync']);
+      for (const gone of [
+        'isCommandAvailable',
+        'delay',
+        'normalizeTriggers',
+        'matchesTrigger',
+        'runCommand',
+      ]) {
+        expect(mod).not.toHaveProperty(gone);
+      }
+    });
+
+    it('编译期钉：五个名字不再是 utils/exec 的导出（复活即 TS2578 红）', () => {
+      // 上面的 @ts-expect-error 只在名字**不存在**时成立；此处消费导入名让指令进入生效路径
+      expect([isCommandAvailable, delay, normalizeTriggers, matchesTrigger, runCommand]).toEqual([
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+      ]);
     });
   });
 });

package/src/__tests__/failure-recorder.test.ts

@@ -4,18 +4,20 @@
 
 import { describe, it, expect, beforeAll, afterAll, beforeEach } from '@jest/globals';
 import { FailureRecorder, createFailureRecorder } from '../failure/recorder';
-import { ErrorType, FailureLevel } from '../failure/types';
+import { ErrorType, FailureLevel } from '../types/failure';
 import * as fs from 'fs';
 import * as path from 'path';
-import type { FailureRecord } from '../failure/types';
+import * as os from 'os';
+import type { FailureRecord } from '../types/failure';
 
 describe('FailureRecorder', () => {
-  const tempDir = path.join(process.cwd(), 'temp-test-recorder');
-  const logFile = path.join(tempDir, 'failures.log');
+  let tempDir: string;
+  let logFile: string;
   let recorder: FailureRecorder;
 
   beforeAll(() => {
-    fs.mkdirSync(tempDir, { recursive: true });
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'temp-test-recorder-'));
+    logFile = path.join(tempDir, 'failures.log');
   });
 
   afterAll(() => {

package/src/__tests__/hooks-pipeline.test.ts

@@ -1,10 +1,13 @@
 /**
  * HookRegistry + HookPipeline 测试（Phase 1）
+ *
+ * #159 起 `enabled` / `errorStrategy` 由 HookConfig 唯一声明，
+ * 注册时以配置填充有效值；HookDefinition 不再携带这两个字段。
  */
 import { describe, it, expect, beforeEach } from '@jest/globals';
 import { HookRegistry } from '../hooks/registry';
 import { HookPipeline } from '../hooks/pipeline';
-import type { HookDefinition } from '../hooks/types';
+import type { HookConfig, HookDefinition } from '../hooks/types';
 
 interface TestContext {
   value: string;
@@ -19,7 +22,6 @@ function makeHook(
     name,
     phase: 'before',
     priority: 100,
-    errorStrategy: 'block',
     execute: async (ctx) => {
       ctx.calls.push(name);
       return { passed: true };
@@ -28,6 +30,10 @@ function makeHook(
   };
 }
 
+function makeConfig(name: string, overrides: Partial<HookConfig> = {}): HookConfig {
+  return { name, enabled: true, errorStrategy: 'block', ...overrides };
+}
+
 describe('HookRegistry', () => {
   let registry: HookRegistry<TestContext, unknown>;
 
@@ -36,34 +42,34 @@ describe('HookRegistry', () => {
   });
 
   it('应注册 hook', () => {
-    registry.register(makeHook('test'));
+    registry.register(makeHook('test'), makeConfig('test'));
     expect(registry.get('test')).toBeDefined();
   });
 
   it('同名注册应覆盖', () => {
-    registry.register(makeHook('test', { priority: 50 }));
-    registry.register(makeHook('test', { priority: 90 }));
+    registry.register(makeHook('test', { priority: 50 }), makeConfig('test'));
+    registry.register(makeHook('test', { priority: 90 }), makeConfig('test'));
     expect(registry.get('test')?.priority).toBe(90);
   });
 
   it('应获取已启用的 hook 按优先级排序', () => {
-    registry.register(makeHook('low', { priority: 200 }));
-    registry.register(makeHook('high', { priority: 10 }));
-    registry.register(makeHook('mid', { priority: 100 }));
-    registry.register(makeHook('disabled', { enabled: false }));
+    registry.register(makeHook('low', { priority: 200 }), makeConfig('low'));
+    registry.register(makeHook('high', { priority: 10 }), makeConfig('high'));
+    registry.register(makeHook('mid', { priority: 100 }), makeConfig('mid'));
+    registry.register(makeHook('disabled'), makeConfig('disabled', { enabled: false }));
 
     const enabled = registry.getEnabled('before');
     expect(enabled.map(h => h.name)).toEqual(['high', 'mid', 'low']);
   });
 
   it('应注销 hook', () => {
-    registry.register(makeHook('test'));
+    registry.register(makeHook('test'), makeConfig('test'));
     expect(registry.unregister('test')).toBe(true);
     expect(registry.get('test')).toBeUndefined();
   });
 
   it('应设置启用/禁用', () => {
-    registry.register(makeHook('test'));
+    registry.register(makeHook('test'), makeConfig('test'));
     expect(registry.setEnabled('test', false)).toBe(true);
     expect(registry.getEnabled('before').length).toBe(0);
     expect(registry.setEnabled('test', true)).toBe(true);
@@ -72,8 +78,8 @@ describe('HookRegistry', () => {
 
   it('应正确统计数量', () => {
     expect(registry.size).toBe(0);
-    registry.register(makeHook('a'));
-    registry.register(makeHook('b'));
+    registry.register(makeHook('a'), makeConfig('a'));
+    registry.register(makeHook('b'), makeConfig('b'));
     expect(registry.size).toBe(2);
   });
 });
@@ -89,8 +95,8 @@ describe('HookPipeline', () => {
 
   it('应执行所有 before hook', async () => {
     const ctx: TestContext = { value: '', calls: [] };
-    registry.register(makeHook('h1'));
-    registry.register(makeHook('h2'));
+    registry.register(makeHook('h1'), makeConfig('h1'));
+    registry.register(makeHook('h2'), makeConfig('h2'));
 
     const result = await pipeline.run('before', ctx);
 
@@ -101,12 +107,11 @@ describe('HookPipeline', () => {
 
   it('blocking hook 失败应停止后续', async () => {
     const ctx: TestContext = { value: '', calls: [] };
-    registry.register(makeHook('pass1'));
+    registry.register(makeHook('pass1'), makeConfig('pass1'));
     registry.register(makeHook('block', {
       execute: async () => ({ passed: false, error: 'blocked' }),
-      errorStrategy: 'block',
-    }));
-    registry.register(makeHook('never_runs'));
+    }), makeConfig('block', { errorStrategy: 'block' }));
+    registry.register(makeHook('never_runs'), makeConfig('never_runs'));
 
     const result = await pipeline.run('before', ctx);
 
@@ -121,9 +126,8 @@ describe('HookPipeline', () => {
     const ctx: TestContext = { value: '', calls: [] };
     registry.register(makeHook('warn_hook', {
       execute: async () => ({ passed: false, error: 'warning' }),
-      errorStrategy: 'warn',
-    }));
-    registry.register(makeHook('should_still_run'));
+    }), makeConfig('warn_hook', { errorStrategy: 'warn' }));
+    registry.register(makeHook('should_still_run'), makeConfig('should_still_run'));
 
     const result = await pipeline.run('before', ctx);
 
@@ -132,28 +136,12 @@ describe('HookPipeline', () => {
     expect(ctx.calls).toContain('should_still_run');
   });
 
-  it('ignore hook 失败应静默继续', async () => {
-    const ctx: TestContext = { value: '', calls: [] };
-    registry.register(makeHook('ignore_hook', {
-      execute: async () => ({ passed: false, error: 'ignored' }),
-      errorStrategy: 'ignore',
-    }));
-    registry.register(makeHook('still_runs'));
-
-    const result = await pipeline.run('before', ctx);
-
-    expect(result.passed).toBe(true);
-    expect(result.warnings).toEqual([]);
-    expect(ctx.calls).toContain('still_runs');
-  });
-
   it('hook 抛异常应被捕获', async () => {
     const ctx: TestContext = { value: '', calls: [] };
     registry.register(makeHook('throws', {
       execute: async () => { throw new Error('crash'); },
-      errorStrategy: 'warn',
-    }));
-    registry.register(makeHook('after_crash', { priority: 200 }));
+    }), makeConfig('throws', { errorStrategy: 'warn' }));
+    registry.register(makeHook('after_crash', { priority: 200 }), makeConfig('after_crash'));
 
     const result = await pipeline.run('before', ctx);
 
@@ -163,10 +151,10 @@ describe('HookPipeline', () => {
 
   it('runFull 应在 before/after 之间执行操作', async () => {
     const ctx: TestContext = { value: '', calls: [] };
-    registry.register(makeHook('before_hook'));
+    registry.register(makeHook('before_hook'), makeConfig('before_hook'));
 
     const afterHook = makeHook('after_hook', { phase: 'after' });
-    registry.register(afterHook);
+    registry.register(afterHook, makeConfig('after_hook'));
 
     const { pipelineResult, operationResult } = await pipeline.runFull(ctx, async () => {
       ctx.calls.push('operation');
@@ -182,8 +170,7 @@ describe('HookPipeline', () => {
     const ctx: TestContext = { value: '', calls: [] };
     registry.register(makeHook('block', {
       execute: async () => ({ passed: false }),
-      errorStrategy: 'block',
-    }));
+    }), makeConfig('block', { errorStrategy: 'block' }));
 
     const { pipelineResult, operationResult } = await pipeline.runFull(ctx, async () => {
       ctx.calls.push('should_not_run');
@@ -201,10 +188,10 @@ describe('HookPipeline', () => {
     expect(result.records).toEqual([]);
   });
 
-  it('应忽略 disabled hook', async () => {
+  it('应忽略配置禁用的 hook', async () => {
     const ctx: TestContext = { value: '', calls: [] };
-    registry.register(makeHook('enabled'));
-    registry.register(makeHook('disabled', { enabled: false }));
+    registry.register(makeHook('enabled'), makeConfig('enabled'));
+    registry.register(makeHook('disabled'), makeConfig('disabled', { enabled: false }));
 
     await pipeline.run('before', ctx);