Files
streamline/control-web/test/dashMetrics.test.ts
T
2026-11-16 17:26:44 -08:00

411 lines
19 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { test, expect, describe } from "bun:test";
import type { BoardItem, ClusterNode } from "../src/types";
import {
computeDashMetrics, isSucceeded, isOutcome, isTaskFinished, pct, pieConic, kindBucketCounts, kindPieSlices, kindOtherSlices, outcomeBandOf, outcomeDisplayN, inStableCohort, stableCohortCutoffExclusiveMs, stableCohortLastDay, PIPELINE_BUCKETS,
} from "../src/lib/dashMetrics";
import { bucketOf, mrIsClosed } from "../src/lib/board";
import { comboTaskStateOf } from "../src/types";
function bug(over: Record<string, unknown>): BoardItem {
return {
kind: "bug", id: "b", title: "t", platform: "android",
status: "awaiting_fix", attempts: 0, createdAt: 1,
...over,
} as BoardItem;
}
function feat(over: Record<string, unknown>): BoardItem {
return {
kind: "feature", id: "f", title: "t", platform: "ios",
status: "awaiting_implementation", attempts: 0, createdAt: 1,
...over,
} as BoardItem;
}
function sec(over: Record<string, unknown>): BoardItem {
return {
kind: "security", id: "s", title: "t", platform: "android",
status: "awaiting_security", attempts: 0, createdAt: 1,
...over,
} as BoardItem;
}
function node(over: Partial<ClusterNode> & { id: string }): ClusterNode {
return {
baseUrl: "http://n", platform: "android", status: "online",
lastSeenAt: 1, evalInFlight: 0, evalCapacity: 1,
fixInFlight: 0, fixCapacity: 1, version: null, createdAt: 1, live: true,
...over,
} as ClusterNode;
}
describe("pct", () => {
test("rounds and guards a zero denominator", () => {
expect(pct(1, 2)).toBe(50);
expect(pct(2, 3)).toBe(67);
expect(pct(0, 0)).toBe(0);
});
});
describe("稳定队列 — 今天 − 14 天(北京日,含截止日)", () => {
// 2026-09-03 18:30 UTC = 北京 9/4 02:30 → 截止日 8/21,次日 0 点 = 8/21 16:00 UTC。
const now = Date.parse("2026-09-03T18:30:00Z");
test("截止日是北京今天减 14 天", () => {
expect(stableCohortLastDay(now)).toBe("2026-08-21");
expect(stableCohortCutoffExclusiveMs(now)).toBe(Date.parse("2026-08-21T16:00:00Z"));
});
test("截止日当天还在队列里,次日 0 点起不算", () => {
expect(inStableCohort({ createdAt: Date.parse("2026-08-21T15:59:59Z") }, now)).toBe(true);
expect(inStableCohort({ createdAt: Date.parse("2026-08-21T16:00:00Z") }, now)).toBe(false);
expect(inStableCohort({ createdAt: 0 }, now)).toBe(false);
});
});
describe("pieConic", () => {
test("空数据是一圈底色,对半切开贴到 180/360", () => {
expect(pieConic([])).toBe("var(--border)");
expect(pieConic([{ color: "#0f0", n: 0 }])).toBe("var(--border)");
expect(pieConic([{ color: "#0f0", n: 1 }, { color: "#f00", n: 1 }]))
.toBe("#0f0 0.0deg 180.0deg, #f00 180.0deg 360.0deg");
});
});
describe("isSucceeded / isOutcome — 三类任务各自的终态", () => {
test("bug 以 fix_succeeded 为通过,cancelled 不进分母", () => {
expect(isSucceeded(bug({ status: "fix_succeeded" }))).toBe(true);
expect(isOutcome(bug({ status: "fix_succeeded" }))).toBe(true);
expect(isOutcome(bug({ status: "fix_failed" }))).toBe(true);
expect(isOutcome(bug({ status: "unreproducible" }))).toBe(true);
expect(isOutcome(bug({ status: "archived" }))).toBe(true);
expect(isSucceeded(bug({ status: "archived" }))).toBe(false);
expect(isOutcome(bug({ status: "cancelled" }))).toBe(false);
expect(isOutcome(bug({ status: "manual_review" }))).toBe(false);
expect(isOutcome(bug({ status: "evaluate_finish" }))).toBe(false);
expect(isSucceeded(bug({ status: "evaluate_finish" }))).toBe(false);
});
test("feature / security 以 completed 为通过", () => {
expect(isSucceeded(feat({ status: "completed" }))).toBe(true);
expect(isOutcome(feat({ status: "implementation_failed" }))).toBe(true);
expect(isOutcome(feat({ status: "archived" }))).toBe(true);
expect(isSucceeded(feat({ status: "archived" }))).toBe(false);
expect(isOutcome(feat({ status: "cancelled" }))).toBe(false);
expect(isSucceeded(sec({ status: "completed" }))).toBe(true);
expect(isOutcome(sec({ status: "unreproducible" }))).toBe(true);
expect(isOutcome(sec({ status: "security_failed" }))).toBe(true);
});
});
describe("isTaskFinished — 流转中 + 待合入 + 已完成 + 确认无法复现", () => {
test("fix_succeeded 全体和确认无法复现算完成;未确认的无法复现不算", () => {
expect(isTaskFinished(bug({
status: "fix_succeeded", mrState: "merged", meegoState: "done",
}))).toBe(true);
expect(isTaskFinished(bug({
status: "fix_succeeded", mergedIntoBaseAt: 1,
}))).toBe(true);
expect(isTaskFinished(bug({
status: "fix_succeeded", mrState: "opened", meegoState: "resolved",
}))).toBe(true);
expect(isTaskFinished(bug({
status: "fix_succeeded", mrState: "opened", meegoState: "done",
}))).toBe(true);
expect(isTaskFinished(feat({ status: "completed" }))).toBe(true);
expect(isTaskFinished(bug({
status: "unreproducible", meegoState: "closed",
}))).toBe(true);
expect(isTaskFinished(bug({
status: "unreproducible", meegoState: "RESOLVED",
}))).toBe(true);
expect(isTaskFinished(bug({ status: "unreproducible", meegoState: "open" }))).toBe(false);
expect(isTaskFinished(bug({ status: "fix_failed" }))).toBe(false);
expect(isTaskFinished(bug({ status: "archived" }))).toBe(false);
expect(isTaskFinished(feat({ status: "archived" }))).toBe(false);
expect(isTaskFinished(bug({ status: "manual_review" }))).toBe(false);
expect(isTaskFinished(bug({ status: "evaluate_finish" }))).toBe(false);
});
test("Meego 已 close/done:MR closed → DONE;开着或没有 MR → 待合入;Bits 已合入 → DONE", () => {
expect(bucketOf(bug({
status: "fix_succeeded", meegoState: "CLOSED", mrState: null,
}))).toBe("awaiting_merge");
expect(bucketOf(bug({
status: "fix_succeeded", meegoState: "done", mrState: "closed",
}))).toBe("merged");
expect(bucketOf(bug({
status: "fix_succeeded", meegoState: "done", mrState: "opened",
}))).toBe("awaiting_merge");
expect(bucketOf(bug({
status: "fix_succeeded", meegoState: "done", mrState: "merged",
}))).toBe("merged");
expect(bucketOf(bug({
status: "fix_succeeded", meegoState: "RESOLVED", mrState: "opened",
}))).toBe("awaiting_qa");
expect(bucketOf(bug({
status: "unreproducible", meegoState: "RESOLVED",
}))).toBe("confirmed_unrepro");
expect(bucketOf(bug({
status: "unreproducible", meegoState: "open",
}))).toBe("unreproducible");
});
test("MR / QA 进度只属于 fix_succeeded:从无法复现打回、带着 OPEN 重跑的单不是待 QA", () => {
for (const status of ["awaiting_fix", "fixing", "manual_review", "unreproducible"]) {
expect(comboTaskStateOf({ status, mrState: null, meegoState: "OPEN" })).toBeNull();
}
expect(bucketOf(bug({ status: "fixing", meegoState: "OPEN" }))).toBe("running");
for (const m of ["OPEN", "IN PROGRESS", "RESOLVED"]) {
expect(comboTaskStateOf({ status: "fix_succeeded", mrState: null, meegoState: m })).toBe("awaiting_qa");
}
expect(comboTaskStateOf({ status: "fix_succeeded", mrState: "merged", meegoState: "REOPENED" })).toBe("qa_reopened");
});
test("QA 打回(fix_succeeded + REOPENED):盖过任何合入信号,算待处理、不算通过;QA 再解决就回到待 QA", () => {
for (const over of [{ mrState: "opened" }, { mrState: "merged" }, { mergedIntoBaseAt: 5 }]) {
const it = bug({ status: "fix_succeeded", meegoState: "REOPENED", ...over });
expect(bucketOf(it)).toBe("qa_reopened");
expect(outcomeBandOf(it)).toBe("pending");
expect(isSucceeded(it)).toBe(false);
expect(isTaskFinished(it)).toBe(false);
}
const back = bug({ status: "fix_succeeded", meegoState: "RESOLVED", mrState: "opened" });
expect(bucketOf(back)).toBe("awaiting_qa");
expect(isSucceeded(back)).toBe(true);
});
test("mrIsClosed — Bits closed/close 才算关,opened / 缺省不算", () => {
expect(mrIsClosed({ mrState: "closed" })).toBe(true);
expect(mrIsClosed({ mrState: "CLOSED" })).toBe(true);
expect(mrIsClosed({ mrState: "close" })).toBe(true);
expect(mrIsClosed({ mrState: "opened" })).toBe(false);
expect(mrIsClosed({ mrState: null })).toBe(false);
expect(mrIsClosed({ mrState: "merged" })).toBe(false);
});
test("搜证另算:completed 和 unreproducible 都算结论,失败不算", () => {
expect(isTaskFinished(sec({ status: "completed" }))).toBe(true);
expect(isTaskFinished(sec({ status: "unreproducible" }))).toBe(true);
expect(isTaskFinished(sec({ status: "security_failed" }))).toBe(false);
expect(isTaskFinished(sec({ status: "manual_review" }))).toBe(false);
});
});
describe("computeDashMetrics", () => {
test("空看板给出零切片,分桶表仍有全部列", () => {
const m = computeDashMetrics([], []);
expect(m.total).toBe(0);
expect(m.live.onlineNodes).toBe(0);
for (const b of PIPELINE_BUCKETS) expect(m.buckets[b].total).toBe(0);
expect(m.byKind.bug.total).toBe(0);
});
test("三类任务分别落入看板分桶,而不是旧的 raw status", () => {
const items: BoardItem[] = [
bug({ id: "1", status: "pending_confirmation" }),
bug({ id: "2", status: "fixing" }),
bug({
id: "3", status: "fix_succeeded",
mrUrl: "https://bits/mr/1", mrState: "opened", meegoState: "done",
}),
bug({
id: "4", status: "fix_succeeded",
mrUrl: "https://bits/mr/2", mrState: "merged", meegoState: "done",
mrMergedAt: 100, finishedAt: 50,
}),
feat({ id: "5", status: "manual_review" }),
feat({ id: "6", status: "completed" }),
sec({ id: "7", status: "security_running" }),
sec({ id: "8", status: "unreproducible" }),
];
expect(bucketOf(items[2])).toBe("awaiting_merge");
expect(bucketOf(items[3])).toBe("merged");
const m = computeDashMetrics(items, [node({ id: "n1" }), node({ id: "n2", live: false, status: "offline" })]);
expect(m.total).toBe(8);
expect(m.byKind.bug.total).toBe(4);
expect(m.byKind.feature.total).toBe(2);
expect(m.byKind.security.total).toBe(2);
expect(m.buckets.confirm.bug).toBe(1);
expect(m.buckets.running.bug).toBe(1);
expect(m.buckets.running.security).toBe(1);
expect(m.buckets.awaiting_merge.bug).toBe(1);
expect(m.buckets.merged.bug).toBe(1);
expect(m.buckets.merged.feature).toBe(1);
expect(m.byKind.bug.finished).toBe(2);
expect(m.byKind.bug.inPlay).toBe(3); // 4 − confirm
expect(kindPieSlices(m, "bug").map((s) => s.bucket))
.toEqual(["running", "awaiting_merge", "merged"]);
expect(kindOtherSlices(m, "bug")).toEqual([{ bucket: "confirm", n: 1 }]);
expect(m.byKind.feature.finished).toBe(1);
expect(m.byKind.security.finished).toBe(1); // unreproducible 另计为结论
expect(m.buckets.review.feature).toBe(1);
expect(m.buckets.unreproducible.security).toBe(1);
expect(m.live.running).toBe(2);
expect(m.live.needsHuman).toBe(3); // confirm + feature review + awaiting_merge
expect(m.live.onlineNodes).toBe(1);
expect(m.live.totalNodes).toBe(2);
expect(kindBucketCounts(m, "bug").map((s) => s.bucket))
.toEqual(["confirm", "running", "awaiting_merge", "merged"]);
expect(kindBucketCounts(m, "feature")).toEqual([
{ bucket: "review", n: 1 },
{ bucket: "merged", n: 1 },
]);
});
test("MR 漏斗只数 bug,合入率分母是已批准且有 MR", () => {
const items: BoardItem[] = [
bug({
id: "open", status: "fix_succeeded",
mrUrl: "https://bits/1", mrState: "opened", meegoState: "resolved",
}),
bug({
id: "wait", status: "fix_succeeded",
mrUrl: "https://bits/2", mrState: "opened", meegoState: "done",
}),
bug({
id: "landed", status: "fix_succeeded",
mrUrl: "https://bits/3", mrState: "merged", meegoState: "done",
mrMergedAt: 200, finishedAt: 100, platform: "ios",
}),
bug({
id: "base", status: "fix_succeeded", mergedIntoBaseAt: 150,
}),
feat({ id: "f", status: "completed", mrUrl: "https://bits/feat" }),
];
const m = computeDashMetrics(items, []);
expect(m.mr.withMr).toBe(3);
expect(m.mr.awaitingQa).toBe(1);
expect(m.mr.awaitingMerge).toBe(1);
expect(m.mr.merged).toBe(2); // bits merged + 合回基线
expect(m.mr.bitsMerged).toBe(1);
expect(m.mr.mergedIntoBase).toBe(1);
expect(m.mr.approvedWithMr).toBe(3);
expect(m.mr.iosMerged).toBe(1);
expect(m.mr.androidMerged).toBe(1);
expect(m.mr.avgMergeMs).toBe(100);
expect(m.byKind.bug.finished).toBe(4); // QA + 待合入 + bits merged + 合回基线
});
test("交付结果:R0/R1/Rn/Fail/Pending 占全期分母;未确认无法复现进 R0;待 QA 不进", () => {
const items: BoardItem[] = [
bug({ id: "r0", status: "fix_succeeded", mrState: "merged", meegoState: "done", humanRejects: 0, totalDurationMs: 1000 }),
bug({ id: "unrepro", status: "unreproducible", meegoState: "open", humanRejects: 3 }),
bug({ id: "r1", status: "fix_succeeded", mrState: "merged", meegoState: "done", humanRejects: 1, totalDurationMs: 3000 }),
bug({ id: "r2", status: "fix_succeeded", mrState: "opened", meegoState: "done", humanRejects: 2 }),
bug({ id: "rn", status: "fix_succeeded", mrState: "merged", meegoState: "done", humanRejects: 3 }),
bug({ id: "closed", status: "fix_succeeded", mrState: "closed", meegoState: "done" }),
bug({ id: "fail", status: "fix_failed" }),
bug({ id: "archived", status: "archived" }),
bug({ id: "pending", status: "manual_review" }),
bug({ id: "qa", status: "fix_succeeded", mrState: "opened", meegoState: "resolved" }),
bug({ id: "confirm", status: "pending_confirmation" }),
feat({ id: "h", status: "completed", attempts: 1, humanRejects: 0, durationMs: 400 }),
feat({ id: "i", status: "awaiting_implementation", attempts: 0 }),
];
expect(outcomeBandOf(items[0])).toBe("r0");
expect(outcomeBandOf(items[1])).toBe("r0");
expect(outcomeBandOf(items[2])).toBe("r1");
expect(outcomeBandOf(items[3])).toBe("r2");
expect(outcomeBandOf(items[4])).toBe("rn");
expect(outcomeBandOf(items[5])).toBe("fail");
expect(outcomeBandOf(items[6])).toBe("fail");
expect(outcomeBandOf(items[7])).toBe("fail");
expect(outcomeBandOf(items[8])).toBe("pending");
expect(outcomeBandOf(items[9])).toBe(null);
expect(outcomeBandOf(items[10])).toBe(null);
const m = computeDashMetrics(items, []);
const bugS = m.byKind.bug;
expect(bugS.outcome).toEqual({ r0: 2, r1: 1, r2: 1, rn: 1, fail: 3, pending: 1, denom: 9 });
expect(outcomeDisplayN(bugS.outcome, "r0")).toBe(2);
expect(outcomeDisplayN(bugS.outcome, "r1")).toBe(3);
expect(outcomeDisplayN(bugS.outcome, "r2")).toBe(4);
expect(outcomeDisplayN(bugS.outcome, "rn")).toBe(5);
expect(outcomeDisplayN(bugS.outcome, "fail")).toBe(3);
expect(bucketOf(items[7])).toBe("archived");
expect(bugS.failed).toBe(2); // fix_failed + archived (closed MR is merged-bucket fail, not failed-bucket)
expect(m.buckets.failed.bug).toBe(2);
expect(bugS.avgDoneMs).toBe(2000);
expect(m.byKind.feature.outcome).toEqual({ r0: 1, r1: 0, r2: 0, rn: 0, fail: 0, pending: 0, denom: 1 });
expect(m.byKind.feature.avgDoneMs).toBe(400);
});
test("archived 落在 Done 分界桶,统计记 Fail", () => {
expect(bucketOf(bug({ status: "archived" }))).toBe("archived");
expect(bucketOf(feat({ status: "archived" }))).toBe("archived");
expect(outcomeBandOf(bug({ status: "archived" }))).toBe("fail");
expect(outcomeBandOf(feat({ status: "archived" }))).toBe("fail");
const m = computeDashMetrics([
bug({ id: "a", status: "archived" }),
feat({ id: "b", status: "archived" }),
], []);
expect(m.byKind.bug.failed).toBe(1);
expect(m.byKind.feature.failed).toBe(1);
expect(m.buckets.failed.bug).toBe(1);
expect(m.buckets.failed.feature).toBe(1);
expect(m.byKind.bug.finished).toBe(0);
expect(m.byKind.feature.finished).toBe(0);
});
test("通过率分母排除 cancelled,平均耗时只算成功的", () => {
const items: BoardItem[] = [
bug({ id: "ok", status: "fix_succeeded", totalDurationMs: 1000 }),
bug({ id: "bad", status: "fix_failed" }),
bug({ id: "abort", status: "cancelled" }),
feat({ id: "okf", status: "completed", durationMs: 400 }),
feat({ id: "badf", status: "implementation_failed" }),
];
const m = computeDashMetrics(items, []);
expect(m.byKind.bug.succeeded).toBe(1);
expect(m.byKind.bug.terminal).toBe(2);
expect(m.byKind.bug.avgSuccessMs).toBe(1000);
expect(m.byKind.feature.succeeded).toBe(1);
expect(m.byKind.feature.terminal).toBe(2);
expect(m.byKind.feature.avgSuccessMs).toBe(400);
});
test("已取消不进交付结果的 Fail,也不进分母", () => {
const cancelledBug = bug({ id: "abort", status: "cancelled" });
const cancelledFeat = feat({ id: "abortf", status: "cancelled" });
expect(outcomeBandOf(cancelledBug)).toBe(null);
expect(outcomeBandOf(cancelledFeat)).toBe(null);
const m = computeDashMetrics([
bug({ id: "bad", status: "fix_failed" }),
cancelledBug,
cancelledFeat,
], []);
expect(m.byKind.bug.outcome).toEqual({ r0: 0, r1: 0, r2: 0, rn: 0, fail: 1, pending: 0, denom: 1 });
expect(m.byKind.feature.outcome.denom).toBe(0);
expect(m.byKind.feature.outcome.fail).toBe(0);
});
test("增量托管没跑的单(只建记录 / 已撤回)落在 Done 的 not_run 桶,不进概览任何比率", () => {
const record = bug({ id: "rec", status: "cancelled", watchWithdrawn: "record:mr" });
const withdrawn = bug({ id: "wd", status: "cancelled", watchWithdrawn: "meego_closed" });
const bond = bug({ id: "bond", status: "cancelled", watchWithdrawn: "mr_bound" });
for (const it of [record, withdrawn, bond]) {
expect(bucketOf(it)).toBe("not_run");
expect(isOutcome(it)).toBe(false);
expect(isTaskFinished(it)).toBe(false);
expect(outcomeBandOf(it)).toBe(null);
}
// 真正的取消(没有增量托管的 watch_withdrawn)还是失败列。
expect(bucketOf(bug({ id: "plain", status: "cancelled" }))).toBe("failed");
const m = computeDashMetrics([record, withdrawn, bug({ id: "ok", status: "fix_succeeded" })], []);
expect(m.total).toBe(1); // 只有 fix_succeeded 那条被数
expect(m.byKind.bug.total).toBe(1);
expect(m.buckets.not_run.bug).toBe(0);
});
test("evaluate_finish 落在 Done 分界桶,不进完成率分子分母也不进交付结果", () => {
expect(bucketOf(bug({ status: "evaluate_finish" }))).toBe("evaluate_finish");
expect(outcomeBandOf(bug({ status: "evaluate_finish" }))).toBe(null);
const parked = bug({ id: "eval", status: "evaluate_finish" });
const pending = bug({ id: "rev", status: "manual_review" });
const done = bug({
id: "ok", status: "fix_succeeded",
mrState: "merged", meegoState: "done", mrMergedAt: 100, finishedAt: 50,
});
const m = computeDashMetrics([parked, pending, done], []);
expect(m.total).toBe(2);
expect(m.byKind.bug.total).toBe(2);
expect(m.byKind.bug.review).toBe(1);
expect(m.byKind.bug.merged).toBe(1);
expect(m.byKind.bug.finished).toBe(1);
expect(m.byKind.bug.inPlay).toBe(2);
expect(m.byKind.bug.outcome.pending).toBe(1);
expect(m.byKind.bug.outcome.denom).toBe(2);
});
});