Files
skills/tests/e2e/test_legend_toggle_e2e.py
T

230 lines
12 KiB
Python
Raw Normal View History

from __future__ import annotations
import json
import os
import shutil
import sys
import time
import unittest
from pathlib import Path
HERE = Path(__file__).resolve().parent
sys.path[:0] = [str(HERE.parent), str(HERE)]
import hub_e2e_kit as base
import test_workbench_w4_e2e as w4
from hub_case import HubCase
OUT = Path(os.environ.get("E2E_OUT", "/tmp/legend-toggle-shots"))
TILE = "metric:tokens/interval/all"
PINS = [
{"kind": "metric", "id": "tokens/interval/all", "w": 6, "h": 4, "view": {"chart": "tokens", "tokens": "interval", "shown": None}},
{"kind": "panel", "id": "tasks/burn", "w": 6, "h": 4},
{"kind": "panel", "id": "stream", "w": 6, "h": 4},
]
OWN = ("agents/orbit", "agents/chord", "agents/swimlane", "artifacts/orbit", "artifacts/chord", "artifacts/swimlane", "tasks/rasci", "tasks/gantt", "tasks/burn")
EXPECTED = {
**{screen: [] for screen in base.SCREENS},
**{screen: [screen] for screen in OWN},
"home": sorted([TILE, "panel:tasks/burn"]),
"resources": ["resources-hardware", "resources-tokens"],
}
READ = """
const PARTS = ".legend > :not(.star, .legend-toggle), .res-legend, .home-metric > .legend-chips";
const owners = () => [...all("#main [data-panel]").filter((host) => !host.closest(".home-tile")), ...all(".home-tile[data-pin]")];
const keyOf = (owner) => owner.dataset.pin || owner.dataset.panel;
const ownerOf = (key) => owners().find((node) => keyOf(node) === key) || null;
const toggleOf = (owner) => (owner ? owner.querySelector(`.legend-toggle[data-legend-key="${keyOf(owner)}"]`) : null);
const infoKeys = () => owners().filter((owner) => owner.getClientRects().length && toggleOf(owner)).map(keyOf).sort();
const shownParts = (owner) => all(PARTS, owner).filter((node) => node.getClientRects().length).length;
const stored = async () => (await (await fetch("/api/view", {cache: "no-store"})).json());
const storedUntil = async (test, ms) => {
const end = Date.now() + ms;
while (Date.now() < end) {
const found = await stored();
if (test(found)) {
return found;
}
await sleep(200);
}
return null;
};
const go = async (hash) => {
location.hash = hash;
return screenShown(8000);
};
const tile = () => document.querySelector(`.home-tile[data-pin="@TILE@"]`);
const plot = () => tile() && tile().querySelector(".res-plot svg");
const tokens = () => document.querySelector('#main [data-panel="resources-tokens"]');
const agents = () => [...new Set(all("svg [data-agent]", tokens()).map((node) => node.dataset.agent))].sort();
const wide = () => document.documentElement.scrollWidth > innerWidth + 1;
"""
SCAN = """(async () => {@HELPERS@@READ@
const flip = async (key) => {
const path = ownerOf(key).dataset.pin ? "tiles" : "views";
const button = () => toggleOf(ownerOf(key));
const placed = path === "tiles" ? button().nextElementSibling.classList.contains("home-open") : button().previousElementSibling.classList.contains("star");
const before = shownParts(ownerOf(key));
button().click();
const hidden = Boolean(await until(() => ownerOf(key) && ownerOf(key).dataset.legend === "hidden" && shownParts(ownerOf(key)) === 0 && button().getAttribute("aria-pressed") === "false", 4000));
const kept = Boolean(await storedUntil((view) => view.legend[path][key] === false, 4000));
button().click();
const back = Boolean(await until(() => ownerOf(key) && ownerOf(key).dataset.legend === "shown" && shownParts(ownerOf(key)) > 0 && button().getAttribute("aria-pressed") === "true", 4000));
const cleared = Boolean(await storedUntil((view) => !Object.hasOwn(view.legend[path], key), 4000));
return {key, placed, before: before > 0, hidden, kept, back, cleared};
};
await Promise.all([ViewStore.update("legend.views", () => ({})), ViewStore.update("legend.tiles", () => ({}))]);
const seen = {};
const flips = [];
for (const [screen, expected] of Object.entries(@EXPECTED@)) {
await go(`#${screen}`);
const keys = await until(() => (JSON.stringify(infoKeys()) === JSON.stringify(expected) ? infoKeys() : null), 8000);
seen[screen] = keys || infoKeys();
for (const key of keys || []) {
flips.push(await flip(key));
}
}
return {seen, flips, wide: wide(), violations: window.e2eViolations || null};
})()"""
ROOM = """(async () => {@HELPERS@@READ@
await Promise.all([ViewStore.update("legend.views", () => ({})), ViewStore.update("legend.tiles", () => ({})), ViewStore.update("resources.hidden", () => [])]);
await go("#home");
if (!(await until(() => plot() && tile().querySelector(".legend-chip"), 15000))) {
return {error: text(document.getElementById("main"))};
}
await sleep(600);
const tall = () => plot().getBoundingClientRect().height;
const before = tall();
toggleOf(tile()).click();
const grown = Boolean(await until(() => plot() && tall() > before + 4, 6000));
const tileHidden = shownParts(tile()) === 0;
await go("#resources");
const chip = () => tokens() && tokens().querySelector('.legend-chip[data-chip="agent:IAM"]');
if (!(await until(chip, 15000))) {
return {error: text(document.getElementById("main"))};
}
const viewShown = shownParts(tokens()) > 0 && toggleOf(tokens()).getAttribute("aria-pressed") === "true";
chip().click();
await storedUntil((view) => view.resources.hidden.includes("agent:IAM"), 4000);
toggleOf(tokens()).click();
await until(() => tokens().dataset.legend === "hidden" && shownParts(tokens()) === 0, 4000);
await sleep(800);
const chart = agents();
await go("#home");
await until(plot, 8000);
const tileStill = tile().dataset.legend === "hidden";
toggleOf(tile()).click();
const tileBack = Boolean(await until(() => shownParts(tile()) > 0, 4000));
const legend = await storedUntil((view) => view.legend.views["resources-tokens"] === false && !Object.hasOwn(view.legend.tiles, "@TILE@"), 4000);
await sleep(600);
return {grown, tileHidden, viewShown, chart, tileStill, tileBack, legend: legend && legend.legend, wide: wide(), violations: window.e2eViolations || null};
})()"""
HIDE = """(async () => {@HELPERS@@READ@
await go("#home");
await until(() => plot() && toggleOf(tile()), 15000);
toggleOf(tile()).click();
const hidden = Boolean(await until(() => shownParts(tile()) === 0, 4000));
await storedUntil((view) => view.legend.tiles["@TILE@"] === false, 4000);
await sleep(600);
return {hidden, wide: wide()};
})()"""
KEPT = """(async () => {@HELPERS@@READ@
if (!(await screenShown(8000)) || !(await until(() => tokens() && toggleOf(tokens()) && agents().length, 15000))) {
return {error: text(document.getElementById("main"))};
}
await sleep(600);
const view = {legend: tokens().dataset.legend, pressed: toggleOf(tokens()).getAttribute("aria-pressed"), parts: shownParts(tokens()), chart: agents()};
const found = await stored();
return {view, stored: found.legend, hidden: found.resources.hidden, wide: wide(), violations: window.e2eViolations || null};
})()"""
def probe(template: str) -> str:
names = {"@HELPERS@": base.HELPERS, "@READ@": READ, "@EXPECTED@": json.dumps(EXPECTED), "@TILE@": TILE}
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 TestLegendToggle(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": agent, "model": "claude-opus-5-5", "input": 1000 * (step + 1), "output": 500, "cache_read": 20000, "cache_write": 1000} for step in range(7) for agent in ("Skills", "IAM")]
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")
status, _, body = self.call("PATCH", "/api/view", json.dumps({"set": {"home.pins": PINS}, "expect": {"home.pins": []}}).encode(), {**self.guard(self.host), "Content-Type": "application/json"})
self.assertEqual(status, 200, body)
def steps(self, browser: str) -> list[dict]:
steps = []
for width, height in base.WIDTHS:
shot = OUT / f"{browser}-{width}"
steps += [
{"width": width, "height": height, "url": f"{self.base}?{width}-scan#home", "wait": 1200, "probe": probe(SCAN), "shot": None},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(ROOM), "shot": f"{shot}-home-shown.png"},
{"width": width, "height": height, "url": f"{self.base}?{width}-kept#resources", "wait": 1200, "probe": probe(KEPT), "shot": f"{shot}-resources-hidden.png"},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(HIDE), "shot": f"{shot}-home-hidden.png"},
]
return steps
def check(self, data: dict, browser: str) -> None:
results = iter(data["results"])
for width, _ in base.WIDTHS:
scan, room, kept, hide = (next(results) for _ in range(4))
with self.subTest(browser=browser, width=width):
self.assertEqual(scan["seen"], EXPECTED)
self.assertEqual([flip for flip in scan["flips"] if set(flip.values()) != {flip["key"], True}], [])
self.assertEqual(len(scan["flips"]), sum(len(keys) for keys in EXPECTED.values()))
self.assertEqual((scan["wide"], w4.quiet(scan["violations"])), (False, []))
self.assertNotIn("error", room, room)
self.assertEqual({key: room[key] for key in ("grown", "tileHidden", "viewShown", "tileStill", "tileBack")}, dict.fromkeys(("grown", "tileHidden", "viewShown", "tileStill", "tileBack"), True), room)
self.assertEqual(room["chart"], ["Skills"])
self.assertEqual(room["legend"], {"views": {"resources-tokens": False}, "tiles": {}})
self.assertEqual((room["wide"], w4.quiet(room["violations"])), (False, []))
self.held(kept, {"views": {"resources-tokens": False}, "tiles": {}})
self.assertEqual((hide["hidden"], hide["wide"]), (True, False))
def held(self, kept: dict, legend: dict) -> None:
self.assertNotIn("error", kept, kept)
self.assertEqual(kept["view"], {"legend": "hidden", "pressed": "false", "parts": 0, "chart": ["Skills"]})
self.assertEqual((kept["stored"], kept["hidden"]), (legend, ["agent:IAM"]))
self.assertEqual((kept["wide"], w4.quiet(kept["violations"])), (False, []))
def other(self, driver: str, binary: str) -> None:
width, height = base.WIDTHS[0]
data = self.drive([{"width": width, "height": height, "url": f"{self.base}?other#resources", "wait": 1200, "probe": probe(KEPT), "shot": None}], None, driver, binary, init=w4.GUARD)
self.held(data["results"][0], {"views": {"resources-tokens": False}, "tiles": {TILE: False}})
def test_chromium_hides_and_shows_legends_per_tile_and_view_and_firefox_sees_the_state(self):
data = self.drive(self.steps("chromium"), None, init=w4.GUARD)
(OUT / "chromium-legend.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
self.assertEqual(data["errors"], [])
self.check(data, "chromium")
firefox = shutil.which(os.environ.get("FIREFOX", "firefox"))
if firefox:
self.other("bidi.mjs", firefox)
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
def test_firefox_hides_and_shows_legends_per_tile_and_view_and_chromium_sees_the_state(self):
data = self.drive(self.steps("firefox"), None, "bidi.mjs", os.environ.get("FIREFOX", "firefox"), init=w4.GUARD)
(OUT / "firefox-legend.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")
self.other("cdp.mjs", os.environ.get("CHROMIUM", "chromium"))
if __name__ == "__main__":
unittest.main()