Files
skills/tests/e2e/test_home_bookmarks_e2e.py
T

487 lines
28 KiB
Python
Raw Normal View History

from __future__ import annotations
import json
import os
import shutil
import sys
import time
import unittest
from collections.abc import Callable
from pathlib import Path
from unittest import mock
HERE = Path(__file__).resolve().parent
sys.path[:0] = [str(HERE.parent), str(HERE)]
import hub_e2e_kit as base
import test_home_dashboard_e2e as dash
import test_resources_view_e2e as res
import test_workbench_w4_e2e as w4
from hub_case import HubCase
from hub_support import (
CORE_WORKTREE,
LONG_REPO,
LONG_TASK,
LONG_VOLUME,
LONG_WORKTREE,
MERGED_BRANCH,
iso,
long_repos,
long_task,
)
OUT = Path(os.environ.get("E2E_OUT", "/tmp/bookmarks-shots"))
CUE = "e2e-bookmarks-vanish"
GHOST = "Ghost"
KEPT = "feature/kept"
HARDWARE = ["disk:/", "disk:/boot/efi", res.CPU, "host:RAM", "host:Swap", res.UTIL, "vram:0000_3a_01_3a_00.0"]
WALKED = ["resources", "artifacts/tree", "agents/hierarchy", "tasks/operator"]
LONG_NAME = "/".join(Path(LONG_REPO).parts[-3:])
LONG_ROWS = ("repo", "worktree", "core", "leaf")
READ = res.READ.replace("const stored = async", "const storedResources = async").replace("await stored()", "await storedResources()")
KIT = """
const stars = (selector) => all(selector).map((owner) => Boolean(ownStar(owner)));
const panel = (kind) => `#main [data-panel="resources-${kind}"]`;
const lineIds = (root) => [...new Set(all("path.res-line", root).map((path) => path.dataset.id))];
const tileOf = (kind) => all("#main .home-tile").find((node) => node.dataset.pin.startsWith(`metric:${kind}/`)) || null;
const pinOf = (kind) => (ViewStore.get("home.pins") || []).find((pin) => pin.kind === "metric" && pin.id.startsWith(`${kind}/`)) || null;
const kept = () => all("#main .branch-row[data-item]").find((row) => row.dataset.item.endsWith("\\u0000@KEPT@")) || null;
const settled = () => until(() => !all("#main .home-tile .empty h2").some((title) => text(title).endsWith("…")), 8000);
const longRows = {
repo: () => all("#main details.repo[data-item]").find((node) => text(node.querySelector("summary")).includes("@LONG_NAME@")) || null,
worktree: () => all("#main .wt[data-item]").find((node) => text(node.querySelector(".wt-head > code")) === "@LONG_WORKTREE@") || null,
core: () => all("#main .wt[data-item]").find((node) => text(node.querySelector(".wt-head > code")) === "@CORE_WORKTREE@") || null,
leaf: () => all("#main li.leaf[data-item]").find((node) => text(node.querySelector("code")) === "@LONG_VOLUME@") || null,
};
const pinKey = (node) => `artifact:${Panels.token(node.dataset.item.slice(node.dataset.item.indexOf(":") + 1))}`;
const timeOverlaps = (root) => {
const boxes = all("text.axis", root).filter((node) => !["left", "right"].includes(node.dataset.axis)).map((node) => node.getBoundingClientRect());
return boxes.filter((box, index) => boxes.slice(index + 1).some((other) => Math.min(box.right, other.right) - Math.max(box.left, other.left) > 0.5 && Math.min(box.bottom, other.bottom) - Math.max(box.top, other.top) > 0.5)).length;
};
"""
CLEAR = """(async () => {
sessionStorage.clear();
await Promise.all([ViewStore.update("home.pins", () => []), ViewStore.update("resources.hidden", () => []), ViewStore.update("resources.combinedHidden", () => []),
ViewStore.set("resources.combined", false), ViewStore.set("resources.tokens", "interval")]);
return true;
})()"""
LOADED = """(async () => {@HELPERS@@READ@
await screenShown(8000);
const drawn = Boolean(await until(() => charts().length === 2 && chip("@CPU@"), 15000));
return {drawn, charts: charts()};
})()"""
FOUND = """(async () => {@HELPERS@@HOME@@KIT@
const found = {};
await go("resources");
found.charts = stars('#main section.res-panel[data-panel^="resources-"]');
found.chips = all("#main .legend-chip .star").length;
found.inHead = all("#main .res-panel .star").every((star) => star.parentElement.classList.contains("res-head"));
await go("artifacts/tree");
await until(() => kept(), 8000);
found.tree = stars('#main [data-panel="artifacts/tree"]');
found.rows = Object.fromEntries(["repo", "branch", "wt"].map((kind) => [kind, stars(`#main [data-item^="artifact:${kind}:"]`)]));
await until(() => Object.values(longRows).every((find) => find()), 8000);
found.long = Object.fromEntries(Object.entries(longRows).map(([key, find]) => [key, find() ? find().dataset.item.length : null]));
found.disabled = all('#main [data-item^="artifact:"]').filter((node) => !ownStar(node) || ownStar(node).disabled).map((node) => node.dataset.item.slice(0, 80));
found.deletes = all('#main button[aria-label="Delete"]').length;
await go("agents/hierarchy");
found.order = stars('#main [data-panel="agents/order"]');
await go("tasks/operator");
found.operator = stars('#main [data-panel="tasks/operator"]');
return found;
})()"""
METRIC = """(async () => {@HELPERS@@HOME@@READ@@KIT@
await go("resources");
if (!(await until(() => charts().length === 2 && chip("@CPU@") && lines().length === @COUNT@, 15000))) {
return {error: text(document.getElementById("main")), charts: charts()};
}
const axisOverlaps = timeOverlaps(document.querySelector("#main .res-panels"));
const others = @HARDWARE@.filter((id) => id !== "@CPU@");
for (const id of others) {
chip(id).click();
await sleep(120);
}
const cpuOnly = Boolean(await until(() => lineIds(document.querySelector(panel("hardware"))).join() === "@CPU@", 5000));
const hardware = await press(panel("hardware"));
const cpuTitle = starOf(panel("hardware")).getAttribute("title");
const tokens = await press(panel("tokens"));
for (const id of others) {
chip(id).click();
await sleep(120);
}
const back = Boolean(await until(() => lineIds(document.querySelector(panel("hardware"))).length === @COUNT@, 5000));
await sleep(200);
const allState = [starOf(panel("hardware")).getAttribute("aria-pressed"), starOf(panel("hardware")).getAttribute("title")];
switched("combined").click();
const combinedOn = Boolean(await until(() => charts().join() === "combined" && burn().length === 2, 5000));
const combined = await press(panel("combined"));
return {cpuOnly, hardware, cpuTitle, tokens, back, allState, combinedOn, combined, axisOverlaps, stored: (ViewStore.get("home.pins") || []).map((pin) => [pin.kind, pin.id, pin.view || null])};
})()"""
COMBINED_OFF = """(async () => {@HELPERS@@HOME@@READ@@KIT@
await go("resources");
await until(() => charts().join() === "combined", 8000);
switched("combined").click();
const off = Boolean(await until(() => charts().length === 2 && lines().length === @COUNT@, 8000));
await sleep(300);
return {off, hardware: [starOf(panel("hardware")).getAttribute("aria-pressed"), starOf(panel("hardware")).getAttribute("title")]};
})()"""
HOME_METRICS = """(async () => {@HELPERS@@HOME@@KIT@
await go("home");
await until(() => ["hardware", "tokens", "combined"].every((kind) => tileOf(kind) && tileOf(kind).querySelector("svg.res-chart")), 15000);
await sleep(300);
const read = (kind) => {
const found = tileOf(kind);
return found ? {
title: text(found.querySelector(".home-title")), lines: lineIds(found), legend: all(".legend-chip", found).map((node) => node.dataset.series),
chart: (found.querySelector("svg.res-chart") || {dataset: {}}).dataset.chart || null, right: all('text[data-axis="right"]', found).length,
burn: all("path.res-burn", found).length, bars: [...new Set(all("rect.res-bar", found).map((rect) => rect.dataset.agent))].sort(),
gone: found.classList.contains("gone"),
} : null;
};
const overlaps = Object.fromEntries(["hardware", "tokens", "combined"].map((kind) => [kind, tileOf(kind) ? timeOverlaps(tileOf(kind)) : null]));
const sized = (kind, step) => ViewStore.update("home.pins", (pins) => pins.map((pin) => (pin.kind === "metric" && pin.id.startsWith(`${kind}/`) ? {...pin, h: pin.h + step} : pin)));
await sized("combined", -1);
await sleep(600);
const body = tileOf("combined").querySelector(".home-body");
const scroll = {scrollable: body.scrollHeight > body.clientHeight + 10};
if (scroll.scrollable) {
body.scrollTop = body.scrollHeight;
scroll.before = body.scrollTop;
await sized("hardware", 1);
await sleep(400);
await sized("hardware", -1);
await sleep(400);
scroll.after = body.scrollTop;
}
await sized("combined", 1);
await sleep(300);
return {tiles: tiles(), hardware: read("hardware"), tokens: read("tokens"), combined: read("combined"), errors: all("#main .home-error").map(text), stored: pinOf("hardware"), overlaps, scroll};
})()"""
PM = """(async () => {@HELPERS@@HOME@@KIT@
await go("artifacts/tree");
const row = await until(() => kept(), 8000);
row.closest("details").open = true;
const tree = await press('#main [data-panel="artifacts/tree"]');
const rowStar = row ? ownStar(row) : null;
if (rowStar) {
rowStar.click();
await sleep(200);
}
const branch = rowStar ? (ownStar(kept()) || rowStar).getAttribute("aria-pressed") : null;
await go("agents/hierarchy");
const order = await press('#main [data-panel="agents/order"]');
await go("tasks/operator");
const operator = await press('#main [data-panel="tasks/operator"]');
await go("agents/orbit");
const node = await until(() => all("#main svg .node[data-pick]").find((found) => (found.getAttribute("aria-label") || "").startsWith("@GHOST@,")), 8000);
let agent = null;
if (node) {
node.dispatchEvent(new MouseEvent("click", {bubbles: true}));
await until(() => document.querySelector('#popup[open] [data-item^="agent:"]'), 5000);
agent = await press('#popup[open] [data-item^="agent:"]');
document.getElementById("popup").close();
}
await go("home");
await settled();
await sleep(500);
const keys = stored();
const pick = (kind) => keys.find((key) => key.startsWith(`${kind}:`)) || null;
const shown = (key) => {
const found = key ? tile(key) : null;
return found ? {gone: found.classList.contains("gone"), title: text(found.querySelector(".home-title"))} : null;
};
return {
pressed: {tree, branch, order, operator, agent}, keys,
tree: [shown("panel:artifacts/tree"), all('#main .home-tile[data-pin="panel:artifacts/tree"] details.repo').length],
order: [shown("panel:agents/order"), all('#main .home-tile[data-pin="panel:agents/order"] .home-order li').map((item) => item.dataset.name)],
operator: [shown("panel:tasks/operator"), all('#main .home-tile[data-pin="panel:tasks/operator"] .home-inbox > li').length],
artifact: [shown(pick("artifact")), text(tile(pick("artifact")) && tile(pick("artifact")).querySelector(".home-body h2.panel-title"))],
agent: [shown(pick("agent")), Boolean(tile(pick("agent")) && tile(pick("agent")).querySelector(".home-agent"))],
errors: all("#main .home-error").map(text),
};
})()"""
LONG = """(async () => {@HELPERS@@HOME@@KIT@
await go("artifacts/tree");
await until(() => Object.values(longRows).every((find) => find()), 8000);
const pressed = {};
const keys = {};
for (const [key, find] of Object.entries(longRows)) {
const star = ownStar(find());
keys[key] = pinKey(find());
pressed[key] = star ? [star.disabled, star.title.startsWith("Pin to Home: Artifact ")] : null;
if (star && !star.disabled) {
star.click();
await sleep(200);
}
pressed[key].push(ownStar(longRows[key]()).getAttribute("aria-pressed"));
}
await go("home");
await settled();
await until(() => Object.values(keys).every((key) => tile(key) && tile(key).querySelector(".home-popup")), 8000);
await sleep(300);
const shown = Object.fromEntries(Object.entries(keys).map(([key, pin]) => {
const found = tile(pin);
return [key, found ? {gone: found.classList.contains("gone"), title: text(found.querySelector(".home-title")), label: text(found.querySelector(".home-body h2.panel-title")), body: text(found.querySelector(".home-body"))} : null];
}));
const treeTile = tile("panel:artifacts/tree");
const body = treeTile ? treeTile.querySelector(".home-body") : null;
const scroll = {deletes: treeTile ? all('button[aria-label="Delete"]', treeTile).length : null, scrollable: body ? body.scrollHeight > body.clientHeight + 40 : null};
if (scroll.scrollable) {
body.scrollTop = 40;
scroll.before = body.scrollTop;
const order = (step) => ViewStore.update("home.pins", (pins) => pins.map((pin) => (pin.kind === "panel" && pin.id === "agents/order" ? {...pin, h: pin.h + step} : pin)));
await order(1);
await sleep(400);
await order(-1);
await sleep(400);
scroll.after = body.isConnected ? body.scrollTop : null;
}
return {pressed, keys, stored: stored(), shown, scroll, errors: all("#main .home-error").map(text)};
})()"""
RELOADED = """(async () => {@HELPERS@@HOME@@KIT@
await screenShown(8000);
await until(() => tileOf("hardware") && tileOf("hardware").querySelector("svg.res-chart"), 15000);
await sleep(300);
return {hash: location.hash, lines: lineIds(tileOf("hardware")), title: text(tileOf("hardware").querySelector(".home-title")), stored: pinOf("hardware")};
})()"""
GONE = """(async () => {@HELPERS@@HOME@@KIT@
await go("home");
const keys = stored();
const agentKey = keys.find((key) => key.startsWith("agent:"));
const artifactKeys = keys.filter((key) => key.startsWith("artifact:"));
const before = [agentKey, ...artifactKeys].map((key) => tile(key).classList.contains("gone"));
await fetch("/api/tts", {method: "POST", headers: {"X-Kvb-Orchestrator": "1", "Content-Type": "application/json"}, body: JSON.stringify({text: "@CUE@", voice: ""}), cache: "no-store"});
const started = Date.now();
const vanished = await until(() => [agentKey, ...artifactKeys].every((key) => tile(key).classList.contains("gone")), 50000);
const seconds = Math.round((Date.now() - started) / 1000);
const words = (key) => (tile(key) ? [text(tile(key).querySelector(".home-gone-word")), name(tile(key).querySelector(".home-gone-unpin"))] : null);
tile(artifactKeys[0]).scrollIntoView({block: "start"});
await sleep(300);
return {before, vanished: Boolean(vanished), seconds, agent: words(agentKey), artifacts: artifactKeys.map(words), agentKey, artifactKeys};
})()"""
UNPIN = """(async () => {@HELPERS@@HOME@@KIT@
await go("home");
const keys = stored();
const metric = keys.find((key) => key.startsWith("metric:hardware/"));
const artifacts = keys.filter((key) => key.startsWith("artifact:"));
tile(metric).querySelector(".home-unpin").click();
await sleep(300);
for (const key of artifacts) {
const gone = tile(key) ? tile(key).querySelector(".home-gone-unpin") : null;
if (gone) {
gone.click();
await sleep(300);
}
}
return {metric, artifacts, tiles: tiles(), stored: stored()};
})()"""
UNPIN_PLAIN = """(async () => {@HELPERS@@HOME@@KIT@
await go("home");
const metric = stored().find((key) => key.startsWith("metric:hardware/"));
tile(metric).querySelector(".home-unpin").click();
await sleep(300);
return {metric, artifacts: [], tiles: tiles(), stored: stored()};
})()"""
def probe(template: str, screens: list[str] | None = None) -> str:
names = {
"@HELPERS@": base.HELPERS, "@HOME@": dash.HOME, "@READ@": READ, "@KIT@": KIT, "@KEPT@": KEPT, "@GHOST@": GHOST, "@CUE@": CUE, "@CPU@": res.CPU,
"@HARDWARE@": json.dumps(HARDWARE), "@COUNT@": str(len(HARDWARE)), "@SCREENS@": json.dumps(screens or WALKED),
"@LONG_NAME@": LONG_NAME, "@LONG_WORKTREE@": LONG_WORKTREE, "@CORE_WORKTREE@": CORE_WORKTREE, "@LONG_VOLUME@": LONG_VOLUME,
}
for key, value in names.items():
template = template.replace(key, value)
return template
@unittest.skipUnless(shutil.which(os.environ.get("CHROMIUM", "chromium")), "no Chromium")
class TestHomeBookmarks(HubCase):
seed = base.OrchestratorE2ECase.seed
subagents = base.OrchestratorE2ECase.subagents
drive = base.OrchestratorE2ECase.drive
sample = w4.TestWorkbenchResources.sample
def setUp(self):
super().setUp()
OUT.mkdir(parents=True, exist_ok=True)
self.seed()
now = int(time.time())
self.start = now - now % 60 - w4.ROWS * 60
hour = self.start - self.start % 3600
tokens = [{"t": hour + step * 3600, "agent": "Skills", "model": "claude-opus-5-5", "input": 1000 * (step + 1), "output": 500, "cache_read": 20000, "cache_write": 1000} for step in range(7)]
tokens += [{"t": hour + step * 3600, "agent": "Stage", "model": "claude-haiku-4-5", "input": 200, "output": 100, "cache_read": 3000, "cache_write": 0} for step in range(0, 7, 2)]
folder = self.kept / "resources"
folder.mkdir()
(folder / "samples.jsonl").write_text(self.jsonl([self.sample(index) for index in range(w4.ROWS)]), encoding="utf-8")
(folder / "tokens.jsonl").write_text(self.jsonl([row for row in tokens if row["t"] <= now]), encoding="utf-8")
register = self.council / "rasci.json"
rows = json.loads(register.read_text(encoding="utf-8"))
rows["work/ghost"] = {"title": "Ghost line", "status": "running", "worker": GHOST, "start": iso(now - 1800), "roles": {GHOST: "RA"}}
rows[LONG_TASK] = long_task(now)
register.write_text(json.dumps(rows), encoding="utf-8")
scan = json.loads(self.tree_file.read_text(encoding="utf-8"))
scan["repos"] += long_repos()
self.tree_file.write_text(json.dumps(scan), encoding="utf-8")
self.write_local_plan(scan, {MERGED_BRANCH: {"skip": None, "actions": ["local-branch"]}})
def vanish(self) -> None:
register = self.council / "rasci.json"
rows = json.loads(register.read_text(encoding="utf-8"))
rows.pop("work/ghost", None)
rows.pop(LONG_TASK, None)
register.write_text(json.dumps(rows), encoding="utf-8")
scan = json.loads(self.tree_file.read_text(encoding="utf-8"))
long = {repo["path"] for repo in long_repos()}
scan["repos"] = [repo for repo in scan["repos"] if repo["path"] not in long]
for repo in scan["repos"]:
repo["items"] = [item for item in repo["items"] if item.get("branch") != KEPT]
self.tree_file.write_text(json.dumps(scan), encoding="utf-8")
def cue(self) -> None:
spoken = base.tone(1, 8000)
def synthesize(body: bytes, admit: Callable[[str], None]) -> bytes:
if json.loads(body)["text"] == CUE:
self.vanish()
return spoken
patch = mock.patch.object(self.httpd.hub.speech, "synthesize", synthesize)
patch.start()
self.addCleanup(patch.stop)
def steps(self, browser: str) -> list[dict]:
self.cue()
steps = []
for index, (width, height) in enumerate(base.WIDTHS):
shot = str(OUT / f"{browser}-{width}")
page = f"{self.base}?{width}"
last = index == len(base.WIDTHS) - 1
steps += [
{"width": width, "height": height, "url": f"{page}-clear#stream", "wait": 600, "probe": CLEAR, "shot": None},
{"width": width, "height": height, "url": f"{page}-loaded#resources", "wait": 1200, "probe": probe(LOADED), "shot": None},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(FOUND), "shot": None},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(dash.STARS), "shot": None},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(METRIC), "shot": f"{shot}-combined-star.png"},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(dash.STARS, ["resources"]), "shot": None},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(COMBINED_OFF), "shot": f"{shot}-metric-star.png"},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(HOME_METRICS), "shot": f"{shot}-home-metrics.png"},
{"width": width, "height": height, "url": f"{page}-reloaded#home", "wait": 1500, "probe": probe(RELOADED), "shot": None},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(PM), "shot": f"{shot}-home-bookmarks.png"},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(LONG), "shot": f"{shot}-home-long-paths.png"},
]
if last:
steps.append({"width": width, "height": height, "url": None, "wait": 0, "probe": probe(GONE), "shot": f"{shot}-gone.png"})
steps.append({"width": width, "height": height, "url": None, "wait": 0, "probe": probe(UNPIN if last else UNPIN_PLAIN), "shot": None})
return steps
def check(self, data: dict, browser: str) -> None:
results = iter(data["results"])
for index, (width, _) in enumerate(base.WIDTHS):
last = index == len(base.WIDTHS) - 1
with self.subTest(browser=browser, width=width):
next(results)
loaded = next(results)
self.assertTrue(loaded["drawn"], loaded)
found = next(results)
self.assertEqual((found["charts"], found["chips"], found["inHead"]), ([True, True, True], 0, True), found)
self.assertEqual(found["tree"], [True], found)
self.assertTrue(found["rows"]["repo"] and all(found["rows"]["repo"]), found)
self.assertTrue(found["rows"]["branch"] and all(found["rows"]["branch"]), found)
self.assertTrue(found["rows"]["wt"] and all(found["rows"]["wt"]), found)
self.assertEqual((found["order"], found["operator"]), ([True], [True]), found)
self.assertTrue(all(found["long"].values()), found)
self.assertGreater(found["long"]["leaf"], 0, found)
self.assertEqual(found["disabled"], [], found)
self.assertGreaterEqual(found["deletes"], 1, found)
walked = next(results)
self.assertEqual((walked["missing"], walked["covered"]), ([], []), walked)
metric = next(results)
self.assertNotIn("error", metric, metric)
self.assertEqual((metric["cpuOnly"], metric["hardware"], metric["tokens"], metric["back"], metric["combinedOn"], metric["combined"]), (True, "true", "true", True, True, "true"), metric)
self.assertEqual(metric["cpuTitle"], "Unpin from Home: Hardware: CPU")
self.assertEqual(metric["axisOverlaps"], 0, metric)
self.assertEqual(metric["allState"], ["false", "Pin to Home: Hardware: all series"])
kinds = [[kind, key.split("/")[0], view] for kind, key, view in metric["stored"]]
self.assertEqual(kinds, [
["metric", "hardware", {"chart": "hardware", "tokens": "interval", "shown": [res.CPU]}],
["metric", "tokens", {"chart": "tokens", "tokens": "interval", "shown": None}],
["metric", "combined", {"chart": "combined", "tokens": "interval", "shown": None}],
])
self.assertRegex(metric["stored"][0][1], r"^hardware/[0-9a-f]{16}$")
self.assertEqual([key for _, key, _ in metric["stored"][1:]], ["tokens/interval/all", "combined/interval/all"])
combined_walk = next(results)
self.assertEqual((combined_walk["missing"], combined_walk["covered"]), ([], []), combined_walk)
self.assertEqual(next(results), {"off": True, "hardware": ["false", "Pin to Home: Hardware: all series"]})
home = next(results)
self.assertEqual(home["errors"], [], home)
self.assertEqual((home["hardware"]["title"], home["hardware"]["lines"], home["hardware"]["legend"], home["hardware"]["chart"]), ("Hardware: CPU", [res.CPU], [res.CPU], "hardware"), home)
self.assertEqual((home["tokens"]["title"], home["tokens"]["bars"]), ("Tokens: all series", ["Skills", "Stage"]), home)
self.assertEqual((home["combined"]["title"], home["combined"]["chart"], home["combined"]["lines"]), ("Combined: all series", "combined", HARDWARE), home)
self.assertGreater(home["combined"]["right"], 0, home)
self.assertEqual(home["combined"]["burn"], 2, home)
self.assertEqual(home["overlaps"], {"hardware": 0, "tokens": 0, "combined": 0}, home)
if home["scroll"]["scrollable"]:
self.assertEqual(home["scroll"]["after"], home["scroll"]["before"], home)
reloaded = next(results)
self.assertEqual((reloaded["hash"], reloaded["lines"], reloaded["title"]), ("#home", [res.CPU], "Hardware: CPU"), reloaded)
self.assertEqual(reloaded["stored"]["view"], {"chart": "hardware", "tokens": "interval", "shown": [res.CPU]})
pm = next(results)
self.assertEqual(pm["pressed"], {"tree": "true", "branch": "true", "order": "true", "operator": "true", "agent": "true"}, pm)
self.assertEqual(pm["errors"], [], pm)
self.assertEqual((pm["tree"][0], pm["order"][0]["gone"], pm["operator"]), ({"gone": False, "title": "Artifacts: tree"}, False, [{"gone": False, "title": "Tasks: Waits on Operator"}, 2]), pm)
self.assertGreaterEqual(pm["tree"][1], 2, pm)
self.assertGreaterEqual(len(pm["order"][1]), 2, pm)
self.assertEqual((pm["artifact"][0]["gone"], pm["artifact"][1]), (False, KEPT), pm)
self.assertEqual((pm["agent"][0], pm["agent"][1]), ({"gone": False, "title": f"Agent {GHOST}"}, True), pm)
self.check_long(next(results))
if last:
gone = next(results)
self.assertEqual(gone["before"], [False] * 6, gone)
self.assertTrue(gone["vanished"], gone)
self.assertEqual((gone["agent"], gone["artifacts"]), (["gone", "Unpin"], [["gone", "Unpin"]] * 5), gone)
unpinned = next(results)
self.assertNotIn(unpinned["metric"], unpinned["tiles"])
self.assertNotIn(unpinned["metric"], unpinned["stored"])
if last:
self.assertEqual(len(unpinned["artifacts"]), 5, unpinned)
self.assertFalse(set(unpinned["artifacts"]) & set(unpinned["tiles"] + unpinned["stored"]), unpinned)
def check_long(self, long: dict) -> None:
self.assertEqual(long["errors"], [], long)
self.assertEqual(long["pressed"], {key: [False, True, "true"] for key in LONG_ROWS}, long)
self.assertEqual([key for key in long["stored"] if key in long["keys"].values()], list(long["keys"].values()), long)
for key in ("core", "leaf"):
self.assertRegex(long["keys"][key], r"^artifact:(wt|artefact)_23_[0-9a-f]{16}$", long)
labels = {"repo": LONG_REPO, "worktree": LONG_WORKTREE, "core": CORE_WORKTREE, "leaf": LONG_VOLUME}
names = {"repo": LONG_NAME, "worktree": "/".join(Path(LONG_WORKTREE).parts[-2:]), "core": "/".join(Path(CORE_WORKTREE).parts[-2:]), "leaf": LONG_VOLUME.split(":", 1)[1]}
for key in LONG_ROWS:
shown = long["shown"][key]
self.assertIsNotNone(shown, (key, long))
self.assertFalse(shown["gone"], (key, shown))
self.assertEqual(shown["label"], names[key], (key, shown))
self.assertIn(labels[key], shown["body"], (key, shown))
self.assertTrue(shown["title"].startswith("Artifact "), (key, shown))
self.assertIn(LONG_WORKTREE, long["shown"]["worktree"]["title"])
self.assertIn(CORE_WORKTREE, long["shown"]["core"]["title"])
self.assertIn(LONG_VOLUME, long["shown"]["leaf"]["title"])
self.assertEqual(long["scroll"]["deletes"], 0, long)
if long["scroll"]["scrollable"]:
self.assertEqual(long["scroll"]["after"], long["scroll"]["before"], long)
def test_chromium_pins_metrics_with_their_selection_views_and_single_elements_at_three_widths(self):
data = self.drive(self.steps("chromium"), None, init=w4.GUARD)
(OUT / "chromium-bookmarks.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_pins_metrics_with_their_selection_views_and_single_elements_at_three_widths(self):
data = self.drive(self.steps("firefox"), None, "bidi.mjs", os.environ.get("FIREFOX", "firefox"), init=w4.GUARD)
(OUT / "firefox-bookmarks.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], [])
self.check(data, "firefox")
if __name__ == "__main__":
unittest.main()