128 lines
4.5 KiB
Python
128 lines
4.5 KiB
Python
"""Cancellation/voice checks against local fake HTTP services, no paid APIs."""
|
|
|
|
import asyncio
|
|
import importlib.util
|
|
import pathlib
|
|
import unittest
|
|
|
|
from aiohttp import web
|
|
from aiohttp.test_utils import TestServer
|
|
|
|
spec = importlib.util.spec_from_file_location(
|
|
"sample_server", pathlib.Path(__file__).resolve().parents[1] / "runtime/server.py"
|
|
)
|
|
server = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(server)
|
|
|
|
|
|
class GatewayChecks(unittest.IsolatedAsyncioTestCase):
|
|
async def asyncSetUp(self):
|
|
self.started = asyncio.Event()
|
|
self.release = asyncio.Event()
|
|
self.mode = "llm"
|
|
self.voice = "xiaoyun"
|
|
self.queued = 0
|
|
self.closed = []
|
|
app = web.Application()
|
|
|
|
async def health(request):
|
|
return web.json_response({"ok": True, "voices": [self.voice]})
|
|
|
|
async def llm(request):
|
|
if self.mode == "llm":
|
|
self.started.set()
|
|
await self.release.wait()
|
|
return web.json_response({"choices": [{"message": {"content": "你好。"}}]})
|
|
|
|
async def tts(request):
|
|
self.started.set()
|
|
await self.release.wait()
|
|
return web.Response(body=b"\0\0" * 2400)
|
|
|
|
async def audio(request):
|
|
self.queued += 1
|
|
return web.json_response({"code": 0})
|
|
|
|
async def close(request):
|
|
self.closed.append((await request.json())["sessionid"])
|
|
return web.json_response({"closed": True})
|
|
|
|
app.router.add_get("/health", health)
|
|
app.router.add_post("/llm", llm)
|
|
app.router.add_post("/tts", tts)
|
|
app.router.add_post("/humanaudio", audio)
|
|
app.router.add_post("/hel714/close", close)
|
|
self.upstream = TestServer(app)
|
|
await self.upstream.start_server()
|
|
base = str(self.upstream.make_url("")).rstrip("/")
|
|
self.gateway = server.Gateway(
|
|
{
|
|
"driver": base,
|
|
"llm": base + "/llm",
|
|
"model": "fixture",
|
|
"tts": base,
|
|
"voice": "xiaoyun",
|
|
}
|
|
)
|
|
await self.gateway.start(None)
|
|
|
|
async def asyncTearDown(self):
|
|
self.release.set()
|
|
await self.gateway.stop(None)
|
|
await self.upstream.close()
|
|
|
|
async def cancel_at(self, mode):
|
|
self.mode = mode
|
|
session = {"sid": "old-session", "task": None}
|
|
self.gateway.sessions["old-token"] = session
|
|
task = session["task"] = asyncio.create_task(self.gateway.reply(session, "测试"))
|
|
await asyncio.wait_for(self.started.wait(), 2)
|
|
await self.gateway.retire("old-token")
|
|
self.assertTrue(task.cancelled())
|
|
self.release.set()
|
|
await asyncio.sleep(0.05)
|
|
self.assertEqual(self.queued, 0)
|
|
self.assertEqual(self.closed, ["old-session"])
|
|
self.assertNotIn("old-token", self.gateway.sessions)
|
|
# Idempotence: a late duplicate cancel cannot close a new session.
|
|
self.gateway.sessions["new-token"] = {"sid": "new-session", "task": None}
|
|
await self.gateway.retire("old-token")
|
|
self.assertIn("new-token", self.gateway.sessions)
|
|
|
|
async def test_cancel_during_llm(self):
|
|
await self.cancel_at("llm")
|
|
|
|
async def test_cancel_during_tts(self):
|
|
await self.cancel_at("tts")
|
|
|
|
async def test_missing_voice_is_explicit(self):
|
|
self.voice = "default"
|
|
with self.assertRaisesRegex(RuntimeError, "未回退"):
|
|
await self.gateway.reply({"sid": "test"}, "测试")
|
|
self.assertEqual(self.queued, 0)
|
|
|
|
async def test_cancel_while_waiting_for_media_ready(self):
|
|
self.mode = "tts"
|
|
session = {"sid": "old-session", "task": None, "ready": asyncio.Event()}
|
|
self.gateway.sessions["old-token"] = session
|
|
task = session["task"] = asyncio.create_task(self.gateway.reply(session, "测试"))
|
|
await asyncio.wait_for(self.started.wait(), 2)
|
|
self.release.set()
|
|
await asyncio.sleep(0.05)
|
|
self.assertEqual(self.queued, 0)
|
|
await self.gateway.retire("old-token")
|
|
session["ready"].set()
|
|
await asyncio.sleep(0.05)
|
|
self.assertTrue(task.cancelled())
|
|
self.assertEqual(self.queued, 0)
|
|
|
|
async def test_model_unreachable(self):
|
|
self.gateway.config["llm"] = "http://127.0.0.1:1/unavailable"
|
|
with self.assertRaises(server.aiohttp.ClientError):
|
|
await self.gateway.reply({"sid": "unreachable"}, "测试")
|
|
self.assertEqual(self.queued, 0)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main(verbosity=2)
|