Files
zyt/app/tests/test_ai_cancel_transport.py
T
2026-10-23 09:26:49 +08:00

222 lines
8.7 KiB
Python

"""Cancellation interrupts idle I/O and uses an independent control request."""
from __future__ import annotations
import asyncio
import json
import socket
from concurrent.futures import ThreadPoolExecutor
from threading import Event, Thread, get_ident
from uuid import uuid4
import httpx
import pytest
from doctor_workstation.services.api_client import ApiClient
from doctor_workstation.services.repository import RemoteDoctorRepository
@pytest.mark.parametrize("stage", ["headers", "body"])
def test_cancel_interrupts_idle_read_and_cleans_up_on_owning_loop(stage):
entered, cancelled = Event(), Event()
body_threads, closed_threads = [], []
class IdleStream(httpx.AsyncByteStream):
async def __aiter__(self):
body_threads.append(get_ident())
entered.set()
await asyncio.sleep(30)
yield b"event: done\ndata: {}\n\n"
async def aclose(self):
closed_threads.append(get_ident())
async def handler(request):
if stage == "headers":
entered.set()
await asyncio.sleep(30)
return httpx.Response(200, headers={"content-type": "text/event-stream"}, stream=IdleStream())
client = ApiClient("https://example.test", transport=httpx.MockTransport(handler))
with ThreadPoolExecutor(max_workers=1) as executor:
future = executor.submit(lambda: list(client.post_event_stream(
"tcm.diagnosis/aiAssistantStream", {"id": 501}, cancelled=cancelled.is_set,
)))
assert entered.wait(2)
cancelled.set()
assert future.result(timeout=0.8) == []
if stage == "body":
assert body_threads == closed_threads
client.close()
@pytest.mark.parametrize("headers_sent", [False, True])
def test_default_transport_closes_idle_local_socket_without_another_line(headers_sent):
entered, disconnected, cancelled = Event(), Event(), Event()
listener = socket.socket()
listener.bind(("127.0.0.1", 0))
listener.listen(1)
listener.settimeout(3)
def serve():
try:
connection, _ = listener.accept()
with connection:
connection.settimeout(3)
request = b""
while b"\r\n\r\n" not in request:
request += connection.recv(4096)
header, body = request.split(b"\r\n\r\n", 1)
length = next(int(line.split(b":", 1)[1]) for line in header.split(b"\r\n") if line.lower().startswith(b"content-length:"))
while len(body) < length:
body += connection.recv(4096)
if headers_sent:
connection.sendall(b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nConnection: close\r\n\r\n")
entered.set()
if connection.recv(1) == b"":
disconnected.set()
finally:
listener.close()
thread = Thread(target=serve, daemon=True)
thread.start()
with ApiClient(f"http://127.0.0.1:{listener.getsockname()[1]}") as client, ThreadPoolExecutor(max_workers=1) as executor:
future = executor.submit(lambda: list(client.post_event_stream(
"tcm.diagnosis/aiAssistantStream", {"id": 501}, cancelled=cancelled.is_set,
)))
try:
assert entered.wait(2)
cancelled.set()
assert future.result(timeout=0.8) == []
assert disconnected.wait(0.8)
finally:
cancelled.set()
thread.join(timeout=1)
assert not thread.is_alive()
def test_cancel_control_post_bypasses_busy_short_request_pool(monkeypatch):
from doctor_workstation.services import api_client as module
entered, release = Event(), Event()
created = []
class Client:
def __init__(self, **options):
created.append(self)
def request(self, *args, **kwargs):
entered.set()
assert release.wait(2)
return httpx.Response(200, json={"code": 1, "data": {}})
def post(self, url, **kwargs):
return httpx.Response(200, json={"code": 1, "data": {"cancel_requested": True}})
def close(self):
pass
def __enter__(self):
return self
def __exit__(self, *args):
self.close()
monkeypatch.setattr(module.httpx, "Client", Client)
client = ApiClient("https://example.test", max_parallel_requests=1)
with ThreadPoolExecutor(max_workers=1) as executor:
future = executor.submit(client.get, "synthetic/busy")
try:
assert entered.wait(1)
assert client.post_independent("tcm.diagnosis/cancelAiAssistant", {"id": 501}) == {"cancel_requested": True}
assert len(created) == 2
finally:
release.set()
future.result(timeout=1)
client.close()
def test_stream_progress_and_cancel_preserve_same_request_identity():
requests = []
request_id = str(uuid4())
def handler(request):
requests.append(request)
if request.url.path.endswith("cancelAiAssistant"):
return httpx.Response(200, json={"code": 1, "data": {"cancel_requested": True, "upstream_stop_confirmed": False}})
return httpx.Response(200, headers={"content-type": "text/event-stream"}, text=(
'event: progress\ndata: {"phase":"attachments","items":[{"kind":"image","label":"图片附件1","status":"submitted"}],"attachment_count":1}\n\n'
'event: done\ndata: {}\n\n'
))
with ApiClient("https://example.test", transport=httpx.MockTransport(handler)) as client:
repository = RemoteDoctorRepository(client)
events = list(repository.stream_diagnosis_ai(501, "合成问题", request_id=request_id))
result = repository.cancel_diagnosis_ai(501, request_id)
assert events[0]["event"] == "progress" and events[0]["items"][0]["status"] == "submitted"
assert json.loads(requests[0].content)["request_id"] == request_id
assert json.loads(requests[1].content) == {"id": 501, "request_id": request_id}
assert result["cancel_requested"] and not result["upstream_stop_confirmed"]
def test_async_bridge_batches_thousands_of_frames_without_per_delta_tasks(monkeypatch):
from doctor_workstation.services import api_client as module
calls = {"tasks": 0, "loop_runs": 0}
new_event_loop = asyncio.new_event_loop
def counted_loop():
loop = new_event_loop()
create_task, run_forever = loop.create_task, loop.run_forever
def task(*args, **kwargs):
calls["tasks"] += 1
return create_task(*args, **kwargs)
def run():
calls["loop_runs"] += 1
return run_forever()
loop.create_task, loop.run_forever = task, run
return loop
monkeypatch.setattr(module.asyncio, "new_event_loop", counted_loop)
chunks = [f"片段{index}🩺" for index in range(6000)]
content = "".join("event: delta\ndata: " + json.dumps({"text": text}) + "\n\n" for text in chunks)
content += 'event: done\ndata: {}\n\n'
transport = httpx.MockTransport(lambda request: httpx.Response(
200, headers={"content-type": "text/event-stream"}, text=content,
))
with ApiClient("https://example.test", transport=transport) as client:
events = list(client.post_event_stream("synthetic/stream", {}, cancelled=lambda: False))
assert [event["data"]["text"] for event in events[:-1]] == chunks
assert events[-1]["event"] == "done"
assert calls["tasks"] <= 8
assert calls["loop_runs"] <= 40
@pytest.mark.parametrize("ending", ["eof", "error"])
def test_async_batch_drains_queued_tail_before_eof_or_error(ending):
class TailStream(httpx.AsyncByteStream):
async def __aiter__(self):
yield b'event: delta\ndata: {"text":"first"}\n\nevent: delta\ndata: {"text":"tail"}\n\n'
if ending == "error":
raise httpx.ReadError("synthetic read failure")
# A valid final SSE frame need not end with a blank line.
yield b'event: delta\ndata: {"text":"last"}'
transport = httpx.MockTransport(lambda request: httpx.Response(
200, headers={"content-type": "text/event-stream"}, stream=TailStream(),
))
with ApiClient("https://example.test", transport=transport) as client:
stream = client.post_event_stream("synthetic/stream", {}, cancelled=lambda: False)
assert next(stream)["data"]["text"] == "first"
assert next(stream)["data"]["text"] == "tail"
if ending == "error":
from doctor_workstation.core.errors import ApiTransportError
with pytest.raises(ApiTransportError, match="stream failed"):
next(stream)
else:
assert next(stream)["data"]["text"] == "last"
assert list(stream) == []