Files
skills/tests/test_hub_radioset.py
T
Kevin Veen-BirkenbachandClaude Opus 5.5 86d539a95f feat(hub): radio Morse mode with WPM speed, per-agent pitch and a 0-100 % speech threshold
Morse keys every picked row whole: class prosign (SOS for MAYDAY), DE with the sender's clear name and the full text, after PARIS timing at the hub's morse.wpm (5-40, default 20) and in the sender's own 550-850 Hz tone from the same sha256 slot as its voice. A higher class cuts a keying row, which keys again whole after it. The speech threshold runs 0-100 % in steps of 10, 100 always open, 0 never. The History card moves into page-radiolog.js to keep page-radioview.js under 500 lines.

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

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 09:46:05 +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", {"mode": "morse"}, "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()