201 lines
8.4 KiB
Python
Executable File
201 lines
8.4 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Fixture tests for the audio layer's parsing and selection.
|
|
|
|
python3 mic-follow/test_selection.py
|
|
|
|
The commands that CHANGE state cannot be tested without a real PipeWire session; what
|
|
can be tested is everything that decides which device those commands are pointed at,
|
|
and that is where the damaging mistakes live — picking a monitor source (transmitting
|
|
what the desktop is playing instead of what the person is saying), or picking a
|
|
different microphone after a reboot because two matched and the order changed.
|
|
|
|
The fixtures are hand-written in pactl's documented JSON shape. VERIFY THEM against
|
|
real output (`pactl -f json list sources`) the first time this runs on the desktop —
|
|
they are the assumption this whole component rests on.
|
|
"""
|
|
|
|
import sys
|
|
import unittest
|
|
from pathlib import Path
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
|
import audio_sources as audio
|
|
import generate
|
|
|
|
SOURCES = [
|
|
{
|
|
"index": 44,
|
|
"name": "alsa_output.pci-0000_0c_00.4.analog-stereo.monitor",
|
|
"description": "Monitor of Family 17h HD Audio",
|
|
"properties": {"device.class": "monitor"},
|
|
},
|
|
{
|
|
"index": 46,
|
|
"name": "alsa_input.usb-Shure_Inc_MV6-00.mono-fallback",
|
|
"description": "MV6 Mono",
|
|
"properties": {"device.class": "sound"},
|
|
},
|
|
{
|
|
"index": 51,
|
|
"name": "bluez_input.AC:12:2F:9B:00:01.headset-head-unit",
|
|
"description": "Arctis Nova 7 (headset mic)",
|
|
"properties": {"device.class": "sound"},
|
|
},
|
|
{
|
|
"index": 58,
|
|
"name": "alsa_input.usb-DJI_MIC_MINI-00.mono-fallback",
|
|
"description": "DJI MIC MINI Mono",
|
|
"properties": {"device.class": "sound"},
|
|
},
|
|
]
|
|
|
|
STREAMS = [
|
|
{"index": 12, "source": 46, "properties": {"application.name": "Discord"}},
|
|
{"index": 13, "source": 46, "properties": {"application.name": "obs"}},
|
|
{"index": 14, "source": 58, "properties": {"application.process.binary": "Discord"}},
|
|
]
|
|
|
|
|
|
class ParsingTests(unittest.TestCase):
|
|
def test_monitors_are_dropped(self):
|
|
names = [s.name for s in audio.parse_sources(SOURCES)]
|
|
self.assertNotIn("alsa_output.pci-0000_0c_00.4.analog-stereo.monitor", names)
|
|
self.assertEqual(len(names), 3)
|
|
|
|
def test_monitor_dropped_by_property_even_without_the_suffix(self):
|
|
odd = [{"index": 1, "name": "weird_monitor_name", "description": "x",
|
|
"properties": {"device.class": "Monitor"}}]
|
|
self.assertEqual(audio.parse_sources(odd), [])
|
|
|
|
def test_description_falls_back_to_the_name(self):
|
|
bare = [{"index": 2, "name": "some.source", "properties": {}}]
|
|
self.assertEqual(audio.parse_sources(bare)[0].description, "some.source")
|
|
|
|
def test_capture_streams_read_either_application_property(self):
|
|
streams = audio.parse_capture_streams(STREAMS)
|
|
self.assertEqual([s.application for s in streams], ["Discord", "obs", "Discord"])
|
|
|
|
def test_garbage_does_not_raise(self):
|
|
self.assertEqual(audio.parse_sources(None), [])
|
|
self.assertEqual(audio.parse_sources(["not a dict"]), [])
|
|
self.assertEqual(audio.parse_capture_streams(None), [])
|
|
|
|
|
|
class SelectionTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.sources = audio.parse_sources(SOURCES)
|
|
|
|
def test_substring_of_the_description(self):
|
|
self.assertEqual(audio.select_source(self.sources, "MV6").index, 46)
|
|
|
|
def test_substring_of_the_node_name(self):
|
|
self.assertEqual(audio.select_source(self.sources, "DJI_MIC").index, 58)
|
|
|
|
def test_case_insensitive(self):
|
|
self.assertEqual(audio.select_source(self.sources, "dji mic mini").index, 58)
|
|
|
|
def test_exact_name_wins_over_a_substring_of_another(self):
|
|
sources = self.sources + [audio.Source(70, "mv6", "Something else entirely")]
|
|
self.assertEqual(audio.select_source(sources, "mv6").index, 70)
|
|
|
|
def test_ambiguous_match_is_deterministic(self):
|
|
# Two headsets, one pattern: the answer must be the same after a reboot, not
|
|
# whichever pactl happened to list first.
|
|
sources = self.sources + [audio.Source(9, "bluez_input.OTHER.headset", "Other headset mic")]
|
|
self.assertEqual(audio.select_source(sources, "headset").index, 9)
|
|
|
|
def test_no_match_is_none_not_a_guess(self):
|
|
self.assertIsNone(audio.select_source(self.sources, "rode wireless"))
|
|
|
|
def test_empty_pattern_is_none(self):
|
|
self.assertIsNone(audio.select_source(self.sources, " "))
|
|
|
|
def test_a_monitor_can_never_be_selected(self):
|
|
# The pattern below matches the monitor's description and nothing else; the
|
|
# right answer is None, never "transmit the desktop's audio".
|
|
self.assertIsNone(audio.select_source(self.sources, "Monitor of Family"))
|
|
|
|
|
|
class StreamMoveTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.streams = audio.parse_capture_streams(STREAMS)
|
|
self.dji = audio.Source(58, "alsa_input.usb-DJI_MIC_MINI-00.mono-fallback", "DJI")
|
|
self.mv6 = audio.Source(46, "alsa_input.usb-Shure_Inc_MV6-00.mono-fallback", "MV6")
|
|
|
|
def test_only_configured_applications_move(self):
|
|
moved = audio.streams_to_move(self.streams, ["Discord"], self.dji)
|
|
self.assertEqual([s.index for s in moved], [12])
|
|
|
|
def test_streams_already_on_the_target_are_left_alone(self):
|
|
moved = audio.streams_to_move(self.streams, ["Discord"], self.mv6)
|
|
self.assertEqual([s.index for s in moved], [14])
|
|
|
|
def test_no_applications_configured_moves_nothing(self):
|
|
self.assertEqual(audio.streams_to_move(self.streams, [], self.dji), [])
|
|
|
|
def test_matching_is_case_insensitive_and_partial(self):
|
|
moved = audio.streams_to_move(self.streams, ["discord"], self.dji)
|
|
self.assertEqual([s.index for s in moved], [12])
|
|
|
|
|
|
class RemoteSourceTests(unittest.TestCase):
|
|
"""The generated hooks for a microphone on another machine.
|
|
|
|
These are worth pinning because the STOP hook is a safety property: a room
|
|
microphone still streaming after the switch left it is a hot mic in a shared flat,
|
|
and "the generator emitted a stop command" is exactly the kind of thing that
|
|
silently stops being true.
|
|
"""
|
|
|
|
def setUp(self):
|
|
self.remote = {
|
|
"room": "loggia",
|
|
"description": "Loggia panel mic",
|
|
"remote": {"host": "touch-panel-loggia", "user": "kiosk", "latency_ms": 40},
|
|
}
|
|
self.local = {"room": "kitchen", "source": "DJI MIC MINI"}
|
|
|
|
def test_remote_source_gets_a_generated_name(self):
|
|
self.assertEqual(generate.remote_source_name(self.remote), "micfollow_loggia")
|
|
|
|
def test_an_explicit_name_wins(self):
|
|
named = dict(self.remote, source="my_own_name")
|
|
self.assertEqual(generate.remote_source_name(named), "my_own_name")
|
|
|
|
def test_remote_source_gets_both_hooks(self):
|
|
entry = generate.source_entry(self.remote, Path("/repo"))
|
|
self.assertEqual(entry["source"], "micfollow_loggia")
|
|
self.assertIn("remote-mic.sh start loggia", entry["start_command"])
|
|
self.assertIn("remote-mic.sh stop loggia", entry["stop_command"])
|
|
|
|
def test_every_remote_source_has_a_stop_hook(self):
|
|
for host in ("panel", "other-machine"):
|
|
entry = generate.source_entry(
|
|
{"room": "x", "remote": {"host": host}}, Path("/repo"))
|
|
self.assertTrue(entry["stop_command"], "a remote source without a stop hook")
|
|
|
|
def test_local_source_is_left_alone(self):
|
|
entry = generate.source_entry(self.local, Path("/repo"))
|
|
self.assertEqual(entry["source"], "DJI MIC MINI")
|
|
self.assertEqual(entry["start_command"], "")
|
|
self.assertEqual(entry["stop_command"], "")
|
|
|
|
def test_env_carries_the_transport_parameters(self):
|
|
env = generate.build_remote_env(self.remote, Path("/repo"))
|
|
self.assertIn("REMOTE_HOST=touch-panel-loggia", env)
|
|
self.assertIn("REMOTE_USER=kiosk", env)
|
|
self.assertIn("SOURCE_NAME=micfollow_loggia", env)
|
|
self.assertIn("LATENCY_MS=40", env)
|
|
# Empty means "the panel's own default input", which is what lets this work
|
|
# without knowing that machine's device names.
|
|
self.assertIn("REMOTE_MIC=", env)
|
|
|
|
def test_room_labels_are_short_and_readable(self):
|
|
self.assertEqual(generate.room_label("loggia"), "Loggia")
|
|
self.assertEqual(generate.room_label("living_room"), "Living room")
|
|
self.assertEqual(generate.room_label("desk"), "Desk")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main(verbosity=2)
|