Working on tests

tests/test_always_streaming.py

@@ -0,0 +1,102 @@
+import asyncio
+import logging
+import os
+from pathlib import Path
+
+import pytest
+from wyoming.audio import AudioChunk
+from wyoming.wake import Detection
+from wyoming.client import AsyncClient
+from wyoming.event import Event, async_write_event
+from wyoming.server import AsyncServer, AsyncEventHandler
+from wyoming_satellite import (
+    AlwaysStreamingSatellite,
+    EventSettings,
+    SatelliteSettings,
+    MicSettings,
+    WakeSettings,
+)
+
+from .shared import WYOMING_INFO, AUDIO_CHUNK
+
+_LOGGER = logging.getLogger()
+
+class MicEventHandler(AsyncEventHandler):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._is_connected = True
+        self._task = asyncio.create_task(self.stream_audio())
+
+    async def handle_event(self, event: Event) -> bool:
+        """Output only."""
+        return True
+
+    async def stream_audio(self) -> None:
+        while self._is_connected:
+            await self.write_event(AUDIO_CHUNK.event())
+            await asyncio.sleep(AUDIO_CHUNK.seconds)
+
+    async def disconnect(self) -> None:
+        self._is_connected = False
+        await self._task
+
+
+class WakeEventHandler(AsyncEventHandler):
+    async def handle_event(self, event: Event) -> bool:
+        _LOGGER.error(event)
+        if AudioChunk.is_type(event.type):
+            await self.write_event(Detection().event())
+
+        return True
+
+
+@pytest.mark.asyncio
+async def test_multiple_wakeups(tmp_path: Path) -> None:
+    mic_socket = tmp_path / "mic.socket"
+    os.mkfifo(mic_socket)
+    mic_uri = f"unix://{mic_socket}"
+    mic_server = AsyncServer.from_uri(mic_uri)
+    mic_task = asyncio.create_task(mic_server.run(MicEventHandler))
+
+    wake_socket = tmp_path / "wake.socket"
+    os.mkfifo(wake_socket)
+    wake_uri = f"unix://{wake_socket}"
+    wake_server = AsyncServer.from_uri(wake_uri)
+    wake_task = asyncio.create_task(wake_server.run(WakeEventHandler))
+
+    wake_event = asyncio.Event()
+
+    class EventEventHandler(AsyncEventHandler):
+        async def handle_event(self, event: Event) -> bool:
+            if Detection.is_type(event.type):
+                wake_event.set()
+
+            return True
+
+    event_socket = tmp_path / "event.socket"
+    os.mkfifo(event_socket)
+    event_uri = f"unix://{event_socket}"
+    event_server = AsyncServer.from_uri(event_uri)
+    event_task = asyncio.create_task(event_server.run(EventEventHandler))
+
+    satellite = AlwaysStreamingSatellite(
+        SatelliteSettings(
+            mic=MicSettings(uri=mic_uri),
+            wake=WakeSettings(uri=wake_uri),
+            event=EventSettings(uri=event_uri),
+        )
+    )
+
+    satellite_task = asyncio.create_task(satellite.run())
+
+    await asyncio.sleep(0.5)
+
+    # async with asyncio.timeout(1):
+    #     await wake_event.wait()
+
+    # await satellite.stop()
+
+    tasks = [mic_task, wake_task, event_task]
+    for task in tasks:
+        task.cancel()
+    await asyncio.wait(tasks)