clawt 2.10.1 → 2.11.1

package/tests/unit/commands/run.test.ts

@@ -25,19 +25,67 @@ vi.mock('../../../src/constants/index.js', () => ({
     INTERRUPT_CONFIRM_CLEANUP: '是否清理已创建的 worktree？',
     INTERRUPT_CLEANED: (count: number) => `已清理 ${count} 个 worktree`,
     INTERRUPT_KEPT: '已保留 worktree',
+    CONCURRENCY_INFO: (concurrency: number, total: number) => `并发限制: ${concurrency}，共 ${total} 个任务`,
+    CONCURRENCY_INVALID: '并发数必须为正整数',
+    FILE_AND_TASKS_CONFLICT: '--file 和 --tasks 不能同时使用',
+    BRANCH_OR_FILE_REQUIRED: '请指定 -b 或 -f',
+    TASK_FILE_LOADED: (count: number, path: string) => `✓ 从 ${path} 加载了 ${count} 个任务`,
+    TASK_FILE_MISSING_TASK_BY_INDEX: (blockIndex: number) => `第 ${blockIndex} 个任务块缺少任务描述`,
   },
 }));
 
-vi.mock('../../../src/utils/index.js', () => ({
-  validateMainWorktree: vi.fn(),
-  validateClaudeCodeInstalled: vi.fn(),
-  createWorktrees: vi.fn(),
-  sanitizeBranchName: vi.fn(),
-  checkBranchExists: vi.fn(),
+/**
+ * mock utils/index.js —— run.ts 的直接依赖
+ * 注意：executeBatchTasks 不在此 mock，由 utils/index.js 的 re-export 指向 task-executor.js 的真实实现
+ */
+vi.mock('../../../src/utils/index.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../../src/utils/index.js')>();
+  return {
+    ...actual,
+    validateMainWorktree: vi.fn(),
+    validateClaudeCodeInstalled: vi.fn(),
+    createWorktrees: vi.fn(),
+    sanitizeBranchName: vi.fn(),
+    checkBranchExists: vi.fn(),
+    getConfigValue: vi.fn().mockReturnValue(0),
+    printSuccess: vi.fn(),
+    printError: vi.fn(),
+    printWarning: vi.fn(),
+    printInfo: vi.fn(),
+    printSeparator: vi.fn(),
+    printDoubleSeparator: vi.fn(),
+    confirmAction: vi.fn(),
+    launchInteractiveClaude: vi.fn(),
+    loadTaskFile: vi.fn(),
+    createWorktreesByBranches: vi.fn(),
+  };
+});
+
+/** task-executor.ts 内部依赖的具体模块 mock */
+vi.mock('../../../src/utils/shell.js', () => ({
   spawnProcess: vi.fn(),
   killAllChildProcesses: vi.fn(),
+  execCommand: vi.fn(),
+  execCommandWithInput: vi.fn(),
+}));
+
+vi.mock('../../../src/utils/worktree.js', () => ({
   cleanupWorktrees: vi.fn(),
-  getConfigValue: vi.fn(),
+  createWorktrees: vi.fn(),
+  getProjectWorktrees: vi.fn(),
+  getProjectWorktreeDir: vi.fn(),
+  getWorktreeStatus: vi.fn(),
+  createWorktreesByBranches: vi.fn(),
+}));
+
+vi.mock('../../../src/utils/config.js', () => ({
+  getConfigValue: vi.fn().mockReturnValue(0),
+  loadConfig: vi.fn(),
+  writeDefaultConfig: vi.fn(),
+  ensureClawtDirs: vi.fn(),
+}));
+
+vi.mock('../../../src/utils/formatter.js', () => ({
   printSuccess: vi.fn(),
   printError: vi.fn(),
   printWarning: vi.fn(),
@@ -45,25 +93,47 @@ vi.mock('../../../src/utils/index.js', () => ({
   printSeparator: vi.fn(),
   printDoubleSeparator: vi.fn(),
   confirmAction: vi.fn(),
-  launchInteractiveClaude: vi.fn(),
+  confirmDestructiveAction: vi.fn(),
+  formatWorktreeStatus: vi.fn(),
+  isWorktreeIdle: vi.fn(),
+  formatDuration: vi.fn(),
+}));
+
+vi.mock('../../../src/utils/progress.js', () => ({
+  ProgressRenderer: class {
+    start = vi.fn();
+    stop = vi.fn();
+    updateActivity = vi.fn();
+    markRunning = vi.fn();
+    markDone = vi.fn();
+    markFailed = vi.fn();
+  },
 }));
 
 import { registerRunCommand } from '../../../src/commands/run.js';
 import {
   createWorktrees,
+  createWorktreesByBranches,
   sanitizeBranchName,
   checkBranchExists,
-  spawnProcess,
   printSuccess,
   launchInteractiveClaude,
+  getConfigValue,
+  loadTaskFile,
 } from '../../../src/utils/index.js';
+import { spawnProcess } from '../../../src/utils/shell.js';
+import { printInfo } from '../../../src/utils/formatter.js';
 
 const mockedCreateWorktrees = vi.mocked(createWorktrees);
+const mockedCreateWorktreesByBranches = vi.mocked(createWorktreesByBranches);
 const mockedSanitizeBranchName = vi.mocked(sanitizeBranchName);
 const mockedCheckBranchExists = vi.mocked(checkBranchExists);
 const mockedSpawnProcess = vi.mocked(spawnProcess);
 const mockedPrintSuccess = vi.mocked(printSuccess);
+const mockedPrintInfo = vi.mocked(printInfo);
 const mockedLaunchInteractiveClaude = vi.mocked(launchInteractiveClaude);
+const mockedGetConfigValue = vi.mocked(getConfigValue);
+const mockedLoadTaskFile = vi.mocked(loadTaskFile);
 
 /**
  * 创建模拟子进程
@@ -78,12 +148,14 @@ function createMockChildProcess(stdout: string, exitCode: number) {
   child.stdout = stdoutStream;
   child.stderr = stderrStream;
   child.pid = 12345;
+  child.exitCode = null;
 
   // 延迟触发 close 事件
   setTimeout(() => {
     stdoutStream.push(stdout);
     stdoutStream.push(null);
     stderrStream.push(null);
+    child.exitCode = exitCode;
     child.emit('close', exitCode);
   }, 10);
 
@@ -92,11 +164,18 @@ function createMockChildProcess(stdout: string, exitCode: number) {
 
 beforeEach(() => {
   mockedCreateWorktrees.mockReset();
+  mockedCreateWorktreesByBranches.mockReset();
   mockedSanitizeBranchName.mockReset();
   mockedCheckBranchExists.mockReset();
   mockedSpawnProcess.mockReset();
   mockedPrintSuccess.mockReset();
+  mockedPrintInfo.mockReset();
   mockedLaunchInteractiveClaude.mockReset();
+  mockedGetConfigValue.mockReset();
+  mockedGetConfigValue.mockReturnValue(0 as any);
+  mockedLoadTaskFile.mockReset();
+  // sanitizeBranchName 默认返回输入值
+  mockedSanitizeBranchName.mockImplementation((name: string) => name);
 });
 
 describe('registerRunCommand', () => {
@@ -160,7 +239,6 @@ describe('handleRun', () => {
 
     expect(mockedCreateWorktrees).toHaveBeenCalledWith('feat', 2);
     expect(mockedSpawnProcess).toHaveBeenCalledTimes(2);
-    expect(mockedPrintSuccess).toHaveBeenCalled();
   });
 
   it('任务执行失败时在通知中报告', async () => {
@@ -192,6 +270,7 @@ describe('handleRun', () => {
     child.stdout = new Readable({ read() {} });
     child.stderr = new Readable({ read() {} });
     child.pid = 12345;
+    child.exitCode = null;
     setTimeout(() => {
       child.emit('error', new Error('spawn error'));
     }, 10);
@@ -204,4 +283,174 @@ describe('handleRun', () => {
 
     expect(mockedSpawnProcess).toHaveBeenCalledTimes(1);
   });
+
+  it('传 --concurrency 限制并发数', async () => {
+    const worktrees = [
+      { path: '/path/feat-1', branch: 'feat-1' },
+      { path: '/path/feat-2', branch: 'feat-2' },
+      { path: '/path/feat-3', branch: 'feat-3' },
+    ];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: false,
+      duration_ms: 5000,
+      total_cost_usd: 0.05,
+    });
+    mockedSpawnProcess
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2', 'task3', '-c', '1'], { from: 'user' });
+
+    expect(mockedCreateWorktrees).toHaveBeenCalledWith('feat', 3);
+    // 所有任务都应执行完毕
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(3);
+    // 应输出并发限制提示
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('并发限制'));
+  });
+
+  it('--concurrency 为 0 时不限制并发', async () => {
+    const worktrees = [
+      { path: '/path/feat-1', branch: 'feat-1' },
+      { path: '/path/feat-2', branch: 'feat-2' },
+    ];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: false,
+      duration_ms: 5000,
+      total_cost_usd: 0.05,
+    });
+    mockedSpawnProcess
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2', '-c', '0'], { from: 'user' });
+
+    // 不限制并发时不输出并发限制提示
+    expect(mockedPrintInfo).not.toHaveBeenCalledWith(expect.stringContaining('并发限制'));
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(2);
+  });
+
+  it('未传 -c 时使用全局配置的 maxConcurrency', async () => {
+    mockedGetConfigValue.mockReturnValue(2 as any);
+
+    const worktrees = [
+      { path: '/path/feat-1', branch: 'feat-1' },
+      { path: '/path/feat-2', branch: 'feat-2' },
+      { path: '/path/feat-3', branch: 'feat-3' },
+    ];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: false,
+      duration_ms: 5000,
+      total_cost_usd: 0.05,
+    });
+    mockedSpawnProcess
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2', 'task3'], { from: 'user' });
+
+    // 应输出并发限制提示（使用配置值 2）
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('并发限制'));
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(3);
+  });
+
+  it('-f 从文件加载任务并执行（无 -b，使用文件中分支名）', async () => {
+    mockedLoadTaskFile.mockReturnValue([
+      { branch: 'feat-login', task: '实现登录功能' },
+      { branch: 'fix-bug', task: '修复问题' },
+    ]);
+    const worktrees = [
+      { path: '/path/feat-login', branch: 'feat-login' },
+      { path: '/path/fix-bug', branch: 'fix-bug' },
+    ];
+    mockedCreateWorktreesByBranches.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: false,
+      duration_ms: 5000,
+      total_cost_usd: 0.05,
+    });
+    mockedSpawnProcess
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-f', 'tasks.md'], { from: 'user' });
+
+    expect(mockedLoadTaskFile).toHaveBeenCalledWith('tasks.md', { branchRequired: true });
+    expect(mockedCreateWorktreesByBranches).toHaveBeenCalledWith(['feat-login', 'fix-bug']);
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(2);
+  });
+
+  it('-f + -b 模式使用 -b 自动编号', async () => {
+    mockedLoadTaskFile.mockReturnValue([
+      { task: '任务1' },
+      { task: '任务2' },
+    ]);
+    const worktrees = [
+      { path: '/path/feat-1', branch: 'feat-1' },
+      { path: '/path/feat-2', branch: 'feat-2' },
+    ];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: false,
+      duration_ms: 5000,
+      total_cost_usd: 0.05,
+    });
+    mockedSpawnProcess
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '-f', 'tasks.md'], { from: 'user' });
+
+    // 应使用 createWorktrees（带 -b 自动编号），而非 createWorktreesByBranches
+    expect(mockedLoadTaskFile).toHaveBeenCalledWith('tasks.md', { branchRequired: false });
+    expect(mockedCreateWorktrees).toHaveBeenCalledWith('feat', 2);
+    expect(mockedCreateWorktreesByBranches).not.toHaveBeenCalled();
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(2);
+  });
+
+  it('-f 和 --tasks 互斥时报错', async () => {
+    mockedLoadTaskFile.mockReturnValue([{ branch: 'feat', task: '任务' }]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+
+    await expect(
+      program.parseAsync(['run', '-f', 'tasks.md', '--tasks', 'task1'], { from: 'user' }),
+    ).rejects.toThrow();
+  });
+
+  it('未传 -b 和 -f 时报错', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+
+    await expect(
+      program.parseAsync(['run', '--tasks', 'task1'], { from: 'user' }),
+    ).rejects.toThrow();
+  });
 });

package/tests/unit/constants/config.test.ts

@@ -30,6 +30,7 @@ describe('DEFAULT_CONFIG', () => {
     expect(DEFAULT_CONFIG.claudeCodeCommand).toBe('claude');
     expect(DEFAULT_CONFIG.autoPullPush).toBe(false);
     expect(DEFAULT_CONFIG.confirmDestructiveOps).toBe(true);
+    expect(DEFAULT_CONFIG.maxConcurrency).toBe(0);
   });
 });
 

package/tests/unit/utils/claude.test.ts

@@ -10,6 +10,12 @@ vi.mock('node:child_process', () => ({
   spawnSync: vi.fn(),
 }));
 
+// mock node:fs
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn(),
+  readdirSync: vi.fn(),
+}));
+
 // mock config
 vi.mock('../../../src/utils/config.js', () => ({
   getConfigValue: vi.fn(),
@@ -22,7 +28,8 @@ vi.mock('../../../src/utils/formatter.js', () => ({
 }));
 
 import { spawnSync } from 'node:child_process';
-import { launchInteractiveClaude } from '../../../src/utils/claude.js';
+import { existsSync, readdirSync } from 'node:fs';
+import { launchInteractiveClaude, hasClaudeSessionHistory } from '../../../src/utils/claude.js';
 import { getConfigValue } from '../../../src/utils/config.js';
 import { printInfo, printWarning } from '../../../src/utils/formatter.js';
 import { ClawtError } from '../../../src/errors/index.js';
@@ -32,6 +39,45 @@ const mockedSpawnSync = vi.mocked(spawnSync);
 const mockedGetConfigValue = vi.mocked(getConfigValue);
 const mockedPrintInfo = vi.mocked(printInfo);
 const mockedPrintWarning = vi.mocked(printWarning);
+const mockedExistsSync = vi.mocked(existsSync);
+const mockedReaddirSync = vi.mocked(readdirSync);
+
+describe('hasClaudeSessionHistory', () => {
+  it('项目目录不存在时返回 false', () => {
+    mockedExistsSync.mockReturnValue(false);
+
+    expect(hasClaudeSessionHistory('/Users/test/project')).toBe(false);
+    expect(mockedExistsSync).toHaveBeenCalled();
+  });
+
+  it('项目目录存在但无 .jsonl 文件时返回 false', () => {
+    mockedExistsSync.mockReturnValue(true);
+    mockedReaddirSync.mockReturnValue(['memory', 'CLAUDE.md'] as unknown as ReturnType<typeof readdirSync>);
+
+    expect(hasClaudeSessionHistory('/Users/test/project')).toBe(false);
+  });
+
+  it('项目目录存在且有 .jsonl 文件时返回 true', () => {
+    mockedExistsSync.mockReturnValue(true);
+    mockedReaddirSync.mockReturnValue([
+      'abc-123.jsonl',
+      'memory',
+    ] as unknown as ReturnType<typeof readdirSync>);
+
+    expect(hasClaudeSessionHistory('/Users/test/project')).toBe(true);
+  });
+
+  it('路径编码规则正确（非字母数字字符替换为 -）', () => {
+    mockedExistsSync.mockReturnValue(false);
+
+    hasClaudeSessionHistory('/Users/qihoo/.clawt/worktrees/clawt/resume');
+
+    // 验证 existsSync 被调用时路径包含编码后的目录名
+    // /Users/qihoo/.clawt/worktrees/clawt/resume → -Users-qihoo--clawt-worktrees-clawt-resume
+    const calledPath = mockedExistsSync.mock.calls[0][0] as string;
+    expect(calledPath).toContain('-Users-qihoo--clawt-worktrees-clawt-resume');
+  });
+});
 
 describe('launchInteractiveClaude', () => {
   const worktree = createWorktreeInfo({
@@ -41,6 +87,7 @@ describe('launchInteractiveClaude', () => {
 
   it('正常启动 Claude Code（退出码为 0）', () => {
     mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: 0,
       error: undefined,
@@ -66,6 +113,7 @@ describe('launchInteractiveClaude', () => {
 
   it('输出分支和路径信息', () => {
     mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: 0,
       error: undefined,
@@ -84,6 +132,7 @@ describe('launchInteractiveClaude', () => {
 
   it('支持带参数的命令（如 npx claude）', () => {
     mockedGetConfigValue.mockReturnValue('npx claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: 0,
       error: undefined,
@@ -105,6 +154,7 @@ describe('launchInteractiveClaude', () => {
 
   it('spawnSync 返回 error 时抛出 ClawtError', () => {
     mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: null,
       error: new Error('命令未找到'),
@@ -121,6 +171,7 @@ describe('launchInteractiveClaude', () => {
 
   it('非零退出码时调用 printWarning', () => {
     mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: 1,
       error: undefined,
@@ -138,6 +189,7 @@ describe('launchInteractiveClaude', () => {
 
   it('退出码为 null 时不调用 printWarning', () => {
     mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: null,
       error: undefined,
@@ -155,6 +207,7 @@ describe('launchInteractiveClaude', () => {
 
   it('退出码为 0 时不调用 printWarning', () => {
     mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
     mockedSpawnSync.mockReturnValue({
       status: 0,
       error: undefined,
@@ -169,4 +222,65 @@ describe('launchInteractiveClaude', () => {
 
     expect(mockedPrintWarning).not.toHaveBeenCalled();
   });
+
+  it('autoContinue 启用且有会话历史时追加 --continue 参数', () => {
+    mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(true);
+    mockedReaddirSync.mockReturnValue(['session-abc.jsonl'] as unknown as ReturnType<typeof readdirSync>);
+    mockedSpawnSync.mockReturnValue({
+      status: 0,
+      error: undefined,
+      stdout: '',
+      stderr: '',
+      pid: 1234,
+      output: [],
+      signal: null,
+    });
+
+    launchInteractiveClaude(worktree, { autoContinue: true });
+
+    const callArgs = mockedSpawnSync.mock.calls[0][1] as string[];
+    expect(callArgs).toContain('--continue');
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('继续上次对话'));
+  });
+
+  it('autoContinue 启用但无会话历史时不追加 --continue 参数', () => {
+    mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(false);
+    mockedSpawnSync.mockReturnValue({
+      status: 0,
+      error: undefined,
+      stdout: '',
+      stderr: '',
+      pid: 1234,
+      output: [],
+      signal: null,
+    });
+
+    launchInteractiveClaude(worktree, { autoContinue: true });
+
+    const callArgs = mockedSpawnSync.mock.calls[0][1] as string[];
+    expect(callArgs).not.toContain('--continue');
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('新对话'));
+  });
+
+  it('不传 autoContinue 时即使有会话历史也不追加 --continue', () => {
+    mockedGetConfigValue.mockReturnValue('claude');
+    mockedExistsSync.mockReturnValue(true);
+    mockedReaddirSync.mockReturnValue(['session-abc.jsonl'] as unknown as ReturnType<typeof readdirSync>);
+    mockedSpawnSync.mockReturnValue({
+      status: 0,
+      error: undefined,
+      stdout: '',
+      stderr: '',
+      pid: 1234,
+      output: [],
+      signal: null,
+    });
+
+    launchInteractiveClaude(worktree);
+
+    const callArgs = mockedSpawnSync.mock.calls[0][1] as string[];
+    expect(callArgs).not.toContain('--continue');
+  });
 });

package/tests/unit/utils/formatter.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { formatWorktreeStatus, printSuccess, printError, printWarning, printInfo, printSeparator, printDoubleSeparator, isWorktreeIdle } from '../../../src/utils/formatter.js';
+import { formatWorktreeStatus, printSuccess, printError, printWarning, printInfo, printSeparator, printDoubleSeparator, isWorktreeIdle, formatDuration } from '../../../src/utils/formatter.js';
 import { createWorktreeStatus } from '../../helpers/fixtures.js';
 
 describe('formatWorktreeStatus', () => {
@@ -110,3 +110,29 @@ describe('print 函数', () => {
     expect(spy.mock.calls[0][0]).toBe('普通消息');
   });
 });
+
+describe('formatDuration', () => {
+  it('小于 60 秒时显示秒数（保留一位小数）', () => {
+    expect(formatDuration(5200)).toBe('5.2s');
+  });
+
+  it('0 毫秒时显示 0.0s', () => {
+    expect(formatDuration(0)).toBe('0.0s');
+  });
+
+  it('59.9 秒时仍显示秒数', () => {
+    expect(formatDuration(59900)).toBe('59.9s');
+  });
+
+  it('大于等于 60 秒时显示分秒格式', () => {
+    expect(formatDuration(83000)).toBe('1m23s');
+  });
+
+  it('整分钟时秒数补零', () => {
+    expect(formatDuration(120000)).toBe('2m00s');
+  });
+
+  it('大数值时正确格式化', () => {
+    expect(formatDuration(3661000)).toBe('61m01s');
+  });
+});