tea-sdlc/test/time-log.test.js

/**
 * 補登工時。
 *
 * 規劃階段最耗時的那一段發生在議題建立之前——那時候沒有標的可起錶，時間只能事後補登。
 * 這一支的價值全在「補多少」：長度由腳本自己算，不由 agent 做減法。終點看議題是不是
 * 這一輪建立的——是就補到建立那一刻，不是就補到現在，那一輪的規劃時間照樣要進報表。
 * 唯一不補的情形是錶已經在這顆議題上跑著，那一段已經有錶在記了。
 */
import test from 'node:test';
import assert from 'node:assert/strict';
import { runScript } from './helpers/run-script.js';
import { healthyRoutes, stubEnv as envFor, withStubGitea } from './helpers/stub-gitea.js';

const REPO = 'plugins/tea-sdlc';
const INDEX = 42;

/** 議題建立於此刻；每支測試的 --since 都相對它往前推 */
const CREATED = '2026-09-17T10:30:00Z';

/** CREATED 往前推 n 秒的 ISO 時間 */
const 早於建立 = (seconds) => new Date(Date.parse(CREATED) - seconds * 1000).toISOString();

/** 議題上跑著的碼錶長什麼樣 */
const stopwatchOn = (index, repo = REPO) => ({
  issue_index: index,
  repo_owner_name: repo.split('/')[0],
  repo_name: repo.split('/')[1],
});

function routes(overrides = {}, { stopwatches = [] } = {}) {
  return healthyRoutes(REPO, {
    [`GET /api/v1/repos/${REPO}/issues/${INDEX}`]: {
      status: 200,
      body: {
        number: INDEX,
        title: '為規劃與分析階段計時並補登規劃時間',
        created_at: CREATED,
        html_url: `https://gitea.jsc.idv.tw/${REPO}/issues/${INDEX}`,
      },
    },
    'GET /api/v1/user/stopwatches': { status: 200, body: stopwatches },
    [`POST /api/v1/repos/${REPO}/issues/${INDEX}/times`]: { status: 200, body: { id: 1 } },
    ...overrides,
  });
}

const withStub = (t, overrides = {}, options) => withStubGitea(t, routes(overrides, options));

const run = (since, args, stub) =>
  runScript('time-log.js', ['--repo', REPO, '--index', String(INDEX), '--since', since, ...args], {
    env: envFor(stub),
  });

/** 會改動 Gitea 的請求；前置檢查打在 issues/0 的探針不算（見 lib 的 checkIssueWrite） */
const writes = (stub) =>
  stub.requests.filter((r) => r.method !== 'GET').filter((r) => !r.path.endsWith('/issues/0'));

test('補登時長等於指令開始到議題建立的差值', async (t) => {
  const stub = await withStub(t);

  const { code, json } = await run(早於建立(25 * 60), [], stub);

  assert.equal(code, 0, json.error?.message);
  assert.equal(json.data.補登, true);
  assert.equal(json.data.秒數, 25 * 60);
  const [write] = writes(stub);
  assert.equal(write.path, `/api/v1/repos/${REPO}/issues/${INDEX}/times`);
  assert.deepEqual(write.body, { time: 25 * 60 });
});

test('長度由腳本自己算：議題的建立時間減掉 --since，agent 不必做減法', async (t) => {
  const stub = await withStub(t);

  const { json } = await run(早於建立(90), [], stub);

  assert.equal(json.data.秒數, 90);
  assert.equal(Date.parse(json.data.迄), Date.parse(CREATED), '終點就是議題建立那一刻');
  assert.equal(json.data.依據, '議題建立');
});

test('不設時間上限：中間去開會的那幾個小時照實補登，不改口問使用者', async (t) => {
  const stub = await withStub(t);
  const 十小時 = 10 * 60 * 60;

  const { code, json } = await run(早於建立(十小時), [], stub);

  assert.equal(code, 0, '時間長不是失敗；記多了看得出來，記不到就永遠找不回來');
  assert.equal(json.data.秒數, 十小時);
  assert.deepEqual(writes(stub).at(0).body, { time: 十小時 });
});

test('錶已經跑在這顆議題上時跳過：補下去會與錶涵蓋的區間重疊', async (t) => {
  const stub = await withStub(t, {}, { stopwatches: [stopwatchOn(INDEX)] });

  const { code, json } = await run(早於建立(600), [], stub);

  assert.equal(code, 0, json.error?.message);
  assert.equal(json.data.補登, false);
  assert.match(json.data.note, /起錶/);
  assert.deepEqual(writes(stub), [], '那一段已經有錶在記，補下去就記了兩遍');
});

