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).filter((id) => !id.startsWith("mic-field-")), }; 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") && !button.classList.contains("mic")); 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") && !button.classList.contains("mic")); 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()