@dijkspicy/opencode-stats-reporter 0.1.0

package/contrib/opencode-session-reporter/reporter.test.ts

@@ -0,0 +1,378 @@
+/**
+ * session-usage-reporter 自包含 mock 测试
+ *
+ * 运行方式（无网络、无需真实 opencode）：
+ *   bun test reporter.test.ts
+ *   bun run reporter.test.ts
+ *
+ * 说明：不使用 bun:test 断言库，自带极简断言与汇总输出，
+ * 因此「bun test」与「bun run」两种方式行为一致（失败时退出码为 1）。
+ */
+
+import { randomUUID } from "node:crypto"
+import { rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import {
+  aggregateSession,
+  buildPayload,
+  computeBackoffMs,
+  createQueue,
+  createReporterCore,
+  loadOrCreateInstallId,
+} from "./session-usage-reporter.ts"
+import type {
+  ReporterClient,
+  ReporterCoreOptions,
+  ReporterScheduler,
+  SessionSnapshot,
+  UsageMessage,
+} from "./session-usage-reporter.ts"
+
+// ---------------------------------------------------------------------------
+// 极简断言与汇总
+// ---------------------------------------------------------------------------
+
+type TestCase = { name: string; ok: boolean; error?: string }
+const results: TestCase[] = []
+
+const runTest = async (name: string, fn: () => void | Promise<void>): Promise<void> => {
+  try {
+    await fn()
+    results.push({ name, ok: true })
+  } catch (error) {
+    results.push({ name, ok: false, error: error instanceof Error ? error.message : String(error) })
+  }
+}
+
+const assert = (condition: boolean, message: string): void => {
+  if (!condition) throw new Error(message)
+}
+
+const assertEqual = (actual: unknown, expected: unknown, label = ""): void => {
+  const a = JSON.stringify(actual)
+  const e = JSON.stringify(expected)
+  if (a !== e) throw new Error(`${label} 期望 ${e}，实际 ${a}`)
+}
+
+// ---------------------------------------------------------------------------
+// mock 构造器
+// ---------------------------------------------------------------------------
+
+const assistantMessage = (over: Partial<NonNullable<UsageMessage["info"]>> = {}): UsageMessage => ({
+  info: {
+    id: `msg_${Math.random().toString(36).slice(2)}`,
+    role: "assistant",
+    modelID: "glm-4.6",
+    providerID: "zhipu",
+    mode: "build",
+    tokens: { input: 10, output: 20, reasoning: 5, cache: { read: 7, write: 3 } },
+    time: { completed: 1_000 },
+    ...over,
+  },
+})
+
+const makeClient = (
+  messages: Record<string, UsageMessage[]>,
+  children: Record<string, string[]> = {},
+): ReporterClient => ({
+  session: {
+    messages: async (args: { path: { id: string } }) => ({ data: messages[args.path.id] ?? [] }),
+    children: async (args: { path: { id: string } }) => ({
+      data: (children[args.path.id] ?? []).map((id) => ({ id })),
+    }),
+  },
+})
+
+const makeFetch = (behavior: "ok" | "fail") => {
+  const calls: Array<{ url: string; init: { method?: string; headers?: Record<string, string>; body?: string } }> = []
+  const fetchFn = (async (url: unknown, init?: unknown) => {
+    calls.push({ url: String(url), init: (init ?? {}) as { method?: string; headers?: Record<string, string>; body?: string } })
+    if (behavior === "fail") throw new Error("boom: network down")
+    return { ok: true, status: 200 }
+  }) as unknown as typeof fetch
+  return { fetchFn, calls }
+}
+
+/** 手动调度器：不创建真实定时器，作业可在需要时人工触发 */
+const makeCore = (client: ReporterClient, overrides: Partial<ReporterCoreOptions> = {}) => {
+  const jobs: Array<{ fn: () => void; delayMs: number }> = []
+  const scheduler: ReporterScheduler = (fn, delayMs) => {
+    jobs.push({ fn, delayMs })
+    return () => {}
+  }
+  const core = createReporterCore({ client, installId: "install_test", scheduler, ...overrides })
+  return { core, jobs }
+}
+
+let snapSeq = 0
+const snap = (sessionID: string, over: Partial<SessionSnapshot> = {}): SessionSnapshot => {
+  snapSeq += 1
+  return {
+    session_id: sessionID,
+    revision: 1,
+    model: null,
+    agent: null,
+    tokens_input: 0,
+    tokens_output: 0,
+    tokens_reasoning: 0,
+    tokens_cache_read: 0,
+    tokens_cache_write: 0,
+    message_count: 1,
+    session_created_at: null,
+    last_activity_at: 1_000 + snapSeq,
+    ...over,
+  }
+}
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+const SESSION_KEYS = [
+  "agent",
+  "last_activity_at",
+  "message_count",
+  "model",
+  "revision",
+  "session_created_at",
+  "session_id",
+  "tokens_cache_read",
+  "tokens_cache_write",
+  "tokens_input",
+  "tokens_output",
+  "tokens_reasoning",
+].sort()
+
+// ---------------------------------------------------------------------------
+// 用例
+// ---------------------------------------------------------------------------
+
+await runTest("aggregateSession 只聚合已完成的助手消息，口径原样分列", () => {
+  const messages: UsageMessage[] = [
+    { info: { id: "m1", role: "user", time: { completed: 900 } } },
+    assistantMessage({ id: "m2", tokens: { input: 10, output: 20, reasoning: 5, cache: { read: 7, write: 3 } }, time: { completed: 1_000 } }),
+    { info: { id: "m3", role: "assistant", tokens: { input: 999 }, time: { completed: null } } }, // 未完成：忽略
+    assistantMessage({ id: "m4", tokens: { input: 1, output: 2, reasoning: 3, cache: { read: 4, write: 5 } }, time: { completed: 2_000 } }),
+  ]
+  const s = aggregateSession("ses_x", messages)
+  assert(!!s, "应产出快照")
+  assertEqual(s!.message_count, 2, "message_count")
+  assertEqual(s!.revision, 2, "revision=message_count")
+  assertEqual(s!.tokens_input, 11, "tokens_input")
+  assertEqual(s!.tokens_output, 22, "tokens_output")
+  assertEqual(s!.tokens_reasoning, 8, "tokens_reasoning")
+  assertEqual(s!.tokens_cache_read, 11, "tokens_cache_read")
+  assertEqual(s!.tokens_cache_write, 8, "tokens_cache_write")
+  assertEqual(s!.last_activity_at, 2_000, "last_activity_at")
+  assertEqual(s!.model, "zhipu/glm-4.6", "model")
+  assertEqual(s!.agent, "build", "agent")
+})
+
+await runTest("aggregateSession 无已完成助手消息时返回 null", () => {
+  assertEqual(aggregateSession("ses_empty", []), null)
+  assertEqual(aggregateSession("ses_partial", [{ info: { role: "assistant", time: { completed: null } } }]), null)
+})
+
+await runTest("父子会话分别成快照：父快照不含子会话用量", async () => {
+  const client = makeClient(
+    {
+      ses_parent: [
+        assistantMessage({ tokens: { input: 100, output: 50, reasoning: 10, cache: { read: 20, write: 5 } } }),
+      ],
+      ses_child: [assistantMessage({ tokens: { input: 7, output: 3, reasoning: 1, cache: { read: 2, write: 1 } }, mode: "plan" })],
+    },
+    { ses_parent: ["ses_child"] },
+  )
+  const { core } = makeCore(client, { endpoint: "http://endpoint.test/usage" })
+  await core.collectSession("ses_parent")
+
+  assertEqual(core.queue.size, 2, "父与子各自一条快照")
+  const drained = core.queue.drainAll()
+  const parent = drained.find((s) => s.session_id === "ses_parent")
+  const child = drained.find((s) => s.session_id === "ses_child")
+  assert(!!parent && !!child, "父/子快照都应存在")
+  assertEqual(parent!.tokens_input, 100, "父 input")
+  assertEqual(parent!.tokens_output, 50, "父 output")
+  assertEqual(parent!.tokens_reasoning, 10, "父 reasoning")
+  assertEqual(parent!.tokens_cache_read, 20, "父 cache_read")
+  assertEqual(parent!.tokens_cache_write, 5, "父 cache_write")
+  assertEqual(child!.tokens_input, 7, "子 input")
+  assertEqual(child!.agent, "plan", "子 agent")
+})
+
+await runTest("session.idle 与 session.status(idle) 都触发采集，其余事件不触发", async () => {
+  const client = makeClient(
+    { ses_p: [assistantMessage()], ses_child: [assistantMessage()] },
+    { ses_p: ["ses_child"] },
+  )
+
+  // 信号一：session.idle
+  const { core: core1 } = makeCore(client, { endpoint: "http://e" })
+  await core1.handleEvent({ type: "session.idle", properties: { sessionID: "ses_p" } })
+  assertEqual(core1.queue.size, 2, "session.idle 触发父+子采集")
+
+  // 信号二：session.status 且 status.type === "idle"
+  const { core: core2 } = makeCore(client, { endpoint: "http://e" })
+  await core2.handleEvent({ type: "session.status", properties: { sessionID: "ses_p", status: { type: "busy" } } })
+  assertEqual(core2.queue.size, 0, "非 idle 状态不采集")
+  await core2.handleEvent({ type: "session.error", properties: { sessionID: "ses_p" } })
+  assertEqual(core2.queue.size, 0, "无关事件不采集")
+  await core2.handleEvent({ type: "session.status", properties: { sessionID: "ses_p", status: { type: "idle" } } })
+  assertEqual(core2.queue.size, 2, "session.status(idle) 触发采集")
+})
+
+await runTest("buildPayload 结构完整、无身份字段、重复会话按最高修订合并", () => {
+  const payload = buildPayload("install_123", "0.1.0-test", [
+    snap("ses_a", { revision: 2, last_activity_at: 111 }),
+    snap("ses_b"),
+    snap("ses_a", { revision: 5, last_activity_at: 222 }),
+  ])
+  assertEqual(payload.schema_version, 1, "schema_version")
+  assertEqual(payload.install_id, "install_123", "install_id")
+  assertEqual(payload.reporter.client, "opencode", "reporter.client")
+  assertEqual(payload.reporter.version, "0.1.0-test", "reporter.version")
+  assertEqual(payload.sessions.length, 2, "同会话合并为一条")
+  const a = payload.sessions.find((s) => s.session_id === "ses_a")
+  assert(!!a && a.revision === 5, "保留最高修订")
+  assertEqual(a!.last_activity_at, 222, "保留最新活动时间")
+  assertEqual(Object.keys(payload).sort(), ["install_id", "reporter", "schema_version", "sessions"], "顶层键")
+  assertEqual(Object.keys(payload.sessions[0]).sort(), SESSION_KEYS, "会话条目键")
+  assert(!/consumer|identity|tenant|forward[-_]?(user|consumer)/i.test(JSON.stringify(payload)), "绝不携带消费者/身份字段")
+})
+
+await runTest("createQueue 有界，溢出丢最旧并计数", () => {
+  const q = createQueue(3)
+  for (const id of ["s1", "s2", "s3", "s4", "s5"]) q.push(snap(id))
+  assertEqual(q.size, 3, "容量封顶")
+  assertEqual(q.dropped, 2, "丢弃计数")
+  assertEqual(
+    q.drainAll().map((s) => s.session_id),
+    ["s3", "s4", "s5"],
+    "最旧的 s1/s2 被丢弃",
+  )
+})
+
+await runTest("flushOnce 失败时批次原样保留在队列并调度退避重试", async () => {
+  const q = createQueue(50)
+  q.push(snap("ses_1"))
+  q.push(snap("ses_2"))
+  const { fetchFn } = makeFetch("fail")
+  const { core, jobs } = makeCore(makeClient({}), { endpoint: "http://e", queue: q, fetchFn })
+
+  const ok = await core.flushOnce()
+  assertEqual(ok, false, "上报失败")
+  assertEqual(q.size, 2, "失败批次无丢失")
+  assertEqual(
+    q.drainAll().map((s) => s.session_id),
+    ["ses_1", "ses_2"],
+    "保留原顺序",
+  )
+  assertEqual(jobs.length, 1, "已调度一次重试")
+  assert(jobs[0]!.delayMs >= 500 && jobs[0]!.delayMs <= 1_500, `首次退避应在 [500,1500]ms，实际 ${jobs[0]!.delayMs}`)
+})
+
+await runTest("flushOnce 成功时清空队列并 POST 正确载荷", async () => {
+  const q = createQueue(50)
+  q.push(snap("ses_1", { tokens_input: 11, revision: 3 }))
+  q.push(snap("ses_2"))
+  const { fetchFn, calls } = makeFetch("ok")
+  const { core } = makeCore(makeClient({}), { endpoint: "http://endpoint.test/usage", queue: q, fetchFn })
+
+  const ok = await core.flushOnce()
+  assertEqual(ok, true, "上报成功")
+  assertEqual(q.size, 0, "队列清空")
+  assertEqual(calls.length, 1, "恰好一次请求")
+  assertEqual(calls[0]!.url, "http://endpoint.test/usage", "端点")
+  assertEqual(calls[0]!.init.method, "POST", "方法")
+  assertEqual(calls[0]!.init.headers?.["content-type"], "application/json", "Content-Type")
+  const body = JSON.parse(calls[0]!.init.body ?? "{}")
+  assertEqual(body.install_id, "install_test", "install_id")
+  assertEqual(body.reporter.client, "opencode", "reporter.client")
+  assertEqual(body.sessions.length, 2, "两条会话")
+})
+
+await runTest("配置 authToken 时带 Authorization 头；未配置则不带", async () => {
+  const q1 = createQueue(50)
+  q1.push(snap("ses_auth"))
+  const { fetchFn: f1, calls: c1 } = makeFetch("ok")
+  const { core: core1 } = makeCore(makeClient({}), {
+    endpoint: "http://endpoint.test/usage", queue: q1, fetchFn: f1, authToken: "gw-key-123",
+  })
+  await core1.flushOnce()
+  assertEqual(c1[0]!.init.headers?.["authorization"], "Bearer gw-key-123", "Authorization 头")
+
+  const q2 = createQueue(50)
+  q2.push(snap("ses_noauth"))
+  const { fetchFn: f2, calls: c2 } = makeFetch("ok")
+  const { core: core2 } = makeCore(makeClient({}), {
+    endpoint: "http://endpoint.test/usage", queue: q2, fetchFn: f2,
+  })
+  await core2.flushOnce()
+  assertEqual(c2[0]!.init.headers?.["authorization"], undefined, "未配置则无 Authorization 头")
+})
+
+await runTest("endpoint 未配置时不发送且队列保留", async () => {
+  const q = createQueue(50)
+  q.push(snap("ses_1"))
+  const { fetchFn, calls } = makeFetch("ok")
+  const { core } = makeCore(makeClient({}), { queue: q, fetchFn })
+  const ok = await core.flushOnce()
+  assertEqual(ok, true, "无事可做视为成功")
+  assertEqual(calls.length, 0, "未发送")
+  assertEqual(q.size, 1, "数据保留")
+})
+
+await runTest("computeBackoffMs 指数增长、带抖动并封顶", () => {
+  assertEqual(computeBackoffMs(0, 0.5), 1_000, "attempt=0")
+  assertEqual(computeBackoffMs(2, 0), 2_000, "attempt=2 下界")
+  assertEqual(computeBackoffMs(2, 1), 6_000, "attempt=2 上界")
+  assertEqual(computeBackoffMs(30, 0.5), 300_000, "封顶 5 分钟")
+  assertEqual(computeBackoffMs(-3, 0.5), 1_000, "负数按 0 处理")
+  const jittered = computeBackoffMs(1, Math.random())
+  assert(jittered >= 1_000 && jittered <= 3_000, `attempt=1 应在 [1000,3000]，实际 ${jittered}`)
+})
+
+await runTest("disposeFlush：成功清空队列；失败保留且立即止损只试一次", async () => {
+  // 成功路径
+  const qOk = createQueue(50)
+  qOk.push(snap("ses_1"))
+  qOk.push(snap("ses_2"))
+  const okFetch = makeFetch("ok")
+  const coreOk = makeCore(makeClient({}), { endpoint: "http://e", queue: qOk, fetchFn: okFetch.fetchFn }).core
+  await coreOk.disposeFlush(1_000)
+  assertEqual(qOk.size, 0, "退出前成功清空")
+  assertEqual(okFetch.calls.length, 1, "一次请求发完")
+
+  // 失败路径：失败后 break，不空转烧预算
+  const qFail = createQueue(50)
+  qFail.push(snap("ses_1"))
+  const failFetch = makeFetch("fail")
+  const coreFail = makeCore(makeClient({}), { endpoint: "http://e", queue: qFail, fetchFn: failFetch.fetchFn }).core
+  await coreFail.disposeFlush(10_000)
+  assertEqual(qFail.size, 1, "失败数据保留")
+  assertEqual(failFetch.calls.length, 1, "失败后立即止损")
+})
+
+await runTest("loadOrCreateInstallId 首次生成、之后稳定复用同一 UUID", async () => {
+  const stateFile = join(tmpdir(), `session-usage-reporter-test-${randomUUID()}.txt`)
+  try {
+    const first = await loadOrCreateInstallId({ stateFile })
+    assert(UUID_RE.test(first), `应为合法 UUID，实际 ${first}`)
+    const second = await loadOrCreateInstallId({ stateFile })
+    assertEqual(second, first, "两次读取应相同")
+  } finally {
+    await rm(stateFile, { force: true })
+  }
+})
+
+// ---------------------------------------------------------------------------
+// 汇总
+// ---------------------------------------------------------------------------
+
+let failed = 0
+for (const result of results) {
+  if (!result.ok) failed += 1
+  const line = `${result.ok ? "✓ 通过" : "✗ 失败"}  ${result.name}`
+  console.log(result.ok ? line : `${line}\n    ${result.error}`)
+}
+console.log(`\n${failed === 0 ? "PASS" : "FAIL"}: ${results.length - failed}/${results.length} 项测试通过`)
+if (failed > 0) process.exitCode = 1