Files
zyt/app/tests/test_im_ai_service.py
T
2026-10-29 16:14:55 +08:00

271 lines
10 KiB
Python

"""Offline tests for native IM AI authorization, synchronization and races."""
from __future__ import annotations
from collections import deque
from threading import BoundedSemaphore, Event
from uuid import uuid4
import pytest
from doctor_workstation.video import im_ai
class Repository:
def __init__(self, pages=None, events=None):
self.pages = deque(pages or [{"completed": True, "errors": []}])
self.events = events or [{"event": "done", "diagnosis_id": 501, "answer": "合成回复"}]
self.sync_calls = []
self.stream_calls = []
self.cancel_calls = []
self.cancel_called = Event()
def sync_im_chat_messages(self, diagnosis_id, **kwargs):
self.sync_calls.append((diagnosis_id, kwargs))
return self.pages.popleft()
def stream_diagnosis_ai(self, diagnosis_id, prompt, **kwargs):
self.stream_calls.append((diagnosis_id, prompt, kwargs))
yield from self.events
def cancel_diagnosis_ai(self, diagnosis_id, request_id):
self.cancel_calls.append((diagnosis_id, request_id))
self.cancel_called.set()
return {"cancel_requested": True}
def controller(repository=None, **kwargs):
return im_ai.ImAiController(
repository or Repository(), diagnosis_id=501, appointment_id=101,
doctor_account="doctor_7", enabled=True, **kwargs,
)
def request(service, **changes):
return {
"source": "doctor-call", "event": "im-ai-request", "sessionId": service.session_id,
"requestId": str(uuid4()), "contextKey": "view-1", "diagnosisId": "501",
"appointmentId": 101, "action": "summary", **changes,
}
@pytest.mark.parametrize("action,task", [("summary", "summary"), ("followup", "custom"), ("reply", "custom")])
def test_current_peer_sync_completes_before_ai_and_keeps_identity(action, task):
token = "a" * 48
repository = Repository(pages=[
{"completed": False, "phase": "checking_accounts", "sync_token": token, "errors": []},
{"completed": False, "phase": "syncing", "sync_token": token, "errors": []},
{"completed": True, "errors": []},
], events=[
{"event": "start"}, {"event": "delta", "text": "合成"},
{"event": "done", "diagnosis_id": 501, "answer": "合成完整回复", "model_label": "模型",
"clinical_review_warnings": [{"code": "PULSE_EXCLUDED_FROM_ASSESSMENT", "source_id": "report"}]},
])
service = controller(repository)
message = request(service, action=action)
assert service.handle(message)
assert service.wait()
result = service.take_result()
assert result["status"] == "success"
assert result["text"] == "合成完整回复"
assert result["requestId"] == message["requestId"]
assert result["modelLabel"] == "模型"
assert "不采集脉象" in result["warnings"][0]
assert len(repository.sync_calls) == 3
assert repository.sync_calls[0] == (501, {"scope": "current", "sync_token": ""})
assert repository.sync_calls[1][1]["sync_token"] == token
assert len(repository.stream_calls) == 1
diagnosis_id, prompt, options = repository.stream_calls[0]
assert diagnosis_id == 501 and options["task"] == task
assert options["request_id"] == message["requestId"]
assert "doctor_7" in prompt and len(prompt) <= 500
assert "不补问脉象" in prompt and "不自动确诊" in prompt
assert not repository.cancel_calls
assert service.take_result() is None
assert not service.handle(message) # A replay cannot submit another billable request.
@pytest.mark.parametrize("changes", [
{"sessionId": "other"}, {"diagnosisId": "502"}, {"diagnosisId": True},
{"diagnosisId": "0501"}, {"appointmentId": 102}, {"requestId": "invalid"},
{"contextKey": ""}, {"contextKey": "x" * 129}, {"action": "prescription"},
{"action": {}}, {"source": "another-page"}, {"event": "send-message"},
])
def test_invalid_identity_or_action_cannot_read_patient_context(changes):
repository = Repository()
service = controller(repository)
assert not service.handle(request(service, **changes))
assert not repository.sync_calls and not repository.stream_calls
def test_permission_default_denied_and_each_host_has_unique_session():
repository = Repository()
disabled = im_ai.ImAiController(
repository, diagnosis_id=501, appointment_id=101, doctor_account="doctor_7"
)
assert disabled.config["enabled"] is False
assert not disabled.handle(request(disabled))
assert controller().session_id != controller().session_id
@pytest.mark.parametrize("page", [
{"queued": True}, {"completed": "true"}, {"completed": True, "errors": ["private detail"]},
{"completed": False, "sync_token": "bad"}, None,
])
def test_incomplete_or_failed_sync_never_generates(page):
repository = Repository(pages=[page])
service = controller(repository)
assert service.handle(request(service))
assert service.wait()
result = service.take_result()
assert result["status"] == "error"
assert "private detail" not in str(result)
assert not repository.stream_calls and not repository.cancel_calls
def test_sync_step_and_time_budget_are_bounded():
page = {"completed": False, "sync_token": "b" * 48, "errors": []}
repository = Repository(pages=[page] * 10)
service = controller(repository, max_sync_steps=2)
service.handle(request(service))
assert service.wait()
assert len(repository.sync_calls) == 2
assert service.take_result()["status"] == "error"
assert not repository.stream_calls
times = iter([0, 0, 46])
repository = Repository()
service = controller(repository, clock=lambda: next(times))
service.handle(request(service))
assert service.wait()
assert "超时" in service.take_result()["message"]
assert not repository.stream_calls
def test_cancel_during_sync_stops_before_model_submission():
entered, release = Event(), Event()
class SlowSync(Repository):
def sync_im_chat_messages(self, diagnosis_id, **kwargs):
entered.set()
assert release.wait(2)
return super().sync_im_chat_messages(diagnosis_id, **kwargs)
repository = SlowSync()
service = controller(repository)
message = request(service)
service.handle(message)
try:
assert entered.wait(1)
assert service.handle({**message, "event": "im-ai-cancel"})
assert "尚未向 AI" in service.take_result()["message"]
finally:
release.set()
assert service.wait()
assert not repository.stream_calls and not repository.cancel_calls
assert service.take_result() is None
def test_cancel_is_independent_and_late_response_cannot_overwrite_next_request():
entered, release, cancel_release = Event(), Event(), Event()
class SlowStream(Repository):
def stream_diagnosis_ai(self, *args, **kwargs):
self.stream_calls.append((args, kwargs))
yield {"event": "delta", "text": "尚未完成"}
entered.set()
assert release.wait(2)
yield {"event": "done", "answer": "迟到的旧结果"}
def cancel_diagnosis_ai(self, *args):
result = super().cancel_diagnosis_ai(*args)
assert cancel_release.wait(2)
return result
repository = SlowStream()
service = controller(repository)
first = request(service)
service.handle(first)
try:
assert entered.wait(1)
assert service.take_result()["text"] == "尚未完成"
service.handle({**first, "event": "im-ai-cancel"})
assert repository.cancel_called.wait(1) # Independent HTTP starts while stream is blocked.
assert service.take_result()["status"] == "cancelled"
second = request(service, contextKey="view-2")
assert service.handle(second)
result = service.take_result()
assert result["requestId"] == second["requestId"] and result["status"] == "error"
assert len(repository.stream_calls) == 1
finally:
release.set()
cancel_release.set()
assert service.wait()
assert service.take_result() is None
def test_close_invalidates_mailbox_and_cancels_without_waiting():
entered, release = Event(), Event()
class SlowStream(Repository):
def stream_diagnosis_ai(self, *args, **kwargs):
entered.set()
assert release.wait(2)
yield {"event": "done", "answer": "旧患者回复"}
repository = SlowStream()
service = controller(repository)
message = request(service)
service.handle(message)
try:
assert entered.wait(1)
service.close()
assert repository.cancel_called.wait(1)
assert service.take_result() is None
assert not service.handle(request(service))
finally:
release.set()
assert service.wait()
assert service.take_result() is None
@pytest.mark.parametrize("events", [
[{"event": "delta", "text": "不完整"}],
[{"event": "done", "answer": ""}],
[{"event": "done", "diagnosis_id": 502, "answer": "其他患者"}],
[{"event": "delta", "text": "x" * (im_ai.MAX_RESULT_CHARS + 1)}],
[{"event": "done", "answer": "x" * (im_ai.MAX_RESULT_CHARS + 1)}],
])
def test_incomplete_mismatched_and_oversized_results_are_not_usable(events):
repository = Repository(events=events)
service = controller(repository)
service.handle(request(service))
assert service.wait()
assert service.take_result()["status"] == "error"
assert repository.cancel_called.wait(1)
assert len(repository.stream_calls) == 1 # No transport/validation retry.
def test_thousands_of_deltas_are_coalesced_into_one_mailbox_result():
events = [{"event": "delta", "text": "字"}] * 4000 + [{"event": "done"}]
service = controller(Repository(events=events))
service.handle(request(service))
assert service.wait()
result = service.take_result()
assert result["status"] == "success" and result["text"] == "字" * 4000
assert service.take_result() is None
def test_capacity_rejection_does_not_spawn_or_sync(monkeypatch):
slots = BoundedSemaphore(1)
slots.acquire()
monkeypatch.setattr(im_ai, "_WORKER_SLOTS", slots)
repository = Repository()
service = controller(repository)
try:
service.handle(request(service))
assert service.take_result()["status"] == "error"
assert not repository.sync_calls
finally:
slots.release()