Files
skills/tests/test_hub_gibberlink.py
T

419 lines
22 KiB
Python
Raw Normal View History

from __future__ import annotations
import json
import re
import subprocess
import time
import unittest
from unittest import mock
from hub_case import HubCase
from hub_support import HUB
from kvb_orchestrator import council, engines, exchange, settings
from kvb_orchestrator.view import ENCODER_CSP
TEMPLATES = HUB / "templates"
RADIOSET = TEMPLATES / "radioset.js"
GIBBERLINK = TEMPLATES / "gibberlink.js"
MORSE = TEMPLATES / "morse.js"
VOICE = TEMPLATES / "voice.js"
PAGE_SPEECH = TEMPLATES / "page-speech.js"
PAGE_MORSE = TEMPLATES / "page-morse.js"
PAGE_GIBBERLINK = TEMPLATES / "page-gibberlink.js"
GGWAVE = HUB / "vendor" / "ggwave" / "ggwave.js"
KEY = "4f0c2a1e-1111-2222-3333-444455556666"
MARK = "[kvb-orchestrator msg 0123456789abcdef]"
2026-11-17 20:14:58 +00:00
WIDE = "\N{LATIN SMALL LETTER A WITH DIAERESIS}€\U0001f600"
ALARMS = ("mayday", "pan-pan", "security")
SOUND = {"protocol": "AUDIBLE_FAST", "pan": -0.4}
FRAMES_PROBE = """
const R = require(process.argv[1]);
const input = JSON.parse(process.argv[2]);
console.log(JSON.stringify({
split: input.texts.map(([key, text]) => R.frames(key, text)),
plans: input.plans.map(([row, set, live]) => R.plan(row, set, live)),
kept: input.sets.map((set) => R.valid(set).fallback),
constants: {modes: R.MODES, fallbacks: R.FALLBACKS, frame: R.FRAME, fallback: R.DEFAULTS.fallback, key: R.KEY},
}));
"""
PLAYING_PROBE = """
const fs = require("fs");
const vm = require("vm");
const RadioSet = require(process.argv[1]);
const Morse = require(process.argv[2]);
const Voice = require(process.argv[3]);
const code = process.argv.slice(4, 7).map((path) => fs.readFileSync(path, "utf8")).join("\\n");
const stub = () => undefined;
const settle = async () => {
for (let round = 0; round < 60; round += 1) {
await new Promise((resolve) => setImmediate(resolve));
}
};
const row = (source, pan, cls, text) => ({class: cls, source, from: source, to: [], called: [], speaker: "E", pitch: 600, protocol: "AUDIBLE_FAST", pan, voice: "v", word: "", rest: "x", text, ts: 1000});
function radio(plays, change) {
const run = {buffers: [], gains: [], pans: [], oscillators: [], encoded: []};
class Source {
constructor() {
Object.assign(this, {type: "", frequency: {value: 0}, buffer: null, ended: null, started: null, stops: []});
}
connect(node) {
return node;
}
addEventListener(type, ended) {
this.ended = ended;
}
start(when) {
this.started = when === undefined ? "now" : when;
if (plays) {
setImmediate(() => this.ended && this.ended());
}
}
stop(when) {
this.stops.push(when === undefined ? "now" : when);
if (when === undefined) {
setImmediate(() => this.ended && this.ended());
}
}
}
const made = (list) => () => {
const node = new Source();
list.push(node);
return node;
};
const param = () => ({value: 0, setValueAtTime: stub, linearRampToValueAtTime: stub, exponentialRampToValueAtTime: stub});
const audio = {
currentTime: 0, sampleRate: 8000, destination: {}, createBufferSource: made(run.buffers), createOscillator: made(run.oscillators),
createGain: () => {
const gain = param();
run.gains.push(gain);
return {gain, connect: (node) => node};
},
createStereoPanner: () => {
const pan = param();
run.pans.push(pan);
return {pan, connect: (node) => node};
},
createBuffer: (channels, frames, rate) => ({length: frames, duration: frames / rate, getChannelData: () => new Float32Array(frames)}),
};
const sandbox = {
RadioSet, Morse, Voice, radioSet: RadioSet.valid({mode: "gibberlink", classes: RadioSet.CLASSES, ...change}),
state: {now: 1000, messages: [], speech: {tts: false, gate: {open: false}}},
speech: {pending: [], busy: false, warned: 0, current: null, source: null, loading: null, timer: 0, item: null},
settings: {bubbles: false, music: {on: false, volume: 0.4}, morse: {wpm: 20}}, SPEECH_QUEUE: 20, SPEECH_QUIET: 60000, SOUND_SLACK: 2, HUMAN: "Operator",
Bubbles: {reading: () => 0.001}, wordsRead: () => 0, saidOf: (item) => item.words,
keep: stub, drawRadioSet: stub, drawBubbles: stub, drawSpeaker: stub, duck: stub, clearBubbles: stub, silenceBeeps: stub, toast: stub,
performance: {now: () => 0}, window: {setTimeout: () => 0, clearTimeout: stub}, context: () => audio,
};
vm.runInNewContext(code, sandbox);
sandbox.gibberEncode = async (step) => {
run.encoded.push([step.pan, step.frames.length]);
return {rate: 48000, samples: step.frames.map((frame) => new Float32Array(frame.length * 10))};
};
run.sandbox = sandbox;
run.say = (item) => sandbox.say({voice: item.voice, tone: "direct", cls: item.class, who: item.source, line: item.text, words: [item.text], silent: false, row: item});
run.idle = () => !sandbox.speech.busy && !sandbox.speech.pending.length && sandbox.speech.source === null;
return run;
}
const long = "E ".repeat(200);
(async () => {
const whole = radio(true, {});
whole.say(row("s1", -0.4, "post", long));
await settle();
const quiet = radio(true, {squelch: 0.5});
quiet.say(row("s1", 0.4, "post", "E"));
await settle();
const mute = radio(true, {squelch: 0});
mute.say(row("s1", 0.4, "post", "E"));
await settle();
const stop = radio(false, {});
stop.say(row("s1", -0.4, "post", long));
await settle();
const playing = [stop.buffers.length, stop.sandbox.speech.source === stop.buffers[0]];
stop.sandbox.cancelSpeech();
await settle();
const urgent = radio(false, {});
urgent.say(row("s1", -0.8, "post", long));
await settle();
urgent.say(row("s2", 0.8, "mayday", "E"));
await settle();
const during = {buffers: urgent.buffers.map((node, index) => [urgent.pans[index].value, node.stops.includes("now")]), pending: urgent.sandbox.speech.pending.map((item) => item.cls)};
urgent.buffers[1].ended();
await settle();
const switched = radio(false, {});
switched.say(row("s1", -0.4, "post", long));
await settle();
switched.sandbox.keepRadio({mode: "morse"});
await settle();
console.log(JSON.stringify({
whole: {encoded: whole.encoded, length: whole.buffers.map((node) => node.buffer.length), pan: whole.pans.map((pan) => pan.value), gain: whole.gains.map((gain) => gain.value), idle: whole.idle()},
quiet: quiet.gains.map((gain) => gain.value),
mute: [mute.encoded.length, mute.buffers.length, mute.idle()],
stop: {playing, stops: stop.buffers[0].stops, idle: stop.idle()},
urgent: {during, encoded: urgent.encoded, after: urgent.buffers.map((node, index) => [urgent.pans[index].value, node.started])},
switched: {stops: switched.buffers[0].stops, oscillators: switched.oscillators.length},
}));
})();
"""
ANSWER_PROBE = """
const fs = require("fs");
const vm = require("vm");
const posted = [];
const listeners = [];
const frame = {contentWindow: {postMessage: (message) => posted.push(message)}, addEventListener: (type, loaded) => loaded()};
const sandbox = {
h: () => frame, document: {body: {append: () => undefined}},
window: {addEventListener: (type, heard) => listeners.push(heard), setTimeout: () => 0, clearTimeout: () => undefined},
};
vm.runInNewContext(fs.readFileSync(process.argv[1], "utf8"), sandbox);
const Floats = vm.runInContext("Float32Array", sandbox);
const settle = () => new Promise((resolve) => setImmediate(resolve));
const outcome = (promise) => promise.then((value) => ({rate: value.rate, parts: value.samples.length}), (error) => ({error: error.message}));
(async () => {
const good = outcome(sandbox.gibberEncode({protocol: "AUDIBLE_FAST", frames: ["a", "b"]}));
const bad = outcome(sandbox.gibberEncode({protocol: "AUDIBLE_FAST", frames: ["c"]}));
const failed = outcome(sandbox.gibberEncode({protocol: "MT_FAST", frames: ["d"]}));
await settle();
const answer = (source, data) => listeners.forEach((heard) => heard({source, data}));
answer({}, {id: 1, rate: 1, samples: []});
answer(frame.contentWindow, {id: 1, rate: 48000, samples: [new Floats(2), new Floats(3)]});
answer(frame.contentWindow, {id: 2, rate: "fast", samples: [[0.1]]});
answer(frame.contentWindow, {id: 3, error: "refused"});
console.log(JSON.stringify({posted, listeners: listeners.length, answers: await Promise.all([good, bad, failed])}));
})();
"""
DECODE_PROBE = """
const factory = require(process.argv[1]);
const Gibberlink = require(process.argv[2]);
const R = require(process.argv[3]);
const input = JSON.parse(process.argv[4]);
factory({print: () => undefined, printErr: () => undefined}).then((ggwave) => {
const frames = R.frames(input.key, input.text);
const heard = (parts, rate) => {
const gap = Math.round(rate * 0.3);
const joined = new Float32Array(parts.reduce((sum, part) => sum + part.length + gap, 0));
parts.reduce((at, part) => {
joined.set(part, at);
return at + part.length + gap;
}, 0);
const parameters = ggwave.getDefaultParameters();
parameters.sampleRateInp = rate;
const listener = ggwave.init(parameters);
const texts = [];
for (let at = 0; at < joined.length; at += 1024) {
const got = ggwave.decode(listener, new Int8Array(joined.slice(at, at + 1024).buffer));
if (got && got.length) {
texts.push(new TextDecoder().decode(new Uint8Array(got.buffer, got.byteOffset, got.length)));
}
}
ggwave.free(listener);
return texts;
};
const decoded = {};
const rates = [];
for (const protocol of input.protocols) {
const {rate, samples} = Gibberlink.encode(ggwave, {protocol, frames});
rates.push(rate);
decoded[protocol] = heard(samples, rate);
}
const refused = input.wrong.map((request) => {
try {
Gibberlink.encode(ggwave, request);
return false;
} catch (error) {
return true;
}
});
console.log(JSON.stringify({frames, decoded, rates, refused, ids: Object.keys(ggwave.ProtocolId)}));
});
"""
def node(script: str, *args: str) -> dict:
return json.loads(subprocess.run(["node", "-e", script, *args], check=True, capture_output=True, text=True, timeout=600).stdout)
def row(cls: str, text: str) -> dict:
return {"class": cls, "source": KEY, "voice": "v1", "word": "W" if cls in ALARMS else "", "rest": "R", "text": text, "speaker": "Docs", "called": ["Docs"], "pitch": 600, **SOUND}
def header(index: int, count: int) -> str:
return f"{KEY if index == 1 else KEY[:8]} {index}/{count} "
def payloads(frames: list[str]) -> list[str]:
return [frame[len(header(index, len(frames))) :] for index, frame in enumerate(frames, start=1)]
class TestFrames(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.long = "a" * 300
cls.edges = ["b" * offset + WIDE * 40 for offset in range(8)]
texts = [[KEY, cls.long], [KEY, ""], *[[KEY, text] for text in cls.edges]]
live = {"tts": True, "open": True}
cls.cases = [(mode, fallback, gate, name) for mode in ("gibberlink", "quiet", "auto", "silence") for fallback in ("gibberlink", "morse", "burst") for gate in (True, False) for name in council.CLASSES]
plans = [[row(name, f"hello {MARK}"), {"mode": mode, "fallback": fallback, "classes": list(council.CLASSES), "muted": []}, {**live, "open": gate}] for mode, fallback, gate, name in cls.cases]
plans.append([row("post", "hello"), {"mode": "gibberlink", "fallback": "burst", "classes": list(council.CLASSES), "muted": []}, {"tts": False, "open": False}])
sets = [{}, {"fallback": "morse"}, {"fallback": "burst"}, {"fallback": "hiss"}, {"fallback": 1}, {"mode": "gibberlink"}]
cls.data = node(FRAMES_PROBE, str(RADIOSET), json.dumps({"texts": texts, "plans": plans, "sets": sets}))
def test_a_300_byte_message_splits_into_frames_of_at_most_140_bytes_with_the_key_header_and_joins_back(self):
frames = self.data["split"][0]
self.assertGreaterEqual(len(frames), 3)
for index, frame in enumerate(frames, start=1):
with self.subTest(frame=index):
self.assertLessEqual(len(frame.encode("utf-8")), 140)
self.assertTrue(frame.startswith(header(index, len(frames))), frame)
self.assertEqual("".join(payloads(frames)), self.long)
self.assertEqual(self.data["split"][1], [f"{KEY} 1/1 "], "an empty text still sends its sender")
def test_umlauts_euro_and_emoji_at_every_frame_edge_split_between_characters(self):
for offset, frames in enumerate(self.data["split"][2:]):
with self.subTest(offset=offset):
sizes = [len(frame.encode("utf-8")) for frame in frames]
self.assertTrue(all(size <= 140 for size in sizes), sizes)
self.assertGreater(max(sizes), 136, "the frames fill the budget up to the last whole character")
self.assertEqual("".join(payloads(frames)), self.edges[offset])
def test_gibberlink_mode_gives_the_alarm_classes_their_word_then_the_whole_message_and_every_other_class_the_frames_only(self):
gibberlink = {"kind": "gibberlink", "frames": [f"{KEY} 1/1 hello"], **SOUND}
for case, plan in zip(self.cases, self.data["plans"], strict=False):
mode, _, _, name = case
if mode != "gibberlink":
continue
with self.subTest(case=case):
self.assertEqual(plan, [{"kind": "word", "text": "W"}, gibberlink] if name in ALARMS else [gibberlink])
self.assertEqual(self.data["plans"][-1], [gibberlink], "without the speech engine no procedure word is rendered")
def test_quiet_and_auto_with_the_gate_closed_play_the_fallback_pick_after_the_word(self):
standins = {"gibberlink": {"kind": "gibberlink", "frames": [f"{KEY} 1/1 hello"], **SOUND}, "burst": {"kind": "burst"}}
for case, plan in zip(self.cases, self.data["plans"], strict=False):
mode, fallback, gate, name = case
word = [{"kind": "word", "text": "W"}] if name in ALARMS else []
with self.subTest(case=case):
if mode == "silence":
self.assertEqual(plan, word)
elif mode == "auto" and gate:
self.assertEqual(plan, [*word, {"kind": "speech", "text": "R"}])
elif mode != "gibberlink" and fallback == "morse":
self.assertEqual((plan[:-1], plan[-1]["kind"], plan[-1]["text"]), (word, "morse", "DE Docs hello "))
elif mode != "gibberlink":
self.assertEqual(plan, [*word, standins[fallback]])
def test_the_fallback_pick_is_kept_per_browser_beside_the_mode_and_never_in_the_hub_settings(self):
self.assertEqual(self.data["kept"], ["gibberlink", "morse", "burst", "gibberlink", "gibberlink", "gibberlink"])
constants = self.data["constants"]
self.assertEqual((constants["modes"], constants["fallbacks"], constants["fallback"]), (["auto", "quiet", "silence", "morse", "gibberlink"], ["gibberlink", "morse", "burst"], "gibberlink"))
self.assertEqual((constants["frame"]["bytes"], constants["frame"]["prefix"], constants["key"]), (140, 8, "kvb-orchestrator.radio"))
self.assertNotIn("fallback", settings.SETTINGS)
self.assertNotIn("fallback", json.dumps(settings.SETTINGS))
class TestSpeakerSound(unittest.TestCase):
def test_every_speaker_gets_one_stable_protocol_and_stereo_position_from_its_slot(self):
keys = [f"s{number}" for number in range(200)]
sounds = [engines.sound_of(key) for key in keys]
self.assertEqual(sounds, [engines.sound_of(key) for key in keys])
self.assertTrue(all(sound["protocol"] in engines.GIBBERLINK and sound["pan"] in engines.PANS for sound in sounds))
self.assertEqual(len({(sound["protocol"], sound["pan"]) for sound in sounds}), len(engines.GIBBERLINK) * len(engines.PANS))
with mock.patch.object(engines, "slot", lambda key, count: count - 1):
self.assertEqual(engines.sound_of("s1"), {"protocol": engines.GIBBERLINK[-1], "pan": engines.PANS[-1]})
self.assertEqual(engines.sound_of("s1")["protocol"], engines.GIBBERLINK[engines.slot("s1", 20) % 4])
def test_speakers_in_distinct_slots_get_distinct_protocols_from_the_vendored_source(self):
picks = {}
for number in range(200):
picks.setdefault(engines.slot(f"s{number}", 20) % len(engines.GIBBERLINK), f"s{number}")
self.assertEqual(len({engines.sound_of(key)["protocol"] for key in picks.values()}), len(engines.GIBBERLINK))
self.assertEqual(engines.GIBBERLINK, ("AUDIBLE_NORMAL", "AUDIBLE_FAST", "AUDIBLE_FASTEST", "DT_FASTEST"))
class TestPlaying(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.data = node(PLAYING_PROBE, str(RADIOSET), str(MORSE), str(VOICE), str(PAGE_SPEECH), str(PAGE_MORSE), str(PAGE_GIBBERLINK))
def test_the_frames_play_once_in_the_sender_position_at_the_tone_volume_times_the_squelch(self):
whole = self.data["whole"]
self.assertEqual(whole["encoded"], [[-0.4, 3]])
self.assertEqual((len(whole["length"]), whole["pan"], whole["gain"], whole["idle"]), (1, [-0.4], [0.5], True))
self.assertGreater(whole["length"][0], 399 * 10 + 3 * 48000 * 0.3 - 1, "every frame with a 0.3 second gap at the encoder's 48 kHz")
self.assertEqual(self.data["quiet"], [0.25])
self.assertEqual(self.data["mute"], [0, 0, True], "squelch 0 encodes and plays nothing")
def test_stop_ends_the_frames_at_once(self):
stop = self.data["stop"]
self.assertEqual((stop["playing"], stop["stops"], stop["idle"]), ([1, True], ["now"], True))
def test_a_mayday_cuts_a_post_whose_frames_play_and_the_post_sends_again_whole_after_it(self):
urgent = self.data["urgent"]
self.assertEqual(urgent["during"], {"buffers": [[-0.8, True], [0.8, False]], "pending": ["post"]})
self.assertEqual(urgent["encoded"], [[-0.8, 3], [0.8, 1], [-0.8, 3]])
self.assertEqual(urgent["after"][2], [-0.8, "now"])
def test_a_mode_change_cuts_the_frames_and_replans_the_row(self):
self.assertEqual(self.data["switched"], {"stops": ["now"], "oscillators": 1})
class TestEncoderAnswers(unittest.TestCase):
def test_the_page_takes_samples_only_from_its_own_encoder_frame_and_refuses_anything_else(self):
data = node(ANSWER_PROBE, str(PAGE_GIBBERLINK))
self.assertEqual(data["listeners"], 1, "one encoder frame, one listener, however often the radio encodes")
self.assertEqual(data["posted"], [{"id": 1, "protocol": "AUDIBLE_FAST", "frames": ["a", "b"]}, {"id": 2, "protocol": "AUDIBLE_FAST", "frames": ["c"]}, {"id": 3, "protocol": "MT_FAST", "frames": ["d"]}])
self.assertEqual(data["answers"], [{"rate": 48000, "parts": 2}, {"error": "the Gibberlink encoder answered no samples"}, {"error": "refused"}])
class TestEncoder(unittest.TestCase):
def test_every_protocol_decodes_back_to_the_frame_texts_and_wrong_requests_are_refused(self):
text = f"disk full on {WIDE} " + "rotate the keys " * 15
wrong = [{"protocol": "MT_FAST", "frames": ["x"]}, {"protocol": "values", "frames": ["x"]}, {"protocol": "AUDIBLE_FAST", "frames": [1]}, {"protocol": "AUDIBLE_FAST", "frames": "x"}, {"frames": ["x"]}]
data = node(DECODE_PROBE, str(GGWAVE), str(GIBBERLINK), str(RADIOSET), json.dumps({"key": KEY, "text": text, "protocols": engines.GIBBERLINK, "wrong": wrong}))
self.assertGreaterEqual(len(data["frames"]), 3)
self.assertEqual(list(data["decoded"]), list(engines.GIBBERLINK))
for name, heard in data["decoded"].items():
with self.subTest(protocol=name):
self.assertEqual(heard, data["frames"])
self.assertEqual((set(data["rates"]), data["refused"]), ({48000}, [True] * len(wrong)))
for name in engines.GIBBERLINK:
with self.subTest(protocol=name):
self.assertIn(f"GGWAVE_PROTOCOL_{name}", data["ids"])
class TestEncoderHttp(HubCase):
def test_the_encoder_page_carries_its_own_csp_and_the_hub_page_never_allows_eval(self):
status, headers, body = self.get("/gibberlink")
page = body.decode("utf-8")
nonces = set(re.findall(r'<script nonce="([^"]+)"', page))
self.assertEqual((status, headers["content-type"], len(nonces)), (200, "text/html; charset=utf-8", 1), page)
csp = headers["content-security-policy"]
self.assertEqual(csp, ENCODER_CSP.format(nonces.pop()))
self.assertIn("'unsafe-eval' 'wasm-unsafe-eval'", csp)
self.assertTrue(csp.startswith("sandbox allow-scripts;"), "the server keeps the encoder in an opaque origin even at top level")
self.assertIn("connect-src 'none'", csp)
self.assertIn('src="/vendor/ggwave.js"', page)
self.assertIn("Gibberlink.serve(window, ggwave_factory(", page)
self.assertLess(page.index("window.fetch = () => Promise.reject("), page.index("Gibberlink.serve("), "the frame asks for nothing before ggwave loads its wasm")
self.assertNotEqual(self.get("/gibberlink")[1]["content-security-policy"], csp, "every load gets a fresh nonce")
index = self.get("/")[1]["content-security-policy"]
self.assertNotIn("unsafe-eval", index)
self.assertIn("frame-src 'self'", index)
def test_the_vendor_route_serves_ggwave_under_the_plain_csp(self):
status, headers, body = self.get("/vendor/ggwave.js")
self.assertEqual((status, headers["content-type"], headers["content-security-policy"]), (200, "text/javascript; charset=utf-8", exchange.PLAIN_CSP))
self.assertEqual(body, GGWAVE.read_bytes())
def test_every_radio_row_carries_the_sender_protocol_and_stereo_position(self):
self.claim("s1", "Docs")
self.claim("s2", "Skills")
now = time.time()
self.write_council({"news.jsonl": self.jsonl([
{"ts": now - 30, "from": "Docs", "to": ["Skills"], "text": "gate red", "class": "call", "v": 2},
{"ts": now - 20, "from": "Skills", "to": [], "text": "MAYDAY disk full", "class": "mayday", "v": 2},
])})
rows = [(row["source"], row["protocol"], row["pan"]) for row in self.snapshot()["radio"]]
self.assertEqual(rows, [(key, *engines.sound_of(key).values()) for key in ("s1", "s2")])
if __name__ == "__main__":
unittest.main()