test('對既有議題重跑時補到現在，那一輪的規劃時間照樣進報表', async (t) => {
  // 議題比 --since 還早，代表這不是這一輪建立的；拿舊的建立時間當終點會算出負數，
  // 等於把這一輪的工夫丟掉
  const stub = await withStub(t);
  const 起 = new Date(Date.now() - 20 * 60 * 1000).toISOString();

  const { code, json } = await run(起, [], stub);

  assert.equal(code, 0, json.error?.message);
  assert.equal(json.data.補登, true);
  assert.equal(json.data.依據, '補登當下');
  assert.ok(Math.abs(json.data.秒數 - 20 * 60) <= 5, `補的應是這一輪的長度，實際 ${json.data.秒數}`);
  assert.equal(writes(stub).at(0).body.time, json.data.秒數);
});

test('重跑是累計不是覆蓋：每一輪各記一筆，加總才是這顆議題真正的規劃時間', async (t) => {
  const stub = await withStub(t);
  const 起 = new Date(Date.now() - 10 * 60 * 1000).toISOString();

  const 第一輪 = await run(起, [], stub);
  const 第二輪 = await run(起, [], stub);

  assert.equal(第一輪.json.data.補登, true);
  assert.equal(第二輪.json.data.補登, true, '前一輪記過了不是跳過的理由');
  assert.equal(writes(stub).length, 2, '兩輪各記一筆');
});

test('錶跑在別顆議題上不影響補登：補登只寫工時，不動任何錶', async (t) => {
  const stub = await withStub(t, {}, { stopwatches: [stopwatchOn(7)] });

  const { code, json } = await run(早於建立(600), [], stub);

  assert.equal(code, 0, json.error?.message);
  assert.equal(json.data.補登, true);
  assert.deepEqual(
    writes(stub).map((r) => r.path),
    [`/api/v1/repos/${REPO}/issues/${INDEX}/times`],
    '不得順手停掉別顆議題上的錶',
  );
});

test('指令開始時間落在未來時什麼都不補，也不算失敗', async (t) => {
  const stub = await withStub(t);

  const { code, json } = await run(new Date(Date.now() + 60 * 1000).toISOString(), [], stub);

  assert.equal(code, 0, '兩邊時鐘差幾秒是常事，不該讓整個流程停在這裡');
  assert.equal(json.data.補登, false);
  assert.deepEqual(writes(stub), []);
});

test('--since 不是可解析的時間時擋在打 Gitea 之前', async (t) => {
  const stub = await withStub(t);

  const { code, json } = await run('剛剛', [], stub);

  assert.equal(code, 1);
  assert.equal(json.error.code, 'BAD_SINCE');
  assert.equal(stub.requests.length, 0);
});

test('議題不存在時回可區分的錯誤碼', async (t) => {
  const stub = await withStub(t, {
    [`GET /api/v1/repos/${REPO}/issues/${INDEX}`]: { status: 404, body: { message: 'not found' } },
  });

  const { json } = await run(早於建立(600), [], stub);

  assert.equal(json.error.code, 'ISSUE_NOT_FOUND');
  assert.deepEqual(writes(stub), []);
});

test('--dry-run 印出將發出的補登，但一個字都不寫進去', async (t) => {
  const stub = await withStub(t);

  const { code, json } = await run(早於建立(1800), ['--dry-run'], stub);

  assert.equal(code, 0);
  assert.equal(json.data.dryRun, true);
  assert.equal(json.data.秒數, 1800);
  assert.deepEqual(json.data.requests, [
    { method: 'POST', path: `/repos/${REPO}/issues/${INDEX}/times`, body: { time: 1800 } },
  ]);
  assert.deepEqual(writes(stub), [], '預覽不得真的寫入');
});

test('--dry-run 會先讀現況：錶已經在跑時預覽出來就是什麼都不做', async (t) => {
  const stub = await withStub(t, {}, { stopwatches: [stopwatchOn(INDEX)] });

  const { json } = await run(早於建立(1800), ['--dry-run'], stub);

  assert.deepEqual(json.data.requests, [], '手寫一份固定的清單會跟實作走鐘');
  assert.equal(json.data.補登, false);
});