Adolfo Reyna
351 lines
15 KiB
Python
351 lines
15 KiB
Python
import unittest
|
|
from unittest.mock import AsyncMock, patch
|
|
|
|
from audio_device_monitor import AudioDeviceSnapshot
|
|
from pipecat.frames.frames import StartFrame
|
|
from sounddevice_transport import (
|
|
SoundDeviceInputTransport,
|
|
SoundDeviceOutputTransport,
|
|
SoundDeviceTransport,
|
|
SoundDeviceTransportParams,
|
|
)
|
|
|
|
|
|
class FakeMonitor:
|
|
def __init__(self):
|
|
self.start = AsyncMock()
|
|
self.stop = AsyncMock()
|
|
|
|
|
|
class SoundDeviceTransportSwitchTests(unittest.IsolatedAsyncioTestCase):
|
|
def _transport(self, *, input_device=None, output_device=None):
|
|
transport = SoundDeviceTransport(
|
|
SoundDeviceTransportParams(input_device=input_device, output_device=output_device)
|
|
)
|
|
transport._input = type("Input", (), {"reopen": AsyncMock()})()
|
|
transport._output = type("Output", (), {"reopen": AsyncMock()})()
|
|
return transport
|
|
|
|
async def test_default_changes_reopen_only_unset_sides(self):
|
|
transport = self._transport(input_device=None, output_device="My Speakers")
|
|
|
|
await transport._on_device_change(AudioDeviceSnapshot(1, "mic", "speakers"))
|
|
await transport._on_device_change(AudioDeviceSnapshot(2, "airpods", "airpods"))
|
|
|
|
transport._input.reopen.assert_awaited_once_with()
|
|
transport._output.reopen.assert_not_awaited()
|
|
|
|
async def test_default_changes_preserve_each_override_for_all_override_combinations(self):
|
|
devices = {
|
|
"old-mic": type("Device", (), {"name": "Built-in Mic", "can_input": True, "can_output": False})(),
|
|
"old-speaker": type("Device", (), {"name": "Built-in Speaker", "can_input": False, "can_output": True})(),
|
|
"new-mic": type("Device", (), {"name": "USB Mic", "can_input": True, "can_output": False})(),
|
|
"new-speaker": type("Device", (), {"name": "USB Speaker", "can_input": False, "can_output": True})(),
|
|
}
|
|
portaudio_devices = [
|
|
{"name": "Built-in Mic", "max_input_channels": 1, "max_output_channels": 0},
|
|
{"name": "Built-in Speaker", "max_input_channels": 0, "max_output_channels": 2},
|
|
{"name": "USB Mic", "max_input_channels": 1, "max_output_channels": 0},
|
|
{"name": "USB Speaker", "max_input_channels": 0, "max_output_channels": 2},
|
|
]
|
|
initial = AudioDeviceSnapshot(1, "old-mic", "old-speaker", devices=devices)
|
|
changed = AudioDeviceSnapshot(2, "new-mic", "new-speaker", devices=devices)
|
|
|
|
with patch("sounddevice_transport.sd.query_devices", return_value=portaudio_devices):
|
|
for input_override, output_override in (
|
|
(None, None),
|
|
("Pinned Mic", None),
|
|
(None, "Pinned Speaker"),
|
|
("Pinned Mic", "Pinned Speaker"),
|
|
):
|
|
with self.subTest(input_override=input_override, output_override=output_override):
|
|
transport = self._transport(
|
|
input_device=input_override,
|
|
output_device=output_override,
|
|
)
|
|
await transport._on_device_change(initial)
|
|
await transport._on_device_change(changed)
|
|
|
|
if input_override is None:
|
|
transport._input.reopen.assert_awaited_once_with(device=2)
|
|
else:
|
|
transport._input.reopen.assert_not_awaited()
|
|
if output_override is None:
|
|
transport._output.reopen.assert_awaited_once_with(device=3)
|
|
else:
|
|
transport._output.reopen.assert_not_awaited()
|
|
|
|
async def test_unavailable_default_does_not_reopen_that_side_but_reopens_other_side(self):
|
|
transport = self._transport()
|
|
devices = {
|
|
"mic": type("Device", (), {"name": "Mic", "can_input": True, "can_output": False})(),
|
|
"speaker": type("Device", (), {"name": "Speaker", "can_input": False, "can_output": True})(),
|
|
"headphones": type("Device", (), {"name": "Headphones", "can_input": False, "can_output": True})(),
|
|
}
|
|
initial = AudioDeviceSnapshot(1, "mic", "speaker", devices=devices)
|
|
unavailable_input = AudioDeviceSnapshot(2, None, "headphones", devices=devices)
|
|
with patch("sounddevice_transport.sd.query_devices", return_value=[
|
|
{"name": "Headphones", "max_input_channels": 0, "max_output_channels": 2},
|
|
]):
|
|
await transport._on_device_change(initial)
|
|
await transport._on_device_change(unavailable_input)
|
|
|
|
transport._input.reopen.assert_not_awaited()
|
|
transport._output.reopen.assert_awaited_once_with(device=0)
|
|
|
|
async def test_input_only_output_only_and_simultaneous_changes_route_independently(self):
|
|
transport = self._transport()
|
|
await transport._on_device_change(AudioDeviceSnapshot(1, "mic", "speaker"))
|
|
|
|
await transport._on_device_change(AudioDeviceSnapshot(2, "airpods-mic", "speaker"))
|
|
transport._input.reopen.assert_awaited_once_with()
|
|
transport._output.reopen.assert_not_awaited()
|
|
|
|
await transport._on_device_change(AudioDeviceSnapshot(3, "airpods-mic", "airpods-speaker"))
|
|
transport._input.reopen.assert_awaited_once_with()
|
|
transport._output.reopen.assert_awaited_once_with()
|
|
|
|
await transport._on_device_change(AudioDeviceSnapshot(4, "mac-mic", "mac-speaker"))
|
|
self.assertEqual(transport._input.reopen.await_count, 2)
|
|
self.assertEqual(transport._output.reopen.await_count, 2)
|
|
|
|
async def test_default_change_uses_current_portaudio_device_not_process_startup_default(self):
|
|
transport = self._transport()
|
|
initial = AudioDeviceSnapshot(1, "built-in-mic", "built-in-speaker")
|
|
switched = AudioDeviceSnapshot(2, "airpods-input", "airpods-output", devices={
|
|
"airpods-input": type("Device", (), {"name": "AirPods", "can_input": True, "can_output": False})(),
|
|
"airpods-output": type("Device", (), {"name": "AirPods", "can_input": False, "can_output": True})(),
|
|
})
|
|
with patch("sounddevice_transport.sd.query_devices", return_value=[
|
|
{"name": "MacBook Air Speakers", "max_input_channels": 0, "max_output_channels": 2},
|
|
{"name": "AirPods", "max_input_channels": 1, "max_output_channels": 0},
|
|
{"name": "AirPods", "max_input_channels": 0, "max_output_channels": 2},
|
|
]):
|
|
await transport._on_device_change(initial)
|
|
await transport._on_device_change(switched)
|
|
|
|
transport._input.reopen.assert_awaited_once_with(device=1)
|
|
transport._output.reopen.assert_awaited_once_with(device=2)
|
|
|
|
async def test_input_override_does_not_follow_default_but_output_does(self):
|
|
params = SoundDeviceTransportParams(input_device="USB Mic", output_device=None)
|
|
transport = SoundDeviceTransport(params)
|
|
transport._input = type("Input", (), {"reopen": AsyncMock()})()
|
|
transport._output = type("Output", (), {"reopen": AsyncMock()})()
|
|
|
|
await transport._on_device_change(AudioDeviceSnapshot(1, "mic", "speakers"))
|
|
await transport._on_device_change(AudioDeviceSnapshot(2, "airpods", "headphones"))
|
|
|
|
transport._input.reopen.assert_not_awaited()
|
|
transport._output.reopen.assert_awaited_once_with()
|
|
|
|
async def test_runtime_event_sink_receives_native_device_snapshot(self):
|
|
sink = AsyncMock()
|
|
transport = SoundDeviceTransport(SoundDeviceTransportParams(), device_event_sink=sink)
|
|
|
|
snapshot = AudioDeviceSnapshot(1, "mic", "speaker")
|
|
await transport._on_device_change(snapshot)
|
|
|
|
sink.assert_awaited_once_with(snapshot)
|
|
|
|
async def test_stale_snapshot_cannot_reopen_a_replaced_stream(self):
|
|
transport = self._transport()
|
|
|
|
await transport._on_device_change(AudioDeviceSnapshot(1, "mic", "speaker"))
|
|
await transport._on_device_change(AudioDeviceSnapshot(3, "airpods", "airpods"))
|
|
await transport._on_device_change(AudioDeviceSnapshot(2, "mic", "speaker"))
|
|
|
|
transport._input.reopen.assert_awaited_once_with()
|
|
transport._output.reopen.assert_awaited_once_with()
|
|
|
|
async def test_failed_input_reopen_keeps_output_route_change_alive(self):
|
|
transport = self._transport()
|
|
transport._input.reopen.side_effect = OSError("device unavailable")
|
|
|
|
await transport._on_device_change(AudioDeviceSnapshot(1, "mic", "speaker"))
|
|
await transport._on_device_change(AudioDeviceSnapshot(2, "airpods", "airpods"))
|
|
|
|
transport._input.reopen.assert_awaited_once_with()
|
|
transport._output.reopen.assert_awaited_once_with()
|
|
|
|
async def test_transport_starts_and_stops_injected_monitor_once(self):
|
|
monitor = FakeMonitor()
|
|
transport = SoundDeviceTransport(SoundDeviceTransportParams(), device_monitor=monitor)
|
|
|
|
await transport.start_device_monitor()
|
|
await transport.start_device_monitor()
|
|
await transport.stop_device_monitor()
|
|
await transport.stop_device_monitor()
|
|
|
|
monitor.start.assert_awaited_once_with(transport._on_device_change)
|
|
monitor.stop.assert_awaited_once_with()
|
|
|
|
async def test_production_transport_installs_macos_monitor_when_defaults_are_unset(self):
|
|
monitor = FakeMonitor()
|
|
with (
|
|
patch("sounddevice_transport.sys.platform", "darwin"),
|
|
patch("sounddevice_transport.create_macos_audio_monitor", return_value=monitor) as factory,
|
|
):
|
|
transport = SoundDeviceTransport(SoundDeviceTransportParams())
|
|
await transport.start_device_monitor()
|
|
|
|
factory.assert_called_once_with()
|
|
monitor.start.assert_awaited_once_with(transport._on_device_change)
|
|
|
|
async def test_production_input_start_installs_and_cleanup_releases_device_monitor(self):
|
|
monitor = FakeMonitor()
|
|
transport = SoundDeviceTransport(
|
|
SoundDeviceTransportParams(), device_monitor=monitor
|
|
)
|
|
input_transport = transport.input()
|
|
|
|
class FakeInputStream:
|
|
device = 0
|
|
|
|
def __init__(self, **_kwargs):
|
|
pass
|
|
|
|
def start(self):
|
|
pass
|
|
|
|
def stop(self):
|
|
pass
|
|
|
|
def close(self):
|
|
pass
|
|
|
|
with (
|
|
patch("sounddevice_transport.sd.RawInputStream", FakeInputStream),
|
|
patch("sounddevice_transport.sd.query_devices", return_value={"name": "Fake Mic"}),
|
|
):
|
|
await input_transport.start(StartFrame(audio_in_sample_rate=16000))
|
|
await input_transport.cleanup()
|
|
|
|
monitor.start.assert_awaited_once_with(transport._on_device_change)
|
|
monitor.stop.assert_awaited_once_with()
|
|
|
|
async def test_production_input_start_skips_unavailable_monitor_off_macos(self):
|
|
transport = SoundDeviceTransport(SoundDeviceTransportParams())
|
|
input_transport = transport.input()
|
|
|
|
class FakeInputStream:
|
|
device = 0
|
|
|
|
def __init__(self, **_kwargs):
|
|
pass
|
|
|
|
def start(self):
|
|
pass
|
|
|
|
def stop(self):
|
|
pass
|
|
|
|
def close(self):
|
|
pass
|
|
|
|
with (
|
|
patch("sounddevice_transport.sys.platform", "linux"),
|
|
patch("sounddevice_transport.create_macos_audio_monitor") as factory,
|
|
patch("sounddevice_transport.sd.RawInputStream", FakeInputStream),
|
|
patch("sounddevice_transport.sd.query_devices", return_value={"name": "Fake Mic"}),
|
|
):
|
|
await input_transport.start(StartFrame(audio_in_sample_rate=16000))
|
|
await input_transport.cleanup()
|
|
|
|
factory.assert_not_called()
|
|
|
|
async def test_cleaning_one_side_keeps_monitor_until_last_side_stops(self):
|
|
monitor = FakeMonitor()
|
|
transport = SoundDeviceTransport(SoundDeviceTransportParams(), device_monitor=monitor)
|
|
input_transport = transport.input()
|
|
output_transport = transport.output()
|
|
|
|
await transport.start_device_monitor(input_transport)
|
|
await transport.start_device_monitor(output_transport)
|
|
await input_transport.cleanup()
|
|
|
|
monitor.stop.assert_not_awaited()
|
|
await output_transport.cleanup()
|
|
|
|
monitor.start.assert_awaited_once_with(transport._on_device_change)
|
|
monitor.stop.assert_awaited_once_with()
|
|
|
|
async def test_failed_runtime_selection_keeps_previous_pin(self):
|
|
transport = self._transport(output_device=5)
|
|
transport._output.reopen.side_effect = OSError("unavailable")
|
|
with patch("sounddevice_transport.sd.query_devices", return_value=[
|
|
{"name": "MacBook Air Speakers", "max_input_channels": 0, "max_output_channels": 2},
|
|
{"name": "AirPods", "max_input_channels": 0, "max_output_channels": 2},
|
|
]):
|
|
with self.assertRaises(OSError):
|
|
await transport.set_runtime_device("output", "airpods")
|
|
|
|
self.assertEqual(transport._params.output_device, 5)
|
|
|
|
async def test_runtime_selection_pins_only_requested_direction(self):
|
|
transport = self._transport()
|
|
with patch("sounddevice_transport.sd.query_devices", return_value=[
|
|
{"name": "MacBook Air Speakers", "max_input_channels": 0, "max_output_channels": 2},
|
|
{"name": "AirPods", "max_input_channels": 1, "max_output_channels": 0},
|
|
{"name": "AirPods", "max_input_channels": 0, "max_output_channels": 2},
|
|
]):
|
|
result = await transport.set_runtime_device("output", "airpods")
|
|
|
|
self.assertEqual(result["device"], 2)
|
|
self.assertEqual(transport._params.output_device, 2)
|
|
self.assertIsNone(transport._params.input_device)
|
|
transport._output.reopen.assert_awaited_once_with(device=2)
|
|
transport._input.reopen.assert_not_awaited()
|
|
|
|
async def test_switching_a_pinned_side_to_default_starts_monitor_for_snapshot(self):
|
|
monitor = FakeMonitor()
|
|
|
|
async def publish_initial_snapshot(callback):
|
|
await callback(AudioDeviceSnapshot(1, "mic", "speaker"))
|
|
|
|
monitor.start.side_effect = publish_initial_snapshot
|
|
transport = SoundDeviceTransport(
|
|
SoundDeviceTransportParams(input_device="USB Mic", output_device="USB Speakers"),
|
|
device_monitor=monitor,
|
|
)
|
|
transport._input = type("Input", (), {"reopen": AsyncMock()})()
|
|
|
|
await transport.set_runtime_device("input", None)
|
|
|
|
monitor.start.assert_awaited_once_with(transport._on_device_change)
|
|
transport._input.reopen.assert_awaited_once_with()
|
|
|
|
async def test_old_input_callback_cannot_deliver_after_replacement(self):
|
|
input_transport = SoundDeviceInputTransport(SoundDeviceTransportParams())
|
|
input_transport.push_audio_frame = AsyncMock()
|
|
input_transport._stream_generation = 2
|
|
|
|
await input_transport._push_audio_frame_if_current(1, object())
|
|
|
|
input_transport.push_audio_frame.assert_not_awaited()
|
|
|
|
async def test_failed_output_stream_start_closes_partial_stream(self):
|
|
class FailingStream:
|
|
closed = False
|
|
|
|
def __init__(self, **_kwargs):
|
|
pass
|
|
|
|
def start(self):
|
|
raise OSError("unavailable")
|
|
|
|
def close(self):
|
|
self.closed = True
|
|
|
|
output = SoundDeviceOutputTransport(SoundDeviceTransportParams())
|
|
output._sample_rate = 24000
|
|
with patch("sounddevice_transport.sd.RawOutputStream", FailingStream):
|
|
with self.assertRaises(OSError):
|
|
await output._open_stream()
|
|
|
|
self.assertIsNone(output._out_stream)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|