Files
skills/tests/e2e/test_radio_layout_e2e.py
T
Kevin Veen-BirkenbachandClaude Opus 5.5 7adb6d63a3 feat(orchestrator): redesign the radio set into device, speak and history cards
The radio shows the device card on the left and the speak and history cards on the right from 45 to 61 rem of height, stacking below that; only the history scrolls. History rows get stable keys (sent-row id, else time, sender and occurrence), and focus moves to the nearest row when the focused one disappears. Tests run once on unify/skills-20261114 after the merge (operator order 2026-11-14).

🎯 Fix: 85 %
💥 Break: 12 %
💸 Tokens: 60 %
⏱️ Velocity: 45 %
🛡️ Security: 100 %
🏆 Score: 100
🚦 Gate: ⛔ fix 85 % < 90, break 12 % > 5

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 21:28:25 +00:00

1259 lines
73 KiB
Python

from __future__ import annotations
import json
import os
import shutil
import sys
import time
import unittest
from pathlib import Path
from unittest import mock
HERE = Path(__file__).resolve().parent
sys.path[:0] = [str(HERE.parent), str(HERE)]
import test_orchestrator_e2e as base
from hub_case import HubCase
from kvb_orchestrator import receipts, skill_scripts
from kvb_orchestrator.presence import SNAPSHOT
from kvb_orchestrator.view import RADIO_WINDOW
OUT = Path(os.environ.get("E2E_OUT", "/tmp/radio-layout-shots"))
LIVE = "f000000000000001"
SILENCE = "f000000000000002"
NEW_ALARM = "disk full again: the cleanup freed too little"
NAMES = ["Skills", "Stage", "Docs", "Atlas", "Beacon", "Comet", "Delta", "Echo", "Falcon", "Harbor"]
SESSIONS = {f"s{index}": name for index, name in enumerate(NAMES, start=1)}
LONG = "Disk at ninety percent on the build host: " + "the gate keeps the swarm waiting while the cache, the images and the logs keep growing; " * 4
FILLERS = 24
WIDTHS = (*base.WIDTHS, (960, 800))
NARROW = (390, 960)
STAGE_SHARE = 0.12
BANDS = ((1280, 720), (976, 744), (768, 976))
SHORT = ((800, 600), (1024, 600), (1280, 600), (1366, 657))
ABOVE = ((800, 976), (960, 976), (976, 744), (1024, 744), (1366, 720))
LAPTOPS = ((1280, 720), (1366, 768), (1440, 900), (1536, 864), (1920, 1080), (1024, 768), (1680, 1050), (820, 1180), (768, 1024), *ABOVE, *SHORT)
DUPS = ("dup first", "dup second")
VIEWS = ("#stream", "#agents/orbit")
STATES = ("idle", "stations", "voice", "speech", "mayday", "mayday-long")
ALARMS = {
"mayday": "disk full",
"mayday-long": "disk full on the build host: every agent pauses its writing steps until the operator frees space under /var/lib/docker and confirms the cleanup "
"on the radio; the gate queue stays frozen, the deploy of the production worktree waits, and every held test run restarts after the clear of this mayday",
}
BANNER_MAX = 48
FOCUS_SIZES = ((1366, 768), (390, 844))
MAIN_SHARE = 0.54
PLAY_MIN = {"BUTTON": (24, 24), "AUDIO": (200, 30)}
POPOVER_SIZES = ((1366, 768), (1280, 720), (390, 844))
HOME_RADIO = [{"kind": "panel", "id": "radio-device", "w": 6, "h": 6}, {"kind": "panel", "id": "radio", "w": 12, "h": 7}]
STREAMS = [{"name": f"Station {index}", "url": f"https://radio.example/{index}.mp3", "from": "00:00", "to": "24:00", "days": list(range(7)), "on": False, "via": []} for index in (1, 2, 3)]
PARTS = ["radio", "radio-device", "radio-speak", "radio-log"]
DEFAULTS = {"radio": [12, 7], "radio-device": [6, 6], "radio-speak": [6, 5], "radio-log": [6, 5]}
SIZES = {"radio": [12, 9], "radio-device": [5, 7], "radio-speak": [7, 6], "radio-log": [8, 6]}
LISTED = {"radio-log"}
SCROLLER = {"radio": "radio-log", "radio-device": None, "radio-speak": None, "radio-log": "radio-log"}
PROBES = """
const transitions = window.e2eTransitions || (window.e2eTransitions = []);
if (document.startViewTransition && !transitions.wrapped) {
const start = document.startViewTransition.bind(document);
document.startViewTransition = (update) => {
const run = start(update);
transitions.push(run);
return run;
};
transitions.wrapped = true;
}
const settle = () => Promise.all(transitions.map((run) => run.finished.catch(() => null)));
const press = (node) => {
node.dispatchEvent(new MouseEvent("mousedown", {bubbles: true, cancelable: true, view: window}));
if (node.matches('button, input, select, textarea, summary, a[href], [tabindex]')) {
node.focus();
} else if (document.activeElement) {
document.activeElement.blur();
}
node.dispatchEvent(new MouseEvent("mouseup", {bubbles: true, cancelable: true, view: window}));
node.click();
};
const box = (node) => node.getBoundingClientRect();
const ownStar = (owner) => all(".star", owner).find((node) => node.closest("[data-panel], [data-item]") === owner) || null;
const openSpot = async () => {
await until(() => typeof Nav === "object" && document.getElementById("radio-spot"), 8000);
const toggle = document.getElementById("radio-open");
if (toggle.getAttribute("aria-expanded") !== "true") {
toggle.click();
await sleep(300);
}
return document.getElementById("radio-spot");
};
const closeSpot = async () => {
const toggle = document.getElementById("radio-open");
if (toggle.getAttribute("aria-expanded") === "true") {
toggle.click();
await sleep(200);
}
};
const longRow = (root) => all(".radio-row", root).find((item) => text(item.querySelector(".radio-line")).startsWith("Disk at ninety"));
const popup = () => document.getElementById("popup");
const openRow = async (row) => {
row.querySelector(".radio-pick").click();
return until(() => popup().open && popup().querySelector(".radio-full") ? popup() : null, 4000);
};
const shown = (node) => node.getClientRects().length > 0;
const scrolls = (node) => {
const look = getComputedStyle(node);
return (node.scrollHeight > node.clientHeight + 1 && ["auto", "scroll"].includes(look.overflowY)) || (node.scrollWidth > node.clientWidth + 1 && ["auto", "scroll"].includes(look.overflowX));
};
const scrollersIn = (root) => [root, ...all("*", root)].filter((node) => node instanceof HTMLElement && node.tagName !== "SELECT" && node.tagName !== "TEXTAREA" && shown(node) && scrolls(node)).map((node) => [...node.classList].at(-1) || node.tagName);
const tile = (id) => document.querySelector(`#main .home-tile[data-pin="panel:${id}"]`);
const pick = (root) => {
const [channel, recipient] = all("select", root.querySelector("form.composer"));
return {channel: channel.value, recipient: recipient.value, toShown: !recipient.closest("label").hidden, focused: document.activeElement === root.querySelector("form.composer textarea")};
};
"""
LAYOUT = """(async () => {@HELPERS@@PROBES@
await ViewStore.update("home.pins", () => []);
const spot = await openSpot();
spot.querySelector('.radio-tabs [data-tab="all"]').click();
await until(() => all(".radio-row .reader", spot).length > 20 && longRow(spot), 20000);
await sleep(300);
window.scrollTo(0, 0);
const cardOf = (node) => (node.parentElement && node.parentElement.closest(".radio-card")) || spot;
const wider = all("*", spot).filter((node) => node.tagName !== "OPTION" && shown(node) && box(node).width > 0).filter((node) => {
const own = box(node);
const card = box(cardOf(node));
return own.left < card.left - 1 || own.right > card.right + 1;
}).map((node) => `${node.tagName}.${node.getAttribute("class")}`);
const list = spot.querySelector(".radio-log");
const listLook = getComputedStyle(list);
const rows = all(".radio-row", spot);
const lineHeight = parseFloat(getComputedStyle(rows[0].querySelector(".radio-line")).lineHeight);
const lines = rows.map((row) => {
const line = row.querySelector(".radio-line");
const look = getComputedStyle(line);
return {height: Math.round(box(row).height), nowrap: look.whiteSpace === "nowrap", ellipsis: look.textOverflow === "ellipsis", flat: line.scrollHeight <= line.clientHeight + 1 && row.scrollHeight <= row.clientHeight + 1, fits: row.scrollWidth <= row.clientWidth + 1 && box(row).right <= box(list).right + 1, width: line.clientWidth};
});
const long = longRow(spot).querySelector(".radio-line");
const avatars = rows.filter((row) => row.querySelector(".reader")).map((row) => {
const edge = box(row);
const line = box(row.querySelector(".radio-line"));
const faces = all(".reader .avatar", row).filter(shown).map(box);
return {
total: Number((row.querySelector(".readers").getAttribute("aria-label").match(/\\d+/) || ["0"])[0]),
count: faces.length,
more: all(".readers-more", row).filter(shown).map(text),
inside: faces.every((face) => face.left >= edge.left - 1 && face.right <= edge.right + 1 && face.top >= edge.top - 1 && face.bottom <= edge.bottom + 1),
after: faces.every((face) => face.left >= line.right - 1),
stacked: faces.slice(1).every((face, index) => face.left < faces[index].right),
sliver: faces.length ? Math.min(...faces.map((face, index) => (index + 1 < faces.length ? faces[index + 1].left : face.right) - face.left)) : null,
};
});
const [device, speak, history] = ["radio-device", "radio-speak", "radio-log"].map((id) => box(spot.querySelector(`[data-panel="${id}"]`)));
const owners = [spot, ...all("[data-panel]", spot)];
const controls = all('button, input, select, textarea, summary, [role="tab"]', spot).filter((node) => shown(node) && !node.classList.contains("star"));
const overlap = (a, b) => Math.max(0, Math.min(a.right, b.right) - Math.max(a.left, b.left)) * Math.max(0, Math.min(a.bottom, b.bottom) - Math.max(a.top, b.top));
const covered = owners.map(ownStar).filter(Boolean).flatMap((star) => controls.filter((node) => !node.contains(star) && overlap(box(star), box(node)) > 1).map((node) => `${star.title} over ${node.getAttribute("aria-label") || text(node)}`));
const knobs = all(".radio-knobs .knob-row", spot).map((row) => Math.round(box(row.querySelector(".knob-label")).left));
return {
page: [document.documentElement.scrollWidth, innerWidth], tall: [document.documentElement.scrollHeight, innerHeight, Math.round(box(spot).height)],
wider, scrollers: scrollersIn(spot),
list: {overflowY: listLook.overflowY, scrollbar: [listLook.scrollbarWidth, listLook.scrollbarColor], scrolls: list.scrollHeight > list.clientHeight + 1},
main: getComputedStyle(document.getElementById("main")).scrollbarColor,
heights: [...new Set(lines.map((line) => line.height))], lineHeight, rows: rows.length,
single: lines.every((line) => line.nowrap && line.ellipsis && line.flat && line.fits),
narrowest: Math.min(...lines.map((line) => line.width)),
long: [long.scrollWidth > long.clientWidth, getComputedStyle(long).textOverflow],
avatars: {rows: avatars.length, most: Math.max(...avatars.map((row) => row.count)), inside: avatars.every((row) => row.inside), after: avatars.every((row) => row.after), stacked: avatars.filter((row) => row.count > 1).every((row) => row.stacked)},
folds: avatars.map((row) => [row.total, row.count, row.more]),
sliver: Math.min(...avatars.map((row) => row.sliver)),
order: {stacked: device.bottom <= speak.top + 1 && speak.bottom <= history.top + 1 && Math.abs(device.left - speak.left) < 2, beside: device.right <= speak.left && speak.bottom <= history.top + 1 && Math.abs(speak.left - history.left) < 2},
labels: [...new Set(knobs)].length,
stars: owners.map((owner) => [owner.dataset.panel, Boolean(ownStar(owner))]), covered,
stations: [Boolean(spot.querySelector("details.radio-station")), spot.querySelector("details.radio-station").open],
};
})()"""
POPUP = """(async () => {@HELPERS@@PROBES@
const spot = document.getElementById("radio-spot");
const copied = [];
navigator.clipboard.writeText = (value) => {
copied.push(value);
return Promise.resolve();
};
const row = longRow(spot);
row.scrollIntoView({block: "center"});
await sleep(200);
const dialog = await openRow(row);
if (!dialog) {
return {error: "no popup"};
}
const card = dialog.querySelector(".popup-box");
const fields = Object.fromEntries(all("dl.meta > div", card).map((pair) => [text(pair.querySelector("dt")), text(pair.querySelector("dd"))]));
const readers = all(".popup-reader", card).map((item) => ({session: item.dataset.session, name: text(item.querySelector("strong")), time: text(item.querySelector(".muted")), acked: item.dataset.acked}));
const copy = card.querySelector(".radio-copy");
const said = card.querySelector(".radio-said");
const heard = () => [copy.getAttribute("aria-label"), said ? text(said) : null];
const region = said ? [said.getAttribute("role"), said.getAttribute("aria-live"), card.contains(said), shown(said) && box(said).width <= 1] : null;
copy.click();
const done = await until(() => (copy.dataset.copied === "true" ? text(copy) : null), 3000);
const success = heard();
const buttons = all(".radio-actions button", card).map(text);
await until(() => copy.getAttribute("aria-label") === "Copy" && copy.dataset.copied === "", 4000);
const reset = heard();
navigator.clipboard.writeText = () => Promise.reject(new DOMException("Denied", "NotAllowedError"));
copy.click();
await until(() => copy.dataset.copied === "false", 3000);
const failure = heard();
return {
open: dialog.open, title: text(card.querySelector(".popup-head h2")), fields, full: dialog.querySelector(".radio-full").textContent, readers,
heading: text(card.querySelector("h3")), buttons, copied, shown: done, region, success, reset, failure,
stray: [...card.childNodes].filter((node) => node.nodeType === 3).map((node) => node.textContent),
inView: (() => {
const edge = box(card);
return edge.left >= 0 && edge.top >= 0 && edge.right <= innerWidth + 1 && edge.bottom <= innerHeight + 1;
})(),
};
})()"""
CLOSE_REPLY = """(async () => {@HELPERS@@PROBES@
const spot = document.getElementById("radio-spot");
(document.activeElement || document.body).dispatchEvent(new KeyboardEvent("keydown", {key: "Escape", bubbles: true}));
await sleep(200);
const escaped = !popup().open;
const dialog = await openRow(longRow(spot));
const card = box(dialog.querySelector(".popup-box"));
const x = card.left > 8 ? Math.floor(card.left / 2) : Math.ceil((card.right + document.documentElement.clientWidth) / 2);
const hit = document.elementFromPoint(x, Math.round(innerHeight / 2));
hit.click();
await sleep(200);
const outside = [hit === popup(), !popup().open];
await openRow(longRow(spot));
all(".radio-actions button", popup()).find((button) => text(button) === "Reply").click();
await sleep(300);
return {escaped, outside, reply: {open: popup().open, ...pick(spot)}};
})()"""
HOME = """(async () => {@HELPERS@@PROBES@
const spot = await openSpot();
const owners = Object.fromEntries(@PARTS@.map((id) => [id, id === "radio" ? spot : spot.querySelector(`[data-panel="${id}"]`)]));
const pressed = {};
for (const [id, owner] of Object.entries(owners)) {
const star = ownStar(owner);
if (star.getAttribute("aria-pressed") !== "true") {
star.click();
await sleep(250);
}
pressed[id] = star.getAttribute("aria-pressed");
}
await until(() => (ViewStore.get("home.pins") || []).length === 4, 5000);
const stored = (ViewStore.get("home.pins") || []).map((pin) => [`${pin.kind}:${pin.id}`, pin.w, pin.h]);
await closeSpot();
location.hash = "#home";
await screenShown(8000);
await until(() => @PARTS@.every((id) => tile(id)) && tile("radio-log").querySelector(".radio-row") && tile("radio").querySelector(".radio-row"), 10000);
await sleep(400);
const measure = () => Object.fromEntries(@PARTS@.map((id) => {
const body = tile(id).querySelector(".home-body");
const list = tile(id).querySelector(".radio-log");
const edge = box(body);
const rows = list ? all(".radio-row", list).filter((row) => box(row).top >= box(list).top - 1 && box(row).bottom <= box(list).bottom + 1).length : null;
return [id, {scrollers: scrollersIn(tile(id)), rows, inside: list ? box(list).bottom <= edge.bottom + 1 && box(list).top >= edge.top - 1 : null, filled: Math.abs(box(tile(id).querySelector(".radio-home")).height - body.clientHeight + parseFloat(getComputedStyle(body).paddingTop) + parseFloat(getComputedStyle(body).paddingBottom)) <= 2}];
}));
const fresh = measure();
const whole = tile("radio");
const bar = whole.querySelector(".spot-head");
const gear = bar ? all("button", bar).find((button) => button.getAttribute("aria-label") === "Read aloud") : null;
const clear = bar ? all("button", bar).find((button) => button.getAttribute("aria-label") === "Cancel mayday") : null;
if (gear) {
gear.click();
await sleep(200);
}
const filters = whole.querySelector(".radio-gear .radio-read");
const tools = {
gear: gear ? [gear.getAttribute("aria-expanded"), Boolean(filters), filters ? box(filters).bottom <= box(whole).bottom + 1 : null] : null,
clear: clear ? [clear.disabled, clear.title] : null,
};
if (gear) {
gear.click();
}
const content = {
tiles: all("#main .home-tile").map((node) => node.dataset.pin),
radio: [".radio-device", ".radio-speak", ".radio-logbox"].map((selector) => Boolean(tile("radio").querySelector(selector))),
device: [text(tile("radio-device").querySelector('[data-field="mode"]')), all(".radio-knobs input[type=range]", tile("radio-device")).length],
speak: [Boolean(tile("radio-speak").querySelector("form.composer textarea")), tile("radio-speak").querySelectorAll("form.composer select option").length > 0],
log: [tile("radio-log").querySelectorAll(".radio-row").length, tile("radio").querySelectorAll(".radio-row").length, document.querySelectorAll("#radio-spot .radio-row").length],
gone: all("#main .home-tile.gone").length,
stars: all("#main .home-tile .home-body .star").length,
ids: all("#main .home-tile .home-body [id]").map((node) => node.id),
};
const count = (id) => tile(id).querySelectorAll(".radio-row").length;
const before = [count("radio-log"), count("radio")];
await fetch("/api/voice/@LIVE@", {cache: "no-store"});
window.dispatchEvent(new Event("focus"));
const first = (id) => text(tile(id).querySelector(".radio-row .radio-line"));
const live = await until(() => (count("radio-log") > before[0] && count("radio") > before[1] && first("radio-log").startsWith("live row") ? [first("radio-log"), first("radio")] : null), 20000);
tile("radio-device").querySelector('.radio-modes button[data-mode="quiet"]').click();
await sleep(200);
const mode = [text(tile("radio").querySelector('[data-field="mode"]')), text(document.querySelector('#radio-spot [data-field="mode"]'))];
tile("radio-device").querySelector('.radio-modes button[data-mode="auto"]').click();
await sleep(200);
const sizes = @SIZES@;
await ViewStore.update("home.pins", (pins) => (pins || []).map((pin) => ({...pin, w: sizes[pin.id][0], h: sizes[pin.id][1]})));
await until(() => @PARTS@.every((id) => tile(id).dataset.w === String(sizes[id][0]) && tile(id).dataset.h === String(sizes[id][1])), 5000);
await sleep(400);
const resized = measure();
window.scrollTo(0, 0);
return {pressed, stored, fresh, resized, tools, content, live, mode, wide: document.documentElement.scrollWidth > innerWidth + 1};
})()"""
FIT = """(async () => {@HELPERS@@PROBES@
await ViewStore.update("home.pins", () => []);
location.hash = "#agents/orbit";
await screenShown(8000);
const spot = await openSpot();
await until(() => spot.querySelector(".radio-row"), 8000);
await sleep(500);
const stage = document.querySelector("#main .stage svg");
const list = spot.querySelector(".radio-log");
const result = {
fit: document.body.classList.contains("fit"), tall: document.documentElement.scrollHeight > innerHeight, wide: document.documentElement.scrollWidth > innerWidth + 1,
stage: stage ? Math.round(box(stage).height) : 0, height: innerHeight, scrollers: scrollersIn(spot),
list: list.clientHeight, speak: (() => {
const card = spot.querySelector(".radio-speak");
return card.scrollHeight <= card.clientHeight + 1;
})(),
};
await closeSpot();
await sleep(300);
const after = document.querySelector("#main .stage svg");
result.closed = {boxes: spot.getClientRects().length, tall: document.documentElement.scrollHeight > innerHeight, stage: after ? Math.round(box(after).height) : 0};
return result;
})()"""
SPOT = """(async () => {@HELPERS@@PROBES@@SPEAKING@
await ViewStore.update("home.pins", () => []);
location.hash = "@VIEW@";
await screenShown(8000);
const spot = await openSpot();
await until(() => spot.querySelector(".radio-row") && spot.querySelectorAll(".radio-device .station").length === 3, 8000);
await settle();
await sleep(500);
window.scrollTo(0, 0);
const fits = (node) => node.scrollHeight <= node.clientHeight + 1;
const list = spot.querySelector(".radio-log");
const fold = spot.querySelector("details.radio-station");
const form = spot.querySelector(".radio-speak form.composer");
const note = form.querySelector(".voice-note");
const display = spot.querySelector(".radio-caption");
const named = (node) => node.getAttribute("aria-label") || text(node) || node.getAttribute("title") || `${node.tagName}.${node.getAttribute("class")}`;
const blocked = () => {
const layer = spot.querySelector(".radio-station[open] > .station-body");
const marks = [spot.querySelector(".radio-lamp"), spot.querySelector('[data-field="cpu"]'), spot.querySelector(".radio-device .group-title")];
const folded = (node) => Boolean(node.closest("details:not([open])")) && !node.closest("summary");
const found = [];
for (const node of [...all('button, input, select, textarea, summary, audio, [role="tab"]', spot), ...marks].filter((item) => shown(item) && !folded(item) && box(item).width > 0 && box(item).height > 0)) {
window.scrollTo(0, 0);
const seen = box(node);
if (seen.bottom > innerHeight) {
window.scrollBy(0, seen.top + seen.height / 2 - innerHeight / 2);
}
const edge = box(node);
const [x, y] = [edge.left + edge.width / 2, edge.top + edge.height / 2];
const hit = document.elementFromPoint(x, y);
if (!(list.contains(node) && (y < box(list).top || y > box(list).bottom)) && !(hit === node || node.contains(hit) || (layer && hit && layer.contains(hit) && !layer.contains(node)))) {
found.push(`${named(node)} <- ${hit ? `${hit.tagName}.${hit.getAttribute("class")}#${hit.id}` : "null"}`);
}
}
window.scrollTo(0, 0);
return found;
};
const stack = () => {
const card = spot.querySelector(".radio-logbox");
const head = [card.querySelector(".radio-tabs"), card.querySelector('input[type="search"]')].map(box);
const chips = all(".chip-select, .radio-filters > button", card).map(box);
return {head: Math.round(Math.max(...head.map((edge) => edge.bottom))), chips: [Math.round(Math.min(...chips.map((edge) => edge.top))), Math.round(Math.max(...chips.map((edge) => edge.bottom)))], list: Math.round(box(list).top)};
};
const measure = () => {
window.scrollTo(0, 0);
const [device, speak, history] = ["radio-device", "radio-speak", "radio-log"].map((id) => box(spot.querySelector(`[data-panel="${id}"]`)));
const svg = document.querySelector("#main .stage svg");
return {
fit: document.body.classList.contains("fit"),
page: [document.documentElement.scrollWidth, document.documentElement.scrollHeight, innerWidth, innerHeight],
scrollers: scrollersIn(spot), cards: [fits(spot.querySelector(".radio-device")), fits(spot.querySelector(".radio-speak"))],
main: Math.round(box(document.getElementById("main")).height), floor: Math.round(innerHeight * @MAIN@ - box(document.getElementById("spot-host")).top),
full: Math.round(innerHeight - document.getElementById("head").offsetHeight - 16), stack: stack(), beneath: box(document.getElementById("main")).top >= box(spot).bottom - 1,
stage: svg ? Math.round(box(svg).height) : null,
list: list.clientHeight, rows: all(".radio-row", list).filter((row) => box(row).top >= box(list).top - 1 && box(row).bottom <= box(list).bottom + 1).length,
order: device.right <= speak.left && device.right <= history.left && speak.bottom <= history.top + 1 && Math.abs(speak.left - history.left) < 2,
active: {stations: fold.open ? all(".station", fold).filter(shown).length : 0, voice: !note.hidden && shown(note), speech: !display.hidden && shown(display)},
blocked: blocked(),
banner: (() => {
const node = document.getElementById("mayday");
if (node.hidden || !shown(node)) {
return null;
}
const words = node.querySelector(".text");
const cancel = node.querySelector("button");
const edge = box(cancel);
const hit = document.elementFromPoint(edge.left + edge.width / 2, edge.top + edge.height / 2);
return {height: Math.round(box(node).height), title: words.title, full: words.textContent, cut: words.scrollWidth > words.clientWidth + 1, cancel: Boolean(hit && cancel.contains(hit))};
})(),
play: [note.querySelector(".voice-play"), note.querySelector("audio")].filter((node) => node && shown(node) && box(node).width > 0).map((node) => [node.tagName, Math.round(box(node).width), Math.round(box(node).height)]),
line: (() => {
const node = display.querySelector(".caption-line");
return node && shown(node) ? [Math.round(node.clientWidth), text(node).length] : null;
})(),
rem: parseFloat(getComputedStyle(document.documentElement).fontSize),
};
};
const wanted = @STATES@;
const states = {};
for (const name of wanted.filter((state) => state === "idle" || state.startsWith("mayday"))) {
states[name] = measure();
}
if (wanted.includes("stations")) {
const summary = fold.querySelector("summary");
summary.focus();
summary.click();
await sleep(300);
states.stations = measure();
document.activeElement.dispatchEvent(new KeyboardEvent("keydown", {key: "Escape", bubbles: true}));
await sleep(200);
states.stations.closed = [fold.open, document.activeElement === summary];
}
if (wanted.includes("voice")) {
const record = all("button", form).find((button) => button.hasAttribute("aria-pressed"));
record.click();
await sleep(1300);
record.click();
const heard = await until(() => !note.hidden && note.querySelector("audio") && form.querySelector("textarea").value, 30000);
await sleep(300);
states.voice = {...measure(), heard: Boolean(heard)};
const toggle = note.querySelector(".voice-play");
if (toggle && shown(toggle)) {
toggle.click();
states.voice.played = Boolean(await until(() => !note.querySelector("audio").paused && toggle.getAttribute("aria-label") === "Pause voice message", 4000));
toggle.click();
states.voice.paused = Boolean(await until(() => note.querySelector("audio").paused && toggle.getAttribute("aria-label") === "Play voice message", 4000));
}
const trash = all("button", note).find((button) => button.getAttribute("aria-label") === "Remove recording");
if (trash) {
trash.click();
}
await sleep(200);
}
if (wanted.includes("speech")) {
const found = await cue("@CUE@");
await sleep(300);
states.speech = {...measure(), who: found && !found.error ? found.who : found};
const stop = display.querySelector("button");
if (stop) {
stop.click();
}
await until(() => display.hidden, 8000);
}
return states;
})()"""
POP = """(async () => {@HELPERS@@PROBES@
await ViewStore.update("home.pins", () => @PINS@);
location.hash = "@VIEW@";
await screenShown(8000);
if (@SPOT@) {
await openSpot();
} else {
await closeSpot();
}
await settle();
await sleep(500);
const outside = (layer) => {
const edge = box(layer);
const clips = [["viewport", {top: 0, bottom: innerHeight, left: 0, right: innerWidth}]];
for (let node = layer.parentElement; node && node !== document.documentElement; node = node.parentElement) {
const look = getComputedStyle(node);
if (look.overflowX !== "visible" || look.overflowY !== "visible") {
clips.push([`${node.tagName}.${node.getAttribute("class")}`, box(node)]);
}
}
return clips.filter(([, clip]) => edge.top < clip.top - 1 || edge.bottom > clip.bottom + 1 || edge.left < clip.left - 1 || edge.right > clip.right + 1)
.map(([name, clip]) => `${name} [${Math.round(clip.top)},${Math.round(clip.bottom)}] vs [${Math.round(edge.top)},${Math.round(edge.bottom)}]`);
};
const out = [];
for (const selector of @ROOTS@) {
const root = document.querySelector(selector);
if (!root || !(await until(() => root.querySelectorAll(".station").length === 3, 8000))) {
out.push({selector, error: "no stations"});
continue;
}
const fold = root.querySelector("details.radio-station");
const summary = fold.querySelector("summary");
const layer = fold.querySelector(".station-body");
fold.scrollIntoView({block: "center"});
await sleep(200);
summary.focus();
summary.click();
await sleep(300);
const whole = all(".station", layer).filter((row) => box(row).top >= box(layer).top - 1 && box(row).bottom <= box(layer).bottom + 1).length;
const opened = {open: fold.open, side: fold.dataset.side, height: Math.round(box(layer).height), outside: outside(layer), whole};
layer.querySelector(".station button").focus();
document.activeElement.dispatchEvent(new KeyboardEvent("keydown", {key: "Escape", bubbles: true}));
await sleep(200);
const escape = [fold.open, document.activeElement === summary];
summary.click();
await sleep(300);
const again = {open: fold.open, outside: outside(layer)};
press(document.getElementById("main"));
await sleep(200);
out.push({selector, opened, escape, again, click: [fold.open, document.activeElement === summary, document.activeElement === document.body]});
}
return out;
})()"""
FOCUS = """(async () => {@HELPERS@@PROBES@
await ViewStore.update("home.pins", () => []);
location.hash = "#agents/orbit";
await screenShown(8000);
const spot = await openSpot();
await until(() => spot.querySelectorAll(".station").length === 3 && spot.querySelector(".radio-row"), 8000);
await settle();
await sleep(300);
const fold = spot.querySelector("details.radio-station");
const night = await until(() => all("details.menu").find((menu) => menu.querySelector("summary").getAttribute("aria-label") === "Day/Night"), 8000);
const label = (node) => (node ? `${node.tagName}.${node.getAttribute("class")}[${node.getAttribute("aria-label") || text(node).slice(0, 24)}]` : "null");
const tab = () => spot.querySelector('.radio-tabs [role="tab"]:not([aria-selected="true"])');
const cases = {};
const run = async (key, menu, target) => {
press(menu.querySelector("summary"));
await sleep(250);
const opened = menu.open;
const node = target();
press(node);
await sleep(400);
const active = document.activeElement;
cases[key] = {opened, closed: !menu.open, active: label(active), summary: Boolean(active && active.matches("summary")), history: Boolean(active && active.closest(".radio-logbox")), body: active === document.body};
menu.open = false;
await sleep(150);
};
await run("night-tab", night, tab);
await run("fold-tab", fold, tab);
await run("night-main", night, () => document.getElementById("main"));
await run("fold-main", fold, () => document.getElementById("main"));
press(fold.querySelector("summary"));
await sleep(250);
fold.querySelector(".station button").focus();
document.activeElement.dispatchEvent(new KeyboardEvent("keydown", {key: "Escape", bubbles: true}));
await sleep(200);
cases.escape = {closed: !fold.open, toggle: document.activeElement === fold.querySelector("summary")};
return cases;
})()"""
LOADS = """
const loads = {count: 0};
const send = window.fetch.bind(window);
window.fetch = async (path, init) => {
const response = await send(path, init);
if (String(path).startsWith("/api/state")) {
const json = response.json.bind(response);
response.json = () => json().then((value) => {
loads.count += 1;
return value;
});
}
return response;
};
const loaded = async (more, ms) => {
const goal = loads.count + more;
const done = await until(() => loads.count >= goal, ms);
await sleep(300);
return Boolean(done);
};
"""
ROWS = """(async () => {@HELPERS@@PROBES@@LOADS@
await ViewStore.update("home.pins", () => []);
location.hash = "#agents/orbit";
await screenShown(8000);
const spot = await openSpot();
await until(() => spot.querySelectorAll(".radio-row").length > 2, 8000);
await settle();
await sleep(300);
const rows = () => spot.querySelectorAll(".radio-row").length;
const deliver = async () => {
const before = rows();
await fetch("/api/voice/@LIVE@", {cache: "no-store"});
window.dispatchEvent(new Event("focus"));
const done = await until(() => rows() > before, 20000);
await sleep(300);
return Boolean(done);
};
const row = spot.querySelectorAll(".radio-row")[1];
const button = row.querySelector(".radio-pick");
const held = () => {
const active = document.activeElement;
const owner = active ? active.closest(".radio-row") : null;
return {same: active === button, key: owner ? owner.dataset.key : null, pick: Boolean(active && active.matches(".radio-pick")), body: active === document.body};
};
button.focus();
const start = {...held(), want: row.dataset.key};
const fresh = {...held(), delivered: await deliver()};
const real = Date.now;
Date.now = () => real.call(Date) + 60000;
window.dispatchEvent(new Event("focus"));
const tick = {...held(), ticked: await loaded(1, 20000)};
Date.now = real;
const tab = spot.querySelector('.radio-tabs [role="tab"][aria-selected="true"]');
tab.focus();
let focusins = 0;
document.addEventListener("focusin", () => {
focusins += 1;
}, true);
const delivered = [await deliver(), await deliver(), await deliver()];
return {start, fresh, tick, tabs: {delivered, focusins, same: document.activeElement === tab, tab: document.activeElement.getAttribute("data-tab")}};
})()"""
KEYS = """(async () => {@HELPERS@@PROBES@
await ViewStore.update("home.pins", () => []);
location.hash = "#agents/orbit";
await screenShown(8000);
const spot = await openSpot();
spot.querySelector('.radio-tabs [role="tab"][data-tab="all"]').click();
const dups = () => all(".radio-row", spot).filter((node) => text(node.querySelector(".radio-line")).startsWith("dup "));
await until(() => dups().length === 2, 8000);
await settle();
await sleep(300);
const rows = () => spot.querySelectorAll(".radio-row").length;
const deliver = async () => {
const before = rows();
await fetch("/api/voice/@LIVE@", {cache: "no-store"});
window.dispatchEvent(new Event("focus"));
const done = await until(() => rows() > before, 20000);
await sleep(300);
return Boolean(done);
};
const line = (node) => (node && node.closest(".radio-row") ? text(node.closest(".radio-row").querySelector(".radio-line")) : null);
const out = {keys: dups().map((node) => node.dataset.key)};
for (const word of @DUPS@) {
const button = dups().find((node) => text(node.querySelector(".radio-line")) === word).querySelector(".radio-pick");
button.focus();
const delivered = await deliver();
const active = document.activeElement;
const result = {delivered, same: active === button, line: line(active), popup: null};
if (active && active.matches(".radio-pick")) {
active.click();
result.popup = await until(() => (popup().open && popup().querySelector(".radio-full") ? popup().querySelector(".radio-full").textContent : null), 4000);
(document.activeElement || document.body).dispatchEvent(new KeyboardEvent("keydown", {key: "Escape", bubbles: true}));
await until(() => !popup().open, 2000);
}
out[word] = result;
}
const victim = all(".radio-row", spot).find((node) => node.dataset.class === "newsletter");
victim.querySelector(".radio-pick").focus();
const chip = spot.querySelector('.chip-select[data-chip="class"] select');
chip.value = "call";
chip.dispatchEvent(new Event("change", {bubbles: true}));
await sleep(500);
const near = document.activeElement;
out.filtered = {gone: !victim.isConnected, pick: Boolean(near && near.matches(".radio-pick")), class: near && near.closest(".radio-row") ? near.closest(".radio-row").dataset.class : null};
const search = spot.querySelector('.radio-logbox input[type="search"]');
search.value = "no radio row says this";
search.dispatchEvent(new Event("input", {bubbles: true}));
await sleep(500);
out.emptied = {gone: !spot.querySelector(".radio-row"), list: document.activeElement === spot.querySelector("ul.radio-log")};
search.value = "";
search.dispatchEvent(new Event("input", {bubbles: true}));
chip.value = "";
chip.dispatchEvent(new Event("change", {bubbles: true}));
await sleep(300);
return out;
})()"""
BANNER = """(async () => {@HELPERS@@PROBES@@LOADS@
await ViewStore.update("home.pins", () => []);
location.hash = "#agents/orbit";
await screenShown(8000);
const banner = document.getElementById("mayday");
await until(() => !banner.hidden && banner.querySelector("button"), 8000);
await settle();
await sleep(300);
const records = [];
new MutationObserver((list) => records.push(...list)).observe(banner, {childList: true, subtree: true, characterData: true, attributes: true});
const cancel = banner.querySelector("button");
cancel.focus();
const polled = await loaded(2, 30000);
const steady = {polled, mutations: records.length, focus: document.activeElement === cancel, body: document.activeElement === document.body};
records.length = 0;
await fetch("/api/voice/@SILENCE@", {cache: "no-store"});
const again = await loaded(3, 45000);
const added = records.filter((record) => record.type === "childList" && record.addedNodes.length > 0).length;
return {steady, changed: {polled: again, text: text(banner.querySelector(".text")), added, shown: !banner.hidden, cancel: Boolean(banner.querySelector("button"))}};
})()"""
COMPOSE_HOME = """(async () => {@HELPERS@@PROBES@
const bodies = [];
const send = window.fetch.bind(window);
window.fetch = (path, init) => {
if (String(path) === "/api/messages") {
bodies.push(JSON.parse(init.body));
}
return send(path, init);
};
window.confirm = () => true;
const spot = await openSpot();
const spotText = spot.querySelector("form.composer textarea");
spotText.value = "draft kept in the spot";
spotText.dispatchEvent(new Event("input", {bubbles: true}));
await ViewStore.update("home.pins", () => [{kind: "panel", id: "radio", w: 12, h: 7}, {kind: "panel", id: "radio-speak", w: 6, h: 5}, {kind: "panel", id: "radio-log", w: 6, h: 5}]);
location.hash = "#home";
await screenShown(8000);
await until(() => tile("radio-speak") && tile("radio-log") && tile("radio") && tile("radio-log").querySelector(".radio-row"), 10000);
await sleep(400);
const homeSpeak = tile("radio-speak");
const form = (root) => root.querySelector("form.composer");
const area = (root) => form(root).querySelector("textarea");
const record = (root) => all("button", form(root)).find((button) => button.hasAttribute("aria-pressed"));
const note = (root) => {
const audio = form(root).querySelector(".voice-note audio");
return audio ? audio.getAttribute("src").replace("/api/voice/", "").replace(".wav", "") : null;
};
const drafts = [area(spot).value, area(homeSpeak).value, area(tile("radio")).value];
record(spot).click();
await sleep(1200);
const first = record(spot).getAttribute("aria-pressed");
record(homeSpeak).click();
const handed = await until(() => (record(homeSpeak).getAttribute("aria-pressed") === "true" ? [record(spot).getAttribute("aria-pressed"), "true"] : null), 5000);
const spotHeard = await until(() => (note(spot) && area(spot).value.includes("hello from the mic") ? area(spot).value : null), 30000);
const homeBefore = area(homeSpeak).value;
await sleep(800);
record(homeSpeak).click();
const homeHeard = await until(() => (note(homeSpeak) && area(homeSpeak).value.includes("hello from the mic") ? area(homeSpeak).value : null), 30000);
const notes = [note(spot), note(homeSpeak)];
const sendFrom = async (root, to, words, attach) => {
const [channel, recipient] = all("select", form(root));
channel.value = "post";
channel.dispatchEvent(new Event("change", {bubbles: true}));
await until(() => [...recipient.options].some((option) => option.value === to), 8000);
recipient.value = to;
area(root).value = words;
area(root).dispatchEvent(new Event("input", {bubbles: true}));
const box = form(root).querySelector('.voice-note input[type="checkbox"]');
if (box) {
box.checked = attach;
}
const shownBefore = new Set(all("#toasts .toast"));
form(root).querySelector('button[type="submit"]').click();
return until(() => all("#toasts .toast").filter((node) => !shownBefore.has(node)).map(text).find((entry) => entry.startsWith("Post to")), 20000);
};
const spotSent = await sendFrom(spot, "Stage", "plain text from the spot", false);
const homeAttach = Boolean(form(homeSpeak).querySelector('.voice-note input[type="checkbox"]'));
const homeSent = await sendFrom(homeSpeak, "Docs", "voice from the Home tile", true);
await closeSpot();
document.getElementById("toasts").replaceChildren();
return {drafts, first, handed, spotHeard, homeBefore, homeHeard, notes, spotSent, homeAttach, homeSent, bodies: bodies.map((body) => [body.to, body.text, body.voice])};
})()"""
REPLY_HOME = """(async () => {@HELPERS@@PROBES@
const spotOpen = () => document.getElementById("radio-open").getAttribute("aria-expanded");
const reply = async (root) => {
const row = longRow(root);
row.scrollIntoView({block: "center"});
await sleep(200);
await openRow(row);
all(".radio-actions button", popup()).find((button) => text(button) === "Reply").click();
await sleep(300);
};
await reply(tile("radio-log"));
const fromLog = {spot: spotOpen(), popup: popup().open, speak: pick(tile("radio-speak")), whole: pick(tile("radio"))};
await reply(tile("radio"));
const fromWhole = {spot: spotOpen(), whole: pick(tile("radio"))};
const sendFrom = async (root, words) => {
const area = root.querySelector("form.composer textarea");
area.value = words;
area.dispatchEvent(new Event("input", {bubbles: true}));
const shownBefore = new Set(all("#toasts .toast"));
root.querySelector('form.composer button[type="submit"]').click();
return until(() => all("#toasts .toast").filter((node) => !shownBefore.has(node)).map(text).find((entry) => entry.startsWith("Post to")), 20000);
};
const sent = await sendFrom(tile("radio"), "reply from the Home radio");
const questions = [];
window.confirm = (question) => {
questions.push(question);
return true;
};
const clear = all(".spot-head button", tile("radio")).find((button) => button.getAttribute("aria-label") === "Cancel mayday");
const enabled = clear ? !clear.disabled : null;
const shownBefore = new Set(all("#toasts .toast"));
if (clear) {
clear.click();
}
const lifted = await until(() => all("#toasts .toast").filter((node) => !shownBefore.has(node)).map(text).find((entry) => entry.startsWith("Cancel mayday")), 15000);
document.getElementById("toasts").replaceChildren();
return {fromLog, fromWhole, sent, enabled, questions, lifted, spot: spotOpen()};
})()"""
def columns(width: int, height: int) -> bool:
return any(width >= low and height >= tall for low, tall in BANDS)
def probe(template: str) -> str:
return (template.replace("@HELPERS@", base.HELPERS).replace("@PROBES@", PROBES).replace("@LOADS@", LOADS).replace("@SPEAKING@", base.SPEAKING).replace("@PARTS@", json.dumps(PARTS))
.replace("@SIZES@", json.dumps(SIZES)).replace("@LIVE@", LIVE).replace("@SILENCE@", SILENCE).replace("@DUPS@", json.dumps(DUPS)).replace("@MAIN@", str(MAIN_SHARE)))
@unittest.skipUnless(shutil.which(os.environ.get("CHROMIUM", "chromium")), "no Chromium")
class TestRadioLayout(HubCase):
drive = base.TestOrchestratorE2E.drive
beside = base.TestOrchestratorE2E.beside
authenticator = base.TestOrchestratorE2E.authenticator
speaks = base.TestOrchestratorE2E.speaks
def setUp(self):
super().setUp()
OUT.mkdir(parents=True, exist_ok=True)
now = time.time()
self.claim("s1", "Skills session")
rows = [{"ts": now - 1200 + index * 30, "from": NAMES[index % len(NAMES)], "to": [], "text": f"status line {index}: build {index} green", "class": "newsletter", "v": 2} for index in range(FILLERS)]
self.call = now - 400
self.long = now - 300
rows += [
{"ts": self.call, "from": "Skills", "to": ["Stage", "Docs"], "text": "gate red on main", "class": "call", "v": 2},
{"ts": self.call + 5, "from": "Stage", "to": ["Skills"], "text": "gate red on main", "class": "receipt", "v": 2, "call": self.call},
{"ts": self.long, "from": "Stage", "to": [], "text": LONG, "class": "broadcast", "v": 2},
]
self.write_council({"news.jsonl": self.jsonl(rows)})
for sid in SESSIONS:
self.mark(sid, now - 100)
self.sessions()
self.beside(self.sessions)
self.httpd.hub.receipt_reads.times[("s5", self.long)] = self.long + 40
self.sight()
self.live = 0
hub = self.httpd.hub
heard = hub.voice_notes.get
def get(note_id: str) -> dict:
if note_id == SILENCE:
self.silence(NEW_ALARM)
return {"id": note_id, "status": "done", "text": "", "error": "", "seconds": None, "created_ts": None}
if note_id != LIVE:
return heard(note_id)
self.live += 1
row = {"ts": time.time(), "from": "Docs", "to": [], "text": f"live row {self.live} for Home", "class": "broadcast", "v": 2}
with (self.council / "news.jsonl").open("a", encoding="utf-8") as handle:
handle.write(self.jsonl([row]))
return {"id": note_id, "status": "done", "text": "", "error": "", "seconds": None, "created_ts": None}
patch = mock.patch.object(hub.voice_notes, "get", get)
patch.start()
self.addCleanup(patch.stop)
def sessions(self) -> None:
payload = {"written": time.time(), "sessions": {sid: {"name": name, "running": True} for sid, name in SESSIONS.items()}}
written = self.state / f".{SNAPSHOT}.e2e"
written.write_text(json.dumps(payload), encoding="utf-8")
os.replace(written, self.state / SNAPSHOT)
def sight(self) -> None:
hub = self.httpd.hub
receipts.sighting_pass(hub.scripts.skills, hub.council, hub.receipt_names, hub.receipt_reads, hub.agent_sessions, RADIO_WINDOW, time.time())
def mark(self, sid: str, ts: float) -> None:
folder = self.council / receipts.SEEN
folder.mkdir(parents=True, exist_ok=True)
written = folder / f".{sid}.e2e"
written.write_text(json.dumps({"radio": ts}), encoding="utf-8")
os.replace(written, folder / f"{sid}.json")
def steps(self, browser: str) -> list[dict]:
steps = []
for width, height in WIDTHS:
shot = str(OUT / f"{browser}-{width}")
steps += [
{"width": width, "height": height, "url": f"http://localhost:{self.port}/?{width}#stream", "wait": 1500, "probe": probe(LAYOUT), "shot": f"{shot}-radio.png"},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(POPUP), "shot": f"{shot}-popup.png", "gesture": True},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(CLOSE_REPLY), "shot": f"{shot}-reply.png"},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(HOME), "shot": f"{shot}-home.png"},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(FIT), "shot": f"{shot}-orbit.png"},
]
return steps
def check_layout(self, layout: dict, size: tuple[int, int], index: int, browser: str) -> None:
width = size[0]
self.assertNotIn("error", layout, layout)
self.assertLessEqual(layout["page"][0], layout["page"][1], layout)
if columns(*size):
self.assertLessEqual(layout["tall"][0], layout["tall"][1], layout)
self.assertEqual(layout["wider"], [], layout)
self.assertEqual(layout["scrollers"], ["radio-log"], layout)
self.assertEqual((layout["list"]["overflowY"], layout["list"]["scrollbar"][0], layout["list"]["scrolls"]), ("auto", "thin", True), layout)
self.assertNotIn(layout["list"]["scrollbar"][1], ("", "auto"), layout)
if browser == "firefox":
self.assertNotIn(layout["main"], ("", "auto"), layout)
self.assertEqual(len(layout["heights"]), 1, layout)
self.assertLess(layout["heights"][0], 2 * layout["lineHeight"], layout)
self.assertTrue(layout["single"], layout)
self.assertGreaterEqual(layout["narrowest"], 30, layout)
self.assertEqual(layout["rows"], FILLERS + 2 + index, layout)
self.assertEqual(layout["long"], [True, "ellipsis"], layout)
self.assertGreaterEqual(layout["avatars"].pop("rows"), 2, layout)
cap = 3 if width in NARROW else 8
self.assertEqual(layout["avatars"], {"most": cap, "inside": True, "after": True, "stacked": True}, layout)
self.assertEqual(layout["folds"], [[total, min(total, cap), [f"+{total - cap}"] if total > cap else []] for total, _, _ in layout["folds"]], layout)
self.assertGreaterEqual(layout["sliver"], 10, layout)
self.assertTrue(layout["order"]["stacked" if width == 390 else "beside"], layout)
self.assertEqual(layout["labels"], 1, layout)
self.assertEqual(layout["stars"], [[part, True] for part in PARTS], layout)
self.assertEqual(layout["covered"], [], layout)
self.assertEqual(layout["stations"], [True, False], layout)
def check_popup(self, popup: dict) -> None:
self.assertNotIn("error", popup, popup)
self.assertTrue(popup["open"], popup)
self.assertEqual(popup["title"], "Stage → all", popup)
self.assertEqual(list(popup["fields"]), ["Sender", "Recipient", "Class", "Time"], popup)
self.assertEqual((popup["fields"]["Sender"], popup["fields"]["Recipient"], popup["fields"]["Class"]), ("Stage", "all", "Broadcast"), popup)
self.assertTrue(popup["fields"]["Time"], popup)
self.assertEqual((popup["full"], popup["stray"]), (LONG, []), popup)
self.assertEqual(popup["heading"], f"Read by {len(popup['readers'])}", popup)
self.assertGreater(len(popup["readers"]), 8, popup)
self.assertLessEqual({reader["name"] for reader in popup["readers"]}, set(NAMES), popup)
timed = [reader for reader in popup["readers"] if reader["time"] != "read, time unknown"]
self.assertEqual([(reader["session"], reader["name"]) for reader in timed], [("s5", "Beacon")], popup)
self.assertRegex(timed[0]["time"], r"^read about \S.*\d", popup)
self.assertEqual(popup["buttons"], ["Reply", "Copied"], popup)
self.assertEqual((popup["copied"], popup["shown"]), ([LONG], "Copied"), popup)
self.assertEqual(popup["region"], ["status", "polite", True, True], popup)
self.assertEqual(popup["success"], ["Copied", "Copied: the full message is on the clipboard"], popup)
self.assertEqual(popup["reset"], ["Copy", ""], popup)
self.assertEqual(popup["failure"], ["Not copied", "Not copied: the browser refused the clipboard"], popup)
self.assertTrue(popup["inView"], popup)
def check_home(self, home: dict, width: int) -> None:
self.assertEqual(home["pressed"], {part: "true" for part in PARTS}, home)
self.assertEqual(home["stored"], [[f"panel:{part}", *DEFAULTS[part]] for part in PARTS], home)
for moment in ("fresh", "resized"):
for part in PARTS:
with self.subTest(moment=moment, tile=part):
found = home[moment][part]
stacked = width == 390 and part == "radio"
expected = ["home-body"] if stacked else [SCROLLER[part]] if SCROLLER[part] else []
self.assertEqual(found["scrollers"], expected, home[moment])
if found["rows"] is not None and not stacked:
self.assertGreaterEqual(found["rows"], 2, home[moment])
self.assertTrue(found["inside"], home[moment])
self.assertTrue(found["filled"], home[moment])
self.assertEqual(home["tools"]["gear"], ["true", True, True], home)
self.assertEqual(home["tools"]["clear"], [True, "Cancel mayday: lift the radio silence so the agents write again; your passkey signs it"], home)
content = home["content"]
self.assertEqual(content["tiles"], [f"panel:{part}" for part in PARTS], home)
self.assertEqual(content["radio"], [True, True, True], home)
self.assertEqual(content["device"], ["Auto", 6], home)
self.assertEqual(content["speak"], [True, True], home)
self.assertEqual(content["log"][0], content["log"][2], home)
self.assertEqual(content["log"][1], content["log"][2], home)
self.assertEqual((content["gone"], content["stars"], content["ids"]), (0, 0, []), home)
self.assertIsNotNone(home["live"], home)
self.assertEqual(home["live"][0], home["live"][1], home)
self.assertEqual(home["mode"], ["Quiet", "Quiet"], home)
self.assertFalse(home["wide"], home)
def check_fit(self, fit: dict, size: tuple[int, int]) -> None:
self.assertTrue(fit["fit"], fit)
self.assertFalse(fit["wide"], fit)
self.assertTrue(fit["speak"], fit)
self.assertEqual((fit["closed"]["boxes"], fit["closed"]["tall"]), (0, False), fit)
self.assertGreaterEqual(fit["closed"]["stage"], 2 * STAGE_SHARE * fit["height"], fit)
self.assertEqual(fit["scrollers"], ["radio-log"], fit)
if not columns(*size):
self.assertTrue(fit["tall"], fit)
self.assertGreaterEqual(fit["stage"], 2 * STAGE_SHARE * fit["height"], fit)
else:
self.assertGreater(fit["closed"]["stage"], fit["stage"], fit)
self.assertFalse(fit["tall"], fit)
self.assertGreaterEqual(fit["stage"], STAGE_SHARE * fit["height"], fit)
self.assertGreaterEqual(fit["list"], 60, fit)
def silence(self, words: str) -> None:
now = time.time()
self.write_council({"radio-silence.json": {"since": now - 60, "until": now + 3600, "by": "Docs", "text": words}})
def stations(self) -> None:
hub = self.httpd.hub
hub.settings.put({**hub.settings.get(), "streams": STREAMS}, hub.settings.get())
def laptop_steps(self, browser: str, states: list[str]) -> list[dict]:
places = [(width, height, view) for width, height in LAPTOPS for view in VIEWS]
return [{"width": width, "height": height, "url": f"http://localhost:{self.port}/?{width}x{height}-{states[-1]}#stream" if view == VIEWS[0] else None, "wait": 1500 if view == VIEWS[0] else 0, "gesture": True,
"probe": probe(SPOT.replace("@VIEW@", view).replace("@STATES@", json.dumps(states)).replace("@CUE@", f"layout-cue-{index}")),
"shot": str(OUT / f"{browser}-{width}x{height}-{view[1:].replace('/', '-')}-{states[-1]}.png")} for index, (width, height, view) in enumerate(places)]
def laptops(self, browser: str, *driver: str) -> dict:
self.stations()
self.speaks(tuple(f"layout-cue-{index}" for index in range(len(LAPTOPS) * len(VIEWS))))
runs = [self.drive(self.laptop_steps(browser, [state for state in STATES if state not in ALARMS]), None, *driver)]
for state, words in ALARMS.items():
self.silence(words)
runs.append(self.drive(self.laptop_steps(browser, [state]), None, *driver))
return {"results": [{key: value for part in parts for key, value in part.items()} for parts in zip(*(run["results"] for run in runs), strict=True)], "errors": [error for run in runs for error in run["errors"]]}
def check_laptops(self, data: dict, browser: str) -> None:
results = iter(data["results"])
for width, height in LAPTOPS:
for view in VIEWS:
states = next(results)
for state in STATES:
with self.subTest(browser=browser, size=f"{width}x{height}", view=view, state=state):
self.check_state(states[state], state, view)
self.check_side(states[state], width, height)
def check_side(self, found: dict, width: int, height: int) -> None:
self.assertGreaterEqual(found["main"], found["floor"], found)
self.assertLessEqual(found["page"][0], found["page"][2], found)
self.assertLessEqual(found["stack"]["head"], found["stack"]["chips"][0] + 1, found)
self.assertLessEqual(found["stack"]["chips"][1], found["stack"]["list"] + 1, found)
if columns(width, height):
self.assertLessEqual(found["page"][1], found["page"][3], found)
self.assertEqual(found["scrollers"], ["radio-log"], found)
self.assertTrue(found["order"], found)
if found["fit"]:
self.assertGreaterEqual(found["stage"], STAGE_SHARE * height, found)
return
self.assertGreaterEqual(found["main"], found["full"] - 1, found)
self.assertTrue(found["beneath"], found)
if found["fit"]:
self.assertGreaterEqual(found["stage"], 2 * STAGE_SHARE * height, found)
def check_state(self, found: dict, state: str, view: str) -> None:
self.assertEqual(found["active"], {"stations": 3 if state == "stations" else 0, "voice": state == "voice", "speech": state == "speech"}, found)
self.assertEqual(found["banner"] is not None, state in ALARMS, found)
if state in ALARMS:
self.assertLessEqual(found["banner"]["height"], BANNER_MAX, found)
self.assertEqual((found["banner"]["title"], found["banner"]["cut"], found["banner"]["cancel"]), (found["banner"]["full"], state == "mayday-long", True), found)
self.assertTrue(found["banner"]["full"].endswith(ALARMS[state]), found)
self.assertEqual(found["blocked"], [], found)
if state == "stations":
self.assertEqual(found["closed"], [False, True], found)
if state == "voice":
self.assertTrue(found["heard"], found)
self.assertEqual(len(found["play"]), 1, found)
kind, width, tall = found["play"][0]
self.assertGreaterEqual(width, PLAY_MIN[kind][0], found)
self.assertGreaterEqual(tall, PLAY_MIN[kind][1], found)
if kind == "BUTTON":
self.assertEqual((found["played"], found["paused"]), (True, True), found)
if state == "speech":
self.assertEqual(found["who"], "Stage speaking", found)
self.assertGreaterEqual(found["line"][0], 4 * found["rem"], found)
self.assertGreater(found["line"][1], 0, found)
self.assertEqual(found["fit"], view != "#stream", found)
self.assertEqual(found["cards"], [True, True], found)
self.assertGreaterEqual(found["list"], 60, found)
self.assertGreaterEqual(found["rows"], 2, found)
def popover_steps(self, browser: str) -> list[dict]:
self.stations()
tiles = json.dumps([f'#main .home-tile[data-pin="panel:{part}"]' for part in ("radio-device", "radio")])
places = (("spot", "#stream", "[]", '["#radio-spot"]', "true"), ("home", "#home", json.dumps(HOME_RADIO), tiles, "false"), ("home-spot", "#home", json.dumps(HOME_RADIO), tiles, "true"))
return [{"width": width, "height": height, "url": f"http://localhost:{self.port}/?{width}-pop#stream" if name == "spot" else None, "wait": 1500 if name == "spot" else 0,
"probe": probe(POP.replace("@VIEW@", view).replace("@PINS@", pins).replace("@ROOTS@", roots).replace("@SPOT@", spot)), "shot": str(OUT / f"{browser}-{width}-pop-{name}.png")}
for width, height in POPOVER_SIZES for name, view, pins, roots, spot in places]
def check_popover(self, data: dict, browser: str) -> None:
results = iter(data["results"])
for width, _ in POPOVER_SIZES:
for place in ("spot", "home", "home-spot"):
found = next(results)
self.assertEqual(len(found), 1 if place == "spot" else 2, found)
for fold in found:
with self.subTest(browser=browser, width=width, place=place, root=fold["selector"]):
self.assertNotIn("error", fold, fold)
self.assertEqual((fold["opened"]["open"], fold["opened"]["outside"]), (True, []), fold)
self.assertGreaterEqual(fold["opened"]["whole"], 1, fold)
self.assertEqual(fold["escape"], [False, True], fold)
self.assertEqual(fold["again"], {"open": True, "outside": []}, fold)
self.assertEqual(fold["click"], [False, False, True], fold)
def focus_steps(self, browser: str) -> list[dict]:
self.stations()
return [{"width": width, "height": height, "url": f"http://localhost:{self.port}/?{width}-focus#stream", "wait": 1500, "probe": probe(FOCUS), "shot": str(OUT / f"{browser}-{width}-focus.png")}
for width, height in FOCUS_SIZES]
def check_focus(self, data: dict, browser: str) -> None:
for (width, _), cases in zip(FOCUS_SIZES, data["results"], strict=True):
for key, found in cases.items():
with self.subTest(browser=browser, width=width, case=key):
if key == "escape":
self.assertEqual(found, {"closed": True, "toggle": True}, found)
continue
self.assertEqual((found["opened"], found["closed"], found["summary"]), (True, True, False), found)
self.assertTrue(found["history"] if key.endswith("tab") else found["body"], found)
def watch(self, browser: str, kind: str, template: str) -> dict:
width, height = FOCUS_SIZES[0]
step = {"width": width, "height": height, "url": f"http://localhost:{self.port}/?{width}-{kind}#stream", "wait": 1500, "probe": probe(template), "shot": str(OUT / f"{browser}-{width}-{kind}.png")}
driver = ("bidi.mjs", os.environ.get("FIREFOX", "firefox")) if browser == "firefox" else ()
data = self.drive([step], None, *driver)
(OUT / f"{browser}-radio-{kind}.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], [])
return data["results"][0]
def check_rows(self, found: dict, browser: str) -> None:
want = {"same": True, "key": found["start"].pop("want"), "pick": True, "body": False}
for moment, done in (("start", None), ("fresh", "delivered"), ("tick", "ticked")):
with self.subTest(browser=browser, moment=moment):
if done:
self.assertTrue(found[moment].pop(done), found)
self.assertEqual(found[moment], want, found)
with self.subTest(browser=browser, moment="tabs"):
self.assertIsNotNone(found["tabs"].pop("tab"), found)
self.assertEqual(found["tabs"], {"delivered": [True, True, True], "focusins": 0, "same": True}, found)
def twins(self) -> None:
now = time.time()
with (self.council / "news.jsonl").open("a", encoding="utf-8") as handle:
handle.write(self.jsonl([{"ts": now - 50, "from": "Docs", "to": [], "text": words, "class": "broadcast", "v": 2} for words in DUPS]))
def check_keys(self, found: dict, browser: str) -> None:
with self.subTest(browser=browser, case="keys"):
self.assertEqual(len(set(found["keys"])), len(DUPS), found)
for words in DUPS:
with self.subTest(browser=browser, case=words):
self.assertEqual(found[words], {"delivered": True, "same": True, "line": words, "popup": words}, found)
with self.subTest(browser=browser, case="filtered"):
self.assertEqual(found["filtered"], {"gone": True, "pick": True, "class": "call"}, found)
with self.subTest(browser=browser, case="emptied"):
self.assertEqual(found["emptied"], {"gone": True, "list": True}, found)
def check_banner(self, found: dict, browser: str) -> None:
with self.subTest(browser=browser, moment="steady"):
self.assertEqual(found["steady"], {"polled": True, "mutations": 0, "focus": True, "body": False}, found)
with self.subTest(browser=browser, moment="changed"):
self.assertTrue(found["changed"].pop("text").endswith(NEW_ALARM), found)
self.assertEqual(found["changed"], {"polled": True, "added": 1, "shown": True, "cancel": True}, found)
def check(self, data: dict, browser: str) -> None:
results = iter(data["results"])
for index, (width, height) in enumerate(WIDTHS):
layout, popup, closing, home, fit = (next(results) for _ in range(5))
with self.subTest(browser=browser, width=width, part="layout"):
self.check_layout(layout, (width, height), index, browser)
with self.subTest(browser=browser, width=width, part="popup"):
self.check_popup(popup)
with self.subTest(browser=browser, width=width, part="close and reply"):
self.assertTrue(closing["escaped"], closing)
self.assertEqual(closing["outside"], [True, True], closing)
self.assertEqual(closing["reply"], {"open": False, "channel": "post", "recipient": "Stage", "toShown": True, "focused": True}, closing)
with self.subTest(browser=browser, width=width, part="home"):
self.check_home(home, width)
with self.subTest(browser=browser, width=width, part="fit view"):
self.check_fit(fit, (width, height))
def test_chromium_lays_the_radio_out_without_overflow_one_line_rows_popup_and_four_home_stars_at_four_widths(self):
data = self.drive(self.steps("chromium"), None)
(OUT / "chromium-radio-layout.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_lays_the_radio_out_without_overflow_one_line_rows_popup_and_four_home_stars_at_four_widths(self):
data = self.drive(self.steps("firefox"), None, "bidi.mjs", os.environ.get("FIREFOX", "firefox"))
(OUT / "firefox-radio-layout.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")
def test_chromium_leaves_the_focus_where_a_click_lands_and_returns_it_to_the_toggle_only_on_escape(self):
data = self.drive(self.focus_steps("chromium"), None)
(OUT / "chromium-radio-focus.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
self.assertEqual(data["errors"], [])
self.check_focus(data, "chromium")
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
def test_firefox_leaves_the_focus_where_a_click_lands_and_returns_it_to_the_toggle_only_on_escape(self):
data = self.drive(self.focus_steps("firefox"), None, "bidi.mjs", os.environ.get("FIREFOX", "firefox"))
(OUT / "firefox-radio-focus.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_focus(data, "firefox")
def test_chromium_holds_the_focus_on_a_history_row_and_its_tab_across_new_rows_and_the_minute_tick(self):
self.check_rows(self.watch("chromium", "rows", ROWS), "chromium")
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
def test_firefox_holds_the_focus_on_a_history_row_and_its_tab_across_new_rows_and_the_minute_tick(self):
self.check_rows(self.watch("firefox", "rows", ROWS), "firefox")
def test_chromium_keys_twin_rows_apart_and_moves_the_focus_of_a_filtered_out_row_to_the_nearest_row_or_the_list(self):
self.twins()
self.check_keys(self.watch("chromium", "keys", KEYS), "chromium")
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
def test_firefox_keys_twin_rows_apart_and_moves_the_focus_of_a_filtered_out_row_to_the_nearest_row_or_the_list(self):
self.twins()
self.check_keys(self.watch("firefox", "keys", KEYS), "firefox")
def test_chromium_redraws_the_mayday_banner_only_when_the_silence_changes(self):
self.silence(ALARMS["mayday"])
self.check_banner(self.watch("chromium", "banner", BANNER), "chromium")
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
def test_firefox_redraws_the_mayday_banner_only_when_the_silence_changes(self):
self.silence(ALARMS["mayday"])
self.check_banner(self.watch("firefox", "banner", BANNER), "firefox")
def test_chromium_keeps_the_main_floor_and_reachable_radio_controls_in_six_states_on_both_sides_of_the_height_threshold(self):
data = self.laptops("chromium")
(OUT / "chromium-radio-laptops.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
self.assertEqual(data["errors"], [])
self.check_laptops(data, "chromium")
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
def test_firefox_keeps_the_main_floor_and_reachable_radio_controls_in_six_states_on_both_sides_of_the_height_threshold(self):
data = self.laptops("firefox", "bidi.mjs", os.environ.get("FIREFOX", "firefox"))
(OUT / "firefox-radio-laptops.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_laptops(data, "firefox")
def test_chromium_places_the_station_popover_inside_every_clip_and_closes_it_on_escape_and_outside_clicks_in_the_spot_and_on_home(self):
data = self.drive(self.popover_steps("chromium"), None)
(OUT / "chromium-radio-popover.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
self.assertEqual(data["errors"], [])
self.check_popover(data, "chromium")
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
def test_firefox_places_the_station_popover_inside_every_clip_and_closes_it_on_escape_and_outside_clicks_in_the_spot_and_on_home(self):
data = self.drive(self.popover_steps("firefox"), None, "bidi.mjs", os.environ.get("FIREFOX", "firefox"))
(OUT / "firefox-radio-popover.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_popover(data, "firefox")
def test_chromium_home_copies_keep_their_own_composer_record_reply_and_cancel_the_mayday(self):
now = time.time()
self.write_council({"radio-silence.json": {"since": now - 60, "until": now + 3600, "by": "Docs", "text": "disk full"}})
steps = []
for width, height in ((1366, 768), (390, 844)):
shot = str(OUT / f"chromium-{width}")
steps += [
{"width": width, "height": height, "url": f"http://localhost:{self.port}/?{width}-copies#stream", "wait": 1500, "probe": probe(COMPOSE_HOME), "shot": f"{shot}-home-composers.png", "gesture": True},
{"width": width, "height": height, "url": None, "wait": 0, "probe": probe(REPLY_HOME), "shot": f"{shot}-home-reply.png"},
]
data = self.drive(steps, self.authenticator())
(OUT / "chromium-radio-home-copies.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
self.assertEqual(data["errors"], [])
results = iter(data["results"])
question = "Lift the radio silence of the active mayday?"
for width in (1366, 390):
composed, replied = next(results), next(results)
with self.subTest(width=width, part="own composer state"):
self.assertEqual(composed["drafts"], ["draft kept in the spot", "", ""], composed)
self.assertEqual((composed["first"], composed["handed"]), ("true", ["false", "true"]), composed)
self.assertIn("hello from the mic", composed["spotHeard"] or "", composed)
self.assertNotIn("hello from the mic", composed["homeBefore"], composed)
self.assertIn("hello from the mic", composed["homeHeard"] or "", composed)
self.assertTrue(all(composed["notes"]) and composed["notes"][0] != composed["notes"][1], composed)
self.assertTrue((composed["spotSent"] or "").startswith("Post to Stage: sent"), composed)
self.assertTrue(composed["homeAttach"], composed)
self.assertTrue((composed["homeSent"] or "").startswith("Post to Docs: sent"), composed)
self.assertEqual(composed["bodies"], [["Stage", "plain text from the spot", ""], ["Docs", "voice from the Home tile", composed["notes"][1]]], composed)
with self.subTest(width=width, part="reply and mayday from Home"):
self.assertEqual(replied["fromLog"], {"spot": "false", "popup": False, "speak": {"channel": "post", "recipient": "Stage", "toShown": True, "focused": True},
"whole": {"channel": "post", "recipient": replied["fromLog"]["whole"]["recipient"], "toShown": True, "focused": False}}, replied)
self.assertEqual(replied["fromWhole"], {"spot": "false", "whole": {"channel": "post", "recipient": "Stage", "toShown": True, "focused": True}}, replied)
self.assertTrue((replied["sent"] or "").startswith("Post to Stage: sent"), replied)
self.assertEqual((replied["enabled"], replied["questions"]), (True, [question]), replied)
self.assertTrue((replied["lifted"] or "").startswith("Cancel mayday: done"), replied)
self.assertEqual(replied["spot"], "false", replied)
radio = [args for script, args in self.scripts.calls if script == skill_scripts.RADIO]
self.assertEqual([args[:3] for args in radio if args[0] == "post"], [["post", "--to", "Stage"], ["post", "--to", "Docs"], ["post", "--to", "Stage"]] * 2, radio)
self.assertEqual([args for args in radio if args[0] == "clear"], [["clear", "--force", "--session", "Operator"]] * 2, radio)
if __name__ == "__main__":
unittest.main()