@dommaker/harness 1.3.0 → 1.4.0

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

@@ -1,19 +1,22 @@
 /**
- * release 命令测试（O6）
+ * release 命令测试（O6 + 架构评审候选7）
  *
- * Seam：release(options) 公开入口。
+ * Seam：release(options, io) 公开入口。
  * 隔离面：
- *   - child_process.execSync → 按命令分发的 fixture（git/npm/tsc 全部 mock，绝不真执行）
+ *   - child_process.execSync → 按命令前缀分发的 fixture（git/npm/tsc 全部 mock，绝不真执行）
  *   - fs.existsSync / readFileSync → fixture 包（package.json + dist 关键文件）
- *   - process.exit → 抛异常断言化（exit code 可断言，且阻断后续真实副作用）
+ *   - 输出 → 注入 captureIO（不再 spyOn(process,'exit') / 断言彩色字符串）
  *
- * 测试止于 dry-run 与「发布前闸门」（分支/同步/干净树/tag 冲突），
- * 不覆盖真实 npm version/publish 路径——禁止真发版。
+ * 判定结果经返回值外溢：每个前置闸门的失败原因含闸门标识（gate <id>），
+ * 测试断言 kind + reason + 「首败即停」（后续闸门副作用未发生）。
+ *
+ * 测试止于 dry-run 与「发布前闸门」，不覆盖真实 npm version/publish 路径——禁止真发版。
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
+import { captureIO, type CapturingIO } from '../../../cli/command-contract';
 import { release } from '../release';
 
 jest.mock('child_process', () => ({
@@ -62,22 +65,53 @@ const PKG_JSON = JSON.stringify({
   exports: { '.': './dist/index.js' },
 });
 
+/** 抛一个带 stderr 的子进程失败（execSync 失败对象的形状） */
+function fail(cmd: string, stderr = cmd): never {
+  const err: any = new Error(`${cmd} exited`);
+  err.stderr = stderr;
+  throw err;
+}
+
+type Override = [prefix: string, handler: (cmd: string) => string];
+
+/**
+ * 全闸门通过的默认流（master / 已同步 / 干净树 / tsc ok / dist ok /
+ * npm version → v0.18.1 / npm view → 0.18.1），overrides 按前缀优先命中。
+ */
+function flow(overrides: Override[] = []): void {
+  mockExecSync.mockImplementation((cmd) => {
+    const c = String(cmd);
+    for (const [prefix, handler] of overrides) {
+      if (c.startsWith(prefix)) return handler(c);
+    }
+    if (c.startsWith('git rev-parse --abbrev-ref')) return 'master';
+    if (c.startsWith('git rev-list --count')) return '0';
+    if (c.startsWith('git status --porcelain')) return '';
+    if (c.startsWith('git tag -l')) return '';
+    if (c.startsWith('npx tsc')) return 'build ok';
+    if (c.startsWith('npm version')) return 'v0.18.1';
+    if (c.startsWith('npm view')) return '0.18.1';
+    return '';
+  });
+}
+
+function execCommands(): string[] {
+  return mockExecSync.mock.calls.map(c => String(c[0]));
+}
+
+/** 断言 fail 结果的 reason 定位到指定闸门 */
+function gateFail(gate: string) {
+  return { kind: 'fail' as const, reason: expect.stringContaining(`gate ${gate}`) };
+}
+
 describe('release command', () => {
-  let consoleSpy: jest.SpyInstance;
-  let errorSpy: jest.SpyInstance;
-  let exitSpy: jest.SpyInstance;
+  let io: CapturingIO;
   let pkgExists: boolean;
-  let tagListResult: string;
 
   beforeEach(() => {
     jest.clearAllMocks();
+    io = captureIO();
     pkgExists = true;
-    tagListResult = '';
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-    errorSpy = jest.spyOn(console, 'error').mockImplementation();
-    exitSpy = jest.spyOn(process, 'exit').mockImplementation((code?: string | number | null) => {
-      throw new Error(`__exit_${code}__`);
-    });
 
     mockFs.existsSync.mockImplementation((p) => {
       if (String(p).endsWith('package.json')) return pkgExists;
@@ -85,99 +119,194 @@ describe('release command', () => {
     });
     mockFs.readFileSync.mockReturnValue(PKG_JSON);
 
-    mockExecSync.mockImplementation((cmd: string) => {
-      const c = String(cmd);
-      if (c.startsWith('git rev-parse --abbrev-ref')) return 'master';
-      if (c.startsWith('git rev-list --count')) return '0';
-      if (c.startsWith('git status --porcelain')) return '';
-      if (c.startsWith('git tag -l')) return tagListResult;
-      if (c.startsWith('npx tsc')) return 'build ok';
-      return '';
-    });
+    flow();
   });
 
-  afterEach(() => {
-    consoleSpy.mockRestore();
-    errorSpy.mockRestore();
-    exitSpy.mockRestore();
+  test('闸门 1 非包目录：fail 定位 package 闸门，零子进程调用', async () => {
+    pkgExists = false;
+
+    const result = await release({}, io);
+
+    expect(result).toEqual(gateFail('package'));
+    expect(io.errLines().join('\n')).toContain('Not a package');
+    expect(execCommands()).toEqual([]);
   });
 
-  test('非包目录：exit 1 并提示 Not a package', async () => {
-    pkgExists = false;
+  test('闸门 2 非 master/main 分支：fail 定位 branch 闸门，后续闸门不执行', async () => {
+    flow([['git rev-parse --abbrev-ref', () => 'feat/x']]);
+
+    const result = await release({}, io);
 
-    await expect(release({})).rejects.toThrow('__exit_1__');
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Not a package'));
+    expect(result).toEqual(gateFail('branch'));
+    expect(io.errText()).toContain('Must be on master or main branch');
+    const commands = execCommands();
+    expect(commands.some(c => c.startsWith('git fetch'))).toBe(false);
+    expect(commands.some(c => c.startsWith('npx tsc'))).toBe(false);
   });
 
-  test('非 master/main 分支：exit 1 并提示', async () => {
-    mockExecSync.mockImplementation((cmd: string) =>
-      String(cmd).startsWith('git rev-parse --abbrev-ref') ? 'feat/x' : '');
+  test('闸门 3 落后于远程：fail 定位 remote-sync 闸门', async () => {
+    flow([['git rev-list --count', () => '3']]);
 
-    await expect(release({})).rejects.toThrow('__exit_1__');
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Must be on master or main branch'));
+    const result = await release({}, io);
+
+    expect(result).toEqual(gateFail('remote-sync'));
+    expect(io.errText()).toContain('behind origin');
+    expect(execCommands().some(c => c.startsWith('npx tsc'))).toBe(false);
   });
 
-  test('落后于远程：exit 1 并提示 behind', async () => {
-    mockExecSync.mockImplementation((cmd: string) => {
-      const c = String(cmd);
-      if (c.startsWith('git rev-parse --abbrev-ref')) return 'master';
-      if (c.startsWith('git rev-list --count')) return '3';
-      return '';
-    });
+  test('闸门 4 工作树不干净：fail 定位 clean-tree 闸门', async () => {
+    flow([['git status --porcelain', () => ' M package.json']]);
 
-    await expect(release({})).rejects.toThrow('__exit_1__');
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('behind origin'));
+    const result = await release({}, io);
+
+    expect(result).toEqual(gateFail('clean-tree'));
+    expect(io.errText()).toContain('Uncommitted changes');
+    expect(execCommands().some(c => c.startsWith('npx tsc'))).toBe(false);
   });
 
-  test('工作树不干净：exit 1 并提示 Uncommitted changes', async () => {
-    mockExecSync.mockImplementation((cmd: string) => {
-      const c = String(cmd);
-      if (c.startsWith('git rev-parse --abbrev-ref')) return 'master';
-      if (c.startsWith('git rev-list --count')) return '0';
-      if (c.startsWith('git status --porcelain')) return ' M package.json';
-      return '';
-    });
+  test('闸门 5 tsc 构建失败：fail 定位 build 闸门', async () => {
+    flow([['npx tsc', (c) => fail(c, 'error TS2304: cannot find name')]]);
+
+    const result = await release({}, io);
 
-    await expect(release({})).rejects.toThrow('__exit_1__');
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Uncommitted changes'));
+    expect(result).toEqual(gateFail('build'));
+    expect(io.errText()).toContain('tsc failed');
+    expect(io.errText()).toContain('TS2304');
   });
 
-  test('dist 关键发布物缺失：发布前闸门 exit 1（不触 npm version）', async () => {
+  test('闸门 6 dist 关键发布物缺失：fail 定位 dist-artifacts 闸门（不触 npm version）', async () => {
     mockFs.existsSync.mockImplementation((p) => {
       if (String(p).endsWith('package.json')) return true;
       if (String(p).includes(`${path.sep}dist${path.sep}`)) return false;
       return true;
     });
 
-    await expect(release({ bumpType: 'patch' })).rejects.toThrow('__exit_1__');
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('dist missing critical artifacts'));
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('dist/index.js'));
-    const commands = mockExecSync.mock.calls.map(c => String(c[0]));
-    expect(commands.some(c => c.startsWith('npm version'))).toBe(false);
-  });
+    const result = await release({ bumpType: 'patch' }, io);
 
-  test('dry-run patch：计算目标版本 0.18.1，exit 0', async () => {
-    await expect(release({ bumpType: 'patch', dryRun: 'true' })).rejects.toThrow('__exit_0__');
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('Dry-run complete. Would publish: @dommaker/harness@0.18.1'),
-    );
+    expect(result).toEqual(gateFail('dist-artifacts'));
+    expect(io.errText()).toContain('dist missing critical artifacts');
+    expect(io.errText()).toContain('dist/index.js');
+    expect(execCommands().some(c => c.startsWith('npm version'))).toBe(false);
   });
 
-  test('dry-run minor：计算目标版本 0.19.0', async () => {
-    await expect(release({ bumpType: 'minor', dryRun: 'true' })).rejects.toThrow('__exit_0__');
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('Dry-run complete. Would publish: @dommaker/harness@0.19.0'),
-    );
+  test.each([
+    ['patch', '0.18.1'],
+    ['minor', '0.19.0'],
+    ['major', '1.0.0'],
+  ] as const)('dry-run %s：ok 且提示目标版本 %s（不触 npm version）', async (bumpType, expected) => {
+    const result = await release({ bumpType, dryRun: 'true' }, io);
+
+    expect(result).toEqual({ kind: 'ok' });
+    expect(io.outText()).toContain(`Dry-run complete. Would publish: @dommaker/harness@${expected}`);
+    expect(execCommands().some(c => c.startsWith('npm version'))).toBe(false);
   });
 
-  test('目标 tag 已存在：发布前闸门 exit 1（不触 npm version）', async () => {
-    tagListResult = 'v0.18.1';
+  test('闸门 7 目标 tag 已存在：fail 定位 tag-conflict 闸门（不触 npm version/publish）', async () => {
+    flow([['git tag -l', () => 'v0.18.1']]);
+
+    const result = await release({ bumpType: 'patch' }, io);
 
-    await expect(release({ bumpType: 'patch' })).rejects.toThrow('__exit_1__');
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('already exists'));
-    // 闸门阻断：npm version / npm publish 从未执行
-    const commands = mockExecSync.mock.calls.map(c => String(c[0]));
+    expect(result).toEqual(gateFail('tag-conflict'));
+    expect(io.errText()).toContain('already exists');
+    const commands = execCommands();
     expect(commands.some(c => c.startsWith('npm version'))).toBe(false);
     expect(commands.some(c => c.startsWith('npm publish'))).toBe(false);
   });
+
+  test('闸门 8 npm version 失败：fail 定位 version-bump 闸门（不触 push）', async () => {
+    flow([['npm version', (c) => fail(c, 'npm ERR! Version prefix required')]]);
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual(gateFail('version-bump'));
+    expect(io.errText()).toContain('npm version failed');
+    expect(execCommands().some(c => c.startsWith('git push'))).toBe(false);
+  });
+
+  test('闸门 9 git push 失败（非保护分支）：fail 定位 git-push 闸门', async () => {
+    flow([['git push origin master', (c) => fail(c, 'error: failed to push some refs')]]);
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual(gateFail('git-push'));
+    expect(io.errText()).toContain('git push failed');
+    expect(execCommands().some(c => c.startsWith('npm publish'))).toBe(false);
+  });
+
+  test('闸门 10 保护分支且 PR 创建失败：fail 定位 pr-create 闸门', async () => {
+    flow([
+      ['git push origin master', (c) => fail(c, 'GH006: push rejected to protected branch')],
+      ['gh pr create', (c) => fail(c, 'could not create pull request')],
+    ]);
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual(gateFail('pr-create'));
+    expect(io.errText()).toContain('PR creation failed');
+    expect(execCommands().some(c => c.startsWith('npm publish'))).toBe(false);
+  });
+
+  test('保护分支且 PR 创建成功：ok（不走 npm publish，打印后续步骤）', async () => {
+    flow([
+      ['git push origin master', (c) => fail(c, 'GH006: push rejected to protected branch')],
+      ['gh pr create', () => 'https://github.com/x/y/pull/9'],
+    ]);
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual({ kind: 'ok' });
+    expect(io.outText()).toContain('PR created: https://github.com/x/y/pull/9');
+    expect(io.outText()).toContain('Next steps');
+    expect(execCommands().some(c => c.startsWith('npm publish'))).toBe(false);
+  });
+
+  test('闸门 11 package.json private=true：fail 定位 private-flag 闸门（不触 npm publish）', async () => {
+    mockFs.readFileSync.mockReturnValue(JSON.stringify({
+      name: '@dommaker/harness',
+      version: '0.18.0',
+      private: true,
+      main: './dist/index.js',
+    }));
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual(gateFail('private-flag'));
+    expect(io.errText()).toContain('"private": true');
+    expect(execCommands().some(c => c.startsWith('npm publish'))).toBe(false);
+  });
+
+  test('闸门 12 npm 版本校验不一致：fail 定位 npm-publish-verify 闸门', async () => {
+    flow([['npm view', () => '0.0.1']]);
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual(gateFail('npm-publish-verify'));
+    expect(io.errText()).toContain('npm publish verification failed');
+    expect(io.errText()).toContain('Expected 0.18.1, registry has 0.0.1');
+  });
+
+  test('发布全流程通过：ok，GitHub Release 失败为非致命告警', async () => {
+    flow([['gh release create', (c) => fail(c, 'gh: could not generate notes')]]);
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual({ kind: 'ok' });
+    expect(io.outText()).toContain('Released @dommaker/harness@0.18.1');
+    expect(io.outText()).toContain('release may have failed (non-fatal)');
+    expect(io.outText()).toContain('npm: published @dommaker/harness@0.18.1');
+  });
+
+  test('闸门标识唯一且覆盖全部前置闸门（失败原因可逐闸门断言）', () => {
+    // 本文件 mock 了 fs，读源码要走真实 fs
+    const source: string = jest.requireActual('fs').readFileSync(path.join(__dirname, '..', 'release.ts'), 'utf-8');
+    expect(source).toContain('export async function release');
+    const gateIds = [...source.matchAll(/gateFail\('([a-z0-9-]+)'/g)].map(m => m[1]);
+    expect(gateIds.length).toBeGreaterThanOrEqual(12);
+    expect(new Set(gateIds).size).toBe(gateIds.length);
+    expect(gateIds).toEqual(expect.arrayContaining([
+      'package', 'branch', 'remote-sync', 'clean-tree', 'build', 'dist-artifacts',
+      'tag-conflict', 'version-bump', 'git-push', 'pr-create', 'private-flag', 'npm-publish-verify',
+    ]));
+    expect(source).not.toContain('process.exit');
+  });
 });

package/src/cli/commands/__tests__/report-extra.test.ts

@@ -3,6 +3,7 @@
  */
 
 import { report } from '../report';
+import { captureIO, type CapturingIO } from '../../command-contract';
 import * as fs from 'fs/promises';
 
 // Mock fs/promises
@@ -19,30 +20,29 @@ jest.mock('chalk', () => ({
 
 const mockFs = fs as jest.Mocked<typeof fs>;
 
+let io: CapturingIO;
+beforeEach(() => {
+  io = captureIO();
+});
+
 describe('report command - 补充覆盖', () => {
-  let consoleSpy: jest.SpyInstance;
 
   beforeEach(() => {
     jest.clearAllMocks();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-  });
-
-  afterEach(() => {
-    consoleSpy.mockRestore();
   });
 
   describe('format 边界情况', () => {
     it('未知格式应该默认输出 JSON', async () => {
-      await report({ format: 'json' });
-      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      await report({ format: 'json' }, io);
+      const output = io.outText();
       expect(output).toContain('timestamp');
     });
   });
 
   describe('Markdown 报告完整内容', () => {
     it('Markdown 报告应该包含所有区块', async () => {
-      await report({ format: 'markdown' });
-      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      await report({ format: 'markdown' }, io);
+      const output = io.outText();
 
       expect(output).toContain('# Harness 检查报告');
       expect(output).toContain('## 约束检查');
@@ -54,8 +54,8 @@ describe('report command - 补充覆盖', () => {
 
   describe('HTML 报告完整内容', () => {
     it('HTML 报告应该包含所有区块', async () => {
-      await report({ format: 'html' });
-      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      await report({ format: 'html' }, io);
+      const output = io.outText();
 
       expect(output).toContain('<!DOCTYPE html>');
       expect(output).toContain('<title>Harness 检查报告</title>');
@@ -68,22 +68,22 @@ describe('report command - 补充覆盖', () => {
     it('Markdown 输出到文件', async () => {
       mockFs.writeFile.mockResolvedValue(undefined);
 
-      await report({ format: 'markdown', output: 'report.md' });
+      await report({ format: 'markdown', output: 'report.md' }, io);
       expect(mockFs.writeFile).toHaveBeenCalledWith('report.md', expect.stringContaining('# Harness'), 'utf-8');
     });
 
     it('HTML 输出到文件', async () => {
       mockFs.writeFile.mockResolvedValue(undefined);
 
-      await report({ format: 'html', output: 'report.html' });
+      await report({ format: 'html', output: 'report.html' }, io);
       expect(mockFs.writeFile).toHaveBeenCalledWith('report.html', expect.stringContaining('<!DOCTYPE html>'), 'utf-8');
     });
   });
 
   describe('JSON 报告内容', () => {
     it('JSON 应该包含完整数据结构', async () => {
-      await report({ format: 'json' });
-      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      await report({ format: 'json' }, io);
+      const output = io.outText();
       const jsonStart = output.indexOf('{');
       const jsonStr = output.slice(jsonStart);
       const data = JSON.parse(jsonStr);

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

@@ -3,6 +3,7 @@
  */
 
 import { report } from '../report';
+import { captureIO, type CapturingIO } from '../../command-contract';
 import * as fs from 'fs/promises';
 
 // Mock fs/promises
@@ -19,60 +20,59 @@ jest.mock('chalk', () => ({
 
 const mockFs = fs as jest.Mocked<typeof fs>;
 
+let io: CapturingIO;
+beforeEach(() => {
+  io = captureIO();
+});
+
 describe('report command', () => {
-  let consoleSpy: jest.SpyInstance;
 
   beforeEach(() => {
     jest.clearAllMocks();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-  });
-
-  afterEach(() => {
-    consoleSpy.mockRestore();
   });
 
   describe('report', () => {
     it('应该生成 JSON 格式报告', async () => {
-      await report({ format: 'json' });
-      expect(consoleSpy).toHaveBeenCalled();
-      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      await report({ format: 'json' }, io);
+      expect(io.outText()).not.toBe('');
+      const output = io.outText();
       expect(output).toContain('timestamp');
     });
 
     it('应该生成 Markdown 格式报告', async () => {
-      await report({ format: 'markdown' });
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Harness 检查报告'));
+      await report({ format: 'markdown' }, io);
+      expect(io.outText()).toContain('Harness 检查报告');
     });
 
     it('应该生成 HTML 格式报告', async () => {
-      await report({ format: 'html' });
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('<!DOCTYPE html>'));
+      await report({ format: 'html' }, io);
+      expect(io.outText()).toContain('<!DOCTYPE html>');
     });
 
     it('应该保存报告到文件', async () => {
       mockFs.writeFile.mockResolvedValue(undefined);
 
-      await report({ format: 'json', output: 'report.json' });
+      await report({ format: 'json', output: 'report.json' }, io);
       expect(mockFs.writeFile).toHaveBeenCalledWith('report.json', expect.any(String), 'utf-8');
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('报告已保存'));
+      expect(io.outText()).toContain('报告已保存');
     });
 
     it('应该使用自定义项目路径', async () => {
-      await report({ format: 'json', projectPath: '/custom/path' });
-      expect(consoleSpy).toHaveBeenCalled();
+      await report({ format: 'json', projectPath: '/custom/path' }, io);
+      expect(io.outText()).not.toBe('');
     });
 
     it('Markdown 报告应包含表格结构', async () => {
-      await report({ format: 'markdown' });
-      const output = consoleSpy.mock.calls.map((c: unknown[]) => c[0]).join('\n');
+      await report({ format: 'markdown' }, io);
+      const output = io.outText();
       expect(output).toContain('| 指标 | 数值 |');
       expect(output).toContain('| 总约束 |');
       expect(output).toContain('报告由 @dommaker/harness 生成');
     });
 
     it('HTML 报告应包含完整结构', async () => {
-      await report({ format: 'html' });
-      const output = consoleSpy.mock.calls.map((c: unknown[]) => c[0]).join('\n');
+      await report({ format: 'html' }, io);
+      const output = io.outText();
       expect(output).toContain('<html lang="zh-CN">');
       expect(output).toContain('</html>');
       expect(output).toContain('Harness 检查报告');
@@ -80,8 +80,8 @@ describe('report command', () => {
     });
 
     it('JSON 报告应包含约束统计', async () => {
-      await report({ format: 'json' });
-      const output = consoleSpy.mock.calls.map((c: unknown[]) => c[0]).join('\n');
+      await report({ format: 'json' }, io);
+      const output = io.outText();
       // 过滤掉 chalk 的 emoji 行，只取 JSON 部分
       const jsonStart = output.indexOf('{');
       const jsonEnd = output.lastIndexOf('}');
@@ -96,13 +96,13 @@ describe('report command', () => {
 
     it('应该支持输出到文件 (markdown)', async () => {
       mockFs.writeFile.mockResolvedValue(undefined);
-      await report({ format: 'markdown', output: 'report.md' });
+      await report({ format: 'markdown', output: 'report.md' }, io);
       expect(mockFs.writeFile).toHaveBeenCalledWith('report.md', expect.stringContaining('# Harness'), 'utf-8');
     });
 
     it('应该支持输出到文件 (html)', async () => {
       mockFs.writeFile.mockResolvedValue(undefined);
-      await report({ format: 'html', output: 'report.html' });
+      await report({ format: 'html', output: 'report.html' }, io);
       expect(mockFs.writeFile).toHaveBeenCalledWith('report.html', expect.stringContaining('<!DOCTYPE html>'), 'utf-8');
     });
   });