271 lines
10 KiB
Python
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()
|