feat(orchestrator): time range and replay move into the rates panel (015)

The navbar time menu goes; the rates panel holds the presets, a two-handle span slider over the hub's history, replay and Live, and the custom From/To range. A custom range becomes a window length plus an end point, so live windows keep their length. The rates chip lists every metric, and the panel wraps instead of spilling at 390 px. Unit and e2e (Chromium, Firefox, 1920/1366/390) cover the window, the slider and the requests.

🎯 Fix: 94 %
💥 Break: 4 %
💸 Tokens: 100 %
⏱️ Velocity: 100 %
🛡️ Security: 100 %
🏆 Score: 90
🚦 Gate: ✅ 90/5, tokens and velocity <= 100, security 100 %

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Kevin Veen-BirkenbachandClaude Opus 5.5 committed 2026-11-17 14:08:13 +00:00
1 parent 09e3f6dabe
commit cc6ea7c230
20 files changed
+462 -416

No files matched your search

+7 -2
View File
@@ -4,14 +4,15 @@ import {createServer} from "node:net";
import {tmpdir} from "node:os";
import {join} from "node:path";
// Args: <firefox binary> <plan.json>; the plan lists steps {width, height, url, wait, probe, shot, gesture} and an optional
// init like cdp.mjs.
// Args: <firefox binary> <plan.json>; the plan lists steps {width, height, url, wait, keys, probe, shot, gesture} and an
// optional init like cdp.mjs.
// Prints {results, errors}: one probe value per step and every JavaScript error the page logged.
const [binary, planFile] = process.argv.slice(2);
const plan = JSON.parse(readFileSync(planFile, "utf8"));
const profile = mkdtempSync(join(tmpdir(), "bidi-"));
writeFileSync(join(profile, "user.js"), ['user_pref("media.navigator.streams.fake", true);', 'user_pref("media.navigator.permission.disabled", true);', ""].join("\n"));
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
const KEYS = {Enter: "", Tab: "", ArrowLeft: "", ArrowRight: ""};
const port = await new Promise((resolve) => {
const probe = createServer().listen(0, "127.0.0.1", () => {
const {port: free} = probe.address();
@@ -81,6 +82,10 @@ try {
await send("browsingContext.navigate", {context, url: step.url, wait: "complete"});
}
await sleep(step.wait);
for (const key of step.keys || []) {
await send("input.performActions", {context, actions: [{type: "key", id: "keyboard", actions: [{type: "keyDown", value: KEYS[key]}, {type: "keyUp", value: KEYS[key]}]}]});
await sleep(250);
}
let value = null;
if (step.probe) {
const answer = await send("script.evaluate", {expression: `(async () => JSON.stringify(await ${step.probe}))()`, target: {context}, awaitPromise: true, resultOwnership: "none", userActivation: Boolean(step.gesture)});
+2 -2
View File
@@ -4,7 +4,7 @@ import {tmpdir} from "node:os";
import {join} from "node:path";
// Args: <chromium binary> <plan.json>; the plan lists steps {width, height, url, wait, keys, probe, shot, media, gesture},
// keys being real key presses (Enter, Tab) on the focused element before the probe and gesture running the probe with a
// keys being real key presses (Enter, Tab, ArrowLeft, ArrowRight) on the focused element before the probe and gesture running the probe with a
// user activation like a click, an optional init, the text of a function every new document runs before its own scripts,
// and an optional authenticator {credentialId, privateKey, rpId}: base64 id and PKCS#8 key of a passkey the page may sign with.
// Prints {results, errors}: one probe value per step and every uncaught page exception.
@@ -17,7 +17,7 @@ const profile = mkdtempSync(join(tmpdir(), "cdp-"));
const flags = ["--headless", "--no-sandbox", "--disable-gpu", "--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--ignore-certificate-errors", "--use-fake-device-for-media-stream", "--use-fake-ui-for-media-stream", "--no-first-run", "--no-default-browser-check", "--hide-scrollbars", `--user-data-dir=${profile}`, "--remote-debugging-port=0", "about:blank"];
const browser = spawn(binary, flags, {stdio: ["ignore", "ignore", "pipe"]});
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
const KEYS = {Enter: [13, "\r"], Tab: [9, ""]};
const KEYS = {Enter: [13, "\r"], Tab: [9, ""], ArrowLeft: [37, ""], ArrowRight: [39, ""]};
const address = await new Promise((resolve, reject) => {
let text = "";
+2 -2
View File
@@ -25,8 +25,8 @@ PROBE = """(async () => {@HELPERS@
layouts: all('#main [aria-label="Layout"] button').map(name),
chips: all('#main [aria-label="Categories"] button').map(name),
menus: all("#main details.menu > summary").map(name),
time: text(document.querySelector("#time > summary")),
replay: Boolean(document.querySelector("#time .replay input[type=range]")),
time: text(document.querySelector("#rates .rate-window")),
replay: Boolean(document.querySelector("#rates .span-slider input[type=range]")),
custom: Boolean(document.querySelector('#main details.menu input[type="datetime-local"]')),
toolbar: all('#main [role="toolbar"] > *').map((node) => name(node.tagName === "DETAILS" ? node.querySelector("summary") : node.querySelector("button") || node)),
spot: (() => {
+1 -1
View File
@@ -144,7 +144,7 @@ class TestOrchestratorE2E(base.OrchestratorE2ECase):
self.assertEqual(probe["badges"], {"tab-home": None, "tab-stream": None, "tab-rules": None, "tab-agents": "1", "tab-artifacts": None, "tab-tasks": "2", "tab-resources": None})
self.assertEqual(probe["banner"], "MAYDAY · Docs: disk full")
self.assertFalse(probe["rail"])
self.assertEqual((probe["time"], probe["replay"]), ("24 h ▾", True))
self.assertEqual((probe["time"], probe["replay"]), ("24 h · /h", True))
self.assertGreater(probe["icons"], 8)
self.assertEqual(labelled(probe), {"unlabelled": [], "broken": []})
self.assertFalse(probe["wide"], "the page scrolls sideways")
+162 -81
View File
@@ -18,22 +18,24 @@ from hub_support import iso
OUT = Path(os.environ.get("E2E_OUT", "/tmp/hub-header-rates-shots"))
HOUR = 3600
DAY = 86400
GIB = 1 << 30
PERIODS = {1920: "day", 1366: "week", 390: "minute"}
BEFORE = {1920: "hour", 1366: "day", 390: "week"}
CHOSEN = {1920: ["tasks", "tokens", "commits"], 1366: ["tasks", "tokens", "cpu"], 390: ["tasks", "tokens", "commits"]}
TASKS = {"minute": ("≈ 0.02/min", "true"), "hour": ("1/h", "false"), "day": ("2/d", "false"), "week": ("2/wk", "false"), "month": ("2/mo", "false"), "year": ("2/yr", "false"), "total": ("2", "false")}
METRICS = ["tasks", "commits", "krs", "tokens", "cpu", "ram", "vram", "swap", "disk"]
HEAD = ["Metric", "Chip", "min", "h", "d", "wk", "mo", "yr", "all"]
PARTS = {"presets": ["1 h", "6 h", "24 h", "7 d", "all"], "thumbs": 2, "replay": True, "live": True, "range": ["From", "To"], "units": ["min", "h", "d", "wk", "mo", "yr", "all"], "head": HEAD}
READ = """
const chip = () => document.querySelector("#rates summary.rates-chip");
const period = () => document.querySelector('#rates select[aria-label="Rate period"]');
const menu = () => document.querySelector("#rates details.rates-menu");
const box = () => document.querySelector("#rates .rates-box");
const thumb = (end) => document.querySelector(`#rates .span-slider .span-${end}`);
const unit = (short) => all("#rates .rates-units button").find((button) => text(button) === short);
const preset = (name) => all('#rates [aria-label="Time range"] button').find((button) => text(button) === name);
const pick = (id) => document.querySelector(`#rates tr[data-metric="${id}"] input[type="checkbox"]`);
const metrics = () => all("#rates summary .rate").map((node) => node.dataset.metric);
const values = () => Object.fromEntries(all("#rates summary .rate").map((node) => [node.dataset.metric, text(node)]));
const loaded = () => Boolean(chip() && metrics().length && !text(chip()).includes("…"));
const shown = () => all("#rates summary .rate").filter((node) => !node.hidden).map((node) => node.dataset.metric);
const value = (id) => text(document.querySelector(`#rates summary .rate[data-metric="${id}"] .rate-value`));
const cell = (id, period) => text(document.querySelector(`#rates tr[data-metric="${id}"] td[data-period="${period}"]`));
const windowText = () => text(document.querySelector("#rates .rate-window"));
const loaded = () => Boolean(chip() && shown().length && !text(chip()).includes("…"));
const stored = async () => (await (await fetch("/api/state", {cache: "no-store"})).json()).settings.rates;
const storedUntil = async (test, ms) => {
const end = Date.now() + ms;
@@ -46,67 +48,125 @@ READ = """
}
return null;
};
if (!window.e2eAsked) {
window.e2eAsked = [];
const send = window.fetch.bind(window);
window.fetch = (path, init) => {
window.e2eAsked.push(String(path));
return send(path, init);
};
}
const asked = (path) => {
const hits = window.e2eAsked.map((entry) => new URL(entry, location.href)).filter((url) => url.pathname === path);
const last = hits[hits.length - 1];
return last ? {from: Number(last.searchParams.get("from")), to: last.searchParams.has("to") ? Number(last.searchParams.get("to")) : null} : null;
};
const inside = (node) => {
const rect = node.getBoundingClientRect();
return rect.width > 0 && rect.left >= -1 && rect.right <= innerWidth + 1;
};
const fits = () => {
const bar = document.querySelector(".navbar");
return {wide: document.documentElement.scrollWidth > innerWidth + 1, bar: bar.scrollWidth > bar.clientWidth + 1, chip: inside(chip()), period: inside(period())};
const spill = menu().open && box().getClientRects().length ? box().scrollWidth > box().clientWidth + 1 : false;
return {wide: document.documentElement.scrollWidth > innerWidth + 1, bar: bar.scrollWidth > bar.clientWidth + 1, chip: inside(chip()), spill};
};
const opened = async () => {
if (!menu().open) {
chip().click();
}
return Boolean(await until(() => menu().open && box().getClientRects().length, 4000));
};
"""
CHOOSE = """(async () => {@HELPERS@@READ@
PANEL = """(async () => {@HELPERS@@READ@
if (!(await until(loaded, 15000))) {
return {error: text(document.getElementById("rates"))};
}
const before = {period: period().value, metrics: metrics()};
period().value = "@PERIOD@";
period().dispatchEvent(new Event("change", {bubbles: true}));
const saved = await storedUntil((found) => found.period === "@PERIOD@", 8000);
await until(() => period().value === "@PERIOD@" && loaded(), 4000);
return {before, saved, after: {period: period().value, metrics: metrics(), values: values(), label: chip().getAttribute("aria-label")}, fits: fits(), open: menu().open, violations: window.e2eViolations || null};
const header = {time: Boolean(document.getElementById("time")), select: all(".navbar select").length, window: windowText()};
const open = await opened();
const parts = {
presets: all('#rates [aria-label="Time range"] button').map(text), thumbs: all("#rates .span-slider input[type=range]").length,
replay: Boolean(document.querySelector('#rates .replay button[aria-label="Replay"]')), live: Boolean(all("#rates .replay button").find((button) => text(button) === "Live")),
range: all('#rates .custom input[type="datetime-local"]').map((input) => input.getAttribute("aria-label")), units: all("#rates .rates-units button").map(text),
head: all("#rates .rates-table thead th").map(text),
};
unit("d").click();
const saved = await storedUntil((found) => found.period === "day", 8000);
preset("7 d").click();
const week = Boolean(await until(() => windowText() === "7 d · /d" && loaded() && value("tokens").endsWith("/d"), 8000));
await sleep(600);
const tokens = {chip: value("tokens"), cell: cell("tokens", "day"), current: all('#rates td[aria-current="true"]').map((node) => node.dataset.period)};
const rates = asked("/api/rates");
thumb("from").focus();
return {header, open, parts, saved, week, tokens, rates, now: Date.now() / 1000, from: Number(thumb("from").value), focused: document.activeElement === thumb("from"), fits: fits(), violations: window.e2eViolations || null};
})()"""
OPEN = """(async () => {@HELPERS@@READ@
STEPPED = """(async () => {@HELPERS@@READ@
await sleep(800);
const stepped = {from: Number(thumb("from").value), to: Number(thumb("to").value)};
thumb("from").value = String(Number(thumb("to").value) - 1);
thumb("from").dispatchEvent(new Event("input", {bubbles: true}));
await sleep(800);
thumb("from").focus();
return {stepped, near: {from: Number(thumb("from").value), to: Number(thumb("to").value)}, focused: document.activeElement === thumb("from")};
})()"""
BLOCKED = """(async () => {@HELPERS@@READ@
await sleep(800);
const blocked = {from: Number(thumb("from").value), to: Number(thumb("to").value)};
thumb("from").value = "100";
thumb("from").dispatchEvent(new Event("input", {bubbles: true}));
thumb("to").value = "800";
thumb("to").dispatchEvent(new Event("input", {bubbles: true}));
const past = Boolean(await until(() => windowText() === "7 d · past · /d" && loaded(), 8000));
await sleep(800);
const label = text(document.querySelector("#rates .window-label"));
return {blocked, past, label, rates: asked("/api/rates"), state: asked("/api/state"), now: Date.now() / 1000, fits: fits(), violations: window.e2eViolations || null};
})()"""
REPLAY = """(async () => {@HELPERS@@READ@
const play = () => document.querySelector("#rates .replay button.icon-only");
const liveButton = () => all("#rates .replay button").find((button) => text(button) === "Live");
play().click();
await sleep(1500);
play().click();
await sleep(800);
const paused = text(document.querySelector("#rates .window-label"));
await sleep(1500);
const held = text(document.querySelector("#rates .window-label")) === paused && !liveButton().disabled;
play().click();
const ended = Boolean(await until(() => liveButton().disabled && text(document.querySelector("#rates .window-label")).endsWith("· live"), 45000));
return {paused: !paused.endsWith("· live"), held, ended, window: windowText(), playing: play().getAttribute("aria-label"), violations: window.e2eViolations || null};
})()"""
NINE = """(async () => {@HELPERS@@READ@
for (const id of @METRICS@) {
if (!pick(id).checked) {
pick(id).click();
await storedUntil((found) => found.metrics.includes(id), 8000);
await until(() => pick(id) && pick(id).checked, 4000);
}
}
menu().open = false;
await until(() => !menu().open, 2000);
window.dispatchEvent(new Event("resize"));
await sleep(400);
const more = document.querySelector("#rates summary .rate-more");
return {stored: (await stored()).metrics.length, shown: shown().length, more: more.hidden ? null : text(more), fits: fits(), violations: window.e2eViolations || null};
})()"""
KEPT = """(async () => {@HELPERS@@READ@
if (!(await until(loaded, 15000))) {
return {error: text(document.getElementById("rates"))};
}
const kept = {period: period().value, metrics: metrics(), values: values()};
chip().click();
const opened = Boolean(await until(() => menu().open && box().getClientRects().length, 4000));
const head = all("#rates .rates-table thead th").map(text);
const rows = all("#rates .rates-table tbody tr").map((row) => [row.dataset.metric, all("td[data-period]", row).length]);
const current = all('#rates .rates-table td[aria-current="true"]').map((cell) => cell.dataset.period);
const tasks = Object.fromEntries(all('#rates tr[data-metric="tasks"] td[data-period]').map((cell) => [cell.dataset.period, [text(cell), cell.dataset.approx]]));
const hint = document.querySelector('#rates tr[data-metric="tasks"] td[data-period="minute"]').title;
const [drop, add] = metrics().includes("cpu") ? ["cpu", "commits"] : ["commits", "cpu"];
const locked = pick(add).disabled;
pick(drop).click();
await storedUntil((found) => !found.metrics.includes(drop), 8000);
await until(() => !metrics().includes(drop) && pick(add) && !pick(add).disabled, 4000);
const fewest = all("#rates tbody input:checked").map((input) => input.disabled);
pick(add).click();
const swapped = await storedUntil((found) => found.metrics.includes(add), 8000);
await until(() => metrics().includes(add), 4000);
return {kept, opened, head, rows, current, tasks, hint, locked, fewest, swapped, chip: metrics(), box: inside(box()), fits: fits(), open: menu().open, violations: window.e2eViolations || null};
})()"""
CLOSE = """(async () => {@HELPERS@@READ@
const was = menu().open;
const kept = {window: windowText(), metrics: (await stored()).metrics.length, unit: all('#rates .rates-units button[aria-pressed="true"]').map(text)};
await opened();
document.body.dispatchEvent(new KeyboardEvent("keydown", {key: "Escape", bubbles: true}));
const escaped = Boolean(await until(() => !menu().open, 3000));
chip().click();
const reopened = Boolean(await until(() => menu().open, 3000));
chip().click();
const clicked = Boolean(await until(() => !menu().open, 3000));
chip().click();
await until(() => menu().open, 3000);
document.getElementById("main").click();
const outside = Boolean(await until(() => !menu().open, 3000));
return {was, escaped, reopened, clicked, outside, fits: fits(), violations: window.e2eViolations || null};
return {kept, escaped, reopened, outside, fits: fits(), violations: window.e2eViolations || null};
})()"""
def probe(template: str, width: int) -> str:
names = {"@HELPERS@": base.HELPERS, "@READ@": READ, "@PERIOD@": PERIODS[width]}
def probe(template: str) -> str:
names = {"@HELPERS@": base.HELPERS, "@READ@": READ, "@METRICS@": json.dumps(METRICS)}
for key, value in names.items():
template = template.replace(key, value)
return template
@@ -117,6 +177,10 @@ def sample(t: int) -> dict:
return {"t": t, "disks": [{"mount": "/", "used": 400 << 30, "total": 1000 << 30}], "cpu": 25.0, "ram": 40.0, "swap": 5.0, "load": 1.0, "gpus": gpus, "queue": {"waiting": 0, "active": 0}}
def token(t: int, amount: int) -> dict:
return {"t": t, "agent": "Skills", "model": "claude-opus-5-5", "input": amount - 400_000, "output": 0, "cache_read": 400_000, "cache_write": 0}
@unittest.skipUnless(shutil.which(os.environ.get("CHROMIUM", "chromium")), "no Chromium")
class TestRatesChip(HubCase):
drive = base.OrchestratorE2ECase.drive
@@ -129,13 +193,15 @@ class TestRatesChip(HubCase):
folder = self.kept / "resources"
folder.mkdir()
(folder / "samples.jsonl").write_text(self.jsonl([sample(now - 2 * HOUR + step * 60) for step in range(140)]), encoding="utf-8")
tokens = [{"t": t, "agent": "Skills", "model": "claude-opus-5-5", "input": 4000, "output": 1000, "cache_read": 20000, "cache_write": 500} for t in (hour - HOUR, hour)]
tokens = [token(hour - 9 * DAY, 500_000), *(token(hour - day * DAY, 1_000_000) for day in range(7))]
(folder / "tokens.jsonl").write_text(self.jsonl(tokens), encoding="utf-8")
self.write_council({"rasci.json": {
"work/first": {"title": "First", "status": "done", "worker": "Skills", "start": iso(now - 5 * HOUR), "end": iso(now - 3 * HOUR), "roles": {"Skills": "RA"}},
"work/second": {"title": "Second", "status": "done", "worker": "Skills", "start": iso(now - 2 * HOUR), "end": iso(now - 1200), "roles": {"Skills": "RA"}, "key_results": [{"text": "shipped", "met": True, "met_at": iso(now - 1300)}]},
"work/third": {"title": "Third", "status": "running", "worker": "Stage", "start": iso(now - HOUR), "roles": {"Stage": "RA"}},
}})
self.write_council({
"rasci.json": {
"work/first": {"title": "First", "status": "done", "worker": "Skills", "start": iso(now - 5 * HOUR), "end": iso(now - 3 * HOUR), "roles": {"Skills": "RA"}},
"work/second": {"title": "Second", "status": "done", "worker": "Skills", "start": iso(now - 2 * HOUR), "end": iso(now - 1200), "roles": {"Skills": "RA"}, "key_results": [{"text": "shipped", "met": True, "met_at": iso(now - 1300)}]},
},
"news.jsonl": self.jsonl([{"ts": now - 10 * DAY, "from": "Skills", "to": [], "text": "the oldest record", "class": "post", "v": 2}]),
})
(self.council / "scores.jsonl").write_text(json.dumps({"time": now - 2 * HOUR, "remote": "example.org/skills", "path": "/repo", "branch": "main", "sha": "d" * 40, "values": {"score": 90}, "digest": "0" * 64}) + "\n", encoding="utf-8")
self.base = f"http://{self.host}/"
@@ -144,50 +210,65 @@ class TestRatesChip(HubCase):
for width, height in base.WIDTHS:
shot = OUT / f"{browser}-{width}"
steps += [
{"width": width, "height": height, "url": f"{self.base}?{width}#home", "wait": 1200, "probe": probe(CHOOSE, width), "shot": f"{shot}-chip.png"},
{"width": width, "height": height, "url": f"{self.base}?{width}-reloaded#home", "wait": 1200, "probe": probe(OPEN, width), "shot": f"{shot}-popover.png"},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(CLOSE, width), "shot": None},
{"width": width, "height": height, "url": f"{self.base}?{width}#home", "wait": 1200, "probe": probe(PANEL), "shot": f"{shot}-panel.png"},
{"width": width, "height": height, "url": None, "wait": 0, "keys": ["ArrowRight"], "probe": probe(STEPPED), "shot": None},
{"width": width, "height": height, "url": None, "wait": 0, "keys": ["ArrowRight"], "probe": probe(BLOCKED), "shot": f"{shot}-past.png"},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(REPLAY), "shot": None},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(NINE), "shot": f"{shot}-nine.png"},
{"width": width, "height": height, "url": f"{self.base}?{width}-reloaded#home", "wait": 1200, "probe": probe(KEPT), "shot": None},
]
return steps
def check(self, data: dict, browser: str) -> None:
results = iter(data["results"])
fitting = {"wide": False, "bar": False, "chip": True, "period": True}
previous = ["tasks", "tokens", "cpu"]
fitting = {"wide": False, "bar": False, "chip": True, "spill": False}
for width, _ in base.WIDTHS:
chosen, opened, closed = next(results), next(results), next(results)
chip = {"day": "2/d", "week": "2/wk", "minute": "≈ 0.02/min"}[PERIODS[width]]
panel, stepped, blocked, replay, nine, kept = (next(results) for _ in range(6))
with self.subTest(browser=browser, width=width):
self.assertNotIn("error", chosen, chosen)
self.assertEqual(chosen["before"], {"period": BEFORE[width], "metrics": previous})
self.assertEqual(chosen["saved"], {"period": PERIODS[width], "metrics": previous})
self.assertEqual((chosen["after"]["period"], chosen["after"]["metrics"], chosen["after"]["values"]["tasks"]), (PERIODS[width], previous, chip))
self.assertTrue(chosen["after"]["label"].startswith("Rates per "), chosen["after"])
self.assertEqual((chosen["fits"], chosen["open"]), (fitting, False))
self.assertEqual(w4.quiet(chosen["violations"]), [])
self.assertNotIn("error", opened, opened)
self.assertEqual((opened["kept"]["period"], opened["kept"]["metrics"], opened["kept"]["values"]["tasks"]), (PERIODS[width], previous, chip))
self.assertTrue(opened["opened"], opened)
self.assertEqual((opened["head"], opened["rows"], opened["current"]), (HEAD, [[metric, 7] for metric in METRICS], [PERIODS[width]] * len(METRICS)))
self.assertEqual({period: tuple(cell) for period, cell in opened["tasks"].items()}, TASKS)
self.assertIn("scaled from the last hour", opened["hint"])
self.assertEqual((opened["locked"], opened["fewest"]), (True, [True, True]))
self.assertEqual((opened["swapped"], opened["chip"]), ({"period": PERIODS[width], "metrics": CHOSEN[width]}, CHOSEN[width]))
self.assertEqual((opened["box"], opened["fits"], opened["open"]), (True, fitting, True))
self.assertEqual(w4.quiet(opened["violations"]), [])
self.assertEqual({key: closed[key] for key in ("was", "escaped", "reopened", "clicked", "outside")}, dict.fromkeys(("was", "escaped", "reopened", "clicked", "outside"), True))
self.assertEqual((closed["fits"], w4.quiet(closed["violations"])), (fitting, []))
previous = CHOSEN[width]
self.assertEqual(self.httpd.hub.settings.get()["rates"], {"period": PERIODS[390], "metrics": CHOSEN[390]})
self.assertNotIn("error", panel, panel)
self.assertEqual(panel["header"]["time"], False)
self.assertEqual(panel["header"]["select"], 0)
self.assertTrue(panel["open"], panel)
self.assertEqual(panel["parts"], PARTS)
self.assertEqual(panel["saved"]["period"], "day", panel)
self.assertTrue(panel["week"], panel)
self.assertEqual(panel["tokens"], {"chip": "1.0M/d", "cell": "1.0M/d", "current": ["day"] * len(METRICS)}, panel)
self.assertLess(abs(panel["rates"]["from"] - (panel["now"] - 7 * DAY)), 120, panel["rates"])
self.assertEqual((panel["focused"], panel["fits"], w4.quiet(panel["violations"])), (True, fitting, []))
self.assertEqual(stepped["stepped"], {"from": panel["from"] + 1, "to": 1000}, stepped)
self.assertEqual((stepped["near"], stepped["focused"]), ({"from": 999, "to": 1000}, True), stepped)
self.assertEqual(blocked["blocked"], {"from": 999, "to": 1000}, blocked)
self.assertTrue(blocked["past"], blocked)
self.assertIn(" – ", blocked["label"])
self.assertFalse(blocked["label"].endswith("· live"), blocked)
self.assertEqual(panel["from"], 300, panel)
for asked in (blocked["rates"], blocked["state"]):
self.assertLess(abs(asked["from"] - (blocked["now"] - 9 * DAY)), 0.01 * 10 * DAY, asked)
self.assertLess(abs(asked["to"] - (blocked["now"] - 2 * DAY)), 0.01 * 10 * DAY, asked)
self.assertEqual((blocked["fits"], w4.quiet(blocked["violations"])), (fitting, []))
self.assertEqual({key: replay[key] for key in ("paused", "held", "ended", "playing")}, {"paused": True, "held": True, "ended": True, "playing": "Replay"}, replay)
self.assertEqual(w4.quiet(replay["violations"]), [])
self.assertEqual(nine["stored"], 9)
if width == 1920:
self.assertEqual((nine["shown"], nine["more"]), (9, None), nine)
if width == 390:
self.assertLess(nine["shown"], 9, nine)
self.assertEqual(nine["more"], f"+{9 - nine['shown']}", nine)
self.assertEqual((nine["fits"], w4.quiet(nine["violations"])), (fitting, []))
self.assertNotIn("error", kept, kept)
self.assertEqual(kept["kept"], {"window": "24 h · /d", "metrics": 9, "unit": ["d"]})
self.assertEqual({key: kept[key] for key in ("escaped", "reopened", "outside")}, dict.fromkeys(("escaped", "reopened", "outside"), True))
self.assertEqual((kept["fits"], w4.quiet(kept["violations"])), (fitting, []))
self.assertEqual(self.httpd.hub.settings.get()["rates"], {"period": "day", "metrics": ["tasks", "tokens", "cpu", "commits", "krs", "ram", "vram", "swap", "disk"]})
def test_chromium_shows_the_rates_chip_keeps_its_period_over_a_reload_and_opens_and_closes_the_table_at_three_widths(self):
def test_chromium_moves_the_time_range_and_the_rate_unit_into_the_rates_panel_at_three_widths(self):
data = self.drive(self.steps("chromium"), None, init=w4.GUARD)
(OUT / "chromium-rates.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
self.assertEqual(data["errors"], [])
self.check(data, "chromium")
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
def test_firefox_shows_the_rates_chip_keeps_its_period_over_a_reload_and_opens_and_closes_the_table_at_three_widths(self):
def test_firefox_moves_the_time_range_and_the_rate_unit_into_the_rates_panel_at_three_widths(self):
data = self.drive(self.steps("firefox"), None, "bidi.mjs", os.environ.get("FIREFOX", "firefox"), init=w4.GUARD)
(OUT / "firefox-rates.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
self.assertEqual([error for error in data["errors"] if "/favicon.ico" not in error], [])
+88 -107
View File
@@ -18,7 +18,8 @@ HOUR = 3600
DAY = 86400
GIB = 1 << 30
NOW = 1_800_000_000 + 1800
EXACT_ZERO = {"value": 0.0, "approx": False, "source": None}
LAST_HOUR = NOW - NOW % HOUR
NOTHING = {"value": None, "approx": False, "covered": None}
def token(t: int, given: int, cached: int) -> dict:
@@ -31,6 +32,10 @@ def sample(t: float, cpu: float, span: int | None = None, vram: tuple[int, int]
return row if span is None else {**row, "span": span}
def per_unit(amount: float, covered: float, approx: bool) -> dict[str, dict]:
return {name: {"value": rates.precise(amount if seconds is None else amount * seconds / covered), "approx": approx and seconds is not None, "covered": covered} for name, seconds in rates.PERIODS}
class TestRates(unittest.TestCase):
def setUp(self):
tmp = tempfile.TemporaryDirectory()
@@ -46,86 +51,88 @@ class TestRates(unittest.TestCase):
def lines(self, path: Path, rows: list[dict]) -> None:
path.write_text("".join(json.dumps(row) + "\n" for row in rows), encoding="utf-8")
def rated(self) -> dict:
return rates.rated(self.council, self.folder.parent, NOW)
def rated(self, begin: float, end: float) -> dict:
return rates.rated(self.council, self.folder.parent, NOW, (begin, end))
def column(self, metric: str) -> dict:
found = self.rated()
def column(self, metric: str, begin: float, end: float) -> dict:
found = self.rated(begin, end)
return {period: found["rates"][period][metric] for period in rates.PERIOD_NAMES}
def test_done_tasks_count_in_every_window_their_end_lies_in_and_total_counts_each_done_task(self):
ends = [NOW - 30, NOW - 1800, NOW - 2 * DAY, NOW - 20 * DAY, NOW - 200 * DAY, NOW - 800 * DAY]
def test_a_week_of_seven_million_tokens_gives_a_million_a_day_seven_a_week_and_seven_in_all(self):
self.lines(self.folder / "tokens.jsonl", [token(LAST_HOUR - 10 * DAY, 5, 0), token(LAST_HOUR - 2 * DAY, 6_000_000, 1_000_000)])
tokens = self.column("tokens", NOW - 7 * DAY, NOW)
self.assertEqual(tokens, per_unit(7_000_000, 7 * DAY, False))
self.assertEqual((tokens["day"]["value"], tokens["week"]["value"], tokens["total"]["value"], tokens["month"]["value"]), (1_000_000.0, 7_000_000.0, 7_000_000.0, 30_000_000.0))
def test_done_tasks_key_results_and_commits_count_inside_the_window_and_scale_per_unit(self):
ends = [NOW - 30, NOW - 1800, NOW - 2 * DAY, NOW - 20 * DAY]
tasks = {f"work/t{index}": {"status": "done", "end": iso(end)} for index, end in enumerate(ends)}
others = {"status": "done", "end": iso(NOW - 10)}
self.register({**tasks, "work/legacy": {"status": "done"}, "work/open": {**others, "status": "running"}, "work/halted": {**others, "status": "stopped"}, "operator/run": others})
counts = dict(zip(rates.PERIOD_NAMES, (1.0, 2.0, 2.0, 3.0, 4.0, 5.0, 7.0), strict=True))
self.assertEqual(self.column("tasks"), {period: {"value": value, "approx": False, "source": None} for period, value in counts.items()})
def test_an_empty_window_takes_the_shortest_longer_window_with_events_scaled_down_and_marked_approx(self):
results = [{"text": "met", "met": True, "met_at": iso(NOW - 1800)}, {"text": "open", "met": False}]
self.register({"work/a": {"status": "running", "key_results": results}})
results = [{"text": "met", "met": True, "met_at": iso(NOW - 600)}, {"text": "old", "met": True}, {"text": "open", "met": False}]
self.register({**tasks, "work/legacy": {"status": "done"}, "work/open": {**others, "status": "running", "key_results": results}, "work/halted": {**others, "status": "stopped"}, "operator/run": others})
commit = {"time": NOW - 5 * HOUR, "remote": "example.org/repo", "sha": "a" * 40, "values": {}}
self.lines(self.council / "scores.jsonl", [commit, commit, {**commit, "sha": None, "time": NOW - 60}, {**commit, "sha": "b" * 40, "values": None}])
krs = self.column("krs")
self.assertEqual(krs["minute"], {"value": 0.01667, "approx": True, "source": "hour"})
self.assertEqual([krs[period] for period in rates.PERIOD_NAMES[1:]], [{"value": 1.0, "approx": False, "source": None}] * 6)
commits = self.column("commits")
self.assertEqual(commits["minute"], {"value": 0.0006944, "approx": True, "source": "day"})
self.assertEqual(commits["hour"], {"value": 0.04167, "approx": True, "source": "day"})
self.assertEqual([commits[period] for period in rates.PERIOD_NAMES[2:]], [{"value": 1.0, "approx": False, "source": None}] * 5)
self.lines(self.council / "scores.jsonl", [commit, commit, {**commit, "sha": None, "time": NOW - 60}, {**commit, "sha": "b" * 40, "time": NOW - 3 * DAY}])
day = self.rated(NOW - DAY, NOW)["rates"]
self.assertEqual({period: day[period]["tasks"] for period in rates.PERIOD_NAMES}, per_unit(2, DAY, False))
self.assertEqual({period: day[period]["krs"] for period in rates.PERIOD_NAMES}, per_unit(1, DAY, False))
self.assertEqual({period: day[period]["commits"] for period in rates.PERIOD_NAMES}, per_unit(1, DAY, False))
past = self.rated(NOW - 3 * DAY, NOW - DAY)["rates"]
self.assertEqual((past["total"]["tasks"]["value"], past["total"]["commits"]["value"], past["day"]["tasks"]["value"]), (1.0, 1.0, 0.5))
def test_key_results_met_before_met_at_existed_count_only_in_total_and_scale_from_there(self):
self.register({"work/a": {"status": "running", "key_results": [{"text": "a", "met": True}]}})
self.lines(self.folder / "samples.jsonl", [sample(NOW - 10 * DAY, 5.0)])
krs = self.column("krs")
self.assertEqual(krs["total"], {"value": 1.0, "approx": False, "source": None})
self.assertEqual(krs["year"], {"value": 1.0, "approx": True, "source": "total"})
self.assertEqual(krs["week"], {"value": 0.7, "approx": True, "source": "total"})
self.assertEqual(krs["minute"], {"value": 6.944e-05, "approx": True, "source": "total"})
def test_a_window_reaching_before_the_first_token_row_divides_by_the_covered_part_and_marks_the_rates_approx(self):
self.register({"work/old": {"status": "done", "end": iso(NOW - 30 * DAY)}})
self.lines(self.folder / "tokens.jsonl", [token(LAST_HOUR - 2 * DAY, 4000, 800)])
tokens = self.column("tokens", NOW - 7 * DAY, NOW)
covered = NOW - (LAST_HOUR - 2 * DAY)
self.assertEqual(tokens, per_unit(4800, covered, True))
self.assertEqual(tokens["total"], {"value": 4800.0, "approx": False, "covered": covered})
self.assertEqual(self.column("tasks", NOW - 7 * DAY, NOW)["day"], {"value": 0.0, "approx": False, "covered": 7 * DAY})
def test_tokens_share_their_hour_by_overlap_and_the_minute_always_takes_a_longer_window(self):
hour = NOW - NOW % HOUR
self.lines(self.folder / "tokens.jsonl", [token(hour, 1000, 800), token(hour - HOUR, 3000, 600), token(hour - 20 * DAY, 7, 0)])
tokens = self.column("tokens")
self.assertEqual(tokens["minute"], {"value": 60.0, "approx": True, "source": "hour"})
self.assertEqual(tokens["hour"], {"value": 3600.0, "approx": False, "source": None})
self.assertEqual((tokens["day"]["value"], tokens["month"]["value"], tokens["total"]["value"]), (5400.0, 5407.0, 5407.0))
def test_a_window_before_every_record_holds_no_value(self):
self.register({"work/a": {"status": "done", "end": iso(NOW - DAY)}})
self.lines(self.folder / "tokens.jsonl", [token(LAST_HOUR - DAY, 100, 0)])
self.lines(self.folder / "samples.jsonl", [sample(NOW - DAY, 40.0)])
found = self.rated(NOW - 9 * DAY, NOW - 8 * DAY)
self.assertEqual({found["rates"][period][kind] == NOTHING for period in rates.PERIOD_NAMES for kind in rates.COUNTS}, {True})
self.assertIsNone(found["rates"]["day"]["cpu"]["value"])
self.assertEqual((found["from"], found["to"], found["since"]), (NOW - 9 * DAY, NOW - 8 * DAY, LAST_HOUR - DAY))
def test_an_empty_hour_takes_the_day_for_tokens_and_so_does_the_minute(self):
hour = NOW - NOW % HOUR
self.lines(self.folder / "tokens.jsonl", [token(hour - 5 * HOUR, 8000, 640)])
tokens = self.column("tokens")
self.assertEqual(tokens["minute"], {"value": 6.0, "approx": True, "source": "day"})
self.assertEqual(tokens["hour"], {"value": 360.0, "approx": True, "source": "day"})
self.assertEqual(tokens["day"], {"value": 8640.0, "approx": False, "source": None})
def test_a_window_shorter_than_an_hour_shares_the_token_hour_and_marks_every_token_rate_approx(self):
self.lines(self.folder / "tokens.jsonl", [token(LAST_HOUR, 1000, 800)])
tokens = self.column("tokens", NOW - 600, NOW)
self.assertEqual(tokens["minute"], {"value": 60.0, "approx": True, "covered": 600})
self.assertEqual(tokens["total"], {"value": 600.0, "approx": True, "covered": 600})
def test_gauges_average_each_window_weighting_raw_rows_fifteen_minute_means_and_daily_means_by_their_span(self):
def test_gauges_average_the_window_weighting_each_row_by_its_sampled_seconds_inside_on_both_ends(self):
start = NOW - 10 * DAY - (NOW - 10 * DAY) % DAY
self.lines(self.folder / "samples.jsonl", [
sample(NOW - 500 * DAY, 0.0, span=DAY),
sample(NOW - 200 * DAY, 90.0, span=DAY),
sample(NOW - 10 * DAY, 50.0, span=900),
sample(NOW - 90, 30.0, vram=(4, 8), boot=70),
sample(NOW - 30, 10.0, vram=(2, 8), boot=90),
{**sample(start, 40.0), "span": 3600, "width": DAY},
{**sample(NOW - 2 * DAY - 300, 70.0, boot=80), "span": 600, "width": 900},
sample(NOW - 30, 10.0, boot=20),
])
found = self.rated()["rates"]
self.assertEqual([found[period]["cpu"]["value"] for period in rates.PERIOD_NAMES], [10.0, 20.0, 20.0, 20.0, 46.5, 89.5, 45.0])
self.assertEqual([found[period]["ram"]["value"] for period in ("minute", "hour")], [11.0, 21.0])
self.assertEqual(found["minute"]["vram"], {"value": 25.0, "used": 2 * GIB, "approx": False, "source": None})
self.assertEqual((found["hour"]["vram"]["value"], found["hour"]["vram"]["used"], found["month"]["vram"]["value"]), (37.5, 3 * GIB, 37.5))
self.assertEqual(found["minute"]["disk"], {"value": 90.0, "mount": "/boot", "used": 90, "total": 100, "approx": False, "source": None})
self.assertEqual((found["hour"]["disk"]["value"], found["month"]["disk"]["value"], found["month"]["disk"]["used"]), (80.0, 53.5, 54))
self.assertEqual(self.rated()["since"], NOW - 500 * DAY)
found = self.rated(start + DAY / 2, NOW - 2 * DAY)["rates"]
self.assertEqual({found[period]["cpu"]["value"] for period in rates.PERIOD_NAMES}, {round((1800 * 40 + 200 * 70) / 2000, 1)})
self.assertEqual(found["hour"]["disk"], {"value": round((1800 * 50 + 200 * 80) / 2000, 1), "mount": "/boot", "used": 53, "total": 100, "approx": False})
self.assertEqual(found["week"]["vram"], {"value": None, "used": None, "approx": False})
def test_a_window_without_a_sample_shows_no_gauge_and_kinds_without_any_event_count_an_exact_zero(self):
def test_gauges_of_the_last_minutes_read_vram_and_the_fullest_disk(self):
self.lines(self.folder / "samples.jsonl", [sample(NOW - 90, 30.0, vram=(4, 8), boot=70), sample(NOW - 30, 10.0, vram=(2, 8), boot=90)])
last = self.rated(NOW - 60, NOW)["rates"]["minute"]
self.assertEqual((last["cpu"]["value"], last["ram"]["value"]), (10.0, 11.0))
self.assertEqual(last["vram"], {"value": 25.0, "used": 2 * GIB, "approx": False})
self.assertEqual(last["disk"], {"value": 90.0, "mount": "/boot", "used": 90, "total": 100, "approx": False})
both = self.rated(NOW - 120, NOW)["rates"]["hour"]
self.assertEqual((both["cpu"]["value"], both["vram"]["value"], both["vram"]["used"], both["disk"]["value"]), (20.0, 37.5, 3 * GIB, 80.0))
def test_a_window_without_a_sample_shows_no_gauge_and_kinds_with_records_but_none_inside_count_an_exact_zero(self):
self.lines(self.folder / "samples.jsonl", [sample(NOW - 2 * HOUR, 40.0)])
found = self.rated()
self.assertEqual([found["rates"][period]["cpu"]["value"] for period in rates.PERIOD_NAMES], [None, None, 40.0, 40.0, 40.0, 40.0, 40.0])
self.assertEqual(found["rates"]["hour"]["vram"], {"value": None, "used": None, "approx": False, "source": None})
self.assertEqual(found["rates"]["minute"]["disk"], {"value": None, "mount": None, "used": None, "total": None, "approx": False, "source": None})
self.assertEqual({found["rates"][period][kind] == EXACT_ZERO for period in rates.PERIOD_NAMES for kind in rates.COUNTS}, {True})
self.assertEqual((found["now"], found["since"], [entry["name"] for entry in found["periods"]]), (NOW, NOW - 2 * HOUR, list(rates.PERIOD_NAMES)))
found = self.rated(NOW - HOUR, NOW)["rates"]
self.assertIsNone(found["day"]["cpu"]["value"])
self.assertEqual(found["minute"]["disk"], {"value": None, "mount": None, "used": None, "total": None, "approx": False})
self.assertEqual({found[period][kind]["value"] for period in rates.PERIOD_NAMES for kind in ("tasks", "commits", "krs")}, {0.0})
self.assertEqual(found["day"]["tokens"], NOTHING)
def test_folded_sampler_rows_feed_the_windows_with_the_seconds_they_sampled(self):
def test_folded_sampler_rows_feed_the_window_with_the_seconds_they_sampled(self):
old = NOW - NOW % DAY - 100 * DAY
raw = [sample(old + 3600 + index * 60, 20.0) for index in range(30)] + [sample(NOW - 9 * DAY + index * 60, 60.0) for index in range(30)] + [sample(NOW - 59, 10.0)]
kept = sampler.retain(sorted(raw, key=lambda row: row["t"]), NOW)
@@ -134,10 +141,10 @@ class TestRates(unittest.TestCase):
self.assertEqual({row["width"] for row in kept[1:-1]}, {900})
self.assertNotIn("span", kept[-1])
self.lines(self.folder / "samples.jsonl", kept)
found = self.rated()["rates"]
month = round((10 * 60 + 60 * 1800) / (60 + 1800), 1)
year = round((10 * 60 + 60 * 1800 + 20 * 1800) / (60 + 1800 * 2), 1)
self.assertEqual([found[period]["cpu"]["value"] for period in ("minute", "week", "month", "year")], [10.0, 10.0, month, year])
cpu = [self.rated(NOW - seconds, NOW)["rates"]["day"]["cpu"]["value"] for seconds in (60, 7 * DAY, 30 * DAY, 365 * DAY)]
self.assertEqual(cpu, [10.0, 10.0, month, year])
def test_a_lone_fifteen_minute_bucket_weighs_its_sampled_seconds_wherever_it_lies_in_its_day(self):
day = NOW - NOW % DAY - 200 * DAY
@@ -156,22 +163,7 @@ class TestRates(unittest.TestCase):
old, recent = NOW - NOW % DAY - 100 * DAY, NOW - NOW % DAY - 8 * DAY
raw = [sample(old + 60 * index, 90.0) for index in range(60)] + [sample(recent + 60 * index, 10.0) for index in range(60)]
self.lines(self.folder / "samples.jsonl", sampler.retain(raw, NOW))
self.assertEqual(self.rated()["rates"]["year"]["cpu"]["value"], 50.0)
def test_a_folded_row_straddling_a_window_start_counts_by_its_share_inside(self):
week, year = NOW - 7 * DAY, NOW - 365 * DAY
self.lines(self.folder / "samples.jsonl", [
{**sample(year - year % DAY, 40.0), "span": 3600, "width": DAY},
{**sample(week - 300, 70.0, boot=80), "span": 600, "width": 900},
sample(NOW - 30, 10.0, boot=20),
])
found = self.rated()["rates"]
inside = (year - year % DAY + DAY - year) / DAY * 3600
self.assertEqual(found["week"]["cpu"]["value"], round((400 * 70 + 60 * 10) / 460, 1))
self.assertEqual(found["month"]["cpu"]["value"], round((600 * 70 + 60 * 10) / 660, 1))
self.assertEqual(found["year"]["cpu"]["value"], round((inside * 40 + 600 * 70 + 60 * 10) / (inside + 660), 1))
self.assertEqual(found["total"]["cpu"]["value"], round((3600 * 40 + 600 * 70 + 60 * 10) / 4260, 1))
self.assertEqual(found["week"]["disk"]["value"], round((400 * 80 + 60 * 20) / 460, 1))
self.assertEqual(self.rated(NOW - 365 * DAY, NOW)["rates"]["year"]["cpu"]["value"], 50.0)
def test_token_rows_older_than_ninety_days_fold_into_one_row_per_day_agent_and_model_kept_forever(self):
day, hour = NOW - NOW % DAY - 100 * DAY, NOW - NOW % HOUR
@@ -181,25 +173,11 @@ class TestRates(unittest.TestCase):
self.assertEqual(kept, [*daily, token(hour - HOUR, 7, 0)])
self.assertEqual(sampler.compact(kept, NOW + 400 * DAY)[:2], daily)
def test_a_daily_token_row_counts_by_the_share_of_its_day_inside_a_window(self):
def test_a_daily_token_row_counts_by_the_share_of_its_day_inside_the_window(self):
year = NOW - 365 * DAY
self.lines(self.folder / "tokens.jsonl", [{**token(year - year % DAY, 8640, 0), "width": DAY}])
tokens = self.column("tokens")
self.assertEqual(tokens["year"], {"value": rates.precise((year - year % DAY + DAY - year) / DAY * 8640), "approx": False, "source": None})
self.assertEqual(tokens["total"], {"value": 8640.0, "approx": False, "source": None})
def test_token_windows_reaching_before_the_first_token_row_are_scaled_estimates_from_the_rows_there_are(self):
hour = NOW - NOW % HOUR
begins = hour - 10 * DAY
self.register({"work/old": {"status": "done", "end": iso(NOW - 400 * DAY)}})
self.lines(self.folder / "tokens.jsonl", [token(begins, 1000, 0), token(hour - HOUR, 500, 0)])
tokens = self.column("tokens")
covered = NOW - begins
self.assertEqual(tokens["minute"], {"value": rates.precise(250 / 60), "approx": True, "source": "hour"})
self.assertEqual([tokens[period] for period in ("hour", "day", "week")], [{"value": value, "approx": False, "source": None} for value in (250.0, 500.0, 500.0)])
for period, seconds in (("month", 30 * DAY), ("year", 365 * DAY), ("total", 400 * DAY)):
with self.subTest(period=period):
self.assertEqual(tokens[period], {"value": rates.precise(1500 * seconds / covered), "approx": True, "source": "total"})
total = self.column("tokens", year, NOW)["total"]
self.assertEqual(total, {"value": rates.precise((year - year % DAY + DAY - year) / DAY * 8640), "approx": False, "covered": NOW - year})
def test_counts_shorten_to_thousands_millions_billions_and_trillions(self):
probe = "const R = require(process.argv[1]); console.log(JSON.stringify(JSON.parse(process.argv[2]).map(R.compact)));"
@@ -209,16 +187,19 @@ class TestRates(unittest.TestCase):
class TestHubRates(HubCase):
def test_the_hub_serves_the_rates_of_the_register_the_journal_and_the_sampler(self):
self.write_council({"rasci.json": {"work/a": {"status": "done", "end": iso(1_700_000_000), "key_results": [{"text": "a", "met": True, "met_at": iso(1_700_000_000)}]}}})
(self.council / "scores.jsonl").write_text(json.dumps({"time": 1_700_000_000, "remote": "example.org/repo", "sha": "c" * 40, "values": {}}) + "\n", encoding="utf-8")
status, headers, body = self.get("/api/rates")
def test_the_hub_serves_the_rates_of_the_window_from_the_register_the_journal_and_the_sampler(self):
done = 1_700_000_000
self.write_council({"rasci.json": {"work/a": {"status": "done", "end": iso(done), "key_results": [{"text": "a", "met": True, "met_at": iso(done)}]}}})
(self.council / "scores.jsonl").write_text(json.dumps({"time": done, "remote": "example.org/repo", "sha": "c" * 40, "values": {}}) + "\n", encoding="utf-8")
status, headers, body = self.get(f"/api/rates?from={done - DAY}&to={done + DAY}")
self.assertEqual((status, headers["content-type"]), (200, "application/json"), body)
found = json.loads(body)
self.assertEqual([entry["name"] for entry in found["periods"]], list(rates.PERIOD_NAMES))
self.assertEqual({kind: found["rates"]["total"][kind]["value"] for kind in rates.COUNTS}, {"tasks": 1.0, "commits": 1.0, "krs": 1.0, "tokens": 0.0})
self.assertEqual({kind: found["rates"]["total"][kind]["value"] for kind in rates.COUNTS}, {"tasks": 1.0, "commits": 1.0, "krs": 1.0, "tokens": None})
self.assertEqual({kind: found["rates"]["day"][kind]["approx"] for kind in ("tasks", "commits", "krs")}, {"tasks": True, "commits": True, "krs": True})
self.assertEqual(set(found["rates"]["hour"]), set(rates.METRICS))
self.assertEqual(found["since"], 1_700_000_000)
self.assertEqual((found["since"], found["from"], found["to"]), (done, done - DAY, done + DAY))
self.assertEqual(self.get(f"/api/rates?from={done}&to={done - 1}")[0], 400)
if __name__ == "__main__":
+3 -3
View File
@@ -5,7 +5,7 @@ import unittest
from hub_case import HubCase
from hub_support import STREAMS, Key, key
from kvb_orchestrator import settings
from kvb_orchestrator import rates, settings
class TestHubSettings(HubCase):
@@ -199,13 +199,13 @@ class TestHubSettings(HubCase):
self.assertEqual((settings.SETTINGS["rates"], self.snapshot()["settings"]["rates"]), (default, default))
good = self.guard(self.host)
wrongs = [{"period": period, "metrics": ["tasks", "cpu"]} for period in ("second", "Hour", "", None, 1)]
wrongs += [{"period": "day", "metrics": metrics} for metrics in (["tasks"], [], ["tasks", "cpu", "ram", "swap"], ["tasks", "tasks"], ["tasks", "gpu"], [1, 2], "tasks,cpu", None)]
wrongs += [{"period": "day", "metrics": metrics} for metrics in (["tasks"], [], [*rates.METRICS, "tasks"], ["tasks", "tasks"], ["tasks", "gpu"], [1, 2], "tasks,cpu", None)]
wrongs += [{"period": "day"}, {"metrics": ["tasks", "cpu"]}, {**default, "extra": 1}, "day", ["day"]]
for wrong in wrongs:
with self.subTest(wrong=wrong):
self.assertEqual(self.post_json("/api/settings", {**settings.SETTINGS, "rates": wrong}, good)[0], 400)
self.assertEqual(self.snapshot()["settings"]["rates"], default)
for chosen in ({"period": "minute", "metrics": ["commits", "krs"]}, {"period": "total", "metrics": ["disk", "vram", "swap"]}, {"period": "week", "metrics": ["ram", "tokens"]}):
for chosen in ({"period": "minute", "metrics": ["commits", "krs"]}, {"period": "total", "metrics": list(reversed(rates.METRICS))}, {"period": "week", "metrics": ["ram", "tokens"]}):
with self.subTest(chosen=chosen):
self.assertIsNone(self.prepared({**self.snapshot()["settings"], "rates": chosen})["payload"])
status, _, body = self.post_json("/api/settings", {**self.snapshot()["settings"], "rates": chosen, "proof": None}, good)