Operator pick 2026-11-14: every tests/e2e file at most 500 lines, so Quality's line limit and medusa's per-file scanner timeout hold. test_orchestrator_e2e.py (3032 lines), test_radio_layout_e2e.py (1258) and test_radio_set_e2e.py (504) become shared helper modules (hub_e2e_kit, hub_e2e_views, hub_e2e_radio, hub_e2e_board, hub_e2e_inbox, hub_e2e_plan, radio_layout_kit, radio_layout_probes, radio_layout_focus_probes, radio_set_kit) and topic test modules (test_hub_radio_e2e, test_hub_board_e2e, test_hub_inbox_e2e, test_hub_plan_e2e, test_radio_focus_e2e); the longest file is now 485 lines. All 98 e2e test methods keep their names and bodies (AST multiset compared before and after); 40 of the 55 moved tests change module or class, so their ids change. The 21 importers and requirement 004 follow. Security acceptances (kvb-think-criticize with an independent skeptic, moved unchanged code): MEDUSA-INF-SCAN-1475, -1616, -2330, -2844, -2970, -3199 radio_layout_kit.py 19 (fixture agent name Beacon); 19 MEDUSA-INF-SCAN rules hub_e2e_kit.py 208 (mkstemp-backed NamedTemporaryFile); B603 hub_e2e_kit.py 211 (list argv, no shell, the repo's own node drivers). 🎯 Fix: 88 % 💥 Break: 4 % 💸 Tokens: – ⏱️ Velocity: – 🛡️ Security: ~100 % 🏆 Score: 84 🚦 Gate: ⛔ fix 88 % < 90 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
372 lines
25 KiB
Python
372 lines
25 KiB
Python
from __future__ import annotations
|
|
|
|
import http.server
|
|
import json
|
|
import os
|
|
import shutil
|
|
import ssl
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import threading
|
|
import time
|
|
import unittest
|
|
from pathlib import Path
|
|
from urllib.parse import urlsplit
|
|
|
|
HERE = Path(__file__).resolve().parent
|
|
sys.path[:0] = [str(HERE.parent), str(HERE)]
|
|
|
|
import hub_e2e_kit as base
|
|
from hub_e2e_kit import CHOICE_CHANNELS, OUT, WIDTHS, tone
|
|
from hub_e2e_radio import (
|
|
ADD_STATION,
|
|
CALL,
|
|
CANCELED,
|
|
CLEAR_MAYDAY,
|
|
COMPOSE,
|
|
COMPOSE_SEND,
|
|
DLF_NODE,
|
|
DLF_PATH,
|
|
GEAR_READ,
|
|
GEAR_SAVE,
|
|
JUMPED,
|
|
MEDIA_LOG,
|
|
RADIO_CLICK,
|
|
RADIO_JUMP,
|
|
RADIO_STOP,
|
|
RADIO_VIEW,
|
|
SPEAK,
|
|
SPEAK_END,
|
|
SPEAK_GRAPH,
|
|
SPOT_SEND,
|
|
STATION_NAME,
|
|
Station,
|
|
)
|
|
from hub_support import HOST_STATE
|
|
from kvb_orchestrator import skill_scripts
|
|
|
|
|
|
@unittest.skipUnless(shutil.which(os.environ.get("CHROMIUM", "chromium")), "no Chromium")
|
|
class TestHubRadio(base.OrchestratorE2ECase):
|
|
def station(self, tls: ssl.SSLContext | None = None, moved: str | None = None) -> str:
|
|
"""Args:
|
|
tls: serves https with this context instead of plain http.
|
|
moved: answers every request with a 302 to this URL instead of
|
|
the tone.
|
|
"""
|
|
httpd = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Station)
|
|
httpd.body, httpd.moved = tone(30, 22050), moved
|
|
if tls:
|
|
httpd.socket = tls.wrap_socket(httpd.socket, server_side=True)
|
|
thread = threading.Thread(target=httpd.serve_forever, args=(0.05,), daemon=True)
|
|
thread.start()
|
|
self.addCleanup(httpd.server_close)
|
|
self.addCleanup(thread.join, 10)
|
|
self.addCleanup(httpd.shutdown)
|
|
return f"{'https' if tls else 'http'}://127.0.0.1:{httpd.server_address[1]}{DLF_PATH if moved else '/tone.wav'}"
|
|
|
|
def redirected(self) -> tuple[str, list[str]]:
|
|
"""Returns:
|
|
A station that replays the recorded Deutschlandfunk chain, a 302
|
|
from st01.sslstream.dlf.de to an f111.rndfnk.com node, as a 302 to
|
|
a second https origin, and that origin as its released via.
|
|
"""
|
|
folder = Path(tempfile.mkdtemp())
|
|
self.addCleanup(shutil.rmtree, folder)
|
|
key, cert = folder / "key.pem", folder / "cert.pem"
|
|
subprocess.run([
|
|
"openssl", "req", "-x509", "-newkey", "ec", "-pkeyopt", "ec_paramgen_curve:P-256", "-nodes", "-subj", "/CN=127.0.0.1",
|
|
"-addext", "subjectAltName=IP:127.0.0.1", "-days", "1", "-keyout", str(key), "-out", str(cert),
|
|
], capture_output=True, timeout=60, check=True)
|
|
tls = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
|
|
tls.load_cert_chain(cert, key)
|
|
node = urlsplit(self.station(tls))
|
|
origin = f"https://{node.netloc}"
|
|
return self.station(tls, f"{origin}{DLF_NODE}"), [origin]
|
|
|
|
def check_radio(self, browser: str, driver: str, binary: str, redirected: bool = False) -> dict:
|
|
"""Args:
|
|
driver: cdp.mjs saves the station through the settings form and
|
|
signs its new origin with a virtual passkey; bidi.mjs has no
|
|
virtual authenticator, so the station is saved before the page
|
|
loads.
|
|
redirected: plays the recorded Deutschlandfunk redirect chain,
|
|
saved before the page loads with its resolved via.
|
|
"""
|
|
station, via = self.redirected() if redirected else (self.station(), [])
|
|
browser = f"{browser}-dlf" if redirected else browser
|
|
signs = driver == "cdp.mjs" and not redirected
|
|
if signs:
|
|
first = {"width": 1366, "height": 768, "url": f"http://localhost:{self.port}/#stream", "wait": 900, "probe": ADD_STATION.replace("@STATION@", station).replace("@NAME@", STATION_NAME), "shot": None, "gesture": True}
|
|
else:
|
|
hub = self.httpd.hub
|
|
hub.settings.put({**hub.settings.get(), "streams": [{"name": STATION_NAME, "url": station, "from": "00:00", "to": "24:00", "days": list(range(7)), "on": True, "via": via}]}, hub.settings.get())
|
|
first = {"width": 1366, "height": 768, "url": f"{self.base}#stream", "wait": 900, "probe": None, "shot": None}
|
|
steps = [
|
|
first,
|
|
{"width": 390, "height": 844, "url": None, "wait": 3000, "probe": RADIO_VIEW, "shot": str(OUT / f"{browser}-390-radio-station.png")},
|
|
{"width": 1366, "height": 768, "url": None, "wait": 0, "probe": RADIO_CLICK, "shot": str(OUT / f"{browser}-1366-radio-playing.png"), "gesture": True},
|
|
{"width": 1366, "height": 768, "url": None, "wait": 0, "probe": RADIO_STOP, "shot": str(OUT / f"{browser}-1366-radio-stopped.png")},
|
|
]
|
|
data = self.drive(steps, self.authenticator() if signs else None, driver, binary, MEDIA_LOG)
|
|
(OUT / f"{browser}-radio.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
|
|
saved, view, click, stopped = data["results"]
|
|
if signs:
|
|
self.assertTrue(any(toast.startswith("New station") for toast in saved["toasts"]), saved)
|
|
self.assertNotIn("error", view)
|
|
self.assertEqual(view["title"], STATION_NAME)
|
|
self.assertEqual(view["line"], ["nowrap", "ellipsis", True, True])
|
|
blocked = [entry for entry in view["log"] if entry.get("play") == "NotAllowedError"]
|
|
if not view["media"]["playing"]:
|
|
self.assertTrue(blocked, view)
|
|
self.assertEqual(view["state"], "blocked", view)
|
|
self.assertIn("Click", view["note"])
|
|
self.assertTrue(any("blocked" in toast for toast in view["toasts"]), view["toasts"])
|
|
self.assertTrue(click["clicked"], click)
|
|
self.assertNotIn("error", click)
|
|
self.assertTrue(click["media"]["playing"], click)
|
|
self.assertEqual(click["state"], "playing", click)
|
|
self.assertEqual([entry for entry in click["log"] if entry.get("csp") == "media-src"], [])
|
|
with self.subTest(browser=browser, part="station stop"):
|
|
self.assertNotIn("error", stopped, stopped)
|
|
self.assertEqual(stopped["button"], ["Stop", f"Stop: pause {STATION_NAME}", "", True])
|
|
self.assertTrue(stopped["paused"], stopped)
|
|
self.assertFalse(stopped["media"]["playing"], stopped)
|
|
self.assertEqual((stopped["media"]["second"]["paused"], stopped["media"]["second"]["src"]), (True, None), stopped)
|
|
self.assertEqual((stopped["state"], stopped["note"], stopped["action"]), ("stopped", "stopped", ["play", "Play"]), stopped)
|
|
self.assertGreater(stopped["tracked"], 0, stopped)
|
|
self.assertEqual(stopped["playing"], [], "an audio element still plays after Stop")
|
|
return data
|
|
|
|
def test_chromium_plays_a_saved_station(self):
|
|
self.check_radio("chromium", "cdp.mjs", os.environ.get("CHROMIUM", "chromium"))
|
|
|
|
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
|
|
def test_firefox_plays_a_saved_station(self):
|
|
self.check_radio("firefox", "bidi.mjs", os.environ.get("FIREFOX", "firefox"))
|
|
|
|
def test_chromium_plays_deutschlandfunk_through_its_redirect(self):
|
|
self.check_radio("chromium", "cdp.mjs", os.environ.get("CHROMIUM", "chromium"), redirected=True)
|
|
|
|
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
|
|
def test_firefox_plays_deutschlandfunk_through_its_redirect(self):
|
|
self.check_radio("firefox", "bidi.mjs", os.environ.get("FIREFOX", "firefox"), redirected=True)
|
|
|
|
def test_chromium_sends_a_call_from_the_agent_panel_and_shows_its_receipt(self):
|
|
handled = []
|
|
|
|
def answer() -> None:
|
|
for script, args in self.scripts.calls[len(handled) :]:
|
|
handled.append(script)
|
|
if script.endswith("radio.py") and args[:2] == ["send", "call"]:
|
|
to, text, now = args[args.index("--to") + 1], args[-1], time.time()
|
|
rows = [{"ts": now, "from": "Operator", "to": [to], "text": text, "class": "call", "v": 2}, {"ts": now + 0.5, "from": to, "to": ["Operator"], "text": text, "class": "receipt", "v": 2, "call": now}]
|
|
self.write_council({"radio-seen/e2e-callee.json": {"radio": now + 0.5}})
|
|
(self.state / "agent-sessions.json").write_text(json.dumps({"written": now, "sessions": {"e2e-callee": {"name": to, "running": True}}}), encoding="utf-8")
|
|
with (self.council / "news.jsonl").open("a", encoding="utf-8") as handle:
|
|
handle.write(self.jsonl(rows))
|
|
|
|
self.beside(answer)
|
|
local = f"http://localhost:{self.port}/"
|
|
data = self.drive([{"width": 1366, "height": 768, "url": f"{local}#stream", "wait": 900, "probe": CALL, "shot": self.shot("1366-call-receipt")}], self.authenticator())
|
|
self.assertEqual(data["errors"], [])
|
|
result = data["results"][0]
|
|
self.assertNotIn("error", result)
|
|
self.assertIsNotNone(result["receipt"], result)
|
|
self.assertTrue(" · read " in result["receipt"] and result["receipt"].endswith(" · acknowledged"), result)
|
|
self.assertEqual(result["read"], 0, result)
|
|
|
|
def test_chromium_shows_who_speaks_while_a_message_is_read(self):
|
|
self.speaks(("e2e-cue-1", "e2e-cue-2"))
|
|
steps = [
|
|
{"width": 1366, "height": 768, "url": f"{self.base}#stream/radio", "wait": 900, "probe": SPEAK.replace("@CUE@", "e2e-cue-1"), "shot": self.shot("1366-radio-speaking"), "gesture": True},
|
|
{"width": 1366, "height": 768, "url": None, "wait": 0, "probe": SPEAK_GRAPH, "shot": self.shot("1366-agents-speaking")},
|
|
{"width": 1366, "height": 768, "url": None, "wait": 0, "probe": SPEAK_END, "shot": None},
|
|
{"width": 390, "height": 844, "url": None, "wait": 0, "probe": SPEAK.replace("@CUE@", "e2e-cue-2"), "shot": self.shot("390-radio-speaking-reduced-motion"), "gesture": True, "media": [{"name": "prefers-reduced-motion", "value": "reduce"}]},
|
|
]
|
|
data = self.drive(steps, None)
|
|
(OUT / "chromium-speaking.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
|
|
self.assertEqual(data["errors"], [])
|
|
speaking, graph, ended, calm = data["results"]
|
|
self.talks(speaking, graph)
|
|
self.assertEqual(ended, {"ended": True, "caption": False, "faces": 0})
|
|
self.assertEqual((calm["who"], calm["line"], calm["ring"]), ("Stage speaking", "Disk almost full (e2e-cue-2)", "none"), calm)
|
|
self.assertEqual(calm["faces"]["speaking"], [True, "none"], calm)
|
|
|
|
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
|
|
def test_firefox_shows_who_speaks_and_moves_only_the_speakers_mouth(self):
|
|
self.speaks(("e2e-cue-1",))
|
|
steps = [
|
|
{"width": 1366, "height": 768, "url": f"{self.base}#stream/radio", "wait": 900, "probe": SPEAK.replace("@CUE@", "e2e-cue-1"), "shot": str(OUT / "firefox-1366-radio-speaking.png"), "gesture": True},
|
|
{"width": 1366, "height": 768, "url": None, "wait": 0, "probe": SPEAK_GRAPH, "shot": str(OUT / "firefox-1366-agents-speaking.png")},
|
|
]
|
|
data = self.drive(steps, None, "bidi.mjs", os.environ.get("FIREFOX", "firefox"))
|
|
(OUT / "firefox-speaking.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.talks(*data["results"])
|
|
|
|
def talks(self, speaking: dict, graph: dict) -> None:
|
|
"""Args:
|
|
speaking: the SPEAK probe while Stage (s2) is read aloud.
|
|
graph: the SPEAK_GRAPH probe on #agents/orbit right after it.
|
|
"""
|
|
self.assertEqual((speaking["who"], speaking["line"], speaking["chip"], speaking["ring"]), ("Stage speaking", "Disk almost full (e2e-cue-1)", "s2", "speaking"), speaking)
|
|
self.assertEqual(speaking["faces"], {"speaking": [True, "talk"], "silent": [False, "none"], "keys": ["s2"]}, speaking)
|
|
self.assertEqual((graph["node"] or "").split(",")[0], "Stage", graph)
|
|
self.assertEqual((graph["ring"], graph["mouth"], graph["silent"]), ("speaking-node", "talk", "none"), graph)
|
|
|
|
def test_chromium_records_transcribes_and_sends_a_signed_call_with_voice(self):
|
|
local = f"http://localhost:{self.port}/"
|
|
steps = [
|
|
{"width": 1366, "height": 768, "url": f"{local}#agents/orbit", "wait": 1200, "probe": COMPOSE.replace("@TO@", "Stage"), "shot": self.shot("1366-radio-spot-composer"), "gesture": True},
|
|
{"width": 1366, "height": 768, "url": None, "wait": 0, "probe": COMPOSE_SEND.replace("@ATTACH@", "false"), "shot": None},
|
|
{"width": 1366, "height": 768, "url": None, "wait": 0, "probe": COMPOSE.replace("@TO@", "Stage"), "shot": None, "gesture": True},
|
|
{"width": 1366, "height": 768, "url": None, "wait": 0, "probe": COMPOSE_SEND.replace("@ATTACH@", "true"), "shot": self.shot("1366-radio-spot-composer-sent")},
|
|
]
|
|
data = self.drive(steps, self.authenticator())
|
|
(OUT / "chromium-composer.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
|
|
self.assertEqual(data["errors"], [])
|
|
composed, plain, again, sent = data["results"]
|
|
self.assertNotIn("error", composed)
|
|
self.assertEqual(composed["channels"], ["post", "call", "newsletter", "broadcast", "pan-pan", "security", "mayday"])
|
|
self.assertIn("Stage", composed["recipients"])
|
|
self.assertEqual(composed["recording"], "true")
|
|
self.assertEqual(composed["text"], "hello from the mic second line", composed)
|
|
self.assertRegex(composed["replay"] or "", r"^/api/voice/[0-9a-f]{16}\.wav$")
|
|
self.assertEqual(composed["attach"], ["Attach recording", False])
|
|
self.assertEqual(composed["clashes"], {"found": [], "outside": []})
|
|
self.assertEqual(again["attach"], ["Attach recording", False])
|
|
note = again["replay"].removeprefix("/api/voice/").removesuffix(".wav")
|
|
for result in (plain, sent):
|
|
self.assertEqual((result["left"], result["voice"]), ("", False), result)
|
|
self.assertTrue(result["sent"].startswith("Call to Stage: sent"), result)
|
|
calls = [args for script, args in self.scripts.calls if script == skill_scripts.RADIO]
|
|
self.assertEqual(len(calls), 2, self.scripts.calls)
|
|
self.assertEqual([call[:4] for call in calls], [["send", "call", "--to", "Stage"]] * 2)
|
|
self.assertTrue(calls[0][-1].endswith("] hello from the mic second line please"), calls[0])
|
|
self.assertTrue(calls[1][-1].endswith(f"] hello from the mic second line please voice: {HOST_STATE}/voice/{note}.wav"), calls[1])
|
|
status, _, body = self.get(f"/api/voice/{note}.wav")
|
|
self.assertEqual((status, body[:4]), (200, b"RIFF"))
|
|
|
|
def test_chromium_clears_the_mayday_from_the_radio_spot_only_after_confirmation_and_passkey_at_three_widths(self):
|
|
local = f"http://localhost:{self.port}/"
|
|
steps = [{"width": width, "height": height, "url": f"{local}?{width}#agents/orbit", "wait": 1200, "probe": CLEAR_MAYDAY, "shot": self.shot(f"{width}-radio-spot-mayday-cleared")} for width, height in WIDTHS]
|
|
data = self.drive(steps, self.authenticator())
|
|
(OUT / "chromium-mayday.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
|
|
self.assertEqual(data["errors"], [])
|
|
question = "Lift the radio silence of the active mayday?"
|
|
for result, (width, _) in zip(data["results"], WIDTHS, strict=True):
|
|
with self.subTest(width=width):
|
|
self.assertNotIn("error", result)
|
|
self.assertEqual(result["toolbar"], ["Priority", "Day/Night", "Drain", "Suspend", "Resume", "Status"])
|
|
self.assertEqual((result["title"], result["shown"]), ("Cancel mayday: lift the radio silence so the agents write again; your passkey signs it", ""))
|
|
self.assertEqual(result["declined"], {"question": [question], "posted": [], "toasts": []})
|
|
self.assertEqual(result["accepted"], {"question": [question], "posted": ["/api/board/sign", "/api/board/clear-mayday"]})
|
|
self.assertTrue((result["done"] or "").startswith("Cancel mayday: done"), result)
|
|
self.assertEqual(self.scripts.calls, [(skill_scripts.RADIO, ["clear", "--force", "--session", "Operator"])] * len(WIDTHS))
|
|
|
|
def test_chromium_sends_every_class_from_the_radio_spot_and_keeps_its_gear_settings_through_a_reload_at_three_widths(self):
|
|
local = f"http://localhost:{self.port}/"
|
|
values = {1920: ("0.35", "false", "true"), 1366: ("0.45", "true", "false"), 390: ("0.55", "false", "true")}
|
|
steps = [{"width": width, "height": height, "url": f"{local}?{width}-jump#stream/radio", "wait": 1200, "probe": RADIO_JUMP, "shot": self.shot(f"{width}-radio-header-spot-every-tab")} for width, height in WIDTHS]
|
|
for width, height in WIDTHS:
|
|
squelch, tone, post = values[width]
|
|
gear = GEAR_SAVE.replace("@SQUELCH@", squelch).replace("@TONE@", tone).replace("@POST@", post)
|
|
steps += [
|
|
{"width": width, "height": height, "url": f"{local}?{width}#agents/orbit", "wait": 1200, "probe": SPOT_SEND.replace("@TEXT@", f"spot {width}"), "shot": self.shot(f"{width}-radio-spot-sent")},
|
|
{"width": width, "height": height, "url": None, "wait": 0, "probe": gear, "shot": None},
|
|
{"width": width, "height": height, "url": f"{local}?{width}-reloaded#agents/orbit", "wait": 1200, "probe": GEAR_READ, "shot": self.shot(f"{width}-radio-spot-gear")},
|
|
]
|
|
data = self.drive(steps, self.authenticator())
|
|
(OUT / "chromium-radio-spot.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
|
|
self.assertEqual(data["errors"], [])
|
|
labels = dict(zip(CHOICE_CHANNELS, ["Post", "Call", "Newsletter", "Broadcast", "Pan-Pan", "Sécurité", "Mayday"], strict=True))
|
|
mayday = "Send a mayday to all? All agents pause writing steps until you cancel it."
|
|
jumps, walked = data["results"][: len(WIDTHS)], data["results"][len(WIDTHS) :]
|
|
for jump, (width, _) in zip(jumps, WIDTHS, strict=True):
|
|
with self.subTest(width=width, part="radio spot on every tab"):
|
|
self.assertEqual(jump, JUMPED)
|
|
for index, (width, _) in enumerate(WIDTHS):
|
|
sent, saved, read = walked[3 * index : 3 * (index + 1)]
|
|
squelch, tone, post = values[width]
|
|
with self.subTest(width=width):
|
|
for probe in (sent, saved, read):
|
|
self.assertNotIn("error", probe)
|
|
self.assertEqual((sent["closed"], sent["open"]), ([True, "false"], [False, "true", True]))
|
|
self.assertEqual(sent["inline"], ["static", True, True])
|
|
self.assertEqual((sent["toolbar"], sent["channels"], sent["record"]), (["Priority", "Day/Night", "Status"], CHOICE_CHANNELS, ["Record"]))
|
|
self.assertEqual(sent["heads"], [["Read aloud", "Read aloud: the classes and agents the radio sounds for"], ["Cancel mayday", "Cancel mayday: lift the radio silence so the agents write again; your passkey signs it"]])
|
|
self.assertEqual((sent["tall"], sent["wide"]), (width == 390, False))
|
|
self.assertEqual([run["cls"] for run in sent["runs"]], CHOICE_CHANNELS)
|
|
for run in sent["runs"]:
|
|
direct = run["cls"] in ("post", "call")
|
|
self.assertEqual((run["direct"], run["question"], run["left"]), (direct, [mayday] if run["cls"] == "mayday" else [], ""), run)
|
|
self.assertTrue((run["toast"] or "").startswith(f"{labels[run['cls']]} to {'Stage' if direct else 'all'}: sent"), run)
|
|
self.assertEqual((saved["expanded"], saved["clashes"]), ("true", [{"found": [], "outside": []}] * 2))
|
|
self.assertEqual(saved["tones"], ["MAYDAY / PAN-PAN", "Reviews, asks, decisions", "Post and calls to you", "All radio", "Squelch", "Threshold"])
|
|
self.assertEqual([entry[0] for entry in saved["classes"]], ["Post", "Call", "Newsletter", "Broadcast", "MAYDAY", "PAN-PAN", "Sécurité"])
|
|
self.assertEqual([entry[1:] for entry in saved["classes"] if entry[0] == "MAYDAY"], [["true", True]])
|
|
self.assertEqual((saved["kept"], saved["after"]), ([float(squelch), tone == "true", post == "true"], ["false", False]))
|
|
self.assertEqual(saved["general"], {"sections": ["Ambience", "Location", "Appearance", "Music", "Notifications", "Passkey"], "radio": 0})
|
|
self.assertEqual((saved["tall"], saved["wide"]), (width == 390, False))
|
|
self.assertEqual(read, {"squelch": float(squelch), "tone": tone == "true", "post": post == "true", "tall": width == 390, "wide": False})
|
|
heads = {"post": ["post", "--to", "Stage"], "call": ["send", "call", "--to", "Stage"], "newsletter": ["post"]}
|
|
radio = [args for script, args in self.scripts.calls if script == skill_scripts.RADIO]
|
|
sends = [(width, cls) for width, _ in WIDTHS for cls in CHOICE_CHANNELS]
|
|
self.assertEqual([args[:-1] for args in radio], [[*heads.get(cls, ["send", cls]), "--session", "Operator"] for _, cls in sends])
|
|
for args, (width, cls) in zip(radio, sends, strict=True):
|
|
with self.subTest(width=width, cls=cls):
|
|
self.assertTrue(args[-1].endswith(f"] spot {width} {cls}"), args)
|
|
self.assertEqual(self.httpd.hub.settings.get()["speech"], {"threshold": 50})
|
|
|
|
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
|
|
def test_firefox_opens_the_radio_spot_on_every_tab_and_asks_the_passkey_for_every_class_and_cancel_mayday_sending_nothing_unsigned_at_three_widths(self):
|
|
self.pin()
|
|
local = f"http://localhost:{self.port}/"
|
|
steps = []
|
|
for width, height in WIDTHS:
|
|
shot = str(OUT / f"firefox-{width}-radio-spot")
|
|
steps += [
|
|
{"width": width, "height": height, "url": f"{local}?{width}-jump#stream/radio", "wait": 1200, "probe": RADIO_JUMP, "shot": f"{shot}-every-tab.png"},
|
|
{"width": width, "height": height, "url": f"{local}?{width}#agents/orbit", "wait": 1200, "probe": SPOT_SEND.replace("@TEXT@", f"spot {width}"), "shot": f"{shot}-unsigned.png"},
|
|
{"width": width, "height": height, "url": f"{local}?{width}-mayday#agents/orbit", "wait": 1200, "probe": CLEAR_MAYDAY, "shot": f"{shot}-mayday-kept.png"},
|
|
]
|
|
data = self.drive(steps, None, "bidi.mjs", os.environ.get("FIREFOX", "firefox"), CANCELED)
|
|
(OUT / "firefox-radio-spot.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
|
|
self.assertEqual([error for error in data["errors"] if "(style-src-elem)" not in error and "/favicon.ico" not in error], [])
|
|
labels = dict(zip(CHOICE_CHANNELS, ["Post", "Call", "Newsletter", "Broadcast", "Pan-Pan", "Sécurité", "Mayday"], strict=True))
|
|
mayday = "Send a mayday to all? All agents pause writing steps until you cancel it."
|
|
question = "Lift the radio silence of the active mayday?"
|
|
hint = "Cancel mayday: lift the radio silence so the agents write again; your passkey signs it"
|
|
results = iter(data["results"])
|
|
for width, _ in WIDTHS:
|
|
jump, sent, cleared = next(results), next(results), next(results)
|
|
with self.subTest(browser="firefox", width=width, part="radio spot on every tab"):
|
|
self.assertEqual(jump, JUMPED)
|
|
with self.subTest(browser="firefox", width=width, part="every class unsigned"):
|
|
self.assertNotIn("error", sent, sent)
|
|
self.assertEqual((sent["closed"], sent["open"], sent["inline"]), ([True, "false"], [False, "true", True], ["static", True, True]))
|
|
self.assertEqual((sent["toolbar"], sent["channels"], sent["record"]), (["Priority", "Day/Night", "Status"], CHOICE_CHANNELS, ["Record"]))
|
|
self.assertEqual(sent["heads"], [["Read aloud", "Read aloud: the classes and agents the radio sounds for"], ["Cancel mayday", hint]])
|
|
self.assertEqual((sent["tall"], sent["wide"]), (width == 390, False))
|
|
self.assertEqual([run["cls"] for run in sent["runs"]], CHOICE_CHANNELS)
|
|
for run in sent["runs"]:
|
|
direct = run["cls"] in ("post", "call")
|
|
self.assertEqual((run["direct"], run["question"], run["left"]), (direct, [mayday] if run["cls"] == "mayday" else [], f"spot {width} {run['cls']}"), run)
|
|
self.assertTrue((run["toast"] or "").startswith(f"{labels[run['cls']]} to {'Stage' if direct else 'all'}: not signed"), run)
|
|
self.assertIn("NotAllowedError", run["toast"], run)
|
|
with self.subTest(browser="firefox", width=width, part="icon-only cancel mayday unsigned"):
|
|
self.assertNotIn("error", cleared, cleared)
|
|
self.assertEqual(cleared["toolbar"], ["Priority", "Day/Night", "Drain", "Suspend", "Resume", "Status"])
|
|
self.assertEqual((cleared["title"], cleared["shown"]), (hint, ""))
|
|
self.assertEqual(cleared["declined"], {"question": [question], "posted": [], "toasts": []})
|
|
self.assertEqual(cleared["accepted"], {"question": [question], "posted": ["/api/board/sign"]})
|
|
self.assertTrue((cleared["done"] or "").startswith("Cancel mayday: not signed"), cleared)
|
|
self.assertEqual(self.scripts.calls, [])
|
|
self.assertTrue((self.council / "radio-silence.json").exists())
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|