2026-11-14 10:02:43 +00:00
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 test_home_dashboard_e2e as dash
import test_orchestrator_e2e as base
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 ,
2026-11-15 09:46:37 +00:00
MERGED_BRANCH ,
2026-11-14 10:02:43 +00:00
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 . TestOrchestratorE2E . seed
subagents = base . TestOrchestratorE2E . subagents
drive = base . TestOrchestratorE2E . 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" )
2026-11-15 09:46:37 +00:00
self . write_local_plan ( scan , { MERGED_BRANCH : { "skip" : None , "actions" : [ "local-branch" ]}})
2026-11-14 10:02:43 +00:00
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 ()