Files
lpt-ai/src/admin/reporter.test.ts
T
cat-shark 4aff5c03fe feat: 用量归属支持 callerRef 透传
- POST /ai/tasks 接受顶层可选 callerRef(限 64 字符),不进入 params、不参与幂等键、不进 prompt
- 结算时写进用量记录,lpt-be 据此做用户维度报表
- 复用已有任务时沿用原归属:那次 LLM 调用只发生一次,账算在原调用方头上
2026-10-10 20:08:51 +08:00

296 lines
10 KiB
TypeScript

import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { emptyUsage } from "../llm/usage.js";
import { UsageReporter, loadReporterConfig, toUsageRecord, type ReporterConfig } from "./reporter.js";
import type { LogEntry } from "./store.js";
let workDir: string;
beforeEach(() => {
workDir = mkdtempSync(join(tmpdir(), "lpt-ai-reporter-"));
});
afterEach(() => {
rmSync(workDir, { recursive: true, force: true });
});
function outboxFile(): string {
return join(workDir, "usage-outbox.json");
}
function reporterConfig(overrides: Partial<ReporterConfig> = {}): ReporterConfig {
return {
url: "http://lpt-be.test",
token: "report-token",
intervalMs: 15_000,
batchSize: 50,
maxPending: 5_000,
timeoutMs: 5_000,
...overrides,
};
}
function makeReporter(
config: Partial<ReporterConfig> = {},
fetchImpl?: typeof fetch,
): UsageReporter {
return new UsageReporter({
loadConfig: () => reporterConfig(config),
outboxFile: outboxFile(),
...(fetchImpl ? { fetchImpl } : {}),
});
}
function entry(overrides: Partial<LogEntry> = {}): LogEntry {
return {
id: 1,
recordId: "rec-1",
timestamp: "2026-10-10T09:38:23.543Z",
endpoint: "/ai/tasks#aggregate-report",
taskType: "aggregate-report",
taskId: "task-1",
model: "deepseek-flash",
attempts: 2,
isLlmCall: true,
usage: {
promptTokens: 1234,
completionTokens: 567,
totalTokens: 1801,
cacheHitTokens: 800,
cacheMissTokens: 434,
reasoningTokens: 0,
},
usageSource: "upstream",
costUsd: 0.001234,
pricing: {
version: "hit0.006|miss0.3|out1.2|off0.5",
peak: false,
effectivePrices: { cacheHitPerM: 0.003, cacheMissPerM: 0.15, outputPerM: 0.6 },
listPrices: { cacheHitPerM: 0.006, cacheMissPerM: 0.3, outputPerM: 1.2 },
},
durationMs: 7466,
status: 200,
requestBody: {},
responseBody: {},
...overrides,
};
}
describe("loadReporterConfig", () => {
it("未配置上报地址时视为关闭", () => {
expect(loadReporterConfig({}).url).toBe("");
});
it("去掉结尾斜杠,避免拼出双斜杠路径", () => {
expect(loadReporterConfig({ LPT_AI_REPORT_URL: "http://be.test/" }).url).toBe("http://be.test");
});
it("非法数值回退到缺省", () => {
const config = loadReporterConfig({ LPT_AI_REPORT_INTERVAL_MS: "-5", LPT_AI_REPORT_BATCH_SIZE: "x" });
expect(config.intervalMs).toBe(15_000);
expect(config.batchSize).toBe(50);
});
});
describe("toUsageRecord", () => {
it("把日志映射成上报载荷,null 字段显式保留", () => {
const record = toUsageRecord(entry({ usage: emptyUsage(), costUsd: null, usageSource: "missing" }));
expect(record).toMatchObject({
recordId: "rec-1",
taskType: "aggregate-report",
attempts: 2,
usageSource: "missing",
promptTokens: null,
completionTokens: null,
cacheHitTokens: null,
costUsd: null,
});
});
it("非 LLM 请求也上报,由 isLlmCall 区分", () => {
const record = toUsageRecord(
entry({ isLlmCall: false, taskType: "fetch-title", model: "", usage: undefined }),
);
expect(record.isLlmCall).toBe(false);
expect(record.taskType).toBe("fetch-title");
expect(record.model).toBe("");
});
it("归属标记原样带上;没传时显式写 null", () => {
expect(toUsageRecord(entry({ callerRef: "U-123" })).callerRef).toBe("U-123");
expect(toUsageRecord(entry()).callerRef).toBeNull();
});
it("必填字段永远非空,否则 lpt-be 会把整批上报判 400", () => {
// 契约 1 的必填项:lpt-be 侧 @NotBlank 的字段不能是空串,@NotNull 的字段不能缺。
// 尤其是 /fetch-title 的 model——它合法地是空串,所以 lpt-be 那边用的是 @NotNull。
const notBlank = ["recordId", "occurredAt", "taskType", "usageSource"] as const;
const notNull = ["model", "attempts", "isLlmCall", "durationMs", "status"] as const;
const cases = [
entry(),
entry({ isLlmCall: false, taskType: "fetch-title", model: "", usage: undefined, usageSource: undefined }),
entry({ usage: emptyUsage(), costUsd: null, usageSource: "missing", status: 500, errorCode: "rate_limited" }),
];
for (const logEntry of cases) {
const record = toUsageRecord(logEntry) as unknown as Record<string, unknown>;
for (const field of notBlank) {
expect(typeof record[field], field).toBe("string");
expect(String(record[field]).trim().length, field).toBeGreaterThan(0);
}
for (const field of notNull) {
expect(record[field], field).not.toBeNull();
expect(record[field], field).not.toBeUndefined();
}
// lpt-be 用 OffsetDateTime.parse 解析 occurredAt,必须是带时区的 ISO 8601
expect(record.occurredAt).toMatch(/Z$|[+-]\d{2}:\d{2}$/);
}
});
});
describe("UsageReporter", () => {
it("未配置上报地址时不入队、不落盘", async () => {
const reporter = makeReporter({ url: "" });
reporter.enqueue(entry());
expect(reporter.isConfigured()).toBe(false);
expect(reporter.pendingCount()).toBe(0);
expect(existsSync(outboxFile())).toBe(false);
await expect(reporter.flush()).resolves.toEqual({ sent: 0, remaining: 0 });
});
it("推送成功后清空队列并落盘", async () => {
const fetchImpl = vi.fn().mockResolvedValue({ ok: true, status: 200 } as Response);
const reporter = makeReporter({}, fetchImpl as unknown as typeof fetch);
reporter.enqueue(entry({ recordId: "rec-1" }));
reporter.enqueue(entry({ recordId: "rec-2" }));
await expect(reporter.flush()).resolves.toEqual({ sent: 2, remaining: 0 });
expect(reporter.pendingCount()).toBe(0);
expect(JSON.parse(readFileSync(outboxFile(), "utf-8"))).toEqual([]);
const [url, init] = fetchImpl.mock.calls[0] as [string, RequestInit];
expect(url).toBe("http://lpt-be.test/internal/ai-usage/records");
expect((init.headers as Record<string, string>)["x-api-token"]).toBe("report-token");
expect(JSON.parse(String(init.body)).records).toHaveLength(2);
});
it("上报失败时保留队列,等下次重试", async () => {
const fetchImpl = vi.fn().mockResolvedValue({
ok: false,
status: 500,
text: async () => "boom",
} as Response);
const reporter = makeReporter({}, fetchImpl as unknown as typeof fetch);
reporter.enqueue(entry());
const result = await reporter.flush();
expect(result.sent).toBe(0);
expect(result.remaining).toBe(1);
expect(result.error).toContain("500");
expect(reporter.pendingCount()).toBe(1);
expect(reporter.dropped).toBe(0);
});
it("4xx 是确定性拒绝:丢弃这批而不是无限重试把队列堵死", async () => {
const fetchImpl = vi.fn().mockResolvedValue({
ok: false,
status: 400,
text: async () => "model 不能为空",
} as Response);
const reporter = makeReporter({}, fetchImpl as unknown as typeof fetch);
reporter.enqueue(entry({ recordId: "bad" }));
reporter.enqueue(entry({ recordId: "good" }));
const result = await reporter.flush();
expect(result.error).toContain("400");
expect(reporter.pendingCount()).toBe(0);
expect(reporter.dropped).toBe(2);
// 后续正常记录不受影响,仍然能上报
fetchImpl.mockResolvedValue({ ok: true, status: 200 } as Response);
reporter.enqueue(entry({ recordId: "later" }));
await expect(reporter.flush()).resolves.toEqual({ sent: 1, remaining: 0 });
});
it("网络异常时不丢队列", async () => {
const fetchImpl = vi.fn().mockRejectedValue(new Error("ECONNREFUSED"));
const reporter = makeReporter({}, fetchImpl as unknown as typeof fetch);
reporter.enqueue(entry());
const result = await reporter.flush();
expect(result.error).toBe("ECONNREFUSED");
expect(reporter.pendingCount()).toBe(1);
});
it("按 batchSize 分批推送,剩余记录留待下一轮", async () => {
const fetchImpl = vi.fn().mockResolvedValue({ ok: true, status: 200 } as Response);
const reporter = makeReporter({ batchSize: 2 }, fetchImpl as unknown as typeof fetch);
for (const id of ["a", "b", "c"]) {
reporter.enqueue(entry({ recordId: id }));
}
await expect(reporter.flush()).resolves.toEqual({ sent: 2, remaining: 1 });
expect(JSON.parse(String((fetchImpl.mock.calls[0][1] as RequestInit).body)).records.map(
(r: { recordId: string }) => r.recordId,
)).toEqual(["a", "b"]);
});
it("超出上限时丢弃最旧的并计数,避免磁盘被写满", () => {
const reporter = makeReporter({ maxPending: 2 });
for (const id of ["a", "b", "c", "d"]) {
reporter.enqueue(entry({ recordId: id }));
}
expect(reporter.pendingCount()).toBe(2);
expect(reporter.dropped).toBe(2);
});
it("新实例从 outbox 文件恢复未上报的记录", () => {
const first = makeReporter();
first.enqueue(entry({ recordId: "rec-persisted" }));
expect(first.pendingCount()).toBe(1);
const second = makeReporter();
expect(second.pendingCount()).toBe(1);
});
it("outbox 文件损坏时从空队列开始,不阻塞后续上报", () => {
const first = makeReporter();
first.enqueue(entry());
const reporter = new UsageReporter({
loadConfig: () => reporterConfig(),
outboxFile: join(workDir, "corrupt.json"),
});
expect(reporter.pendingCount()).toBe(0);
});
it("并发调用 flush 时第二次直接返回,不重复推送", async () => {
let release!: (value: Response) => void;
const fetchImpl = vi.fn().mockImplementation(
() => new Promise<Response>((resolve) => { release = resolve; }),
);
const reporter = makeReporter({}, fetchImpl as unknown as typeof fetch);
reporter.enqueue(entry());
const first = reporter.flush();
const second = await reporter.flush();
expect(second).toEqual({ sent: 0, remaining: 1 });
release({ ok: true, status: 200 } as Response);
await expect(first).resolves.toEqual({ sent: 1, remaining: 0 });
expect(fetchImpl).toHaveBeenCalledTimes(1);
});
});