fix: harden realtime pipeline lifecycle

2026-09-07 08:27:52 +08:00
parent 43f2cc445e
commit 8025ed8aa0
12 changed files with 445 additions and 42 deletions
@@ -0,0 +1,101 @@
+"""Regression checks for whole-pipeline assembly and terminal outcomes."""
+
+import asyncio
+import unittest
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, patch
+
+from models import AssistantConfig
+from pipecat.frames.frames import CancelFrame, EndFrame, ErrorFrame, StartFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.worker import PipelineWorker
+from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+from services.pipecat import pipeline
+from services.pipecat.pipeline_runner import run_media_worker
+
+
+class PipelineAssemblyTest(unittest.IsolatedAsyncioTestCase):
+    async def test_realtime_startup_preserves_client_capabilities(self):
+        brain = SimpleNamespace(
+            spec=SimpleNamespace(supported_runtime_modes={"realtime"}),
+            system_prompt=lambda cfg: "test",
+            greeting=AsyncMock(return_value=""),
+            setup_realtime=AsyncMock(),
+            on_session_update=AsyncMock(),
+        )
+        transport = SimpleNamespace(
+            input=lambda: FrameProcessor(),
+            output=lambda: FrameProcessor(),
+            event_handler=lambda name: lambda handler: handler,
+        )
+        with (
+            patch.object(pipeline, "build_brain", return_value=brain),
+            patch.object(pipeline, "create_realtime_service", return_value=FrameProcessor()),
+            patch.object(pipeline.ConversationRecorder, "start", new=AsyncMock(return_value=None)),
+            patch.object(pipeline, "run_media_worker", new=AsyncMock()) as run,
+        ):
+            await pipeline.run_pipeline(
+                transport, AssistantConfig(runtimeMode="realtime"),
+                client_tool_names={"show_message"},
+            )
+        run.assert_awaited_once()
+        runtime = brain.setup_realtime.await_args.args[1]
+        self.assertTrue(runtime.client_tools.supports("show_message"))
+        self.assertFalse(runtime.client_tools.supports("unregistered_tool"))
+
+
+class TerminalProcessor(FrameProcessor):
+    def __init__(self, terminal):
+        super().__init__()
+        self.terminal = terminal
+
+    async def process_frame(self, frame, direction):
+        await super().process_frame(frame, direction)
+        await self.push_frame(frame, direction)
+        if isinstance(frame, StartFrame):
+            if isinstance(self.terminal, ErrorFrame):
+                await self.push_frame(self.terminal, FrameDirection.UPSTREAM)
+            else:
+                await self.push_frame(self.terminal)
+
+
+class PipelineOutcomeTest(unittest.IsolatedAsyncioTestCase):
+    async def test_fatal_error_is_failed_even_when_runner_returns_normally(self):
+        worker = PipelineWorker(
+            Pipeline([TerminalProcessor(ErrorFrame(error="provider failed", fatal=True))]),
+            enable_rtvi=False,
+        )
+        recorder = SimpleNamespace(finish=AsyncMock())
+        await asyncio.wait_for(run_media_worker(worker, recorder), 3)
+        recorder.finish.assert_awaited_once_with(status="failed")
+
+    async def test_normal_end_and_client_disconnect_are_completed(self):
+        for terminal in (EndFrame(), CancelFrame(reason="client_disconnected")):
+            with self.subTest(terminal=type(terminal).__name__):
+                worker = PipelineWorker(Pipeline([Passthrough()]), enable_rtvi=False)
+                recorder = SimpleNamespace(finish=AsyncMock())
+                await worker.queue_frame(terminal)
+                await asyncio.wait_for(run_media_worker(worker, recorder), 3)
+                recorder.finish.assert_awaited_once_with(status="completed")
+
+    async def test_server_task_cancellation_remains_failed_and_propagates(self):
+        worker = PipelineWorker(Pipeline([Passthrough()]), enable_rtvi=False)
+        started = asyncio.Event()
+
+        @worker.event_handler("on_pipeline_started")
+        async def on_started(_worker, _frame):
+            started.set()
+
+        recorder = SimpleNamespace(finish=AsyncMock())
+        task = asyncio.create_task(run_media_worker(worker, recorder))
+        await asyncio.wait_for(started.wait(), 3)
+        task.cancel()
+        with self.assertRaises(asyncio.CancelledError):
+            await asyncio.wait_for(task, 3)
+        recorder.finish.assert_awaited_once_with(status="failed")
+
+
+class Passthrough(FrameProcessor):
+    async def process_frame(self, frame, direction):
+        await super().process_frame(frame, direction)
+        await self.push_frame(frame, direction)