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

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

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

646 lines
31 KiB
Python

from __future__ import annotations
import json
import subprocess
import unittest
from hub_support import HUB
from kvb_orchestrator import council
RADIOSET = HUB / "templates" / "radioset.js"
PROBE = """
const R = require(process.argv[1]);
const input = JSON.parse(process.argv[2]);
const out = {};
for (const [name, args] of Object.entries(input)) {
out[name] = args.map((call) => R[call[0]](...call.slice(1)));
}
out.constants = {key: R.KEY, modes: R.MODES, tones: R.TONES, classes: R.CLASSES, tabs: R.TABS, chips: R.CHIPS, defaults: R.DEFAULTS};
console.log(JSON.stringify(out));
"""
PAGE_LOAD = HUB / "templates" / "page-load.js"
STALE_PROBE = """
const fs = require("fs");
const vm = require("vm");
const code = fs.readFileSync(process.argv[1], "utf8");
const stub = () => undefined;
const settle = async () => {
for (let round = 0; round < 8; round += 1) {
await new Promise((resolve) => setImmediate(resolve));
}
};
function page() {
const pending = [];
const announced = [];
const timers = [];
const fetch = (url, options) => new Promise((resolve, reject) => {
pending.push({resolve, reject});
if (options && options.signal) {
options.signal.addEventListener("abort", () => reject(new Error("aborted")));
}
});
const context = {
fetch, AbortController, STATE_TIMEOUT: 15000, windowQuery: () => "", FADE: 0, MOVE: 0,
state: {now: 0, radio: []}, ui: {offline: false}, settingsSig: "", motion: {current: new Map([[1, 1]]), asOf: null},
window: {getSelection: () => "", setTimeout: (run, ms) => timers.push({run, ms}), clearTimeout: stub}, document: {hidden: false},
adoptSettings: stub, tuneMusic: stub, drawSky: stub, render: stub, drawTime: stub, drawAgent: stub, drawStream: stub, relayout: stub, pulses: stub, tick: stub,
};
context.announce = () => announced.push(context.state.now);
vm.runInNewContext(code, context);
return {context, pending, announced, timers};
}
const answer = (now) => ({ok: true, json: async () => ({now, radio: []})});
(async () => {
const slow = page();
slow.context.load();
for (let ticket = 1; ticket <= 6; ticket += 1) {
slow.context.load();
slow.pending[ticket - 1].resolve(answer(ticket));
await settle();
}
slow.pending[6].resolve(answer(7));
await settle();
const stale = page();
stale.context.load();
stale.context.load();
stale.pending[1].resolve(answer(3));
await settle();
stale.pending[0].resolve(answer(2));
await settle();
const failing = page();
failing.context.load();
failing.context.load();
failing.pending[1].resolve(answer(5));
await settle();
failing.pending[0].reject(new Error("503"));
await settle();
const lateError = failing.context.ui.offline;
failing.context.load();
failing.pending[2].reject(new Error("503"));
await settle();
const polling = page();
polling.context.load();
polling.context.poll();
const busy = polling.pending.length;
polling.pending[0].resolve(answer(1));
await settle();
polling.context.poll();
const hung = page();
for (let tick = 0; tick < 60; tick += 1) {
hung.context.poll();
await settle();
}
const stuck = [hung.pending.length, hung.context.ui.offline];
hung.timers.forEach((timer) => timer.run());
await settle();
hung.context.poll();
console.log(JSON.stringify({
slow: slow.announced, stale: [stale.context.state.now, stale.announced], errors: [lateError, failing.context.ui.offline], polls: [busy, polling.pending.length],
hung: {stuck, freed: [hung.pending.length, hung.context.ui.offline], waits: hung.timers.map((timer) => timer.ms)},
}));
})();
"""
PAGE_SPEECH = HUB / "templates" / "page-speech.js"
PAGE_RADIOVIEW = HUB / "templates" / "page-radioview.js"
TRANSMIT_PROBE = """
const fs = require("fs");
const vm = require("vm");
const RadioSet = require(process.argv[1]);
const speechCode = fs.readFileSync(process.argv[2], "utf8");
const viewCode = fs.readFileSync(process.argv[3], "utf8");
const stub = () => undefined;
const settle = async () => {
for (let round = 0; round < 40; round += 1) {
await new Promise((resolve) => setImmediate(resolve));
}
};
const row = {class: "security", source: "s1", voice: "v1", word: "W", rest: "R", text: "t"};
async function queued(flip) {
const heard = [];
const sandbox = {
RadioSet, radioSet: RadioSet.valid({mode: "auto"}), state: {speech: {tts: true, gate: {open: true}}},
speech: {pending: [], busy: false, current: null, source: null, item: null, timer: 0}, settings: {bubbles: false}, SPEECH_QUEUE: 9,
Voice: {enqueue: (pending, next) => [...pending, next]}, drawBubbles: stub, drawSpeaker: stub,
};
vm.runInNewContext(speechCode, sandbox);
sandbox.context = () => ({});
sandbox.spoken = async (audio, item, step) => {
heard.push(step.text);
if (heard.length === 1 && flip) {
sandbox.radioSet = RadioSet.valid({mode: flip});
}
return "";
};
sandbox.burst = async () => {
heard.push("burst");
};
sandbox.say({row});
sandbox.say({row});
await settle();
return heard;
}
async function stalled() {
const waits = [];
const sandbox = {
speech: {current: null, source: null}, SOUND_SLACK: 2, performance: {now: () => 0}, duck: stub, drawSpeaker: stub,
window: {setTimeout: (run, ms) => waits.push({run, ms}), clearTimeout: stub},
};
vm.runInNewContext(speechCode, sandbox);
let done = false;
let stops = 0;
const source = {addEventListener: stub, stop: () => {
stops += 1;
}};
sandbox.sounded({}, source, 0.5).then(() => {
done = true;
});
await settle();
const before = [done, sandbox.speech.source === source];
waits.forEach((wait) => wait.run());
await settle();
return {before, after: [done, sandbox.speech.source], waits: waits.map((wait) => wait.ms), stops};
}
function pressed() {
const calls = [];
const sandbox = {RadioSet, h: (tag, attrs, ...children) => ({tag, attrs: attrs || {}, children: children.flat()}), icon: (name) => name, named: (label, hint) => ({"aria-label": label, title: hint})};
vm.runInNewContext(viewCode, sandbox);
sandbox.knobs = () => [];
sandbox.context = () => calls.push("context");
sandbox.keepRadio = (change) => calls.push(change);
const modes = sandbox.faceplate({}).children.find((child) => child.attrs["aria-label"] === "Mode");
modes.children.forEach((button) => button.attrs.on.click());
return calls;
}
(async () => {
console.log(JSON.stringify({
auto: await queued(""), silence: await queued("silence"), quiet: await queued("quiet"), stalled: await stalled(), pressed: pressed(),
}));
})();
"""
VOICE_JS = HUB / "templates" / "voice.js"
MODES_PROBE = """
const fs = require("fs");
const vm = require("vm");
const RadioSet = require(process.argv[1]);
const Voice = require(process.argv[2]);
const code = fs.readFileSync(process.argv[3], "utf8");
const stub = () => undefined;
const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
const until = async (check) => {
for (let round = 0; round < 500 && !check(); round += 1) {
await wait(1);
}
};
const WORD = "MAYDAY MAYDAY MAYDAY";
const rest = (id) => `this is ${id}, over`;
function radio({running = true, hold = "", long = "", fail = 0, scale = 1000, bubbles = false} = {}) {
const run = {log: [], releases: [], gesture: running, sources: [], beeps: 0, reads: 0};
class Source {
constructor() {
Object.assign(this, {buffer: null, ended: null, stopped: false, audible: false});
}
connect(node) {
return node;
}
addEventListener(type, ended) {
this.ended = ended;
}
label() {
return this.buffer && this.buffer.text ? this.buffer.text : "burst";
}
start() {
run.sources.push(this);
if (audio.state === "running") {
audio.play(this);
}
}
stop(when) {
if (when === undefined && !this.stopped) {
this.stopped = true;
run.log.push(["stop", this.label()]);
setImmediate(() => this.ended && this.ended());
}
}
}
const audio = {
state: running ? "running" : "suspended", currentTime: 0, sampleRate: 8000, destination: {},
play(source) {
if (!source.audible && !source.stopped) {
source.audible = true;
run.log.push(["audible", source.label(), sandbox.radioSet.mode]);
if (source.label() !== long) {
setImmediate(() => source.ended && source.ended());
}
}
},
resume() {
if (run.gesture) {
audio.state = "running";
run.sources.forEach((source) => audio.play(source));
}
return Promise.resolve();
},
createBufferSource: () => new Source(),
createGain: () => ({gain: {value: 0, setValueAtTime: stub, exponentialRampToValueAtTime: stub}, connect: (node) => node}),
createBiquadFilter: () => ({type: "", frequency: {value: 0}, Q: {value: 0}, connect: (node) => node}),
createBuffer: (channels, frames) => ({getChannelData: () => new Float32Array(frames)}),
decodeAudioData: async (data) => ({duration: data.text === long ? 60 : 1, text: data.text}),
};
const sandbox = {
RadioSet, Voice, radioSet: RadioSet.valid(null), state: {now: 1000, messages: [], speech: {tts: true, gate: {open: true}}},
speech: {pending: [], busy: false, warned: 0, current: null, source: null, loading: null, timer: 0, item: null},
settings: {bubbles, music: {on: false, volume: 0.4}}, SPEECH_QUEUE: 20, SPEECH_QUIET: 60000, SOUND_SLACK: 2, HUMAN: "Operator", Bubbles: {reading: () => 0.001},
keep: stub, drawRadioSet: stub, drawBubbles: stub, drawSpeaker: stub, duck: stub, clearBubbles: stub, toast: (title) => run.log.push(["toast", title]),
silenceBeeps: () => {
run.beeps += 1;
},
performance: {now: () => 0}, window: {setTimeout: (next, ms) => setTimeout(next, ms / scale), clearTimeout: (id) => clearTimeout(id)},
context: () => {
if (audio.state === "suspended") {
audio.resume();
}
return audio;
},
fetch: async (url, options) => {
const text = JSON.parse(options.body).text;
run.log.push(["tts", text]);
if (text === hold) {
await new Promise((resolve) => run.releases.push(resolve));
}
if (fail && text !== WORD) {
return {ok: false, status: fail, headers: {get: () => (fail === 503 ? "application/json" : "text/plain")}, text: async () => (fail === 503 ? "{\\"reason\\": \\"busy\\"}" : "piper failed")};
}
return {ok: true, status: 200, headers: {get: () => "audio/wav"}, arrayBuffer: async () => ({text}), text: async () => ""};
},
};
vm.runInNewContext(code, sandbox);
const read = sandbox.readSilently;
sandbox.readSilently = (item, next) => {
run.reads += 1;
read(item, next);
};
run.state = sandbox.state;
run.finish = () => run.sources.filter((source) => source.audible && !source.stopped).forEach((source) => source.ended && source.ended());
run.say = (id) => sandbox.say({row: {class: "mayday", word: WORD, rest: rest(id), voice: "v", source: id, from: id, to: [], text: "help", ts: 1000}, voice: "v", tone: "mayday", cls: "mayday", who: id, line: "help", words: [], silent: false});
run.press = (mode) => {
sandbox.keepRadio({mode});
sandbox.context();
};
run.keep = (change) => sandbox.keepRadio(change);
run.heard = () => run.log.filter(([event]) => event === "audible").map(([, text, mode]) => [text, mode]);
run.stops = () => run.log.filter(([event]) => event === "stop").map(([, text]) => text);
run.idle = () => !sandbox.speech.busy && !sandbox.speech.pending.length;
return run;
}
async function pressedWhilePlaying(long, count, mode) {
const run = radio({long});
run.say("A");
await until(() => run.heard().length === count);
run.press(mode);
await wait(20);
return {heard: run.heard(), stops: run.stops()};
}
async function failedWhileRendering(fail, mode) {
const run = radio({hold: rest("A"), fail});
run.say("A");
await until(() => run.releases.length);
run.press(mode);
run.releases.forEach((release) => release());
await until(run.idle);
await wait(10);
return run.heard();
}
(async () => {
const inflight = radio({hold: rest("A")});
inflight.say("A");
await until(() => inflight.releases.length);
inflight.press("silence");
inflight.releases.forEach((release) => release());
await until(inflight.idle);
const playing = await pressedWhilePlaying(rest("A"), 2, "silence");
const word = await pressedWhilePlaying(WORD, 1, "silence");
const quiet = await pressedWhilePlaying(rest("A"), 2, "quiet");
const failed = {
silence503: await failedWhileRendering(503, "silence"), silence500: await failedWhileRendering(500, "silence"), quiet503: await failedWhileRendering(503, "quiet"),
};
const kept = radio({fail: 500, long: "burst", scale: 10});
kept.say("A");
await until(() => kept.heard().length === 2);
kept.keep({squelch: 0.5});
kept.keep({log: {tab: "all", chips: {}, q: "gate"}});
await wait(20);
const fallback = {heard: kept.heard(), stops: kept.stops()};
const beeper = radio({});
beeper.press("quiet");
const quietBeeps = beeper.beeps;
beeper.press("silence");
const silenceBeeps = beeper.beeps;
beeper.keep({squelch: 0.5});
beeper.press("silence");
const beeps = [quietBeeps, silenceBeeps, beeper.beeps];
const natural = {};
for (const flag of ["open", "tts"]) {
const run = radio({long: rest("A"), bubbles: true});
run.say("A");
await until(() => run.heard().length === 2);
if (flag === "open") {
run.state.speech.gate = {open: false};
} else {
run.state.speech.tts = false;
}
run.finish();
await until(run.idle);
await wait(10);
natural[flag] = {heard: run.heard(), reads: run.reads};
}
const renderedRun = radio({hold: rest("A")});
renderedRun.say("A");
await until(() => renderedRun.releases.length);
renderedRun.state.speech.gate = {open: false};
renderedRun.releases.forEach((release) => release());
await until(renderedRun.idle);
await wait(10);
const renderedLine = renderedRun.heard();
const suspended = radio({running: false});
suspended.say("B");
suspended.say("C");
await until(suspended.idle);
const started = suspended.sources.length;
suspended.gesture = true;
suspended.press("silence");
await wait(20);
console.log(JSON.stringify({
inflight: {tts: inflight.log.filter(([event]) => event === "tts").map(([, text]) => text), heard: inflight.heard()},
playing, word, quiet, failed, fallback, beeps, natural, renderedLine, suspended: {started, heard: suspended.heard(), stopped: suspended.sources.filter((source) => source.stopped).length},
}));
})();
"""
PAGE_ALERTS = HUB / "templates" / "page-alerts.js"
BEEPS_PROBE = """
const fs = require("fs");
const vm = require("vm");
const code = fs.readFileSync(process.argv[1], "utf8");
const stub = () => undefined;
const stops = [];
let made = 0;
const audio = {
currentTime: 0, destination: {},
createOscillator: () => {
made += 1;
return {type: "", frequency: {value: 0}, connect: (node) => node, addEventListener: stub, start: stub, stop: (when) => stops.push(when === undefined ? "now" : "scheduled")};
},
createGain: () => ({gain: {setValueAtTime: stub, exponentialRampToValueAtTime: stub}, connect: (node) => node}),
};
const sandbox = {TONES: {mayday: [[880, 0, 0.2], [660, 0.25, 0.2]], radio: [[440, 0, 0.1]]}, duck: stub, context: () => audio};
vm.runInNewContext(code, sandbox);
sandbox.play("mayday", 0.8);
sandbox.play("radio", 0.5);
const now = () => stops.filter((kind) => kind === "now").length;
const queued = [made, now()];
sandbox.silenceBeeps();
const silenced = now();
sandbox.silenceBeeps();
console.log(JSON.stringify({queued, silenced, again: now()}));
"""
HUMAN = "Operator"
WORD = "MAYDAY MAYDAY MAYDAY"
ROWS = {
"mayday": {"class": "mayday", "source": "s1", "voice": "v1", "word": WORD, "rest": "this is Docs Docs Docs, disk full, over"},
"security": {"class": "security", "source": "s2", "voice": "v2", "word": "say-cure-ee-tay say-cure-ee-tay say-cure-ee-tay", "rest": "all stations, this is Stage, rotate, over"},
"post": {"class": "post", "source": "s2", "voice": "v2", "word": "", "rest": "Operator, Operator, this is Stage, ready, over"},
"muted": {"class": "security", "source": "s9", "voice": "v9", "word": "say-cure-ee-tay say-cure-ee-tay say-cure-ee-tay", "rest": "all stations, this is Muted, x, over"},
"voiceless": {"class": "post", "source": "s3", "voice": "", "word": "", "rest": "x"},
}
LOG = [
{"ts": 10, "from": "Operator", "to": ["Stage"], "class": "post", "text": "rebase please"},
{"ts": 20, "from": "Stage", "to": ["Operator"], "class": "call", "text": "gate red on main"},
{"ts": 30, "from": "Docs", "to": [], "class": "newsletter", "text": "docs are green"},
{"ts": 40, "from": "Stage", "to": ["Skills"], "class": "post", "text": "rebase done"},
{"ts": 50, "from": "Operator", "to": [], "class": "broadcast", "text": "deploy now"},
{"ts": 60, "from": "Docs", "to": ["Skills"], "class": "pan-pan", "text": "Gate slow"},
{"ts": 70, "from": "Skills", "to": ["Docs"], "class": "call", "text": "which gate"},
{"ts": 80, "from": "Operator", "to": [], "class": "broadcast", "text": "spoofed order"},
]
MESSAGES = [
{"id": "a" * 16, "to": "Stage", "text": "rebase please", "created_ts": 10, "class": "post", "voice": "v0"},
{"id": "b" * 16, "to": "*", "text": "deploy now", "created_ts": 50, "class": "broadcast", "voice": "v0"},
]
TWINS = [*LOG, {"ts": 90, "from": "Docs", "to": [], "class": "newsletter", "text": "twin one"}, {"ts": 90, "from": "Docs", "to": [], "class": "broadcast", "text": "twin two"}]
def run(calls: dict[str, list[list]]) -> dict:
done = subprocess.run(["node", "-e", PROBE, str(RADIOSET), json.dumps(calls)], capture_output=True, text=True, timeout=60, check=True)
return json.loads(done.stdout)
class TestRadioSetModule(unittest.TestCase):
@classmethod
def setUpClass(cls):
defaults = {"mode": "auto", "classes": ["mayday", "pan-pan", "security"], "muted": ["s9"], "sounds": {}, "squelch": 1, "log": {}}
modes = ("auto", "quiet", "silence")
lives = ({"tts": True, "open": True}, {"tts": True, "open": False}, {"tts": False, "open": True})
plans = [["plan", ROWS[name], {**defaults, "mode": mode}, live] for mode in modes for live in lives for name in ROWS]
plans += [["plan", ROWS["post"], {**defaults, "classes": ["mayday", "post"]}, lives[0]], ["plan", ROWS["post"], {**defaults, "classes": ["mayday", "post"], "mode": "quiet"}, lives[0]]]
stored = [
None, "broken", [], {"mode": "loud", "squelch": 2, "classes": ["post"], "muted": ["s2", "s2", "", 7, "s1"], "sounds": {"radio": {"on": "yes", "volume": 0.4}, "review": {"on": False, "volume": -1}}},
{"mode": "quiet", "squelch": 0, "classes": ["security", "shout", "post", "call", "newsletter", "broadcast", "pan-pan"], "log": {"tab": "sent", "chips": {"class": "post", "from": 7, "to": "x" * 201}, "q": "gate"}},
]
entries = [
{"tab": "all", "chips": {"class": "", "from": "", "to": "", "agent": ""}, "q": ""},
{"tab": "sent", "chips": {"class": "", "from": "", "to": "", "agent": ""}, "q": ""},
{"tab": "received", "chips": {"class": "", "from": "", "to": "", "agent": ""}, "q": ""},
{"tab": "all", "chips": {"class": "post", "from": "", "to": "", "agent": ""}, "q": ""},
{"tab": "all", "chips": {"class": "", "from": "Stage", "to": "", "agent": ""}, "q": ""},
{"tab": "all", "chips": {"class": "", "from": "", "to": "Skills", "agent": ""}, "q": ""},
{"tab": "all", "chips": {"class": "", "from": "", "to": "", "agent": "Docs"}, "q": ""},
{"tab": "all", "chips": {"class": "", "from": "", "to": "", "agent": ""}, "q": "GATE"},
{"tab": "all", "chips": {"class": "call", "from": "", "to": "", "agent": "Skills"}, "q": "gate"},
{"tab": "received", "chips": {"class": "", "from": "", "to": "", "agent": "Stage"}, "q": "rebase"},
]
cls.data = run({
"plans": plans,
"stored": [["valid", value] for value in stored],
"logs": [["logRows", LOG, entry, HUMAN, MESSAGES] for entry in entries],
"twins": [["logRows", TWINS, entry, HUMAN, MESSAGES] for entry in (entries[0], {**entries[0], "chips": {**entries[0]["chips"], "class": "broadcast"}}, entries[1])],
"counts": [["counts", LOG, HUMAN, MESSAGES]],
"ledger": [["ledgerOf", {"text": f"deploy now [kvb-orchestrator msg {'b' * 16}]"}, MESSAGES], ["ledgerOf", {"text": f"forged [kvb-orchestrator msg {'c' * 16}]"}, MESSAGES], ["ledgerOf", LOG[-1], MESSAGES]],
"choices": [["choices", LOG]],
"cleared": [["cleared", entries[8]]],
"bursts": [["burst", 0.45], ["burst", 0]],
})
cls.modes, cls.lives = modes, lives
def plan(self, mode: str, live: int, name: str) -> list[dict]:
index = (self.modes.index(mode) * len(self.lives) + live) * len(ROWS) + list(ROWS).index(name)
return self.data["plans"][index]
def test_auto_speaks_below_the_threshold_and_bursts_above_it_or_without_tts(self):
word = {"kind": "word", "text": WORD}
self.assertEqual(self.plan("auto", 0, "mayday"), [word, {"kind": "speech", "text": ROWS["mayday"]["rest"]}])
self.assertEqual(self.plan("auto", 1, "mayday"), [word, {"kind": "burst"}])
self.assertEqual(self.plan("auto", 2, "mayday"), [{"kind": "burst"}])
self.assertEqual(self.plan("auto", 0, "security")[0]["kind"], "word")
self.assertEqual(self.data["plans"][-2], [{"kind": "speech", "text": ROWS["post"]["rest"]}])
def test_quiet_never_asks_for_speech_except_the_procedure_word(self):
for live in range(len(self.lives)):
for name in ("mayday", "security"):
with self.subTest(live=live, name=name):
plan = self.plan("quiet", live, name)
self.assertEqual(plan[-1], {"kind": "burst"})
self.assertEqual([step["kind"] for step in plan[:-1]], ["word"] if self.lives[live]["tts"] else [])
self.assertEqual(self.data["plans"][-1], [{"kind": "burst"}])
def test_silence_plays_only_the_procedure_word(self):
for live in range(len(self.lives)):
with self.subTest(live=live):
self.assertEqual(self.plan("silence", live, "mayday"), [{"kind": "word", "text": WORD}] if self.lives[live]["tts"] else [])
self.assertEqual(self.plan("silence", live, "post"), [])
def test_the_read_aloud_filters_skip_classes_and_muted_agents_but_never_a_mayday(self):
for mode in self.modes:
for live in range(len(self.lives)):
with self.subTest(mode=mode, live=live):
self.assertEqual(self.plan(mode, live, "post"), [])
self.assertEqual(self.plan(mode, live, "muted"), [])
self.assertEqual(self.plan(mode, live, "voiceless"), [])
self.assertNotEqual(self.plan("auto", 0, "security"), [])
def test_the_burst_is_band_passed_noise_of_about_0_6_seconds_at_the_given_loudness(self):
loud, silent = self.data["bursts"]
self.assertTrue(0.4 <= loud["seconds"] <= 0.8, loud)
self.assertEqual((loud["gain"], silent["gain"]), (0.45, 0))
self.assertTrue(300 <= loud["frequency"] <= 3400 and loud["q"] > 0, loud)
def test_the_stored_radio_set_is_normalised_and_mayday_stays_read_aloud(self):
defaults = self.data["constants"]["defaults"]
empty, broken, listed, wrong, chosen = self.data["stored"]
self.assertEqual((empty, broken, listed), (defaults, defaults, defaults))
self.assertEqual(defaults["mode"], "auto")
self.assertEqual(self.data["constants"]["key"], "kvb-orchestrator.radio")
self.assertEqual((wrong["mode"], wrong["squelch"], wrong["classes"], wrong["muted"]), ("auto", 1, ["post", "mayday"], ["s1", "s2"]))
self.assertEqual(wrong["sounds"]["radio"], {"on": False, "volume": 0.4})
self.assertEqual(wrong["sounds"]["review"], {"on": False, "volume": 0.6})
self.assertEqual((chosen["mode"], chosen["squelch"], chosen["classes"]), ("quiet", 0, list(council.CLASSES)))
self.assertEqual(chosen["log"], {"tab": "sent", "chips": {"class": "post", "from": "", "to": "", "agent": ""}, "q": "gate"})
self.assertEqual(self.data["constants"]["classes"], list(council.CLASSES))
self.assertEqual(self.data["constants"]["tones"], ["mayday", "review", "direct", "radio"])
def test_the_log_tabs_chips_and_search_combine_with_and_newest_first(self):
texts = [[row["text"] for row in rows] for rows in self.data["logs"]]
self.assertEqual(texts[0], [row["text"] for row in reversed(LOG)])
self.assertEqual(texts[1], ["deploy now", "rebase please"])
self.assertEqual(texts[2], ["spoofed order", "Gate slow", "deploy now", "docs are green", "gate red on main"])
self.assertEqual(texts[3], ["rebase done", "rebase please"])
self.assertEqual(texts[4], ["rebase done", "gate red on main"])
self.assertEqual(texts[5], ["Gate slow", "rebase done"])
self.assertEqual(texts[6], ["which gate", "Gate slow", "docs are green"])
self.assertEqual(texts[7], ["which gate", "Gate slow", "gate red on main"])
self.assertEqual(texts[8], ["which gate"])
self.assertEqual(texts[9], [])
self.assertEqual(self.data["counts"], [{"sent": 2, "received": 5, "all": 8}])
self.assertEqual(self.data["choices"][0]["class"], ["post", "call", "newsletter", "broadcast", "pan-pan"])
self.assertEqual(self.data["choices"][0]["agent"], ["Docs", "Operator", "Skills", "Stage"])
self.assertEqual(self.data["cleared"], [{"tab": "all", "chips": {"class": "", "from": "", "to": "", "agent": ""}, "q": ""}])
def test_every_log_row_has_a_unique_key_that_a_filter_keeps_and_twins_of_one_time_and_sender_differ(self):
everything, broadcasts, sent = ({row["text"]: row["key"] for row in rows} for rows in self.data["twins"])
self.assertEqual(len(set(everything.values())), len(TWINS), everything)
self.assertEqual((everything["twin one"], everything["twin two"]), ("90 Docs 0", "90 Docs 1"), everything)
self.assertEqual(broadcasts, {text: everything[text] for text in broadcasts}, broadcasts)
self.assertIn("twin two", broadcasts)
self.assertEqual(sent, {"deploy now": f"sent {'b' * 16} 0", "rebase please": f"sent {'a' * 16} 0"}, sent)
def test_sent_comes_from_the_hub_ledger_and_a_row_only_named_operator_is_not_sent(self):
sent = self.data["logs"][1]
self.assertEqual([(row["to"], row["class"], row["sent"]) for row in sent], [([], "broadcast", True), (["Stage"], "post", True)])
self.assertNotIn("spoofed order", [row["text"] for row in sent])
self.assertEqual(self.data["ledger"], [MESSAGES[1], None, None])
class TestStaleState(unittest.TestCase):
@classmethod
def setUpClass(cls):
done = subprocess.run(["node", "-e", STALE_PROBE, str(PAGE_LOAD)], capture_output=True, text=True, timeout=60, check=True)
cls.data = json.loads(done.stdout)
def test_every_answer_newer_than_the_applied_one_applies_even_while_slower_requests_overlap(self):
self.assertEqual(self.data["slow"], [1, 2, 3, 4, 5, 6, 7])
def test_an_answer_older_than_the_applied_one_is_dropped_so_no_radio_row_is_announced_twice(self):
self.assertEqual(self.data["stale"], [3, [3]])
def test_only_a_failure_newer_than_the_applied_answer_marks_the_page_offline(self):
self.assertEqual(self.data["errors"], [False, True])
def test_the_poller_skips_its_tick_while_a_request_is_in_flight(self):
self.assertEqual(self.data["polls"], [1, 2])
def test_a_hung_state_request_is_aborted_after_its_timeout_marks_the_page_offline_and_frees_the_poller(self):
self.assertEqual(self.data["hung"], {"stuck": [1, False], "freed": [2, True], "waits": [15000, 15000]})
class TestTransmit(unittest.TestCase):
@classmethod
def setUpClass(cls):
done = subprocess.run(["node", "-e", TRANSMIT_PROBE, str(RADIOSET), str(PAGE_SPEECH), str(PAGE_RADIOVIEW)], capture_output=True, text=True, timeout=60, check=True)
cls.data = json.loads(done.stdout)
def test_a_mode_change_replans_the_playing_and_the_queued_rows_at_play_time(self):
self.assertEqual(self.data["auto"], ["W", "R", "W", "R"])
self.assertEqual(self.data["silence"], ["W", "W"])
self.assertEqual(self.data["quiet"], ["W", "burst", "W", "burst"])
def test_a_sound_that_never_ends_frees_the_speaker_after_its_duration_plus_two_seconds(self):
self.assertEqual(self.data["stalled"], {"before": [False, True], "after": [True, None], "waits": [2500], "stops": 1})
def test_every_mode_button_keeps_the_mode_before_it_resumes_the_audio_context(self):
self.assertEqual(self.data["pressed"], [{"mode": "auto"}, "context", {"mode": "quiet"}, "context", {"mode": "silence"}, "context"])
class TestSpeechModes(unittest.TestCase):
@classmethod
def setUpClass(cls):
done = subprocess.run(["node", "-e", MODES_PROBE, str(RADIOSET), str(VOICE_JS), str(PAGE_SPEECH)], capture_output=True, text=True, timeout=60, check=True)
cls.data = json.loads(done.stdout)
def test_silence_pressed_while_the_rest_line_renders_starts_no_sound_once_it_arrives(self):
self.assertEqual(self.data["inflight"], {"tts": [WORD, "this is A, over"], "heard": [[WORD, "auto"]]})
def test_silence_pressed_while_the_rest_line_plays_stops_it_and_keeps_a_playing_procedure_word(self):
self.assertEqual(self.data["playing"], {"heard": [[WORD, "auto"], ["this is A, over", "auto"]], "stops": ["this is A, over"]})
self.assertEqual(self.data["word"], {"heard": [[WORD, "auto"]], "stops": []})
def test_sounds_started_on_a_suspended_context_are_stopped_so_a_later_resume_plays_none_of_them(self):
self.assertEqual(self.data["suspended"], {"started": 4, "heard": [], "stopped": 4})
def test_a_rest_line_the_hub_holds_or_fails_after_silence_was_pressed_plays_no_fallback_burst(self):
word = [WORD, "auto"]
self.assertEqual(self.data["failed"], {"silence503": [word], "silence500": [word], "quiet503": [word, ["burst", "quiet"]]})
def test_quiet_pressed_while_the_rest_line_plays_stops_it_and_plays_the_burst_instead(self):
self.assertEqual(self.data["quiet"], {"heard": [[WORD, "auto"], ["this is A, over", "auto"], ["burst", "quiet"]], "stops": ["this is A, over"]})
def test_a_volume_or_log_change_keeps_the_fallback_burst_of_a_failed_rest_line_playing(self):
self.assertEqual(self.data["fallback"], {"heard": [[WORD, "auto"], ["burst", "auto"]], "stops": []})
def test_only_the_switch_to_silence_stops_the_queued_alert_beeps_and_a_later_knob_drag_does_not(self):
self.assertEqual(self.data["beeps"], [0, 1, 1])
def test_a_gate_or_tts_change_after_a_line_ends_by_itself_voices_the_row_once_with_no_burst_and_no_bubble(self):
voiced = {"heard": [[WORD, "auto"], ["this is A, over", "auto"]], "reads": 0}
self.assertEqual(self.data["natural"], {"open": voiced, "tts": voiced})
def test_a_gate_that_closes_while_the_rest_line_renders_still_plays_the_rendered_line(self):
self.assertEqual(self.data["renderedLine"], [[WORD, "auto"], ["this is A, over", "auto"]])
class TestAlertBeeps(unittest.TestCase):
def test_silencing_stops_every_beep_play_scheduled_and_forgets_it(self):
done = subprocess.run(["node", "-e", BEEPS_PROBE, str(PAGE_ALERTS)], capture_output=True, text=True, timeout=60, check=True)
self.assertEqual(json.loads(done.stdout), {"queued": [3, 0], "silenced": 3, "again": 3})
if __name__ == "__main__":
unittest.main()