Files
skills/tests/test_hub_home.py
T
Kevin Veen-BirkenbachandClaude Opus 5.5 48f26b678a feat(orchestrator): bookmark metrics, artifacts, priority and operator views to Home
Stars now pin each resources chart (hardware, tokens, combined overlay) with its chip selection, the artifacts tree and single artifacts, Agent priority, Waits on Operator and a single agent card as live Home tiles. A long artifact id pins as <kind>#<digest>, the view store keys selections by digest, refuses pins it cannot keep and Home shows a gone tile with unpin. Fixtures use synthetic operator-example-01 paths; requirement 008 lists the new pins.

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

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 10:02:43 +00:00

846 lines
50 KiB
Python

from __future__ import annotations
import json
import re
import subprocess
import time
import unittest
from typing import ClassVar
from hub_case import HubCase
from hub_support import (
CORE_BRANCH,
CORE_REPO,
CORE_WORKTREE,
HUB,
LONG_BRANCH,
LONG_REPO,
LONG_TASK,
LONG_VOLUME,
LONG_WORKTREE,
MERGED_BRANCH,
NAV,
long_repos,
long_task,
)
from kvb_orchestrator.viewstore import SERIES_ID, SHOWN_LIMIT
TEMPLATES = HUB / "templates"
PANELS = TEMPLATES / "panels.js"
HOME = TEMPLATES / "page-home.js"
PIN = {"kind": "panel", "id": "tasks/gantt", "w": 6, "h": 4}
LAYOUT_PROBE = """
const P = require(process.argv[1]);
const pin = (id, extra) => ({kind: "task", id, w: 4, h: 3, ...extra});
const many = (count) => Array.from({length: count}, (_, index) => pin(`work/t${index}`));
const cases = {
ok: [pin("work/a"), {kind: "panel", id: "tasks/gantt", w: 12, h: 1}],
full: many(64),
over: many(65),
wide: [pin("work/a", {w: 13})],
flat: [pin("work/a", {h: 0})],
half: [pin("work/a", {w: 2.5})],
text: [pin("work/a", {w: "4"})],
space: [pin("work a")],
long: [pin("x".repeat(201))],
kind: [{kind: "k".repeat(33), id: "a", w: 1, h: 1}],
empty: [{kind: "", id: "a", w: 1, h: 1}],
extra: [pin("work/a", {x: 1})],
twice: [pin("work/a"), pin("work/a")],
object: {pins: []},
};
const valid = Object.fromEntries(Object.entries(cases).map(([name, value]) => [name, P.validLayout(value)]));
const cleaned = P.clean([pin("work/a"), pin("bad id"), pin("work/a"), null, pin("work/b", {extra: 1}), ...many(70)]);
console.log(JSON.stringify({valid, cleaned: [cleaned.length, cleaned[0], cleaned[1].id], notList: P.clean("x")}));
"""
REORDER_PROBE = """
const P = require(process.argv[1]);
const pins = ["a", "b", "c", "d"].map((id) => ({kind: "task", id, w: 4, h: 3}));
const ids = (list) => list.map((pin) => pin.id).join("");
const out = {
place: [ids(P.place(pins, 0, 2)), ids(P.place(pins, 3, 0)), ids(P.place(pins, 1, 1)), ids(P.place(pins, 5, 0)), ids(P.place(pins, 0, -1))],
move: [ids(P.move(pins, 0, -1)), ids(P.move(pins, 0, 1)), ids(P.move(pins, 3, 1)), ids(P.move(pins, 2, -1))],
resize: [P.resize(pins, 1, 0, 13)[1], P.resize(pins, 1, 12, 1)[1], P.resize(pins, 1, 7.4, 2.6)[1]],
stretch: [P.stretch({w: 4, h: 3}, 200, 0, 100, 80), P.stretch({w: 4, h: 3}, -1000, -1000, 100, 80), P.stretch({w: 4, h: 3}, 5000, 5000, 100, 80), P.stretch({w: 4, h: 3}, 140, 30, 100, 80)],
untouched: ids(pins),
};
const full = Array.from({length: 64}, (_, index) => ({kind: "task", id: `t${index}`, w: 4, h: 3}));
const added = P.add(pins, "panel", "tasks/gantt");
const removed = P.remove(added.pins, "panel", "tasks/gantt");
out.add = [added.refused, added.pins.at(-1), P.add(added.pins, "panel", "tasks/gantt").pins.length, removed.length, P.remove(removed, "panel", "tasks/gantt").length,
P.add(full, "task", "t64").refused, P.add(full, "task", "t64").pins.length, P.add(full, "task", "t3").refused, P.add(full, "task", "t3").pins.length];
out.keys = [ids(P.placeKey(pins, "task:a", "task:c")), ids(P.placeKey(pins, "task:x", "task:a")), ids(P.moveKey(pins, "task:b", 1)), ids(P.moveKey(pins, "task:x", 1)),
P.resizeKey(pins, "task:b", 5, 2)[1], P.resizeBy(pins, "task:b", 1, -1)[1], ids(P.resizeBy(pins, "task:x", 1, 1)), ids(P.resizeKey(pins, "task:x", 1, 1))];
P.panel("agents/3d", "Agents: 3D", () => "a", "3d");
P.panel("tasks/3d", "Tasks: 3D", () => "t", "3d");
const one = P.add(pins, "panel", "agents/3d");
const second = P.add(one.pins, "panel", "tasks/3d");
const swapped = P.add(P.remove(one.pins, "panel", "agents/3d"), "panel", "tasks/3d");
const both = [...one.pins, {kind: "panel", id: "tasks/3d", w: 6, h: 4}];
out.group = [one.refused, second.refused, second.holder, second.pins.length, swapped.refused, swapped.pins.at(-1).id, P.add(one.pins, "panel", "tasks/gantt").refused,
P.firstOfGroup(both, both[4]), P.firstOfGroup(both, both[5]), P.firstOfGroup(both, both[0])];
console.log(JSON.stringify(out));
"""
REGISTRY_PROBE = """
const P = require(process.argv[1]);
P.panel("tasks/gantt", "Tasks: Gantt", (size) => `gantt ${size.w}x${size.h}`);
P.item("task", (id) => `Task ${id}`, (size, id) => (id === "work/live" ? `task ${id} ${size.w}` : null));
P.item("artifact", "Artifact", (size, id) => id);
const odd = "branch:/repo\\u0000feature x";
const token = P.token(odd);
const gantt = P.lookup("panel", "tasks/gantt");
const live = P.lookup("task", "work/live");
const art = P.lookup("artifact", token);
console.log(JSON.stringify({
gantt: [gantt.title, gantt.render({w: 6, h: 4})],
live: [live.title, live.render({w: 3, h: 2})],
gone: P.lookup("task", "work/deleted").render({w: 3, h: 2}),
unknownPanel: P.lookup("panel", "nope"),
unknownKind: P.lookup("nope", "x"),
token: [token, P.ID.test(token), P.raw(token) === odd, art.render({w: 1, h: 1}) === odd, P.token("work/plain"), P.token("a_b"), P.raw(P.token("a_b")), P.token("y".repeat(400)), P.token("1763.5/radio:work/x:9")],
}));
"""
STORE_PROBE = """
const P = require(process.argv[1]);
const calls = [];
const listeners = [];
const pin = (id) => ({kind: "task", id, w: 1, h: 1});
const backend = {
value: [{kind: "task", id: "work/a", w: 4, h: 3}, {kind: "task", id: "bad id", w: 1, h: 1}],
get(path) { calls.push(["get", path]); return this.value; },
update(path, change) { this.value = change(this.value); calls.push(["update", path, this.value.map((one) => one.id)]); return Promise.resolve(true); },
set(path) { throw new Error(`${path} holds a list: use update()`); },
on(path, listen) { calls.push(["on", path]); listeners.push(listen); },
};
const store = P.store(backend, "home.pins");
const seen = [];
store.watch((pins) => seen.push(pins.length));
listeners.forEach((listen) => listen([{kind: "task", id: "work/b", w: 2, h: 2}, "junk"]));
(async () => {
const read = store.read();
backend.value = [...backend.value, pin("work/other")];
const wrote = await store.change((pins) => [...pins, pin("work/c")]);
const refused = await store.change(() => Array.from({length: 65}, (_, index) => pin(`t${index}`))).then(() => "stored", (error) => error.message);
backend.value = Array.from({length: 64}, (_, index) => pin(`t${index}`));
backend.get = () => backend.value.slice(0, 63);
const late = await store.change((pins) => [...pins, pin("work/late")]);
const memory = P.memory();
const heard = [];
memory.on("home.pins", (value) => heard.push(value.length));
await memory.update("home.pins", () => [1, 2]);
const unknownPath = () => { throw new Error("unknown view path home.pins"); };
const strict = P.store({get: unknownPath, update: unknownPath, on: unknownPath, error: () => "another browser kept changing home.pins; try again"}, "home.pins");
const thrown = await strict.change(() => []).then(() => "stored", (error) => error.message);
const unknown = [strict.read(), strict.watch(() => null), thrown, strict.error(), P.store(backend, "home.pins").error()];
console.log(JSON.stringify({read: read.map((one) => one.id), wrote, refused, late: [late, backend.value.length, calls.at(-1)[2].includes("work/late")], calls: calls.slice(0, 4), seen,
memory: [memory.get("home.pins").length, heard], unknown}));
})();
"""
START_PROBE = """
const N = require(process.argv[1]);
console.log(JSON.stringify({
first: N.TABS[0], icon: N.ICONS.home,
routes: [["", 0], ["", 1], ["#", 3], ["#home", 0], ["#home", 2], ["#tasks/gantt", 2], ["#stream", 5], ["#bogus", 1], ["", undefined]].map(([hash, pinned]) => N.route(hash, pinned)),
}));
"""
TAB_KIT = """
const fs = require("fs");
const vm = require("vm");
const [panelsFile, homeFile] = process.argv.slice(1);
const clone = (value) => JSON.parse(JSON.stringify(value));
const settle = () => new Promise((resolve) => setTimeout(resolve, 5));
const keys = (pins) => pins.map((pin) => `${pin.kind}:${pin.id}`);
function hub(value) {
return {value: clone(value), hostile: false, patches: 0,
patch(body) {
this.patches += 1;
if (this.hostile) {
this.value = this.value.map((pin, at) => (at ? pin : {...pin, w: (pin.w % 12) + 1}));
}
if (JSON.stringify(body.expect) !== JSON.stringify(this.value)) {
return {status: 409, view: clone(this.value)};
}
this.value = clone(body.set);
return {status: 200, data: clone(this.value)};
}};
}
function viewStore(server) {
let saved = clone(server.value);
let error = "";
const pending = [];
const fold = (changes, base) => changes.reduce((value, change) => clone(change(clone(value))), base);
const store = {
sent: [],
get: (path) => clone(fold(pending, saved)),
set(path) { throw new Error(`${path} holds a list: use update()`); },
on() {},
error: () => error,
update(path, change) {
store.sent.push(path);
pending.push(change);
return new Promise((resolve) => setTimeout(() => resolve(flush()), 0));
},
};
function flush() {
const changes = pending.splice(0);
for (let attempt = 1; changes.length; attempt += 1) {
const answer = server.patch({set: fold(changes, saved), expect: saved});
saved = answer.status === 200 ? answer.data : answer.view;
if (answer.status === 200) {
error = "";
return true;
}
if (attempt === 3) {
error = "another browser kept changing home.pins; try again";
return false;
}
}
return true;
}
return store;
}
function page(server) {
const store = viewStore(server);
const toasts = [];
const context = vm.createContext({ViewStore: store, labelOf: (key) => key, toast: (title, lines, good) => toasts.push([title, lines.join(" "), good]), tree: {data: null, model: null}, console});
vm.runInContext(fs.readFileSync(panelsFile, "utf8"), context);
vm.runInContext(`${fs.readFileSync(homeFile, "utf8")}
globalThis.probe = {homePress, homeUnpin, homeView, Panels};`, context);
const probe = context.probe;
probe.homeView.pins = probe.Panels.clean(store.get("home.pins"));
return {...probe, store, toasts};
}
"""
PAGE_PROBE = TAB_KIT + """
const server = hub([]);
const tab = page(server);
const {homePress, homeUnpin, homeView, Panels} = tab;
const ids = Object.fromEntries(["panel", "task", "message", "artifact", "agent", "ancestry", "metric", "nope"].map((kind) => [kind, Boolean(Panels.lookup(kind, kind === "panel" ? "stream" : "x"))]));
const panels = ["stream", "radio-log", "agents/orbit", "agents/chord", "agents/swimlane", "agents/3d", "agents/tree", "agents/hierarchy", "agents/order", "artifacts/orbit", "artifacts/chord", "artifacts/swimlane", "artifacts/tree", "artifacts/3d",
"tasks/list", "tasks/board", "tasks/rasci", "tasks/gantt", "tasks/burn", "tasks/3d", "tasks/operator"].filter((id) => !Panels.lookup("panel", id));
(async () => {
homePress("panel", "tasks/gantt", "Gantt");
await settle();
const one = keys(server.value);
homePress("panel", "tasks/gantt", "Gantt");
await settle();
const none = server.value.length;
homePress("panel", "agents/3d", "Agents: 3D");
homePress("panel", "tasks/3d", "Tasks: 3D");
await settle();
const solid = keys(server.value);
homeUnpin("panel:agents/3d");
await settle();
Array.from({length: 64}, (_, index) => homePress("task", `work/t${index}`, `t${index}`));
await settle();
const sent = tab.store.sent.length;
homePress("task", "work/t64", "Task work/t64");
await settle();
const full = [server.value.length, tab.store.sent.length - sent];
homeUnpin("task:work/t0");
await settle();
const after = server.value.length;
server.hostile = true;
const patches = server.patches;
homeUnpin("task:work/t1");
const optimistic = homeView.pins.length;
await settle();
console.log(JSON.stringify({ids, panels, one, none, solid, full, after, optimistic, reverted: homeView.pins.length, tries: server.patches - patches,
fellBack: JSON.stringify(homeView.pins) === JSON.stringify(Panels.clean(server.value)), paths: [...new Set(tab.store.sent)], toasts: tab.toasts}));
})();
"""
RACE_PROBE = TAB_KIT + """
(async () => {
const server = hub([]);
const one = page(server);
const other = page(server);
one.homePress("panel", "tasks/gantt", "Gantt");
other.homePress("task", "work/b", "Task work/b");
await settle();
const pinned = [keys(server.value), server.patches, keys(other.store.get("home.pins"))];
const seed = Array.from({length: 63}, (_, index) => ({kind: "task", id: `work/s${index}`, w: 2, h: 1}));
const crowded = hub(seed);
const first = page(crowded);
const late = page(crowded);
first.homePress("task", "work/c", "Task work/c");
late.homePress("task", "work/d", "Task work/d");
await settle();
const ids = keys(crowded.value);
const stale = hub([{kind: "task", id: "work/a", w: 4, h: 3}, {kind: "task", id: "work/b", w: 4, h: 3}]);
const mover = page(stale);
const pinner = page(stale);
pinner.homePress("task", "work/c", "Task work/c");
mover.homeUnpin("task:work/a");
await settle();
console.log(JSON.stringify({pinned, full: [ids.length, ids.includes("task:work/c"), ids.includes("task:work/d"), late.toasts, first.toasts],
unpinned: keys(stale.value), toasts: [...one.toasts, ...other.toasts, ...mover.toasts, ...pinner.toasts]}));
})();
"""
DOM_KIT = """
const fs = require("fs");
const vm = require("vm");
const XHTML = "http://www.w3.org/1999/xhtml";
const parts = (selector) => selector.split(",").map((part) => {
const found = /^\\s*([a-z]*)((?:\\[[^\\]]+\\])*)\\s*$/.exec(part);
return {tag: found[1], attrs: [...found[2].matchAll(/\\[([\\w-]+)(?:="([^"]*)")?\\]/g)].map(([, name, value]) => [name, value])};
});
const matches = (node, selector) => parts(selector).some(({tag, attrs}) => (!tag || node.tagName === tag.toUpperCase()) && attrs.every(([name, value]) => node.attrs.has(name) && (value === undefined || node.attrs.get(name) === value)));
class El {
constructor(tag, ns) { this.tagName = tag.toUpperCase(); this.namespaceURI = ns || XHTML; this.attrs = new Map(); this.children = []; this.parentNode = null; this.listeners = {}; }
setAttribute(name, value) { this.attrs.set(name, String(value)); }
getAttribute(name) { return this.attrs.has(name) ? this.attrs.get(name) : null; }
hasAttribute(name) { return this.attrs.has(name); }
removeAttribute(name) { this.attrs.delete(name); }
get classList() { const list = (this.getAttribute("class") || "").split(/\\s+/); return {contains: (name) => list.includes(name)}; }
get isConnected() { let at = this; while (at.parentNode) { at = at.parentNode; } return at === document.body; }
focus() { document.activeElement = this; }
detach() {
if (this.parentNode) {
if (this.contains(document.activeElement)) { document.activeElement = document.body; }
this.parentNode.children = this.parentNode.children.filter((child) => child !== this); this.parentNode = null;
}
}
append(...nodes) { nodes.forEach((child) => { child.detach(); child.parentNode = this; this.children.push(child); }); }
prepend(...nodes) { nodes.reverse().forEach((child) => { child.detach(); child.parentNode = this; this.children.unshift(child); }); }
replaceChildren(...nodes) { [...this.children].forEach((child) => child.detach()); this.append(...nodes); }
contains(node) { for (let at = node; at; at = at.parentNode) { if (at === this) { return true; } } return false; }
all() { return this.children.flatMap((child) => [child, ...child.all()]); }
querySelectorAll(selector) { return this.all().filter((child) => matches(child, selector)); }
closest(selector) { for (let at = this; at; at = at.parentNode) { if (matches(at, selector)) { return at; } } return null; }
addEventListener(name, listen) { (this.listeners[name] = this.listeners[name] || []).push(listen); }
}
const el = (tag, attrs, ...children) => {
const made = new El(tag);
Object.entries(attrs).forEach(([name, value]) => made.setAttribute(name, value));
made.append(...children);
return made;
};
const document = {createElement: (tag) => new El(tag), createElementNS: (ns, tag) => new El(tag, ns), body: null, activeElement: null};
document.body = new El("body");
document.activeElement = document.body;
const text = (value) => {
const made = new El("#text");
made.textContent = String(value);
return made;
};
const h = (tag, attrs, ...children) => {
const made = new El(tag);
Object.entries(attrs || {}).filter(([name, value]) => name !== "on" && value !== null && value !== undefined && value !== false).forEach(([name, value]) => made.setAttribute(name, value));
made.append(...children.flat(Infinity).filter((child) => child !== null && child !== undefined && child !== false && child !== "").map((child) => (child instanceof El ? child : text(child))));
return made;
};
const textOf = (node) => (node.tagName === "#TEXT" ? node.textContent : node.children.map(textOf).join(""));
const context = vm.createContext({document, MutationObserver: class { observe() {} }, console});
vm.runInContext(fs.readFileSync(process.argv[1], "utf8"), context);
const P = vm.runInContext("Panels", context);
"""
STAR_PROBE = DOM_KIT + """
P.panel("tasks/list", "Tasks: list", () => null);
P.panel("radio-log", "Radio log", () => null);
P.item("task", (id) => `Task ${id}`, () => null);
const slot = el("div", {class: "head-row", "data-star-slot": ""}, el("code", {}), el("button", {class: "priority"}));
const task = el("li", {"data-item": "task:work/a"}, slot, el("span", {}));
const bare = el("li", {"data-item": "task:work/b"}, el("span", {}));
const list = el("div", {"data-panel": "tasks/list"}, el("ol", {}, task, bare));
const svg = new El("g", "http://www.w3.org/2000/svg");
svg.setAttribute("data-item", "task:work/c");
const radio = el("section", {"aria-label": "Radio log"}, el("ul", {"aria-label": "Radio log"}));
const root = el("main", {}, list, el("div", {}, svg), radio, el("div", {"data-panel": "nope"}));
const clicked = [];
const stars = () => root.querySelectorAll("[class]").filter((node) => node.classList.contains("star"));
const own = (host) => stars().filter((node) => node.closest("[data-panel], [data-item]") === host);
const mark = P.decorate(root, {pinned: (kind, id) => kind === "task" && id === "work/a", press: (...args) => clicked.push(args), marks: [['section[aria-label="Radio log"]', "radio-log"]]});
const before = stars().length;
mark();
const [panelStar] = own(list);
const [taskStar] = own(task);
const out = {
panel: {first: list.children[0].getAttribute("class"), stars: own(list).length, pressed: panelStar.getAttribute("aria-pressed"), title: panelStar.getAttribute("title")},
task: {inSlot: taskStar.parentNode === slot, slotLast: slot.children.at(-1) === taskStar, rows: task.children.filter((child) => child.classList.contains("star-row")).length,
pressed: taskStar.getAttribute("aria-pressed"), label: taskStar.getAttribute("aria-label")},
bare: {first: bare.children[0].getAttribute("class"), stars: own(bare).length},
svg: svg.children.length,
radio: [radio.getAttribute("data-panel"), radio.children[0].getAttribute("class")],
again: [before, stars().length],
};
taskStar.listeners.click[0]({preventDefault: () => null, stopPropagation: () => null});
const fresh = el("div", {"data-star-slot": ""});
task.replaceChildren(fresh, el("span", {}));
mark();
out.redrawn = [own(task)[0].parentNode === fresh, stars().length];
out.clicked = clicked;
console.log(JSON.stringify(out));
"""
MESSAGE_PROBE = """
const fs = require("fs");
const vm = require("vm");
const [panelsFile, homeFile] = process.argv.slice(1);
const urls = [];
const answers = {1762999999: {events: [{id: "radio:abc", ts: 1763000000.5}], entries: []}, 1762999899: {events: [], entries: [{id: "transcript:9", ts: 1762999900}]}};
const fetch = async (url) => {
urls.push(url);
return {ok: true, json: async () => answers[new URL(url, "http://hub.invalid").searchParams.get("from")]};
};
const stream = {events: [], entries: [{id: "transcript:7", ts: 5}], key: "view=fuer-dich", busy: false};
const context = vm.createContext({fetch, stream, filter: {view: "fuer-dich", waiting: true}, ui: {}, labelOf: (key) => key, toast: () => null, emptyState: () => "wait",
eventRow: (entry) => `row ${entry.id}`, h: (tag, attrs, child) => child, URL, console});
vm.runInContext(fs.readFileSync(panelsFile, "utf8"), context);
vm.runInContext(fs.readFileSync(homeFile, "utf8"), context);
const P = vm.runInContext("Panels", context);
const tile = (raw) => P.lookup("message", P.token(raw)).render({w: 4, h: 3});
const settle = () => new Promise((resolve) => setTimeout(resolve, 0));
(async () => {
const first = tile("1763000000.5/radio:abc");
await settle();
await settle();
const found = tile("1763000000.5/radio:abc");
tile("1762999900/radio:gone");
await settle();
await settle();
const gone = tile("1762999900/radio:gone");
const cached = tile("5/transcript:7");
const broken = tile("nonsense");
console.log(JSON.stringify({first, found, gone, cached, broken, urls, fetches: urls.length}));
})();
"""
VIEW_PROBE = """
const P = require(process.argv[1]);
const view = {chart: "hardware", tokens: "interval", shown: ["host:CPU"]};
const pin = {kind: "metric", id: "hardware/x", w: 4, h: 3, view};
P.item("metric", (id, seen) => `Metric ${id} ${seen ? seen.shown.join() : "none"}`, (size, id, seen) => (seen ? `${id} ${size.w} ${seen.chart}` : null));
const added = P.add([], "metric", "hardware/x", view);
const looked = P.lookup("metric", "hardware/x", view);
const bare = P.lookup("metric", "hardware/x");
console.log(JSON.stringify({
valid: [P.validLayout([pin]), P.validLayout([{...pin, view: []}]), P.validLayout([{...pin, view: "x"}]), P.validLayout([{...pin, view: null}]), P.validLayout([{...pin, extra: 1}])],
cleaned: P.clean([pin, {...pin, id: "hardware/y", view: [1]}]),
added: [added.pins, P.add([], "task", "work/a").pins, P.add([], "task", "work/a", "x").pins],
resized: P.resizeKey(added.pins, "metric:hardware/x", 6, 5),
lookup: [looked.title, looked.render({w: 4, h: 3}), bare.title, bare.render({w: 1, h: 1})],
digest: [P.digest("host:CPU") === P.digest("host:CPU"), P.digest("host:CPU") === P.digest("host:RAM"), /^[0-9a-f]{16}$/.test(P.digest("")), P.ID.test(`hardware/${P.digest("x")}`)],
}));
"""
CAPTURE_PROBE = DOM_KIT + """
P.item("metric", (id, view) => `Metric ${view.shown === null ? "all" : view.shown.join()}`, () => null);
let selection = null;
P.capture("resources-hardware", () => ({kind: "metric", id: selection === null ? "hardware/all" : "hardware/cpu", view: {chart: "hardware", tokens: "interval", shown: selection}}));
const head = el("div", {class: "res-head", "data-star-slot": ""}, el("span", {class: "res-title"}));
const chart = el("section", {"data-panel": "resources-hardware"}, head, el("div", {class: "res-plot"}));
const loose = el("section", {"data-panel": "resources-unknown"});
const root = el("main", {}, chart, loose);
const clicked = [];
const mark = P.decorate(root, {pinned: (kind, id) => `${kind}:${id}` === "metric:hardware/cpu", press: (...args) => clicked.push(args)});
const star = () => head.children.find((child) => child.classList.contains("star"));
const before = [star().getAttribute("aria-pressed"), star().getAttribute("title"), loose.children.length, chart.children[0] === head];
selection = ["host:CPU"];
mark();
const after = [star().getAttribute("aria-pressed"), star().getAttribute("title"), head.children.filter((child) => child.classList.contains("star")).length];
star().listeners.click[0]({preventDefault: () => null, stopPropagation: () => null});
console.log(JSON.stringify({before, after, clicked, target: P.targetOf(chart)}));
"""
METRIC_PROBE = """
const fs = require("fs");
const vm = require("vm");
const [panelsFile, resourcesFile, homeFile] = process.argv.slice(1);
const context = vm.createContext({ViewStore: {get: () => ({tokens: "accumulated"}), update: () => Promise.resolve(true), on: () => null}, labelOf: (key) => key, toast: () => null, console});
vm.runInContext(fs.readFileSync(panelsFile, "utf8"), context);
vm.runInContext(`${fs.readFileSync(resourcesFile, "utf8")}\\n${fs.readFileSync(homeFile, "utf8")}\\nglobalThis.probe = {resourcePin, resourceView, Panels};`, context);
const {resourcePin, resourceView, Panels} = context.probe;
const empty = resourcePin("tokens");
resourceView.series.hardware = {ids: ["host:RAM", "host:CPU", "disk:/"], shown: ["host:CPU"], tokens: "accumulated"};
resourceView.series.tokens = {ids: ["agent:Skills", "agent:Stage"], shown: ["agent:Stage", "agent:Skills"], tokens: "accumulated"};
resourceView.series.combined = {ids: ["host:CPU", "agent:Skills", "burn:done"], shown: ["host:CPU", "burn:done"], tokens: "interval"};
const pins = ["hardware", "tokens", "combined"].map(resourcePin);
resourceView.series.hardware = {ids: ["host:RAM", "host:CPU", "disk:/"], shown: ["host:RAM", "host:CPU", "disk:/"], tokens: "interval"};
const all = resourcePin("hardware");
const titles = [...pins, all, empty].map((pin) => Panels.lookup(pin.kind, pin.id, pin.view).title);
const four = Panels.lookup("metric", "x", {chart: "tokens", tokens: "interval", shown: ["agent:a", "agent:b", "agent:c", "agent:d"]}).title;
const broken = [Panels.lookup("metric", "x").title, Panels.lookup("metric", "x", {chart: "disks", shown: null}).render({w: 1, h: 1})];
const limit = Number(process.argv[4]);
const agents = (count) => Array.from({length: count}, (_, index) => `agent:a${String(index).padStart(3, "0")}`);
const selected = (count, off) => {
resourceView.series.tokens = {ids: agents(count), shown: agents(count).slice(off), tokens: "interval"};
const pin = resourcePin("tokens");
return [pin.view.shown === null ? null : pin.view.shown.length, pin.refused || null, pin.id.split("/").length];
};
const limits = [selected(limit + 1, 1), selected(limit + 2, 1), selected(limit + 2, 0), selected(limit + 2, limit + 2)];
console.log(JSON.stringify({empty, pins, all, titles, four, broken, limits, digests: [Panels.digest("host:CPU"), Panels.digest("burn:done\\nhost:CPU")]}));
"""
PRESS_PROBE = TAB_KIT + """
const server = hub([]);
const tab = page(server);
const view = {chart: "hardware", tokens: "interval", shown: ["host:CPU"]};
(async () => {
tab.homePress("metric", "hardware/abc", "Hardware: CPU", view);
await settle();
const stored = clone(server.value);
tab.homePress("metric", "hardware/abc", "Hardware: CPU", view);
await settle();
console.log(JSON.stringify({stored, after: server.value, pins: tab.homeView.pins}));
})();
"""
REFUSED_PROBE = DOM_KIT + """
P.item("metric", (id) => `Metric ${id}`, () => null);
P.item("artifact", (id) => `Artifact ${id}`, () => null);
let over = true;
P.capture("resources-tokens", () => (over ? {kind: "metric", id: "tokens/interval/x", view: {chart: "tokens"}, refused: "too many series"} : {kind: "metric", id: "tokens/interval/y", view: {chart: "tokens"}}));
const chart = el("section", {"data-panel": "resources-tokens"}, el("div", {"data-star-slot": ""}));
const long = el("li", {"data-item": `artifact:wt:/${"p".repeat(300)}`});
const root = el("main", {}, chart, long);
const clicked = [];
const mark = P.decorate(root, {pinned: () => false, press: (...args) => clicked.push(args)});
const star = (host) => host.all().find((node) => node.classList.contains("star"));
const read = (host) => [star(host).hasAttribute("disabled"), star(host).getAttribute("title"), star(host).getAttribute("aria-pressed")];
const fire = (host) => (star(host).listeners.click || []).forEach((listen) => listen({preventDefault: () => null, stopPropagation: () => null}));
const refused = read(chart);
const first = star(chart);
fire(chart);
over = false;
mark();
const freed = [...read(chart), star(chart) === first];
fire(chart);
over = true;
mark();
const again = read(chart);
fire(chart);
fire(long);
console.log(JSON.stringify({refused, freed, again, long: read(long), clicked}));
"""
ORDER_PROBE = DOM_KIT + """
Object.assign(context, {h, state: {agent_order: ["Skills", "Stage"]}, ui: {order: null}, counter: (value) => text(value), face: () => text("face"), person: (name) => text(name),
icon: () => text("icon"), officeBtn: (name, label) => h("button", {"aria-label": label}), focusKey: () => null, refocus: () => null, act: async () => true, go: () => null});
vm.runInContext(`${fs.readFileSync(process.argv[2], "utf8")}\\nglobalThis.probe = {orderDom, drawAgentOrder};`, context);
const {orderDom, drawAgentOrder} = context.probe;
P.panel("agents/order", "Agents: priority", () => null);
orderDom.box = el("section", {"data-panel": "agents/order"});
orderDom.slot = el("span", {"data-star-slot": ""});
document.body.append(orderDom.box);
const mark = P.decorate(document.body, {pinned: () => false, press: () => null});
const stars = () => orderDom.box.all().filter((node) => node.classList.contains("star"));
drawAgentOrder();
mark();
const first = stars()[0];
first.focus();
drawAgentOrder();
mark();
context.state.agent_order = ["Stage", "Skills", "Docs"];
drawAgentOrder();
mark();
console.log(JSON.stringify({count: stars().length, same: stars()[0] === first, focused: document.activeElement === first, head: first.parentNode.parentNode === orderDom.box.children[0],
ranks: orderDom.box.all().filter((node) => node.tagName === "LI").map((node) => node.getAttribute("data-name"))}));
"""
TREE_PROBE = DOM_KIT + """
const [, artifactsFile, treeFile, homeFile, dataFile] = process.argv.slice(1);
Object.assign(context, {
h, icon: () => text(""), named: (label, hint) => ({title: hint || label, "aria-label": label}), iconBtn: (name, label, cls, run, hint) => h("button", {"aria-label": label, title: hint}),
counter: (value) => text(value), emptyState: (title, words) => h("div", {class: "empty", "data-title": title}, words), branchAncestry: () => null, gateIcons: () => h("span", {class: "gates"}),
flowLine: () => null, flowDetails: () => null, flowEdges: () => [], copyButton: () => null, face: () => null, person: (name) => text(name), status: (value) => text(value), pill: (words) => text(words),
workChips: () => null, popupHead: (glyph, label) => h("h2", {class: "panel-title"}, label), meta: (rows) => h("dl", {}, rows.map(([key, value]) => h("div", {"data-key": key}, value === null || value === undefined ? "" : value))),
WORK_CHIPS: {}, clock: {format: () => "c"}, stampOf: (t) => t, nowSeconds: () => 1763000000, labelOf: (key) => key, toast: () => null,
tree: {data: JSON.parse(fs.readFileSync(dataFile, "utf8")), model: null, busy: false, q: "", open: new Set(), dom: null},
});
vm.runInContext(`${[artifactsFile, treeFile, homeFile].map((file) => fs.readFileSync(file, "utf8")).join("\\n")}
tree.model = artifactModel(tree.data);
homeView.fetched.tree = Date.now();
globalThis.probe = {treeCards};`, context);
const {treeCards} = context.probe;
const tree = context.tree;
const flat = (nodes) => nodes.filter((node) => node instanceof El).flatMap((node) => [node, ...node.all()]);
const deletes = (nodes) => flat(nodes).filter((node) => node.getAttribute("aria-label") === "Delete").length;
const rows = flat(treeCards("", false).nodes).filter((node) => node.hasAttribute("data-item"));
const pinned = rows.map((row) => {
const target = P.targetOf(row);
const entry = target.id ? P.lookup(target.kind, target.id) : null;
const shown = entry ? entry.render({w: 4, h: 3}) : null;
const head = shown ? shown.all().find((node) => node.classList.contains("panel-title")) : null;
const path = shown ? shown.all().find((node) => node.getAttribute("data-key") === "Path" || node.getAttribute("data-key") === "Ref") : null;
return {id: target.id, refused: target.refused || null, title: entry ? entry.title : null, label: head ? textOf(head) : null, path: path ? textOf(path) : null, deletes: shown ? deletes([shown]) : null};
});
const home = P.lookup("panel", "artifacts/tree").render({w: 6, h: 4});
const glance = [deletes(treeCards("", false).nodes), deletes(treeCards("", true).nodes), deletes([home])];
const digested = pinned.map((entry) => entry.id).filter((id) => /_23_/.test(id || ""));
const kept = tree.data;
tree.data = {...kept, repos: [], tasks: [], cleanups: []};
const empty = [treeCards("", true).nodes[0].getAttribute("data-title"), treeCards("zz", false).nodes[0].getAttribute("data-title"), textOf(P.lookup("panel", "artifacts/tree").render({w: 6, h: 4}).children[0])];
tree.data = kept;
tree.model = context.artifactModel({...kept, repos: [], tasks: []});
const gone = digested.map((id) => [P.lookup("artifact", id).render({w: 4, h: 3}), P.lookup("artifact", id).title]);
console.log(JSON.stringify({pinned, glance, empty, gone}));
"""
def node(probe: str, *args: str) -> dict:
done = subprocess.run(["node", "-e", probe, *args], capture_output=True, text=True, timeout=60, check=True)
return json.loads(done.stdout)
def escaped(raw: str) -> str:
return re.sub(r"[^A-Za-z0-9./-]", lambda found: f"_{ord(found.group()):x}_", raw)
class TestHomeLayout(unittest.TestCase):
def test_the_layout_validation_takes_at_most_64_pins_of_kind_id_w_and_h_in_their_ranges(self):
data = node(LAYOUT_PROBE, str(PANELS))
self.assertEqual(data["valid"], {
"ok": True, "full": True, "over": False, "wide": False, "flat": False, "half": False, "text": False, "space": False, "long": False,
"kind": False, "empty": False, "extra": False, "twice": False, "object": False,
})
self.assertEqual(data["cleaned"], [64, {"kind": "task", "id": "work/a", "w": 4, "h": 3}, "work/t0"])
self.assertEqual(data["notList"], [])
class TestHomeReorder(unittest.TestCase):
def test_reorder_resize_add_and_remove_are_idempotent_and_hold_their_bounds(self):
data = node(REORDER_PROBE, str(PANELS))
self.assertEqual(data["place"], ["bcad", "dabc", "abcd", "abcd", "abcd"])
self.assertEqual(data["move"], ["abcd", "bacd", "abcd", "acbd"])
self.assertEqual([(pin["w"], pin["h"]) for pin in data["resize"]], [(1, 12), (12, 1), (7, 3)])
self.assertEqual(data["stretch"], [{"w": 6, "h": 3}, {"w": 1, "h": 1}, {"w": 12, "h": 12}, {"w": 5, "h": 3}])
self.assertEqual(data["untouched"], "abcd")
self.assertEqual(data["add"], ["", PIN, 5, 4, 4, "full", 64, "", 64])
def test_reorder_and_resize_find_their_pin_by_key_and_leave_the_list_alone_without_it(self):
data = node(REORDER_PROBE, str(PANELS))
resized = {"kind": "task", "id": "b", "w": 5, "h": 2}
self.assertEqual(data["keys"], ["bcad", "abcd", "acbd", "abcd", resized, resized, "abcd", "abcd"])
def test_home_holds_one_3d_tile_and_refuses_a_second_with_its_holder(self):
data = node(REORDER_PROBE, str(PANELS))
holder = {"kind": "panel", "id": "agents/3d", "w": 6, "h": 4}
self.assertEqual(data["group"], ["", "group", holder, 5, "", "tasks/3d", "", True, False, True])
class TestHomeRegistry(unittest.TestCase):
def test_the_registry_finds_panels_and_item_kinds_and_a_missing_item_renders_none(self):
data = node(REGISTRY_PROBE, str(PANELS))
self.assertEqual(data["gantt"], ["Tasks: Gantt", "gantt 6x4"])
self.assertEqual(data["live"], ["Task work/live", "task work/live 3"])
self.assertIsNone(data["gone"])
self.assertIsNone(data["unknownPanel"])
self.assertIsNone(data["unknownKind"])
self.assertEqual(data["token"], ["branch_3a_/repo_0_feature_20_x", True, True, True, "work/plain", "a_5f_b", "a_b", None, "1763.5/radio_3a_work/x_3a_9"])
@unittest.skipUnless((TEMPLATES / "view-store.js").exists(), "waits on 007: view-store.js is not on this branch yet")
def test_pin_ids_follow_the_view_store_id_grammar(self):
probe = 'const P = require(process.argv[1]); const V = require(process.argv[2]); const ids = ["work/a", "branch:/r\\u0000x y", "a_b", "1763.5/radio:w:9"]; console.log(JSON.stringify(ids.map((id) => [P.token(id), V.id(id)])));'
done = subprocess.run(["node", "-e", probe, str(PANELS), str(TEMPLATES / "view-store.js")], capture_output=True, text=True, timeout=60, check=True)
for mine, theirs in json.loads(done.stdout):
self.assertEqual(mine, theirs)
def test_the_store_changes_the_stored_pins_through_update_and_refuses_an_invalid_layout_before_the_backend(self):
data = node(STORE_PROBE, str(PANELS))
self.assertEqual(data["read"], ["work/a"])
self.assertTrue(data["wrote"])
self.assertEqual(data["calls"], [["on", "home.pins"], ["get", "home.pins"], ["get", "home.pins"], ["update", "home.pins", ["work/a", "work/other", "work/c"]]])
self.assertEqual(data["refused"], "invalid layout")
self.assertEqual(data["late"], [True, 64, False])
self.assertEqual(data["unknown"], [[], False, "unknown view path home.pins", "another browser kept changing home.pins; try again", ""])
self.assertEqual(data["seen"], [1])
self.assertEqual(data["memory"], [2, [2]])
class TestHomeStart(unittest.TestCase):
def test_home_is_the_first_tab_and_the_start_once_a_pin_exists_while_an_explicit_hash_wins(self):
data = node(START_PROBE, str(NAV))
self.assertEqual((data["first"], data["icon"]), (["home", "Home"], "bi-house-door"))
stream = {"screen": "stream", "view": None, "redirect": None}
home = {"screen": "home", "view": None, "redirect": None}
self.assertEqual(data["routes"], [
stream, {"screen": "home", "view": None, "redirect": "#home"}, {"screen": "home", "view": None, "redirect": "#home"}, home, home,
{"screen": "tasks", "view": "gantt", "redirect": None}, stream, stream, stream,
])
class TestHomePage(unittest.TestCase):
def test_the_page_registers_every_panel_and_item_kind_and_refuses_the_65th_pin_before_any_update(self):
data = node(PAGE_PROBE, str(PANELS), str(HOME))
self.assertEqual(data["ids"], {"panel": True, "task": True, "message": True, "artifact": True, "agent": True, "ancestry": True, "metric": True, "nope": False})
self.assertEqual(data["panels"], [])
self.assertEqual((data["one"], data["none"], data["solid"], data["full"], data["after"]), (["panel:tasks/gantt"], 0, ["panel:agents/3d"], [64, 0], 63))
self.assertEqual(data["paths"], ["home.pins"])
self.assertEqual(data["toasts"][:2], [
["One 3D tile at a time", "Home already holds Agents: 3D: unpin it before you pin Tasks: 3D.", False],
["Home is full", "At most 64 pins: unpin one before you pin Task work/t64.", False],
])
def test_a_refused_update_falls_back_to_the_stored_pins_and_shows_the_store_error(self):
data = node(PAGE_PROBE, str(PANELS), str(HOME))
self.assertEqual((data["optimistic"], data["tries"], data["reverted"], data["fellBack"]), (62, 3, 63, True))
self.assertEqual(data["toasts"][2:], [["Home not saved", "another browser kept changing home.pins; try again", False]])
def test_two_stale_tabs_keep_both_pins_and_a_late_65th_pin_is_refused_visibly(self):
data = node(RACE_PROBE, str(PANELS), str(HOME))
both = ["panel:tasks/gantt", "task:work/b"]
self.assertEqual(data["pinned"], [both, 3, both])
self.assertEqual(data["full"], [64, True, False, [["Home is full", "At most 64 pins: unpin one before you pin Task work/d.", False]], []])
self.assertEqual(data["unpinned"], ["task:work/b", "task:work/c"])
self.assertEqual(data["toasts"], [])
def test_every_data_panel_and_data_item_kind_in_the_templates_is_registered(self):
home = HOME.read_text(encoding="utf-8")
registered = set(re.findall(r'Panels\.panel\("([^"]+)"', home))
kinds = set(re.findall(r'Panels\.item\("([^"]+)"', home))
sources = "\n".join(path.read_text(encoding="utf-8") for path in TEMPLATES.glob("page-*.js"))
literal = set(re.findall(r'"data-panel": "([^"]+)"', sources))
views = {"agents": ["orbit", "chord", "swimlane", "3d"], "artifacts": ["orbit", "chord", "swimlane", "3d"], "tasks": ["list", "board", "rasci", "gantt", "burn"]}
dynamic = {f"{tab}/{view}" for tab in re.findall(r'"data-panel": `(\w+)/\$\{view\}`', sources) for view in views[tab]}
used = set(re.findall(r'(?:"data-item"|item): `(\w+):', sources))
marked = set(re.findall(r"\['[^']+', \"([^\"]+)\"\]", home))
captured = set(re.findall(r'Panels\.capture\("([^"]+)"', home))
made = set(re.findall(r'\{kind: "(\w+)", id, view[,}]', sources))
self.assertEqual((len(literal), marked), (7, {"radio-log"}))
literal |= marked
self.assertEqual(len(dynamic), 13)
self.assertEqual(sorted(literal | dynamic), sorted(registered))
self.assertIn('"data-panel": `resources-${kind}`', sources)
self.assertEqual(captured, {"resources-hardware", "resources-tokens", "resources-combined"})
self.assertFalse(captured & registered)
self.assertEqual((made, sorted(used | made)), ({"metric"}, sorted(kinds)))
class TestHomeStars(unittest.TestCase):
def test_a_star_sits_in_flow_in_its_own_hosts_slot_or_a_star_row_and_never_twice(self):
data = node(STAR_PROBE, str(PANELS))
self.assertEqual(data["panel"], {"first": "star-row", "stars": 1, "pressed": "false", "title": "Pin to Home: Tasks: list"})
self.assertEqual(data["task"], {"inSlot": True, "slotLast": True, "rows": 0, "pressed": "true", "label": "Unpin from Home"})
self.assertEqual(data["bare"], {"first": "star-row", "stars": 1})
self.assertEqual((data["svg"], data["radio"], data["again"], data["redrawn"]), (0, ["radio-log", "star-row"], [4, 4], [True, 4]))
self.assertEqual(data["clicked"], [["task", "work/a", "Task work/a", None]])
def test_the_star_css_positions_nothing_and_leaves_the_starred_elements_alone(self):
css = (TEMPLATES / "style-home.css").read_text(encoding="utf-8")
star = re.findall(r"^\.star(?:-row)?(?:\[[^\]]+\])? \{([^}]*)\}", css, re.MULTILINE)
self.assertEqual(len(star), 3)
self.assertFalse(any("position" in rule for rule in star), star)
self.assertNotIn("[data-panel]", css)
self.assertNotIn("[data-item]", css)
class TestHomeBookmarks(unittest.TestCase):
VIEW: ClassVar[dict] = {"chart": "hardware", "tokens": "interval", "shown": ["host:CPU"]}
def test_a_pin_may_carry_a_plain_view_that_cleaning_adding_resizing_and_the_registry_keep(self):
data = node(VIEW_PROBE, str(PANELS))
pin = {"kind": "metric", "id": "hardware/x", "w": 4, "h": 3, "view": self.VIEW}
self.assertEqual(data["valid"], [True, False, False, False, False])
self.assertEqual(data["cleaned"], [pin])
self.assertEqual(data["added"], [[pin], [{"kind": "task", "id": "work/a", "w": 4, "h": 3}], [{"kind": "task", "id": "work/a", "w": 4, "h": 3}]])
self.assertEqual(data["resized"], [{**pin, "w": 6, "h": 5}])
self.assertEqual(data["lookup"], ["Metric hardware/x host:CPU", "hardware/x 4 hardware", "Metric hardware/x none", None])
self.assertEqual(data["digest"], [True, False, True, True])
def test_a_captured_panel_stars_the_pin_its_capture_makes_now_and_presses_it_with_its_view(self):
data = node(CAPTURE_PROBE, str(PANELS))
self.assertEqual(data["before"], ["false", "Pin to Home: Metric all", 0, True])
self.assertEqual(data["after"], ["true", "Unpin from Home: Metric host:CPU", 1])
self.assertEqual(data["clicked"], [["metric", "hardware/cpu", "Metric host:CPU", self.VIEW]])
self.assertEqual(data["target"], {"kind": "metric", "id": "hardware/cpu", "view": self.VIEW})
def test_a_chart_star_pins_the_series_switched_on_now_so_another_selection_is_another_pin(self):
data = node(METRIC_PROBE, str(PANELS), str(TEMPLATES / "page-resources.js"), str(HOME))
cpu, mixed = data["digests"]
self.assertEqual(data["empty"], {"kind": "metric", "id": "tokens/accumulated/all", "view": {"chart": "tokens", "tokens": "accumulated", "shown": None}})
self.assertEqual(data["pins"], [
{"kind": "metric", "id": f"hardware/{cpu}", "view": self.VIEW},
{"kind": "metric", "id": "tokens/accumulated/all", "view": {"chart": "tokens", "tokens": "accumulated", "shown": None}},
{"kind": "metric", "id": f"combined/interval/{mixed}", "view": {"chart": "combined", "tokens": "interval", "shown": ["burn:done", "host:CPU"]}},
])
self.assertEqual(data["all"], {"kind": "metric", "id": "hardware/all", "view": {"chart": "hardware", "tokens": "interval", "shown": None}})
self.assertEqual(data["titles"], ["Hardware: CPU", "Tokens (accumulated): all series", "Combined: done, CPU", "Hardware: all series", "Tokens (accumulated): all series"])
self.assertEqual((data["four"], data["broken"]), ("Tokens: 4 series", ["Metric", None]))
def test_pressing_a_metric_star_stores_its_view_with_the_pin_and_pressing_again_unpins_it(self):
data = node(PRESS_PROBE, str(PANELS), str(HOME))
pin = {"kind": "metric", "id": "hardware/abc", "w": 4, "h": 3, "view": self.VIEW}
self.assertEqual((data["stored"], data["after"], data["pins"]), ([pin], [], []))
def test_a_chart_star_refuses_a_selection_past_the_view_stores_series_limit_and_names_why(self):
data = node(METRIC_PROBE, str(PANELS), str(TEMPLATES / "page-resources.js"), str(HOME), str(SHOWN_LIMIT))
why = f"more than {SHOWN_LIMIT} series are switched on: switch some off, or all of them on"
self.assertEqual(data["limits"], [[SHOWN_LIMIT, None, 3], [SHOWN_LIMIT + 1, why, 3], [None, None, 3], [0, None, 3]])
def test_a_refused_capture_or_an_overlong_id_disables_the_star_with_its_reason_and_a_press_pins_nothing(self):
data = node(REFUSED_PROBE, str(PANELS))
refused = [True, "Pin to Home: not possible, too many series", "false"]
self.assertEqual((data["refused"], data["again"]), (refused, refused))
self.assertEqual(data["freed"], [False, "Pin to Home: Metric tokens/interval/y", "false", True])
self.assertEqual(data["long"], [True, "Pin to Home: not possible, the id runs past 200 characters", "false"])
self.assertEqual(data["clicked"], [["metric", "tokens/interval/y", "Metric tokens/interval/y", {"chart": "tokens"}]])
def test_the_agent_priority_star_stays_the_same_button_and_keeps_its_focus_through_a_redraw(self):
data = node(ORDER_PROBE, str(PANELS), str(TEMPLATES / "page-agent-order.js"))
self.assertEqual(data, {"count": 1, "same": True, "focused": True, "head": True, "ranks": ["Stage", "Skills", "Docs"]})
def test_the_client_pin_id_grammar_is_the_hubs(self):
done = subprocess.run(["node", "-e", "console.log(JSON.stringify(require(process.argv[1]).ID.source))", str(PANELS)], capture_output=True, text=True, timeout=60, check=True)
self.assertEqual(json.loads(done.stdout), f"^{SERIES_ID.pattern}$")
class TestHomeTree(HubCase):
def served_tree(self) -> str:
self.tree_file.write_text(json.dumps({"generated_at": "2026-11-14T12:00:00+00:00", "delete_ready": False, "delete_reason": "Secret Service locked", "repos": long_repos()}), encoding="utf-8")
self.write_council({"rasci.json": {LONG_TASK: long_task(time.time())}})
status, _, body = self.get("/api/tree")
self.assertEqual(status, 200, body[:300])
served = self.outside / "served-tree.json"
served.write_bytes(body)
return str(served)
def test_every_tree_row_on_paths_of_real_length_pins_shows_that_one_element_on_home_and_turns_gone(self):
data = node(TREE_PROBE, str(PANELS), str(TEMPLATES / "page-artifacts.js"), str(TEMPLATES / "page-tree.js"), str(HOME), self.served_tree())
rows = [
(f"repo:{CORE_REPO}", "github.com/infinito-nexus/core", CORE_REPO),
(f"branch:{CORE_REPO}\0{CORE_BRANCH}", CORE_BRANCH, None),
(f"wt:{CORE_WORKTREE}", CORE_BRANCH, CORE_WORKTREE),
(f"repo:{LONG_REPO}", "github.com/operator-example-01/skills", LONG_REPO),
(f"branch:{LONG_REPO}\0{LONG_BRANCH}", LONG_BRANCH, None),
(f"wt:{LONG_WORKTREE}", LONG_BRANCH, LONG_WORKTREE),
(f"artefact:wt:{LONG_WORKTREE}\0{LONG_TASK}\0{LONG_VOLUME}", LONG_VOLUME.split(":", 1)[1], LONG_VOLUME),
(f"branch:{LONG_REPO}\0{MERGED_BRANCH}", MERGED_BRANCH, None),
]
self.assertEqual(len(data["pinned"]), len(rows), data["pinned"])
digested = []
for found, (raw, label, path) in zip(data["pinned"], rows, strict=True):
with self.subTest(row=raw):
self.assertEqual((found["refused"], found["title"], found["label"], found["path"], found["deletes"]), (None, f"Artifact {raw.replace(chr(0), ' ')}", label, path, 0), found)
self.assertTrue(SERIES_ID.fullmatch(found["id"]), found)
if len(escaped(raw)) <= 200:
self.assertEqual(found["id"], escaped(raw))
else:
self.assertRegex(found["id"], rf"^{raw.split(':', 1)[0]}_23_[0-9a-f]{{16}}$")
digested.append(found["id"].split("_23_")[0])
self.assertEqual(digested, ["wt", "artefact"])
self.assertEqual(data["glance"], [1, 0, 0])
self.assertEqual(data["empty"], ["No repository", "Nothing found", "pkgmgr names no repository."])
self.assertEqual([gone[0] for gone in data["gone"]], [None, None])
for gone, kind in zip(data["gone"], digested, strict=True):
self.assertRegex(gone[1], rf"^Artifact {kind}#[0-9a-f]{{16}}$")
class TestHomeMessage(unittest.TestCase):
def test_a_pinned_message_resolves_by_its_own_id_and_time_whatever_the_stream_shows(self):
data = node(MESSAGE_PROBE, str(PANELS), str(HOME))
self.assertEqual(data["first"], "wait")
self.assertEqual(data["urls"], ["/api/events?from=1762999999&to=1763000002&after=0", "/api/events?from=1762999899&to=1762999901&after=0"])
self.assertEqual((data["found"], data["gone"], data["cached"], data["broken"]), ("row radio:abc", None, "row transcript:7", None))
self.assertEqual(len(data["urls"]), data["fetches"])
class TestHomeIndex(HubCase):
def test_the_index_embeds_the_registry_the_home_page_and_its_styles(self):
html = self.index()
for name in ("panels.js", "page-home.js", "style-home.css"):
with self.subTest(name=name):
self.assertIn((TEMPLATES / name).read_text(encoding="utf-8").strip(), html)
for glyph in ("bi-star", "bi-star-fill", "bi-house-door", "bi-grip-vertical", "bi-arrow-down-right"):
with self.subTest(glyph=glyph):
self.assertIn(f'<symbol id="{glyph}"', html)
if __name__ == "__main__":
unittest.main()