Files
zyt/app/tests/test_tongue_screenshot.py
T
2026-11-03 17:20:35 +08:00

391 lines
17 KiB
Python

from __future__ import annotations
import base64
import hashlib
from copy import deepcopy
from threading import BoundedSemaphore, Event
from types import SimpleNamespace
from uuid import uuid4
import httpx
import pytest
from doctor_workstation.core.errors import ApiBusinessError, ApiTimeoutError
from doctor_workstation.services.api_client import ApiClient
from doctor_workstation.services.repository import RemoteDoctorRepository
from doctor_workstation.video import tongue_screenshot as tongue
from doctor_workstation.video import window
JPEG = b"\xff\xd8synthetic-test-bytes\xff\xd9"
URL = "data:image/jpeg;base64," + base64.b64encode(JPEG).decode()
def response(request_id, content=JPEG, model="qwen"):
return {"request_id": request_id, "diagnosis_id": 71, "image_sha256": hashlib.sha256(content).hexdigest(),
"model": model, "model_label": "合成模型", "analysis": {"image_quality": "unusable", "quality_note": "未見清晰舌體。",
"features": [], "limitations": ["請重新截圖。"], "tcm_diagnosis": {
"status": "insufficient", "summary": "無法根據此圖辨證。", "candidates": [],
"missing_information": ["清晰舌象、症狀與脈象"]}}}
class Repo:
def __init__(self):
self.calls = []
self.started = Event()
self.release = Event()
self.release.set()
self.change = lambda value: value
self.error = None
def analyze_tongue_screenshot(self, diagnosis_id, content, *, request_id, model="qwen"):
self.calls.append((diagnosis_id, content, request_id))
self.started.set()
assert self.release.wait(3)
if self.error:
raise self.error
return self.change(response(request_id, content, model))
@pytest.fixture
def service(monkeypatch):
monkeypatch.setattr(tongue, "_SLOTS", BoundedSemaphore(2))
repo = Repo()
controller = tongue.TongueScreenshotController(repo, diagnosis_id=71, enabled=True)
controller.register_capture(URL)
yield controller, repo
controller.close()
repo.release.set()
assert controller.wait(3)
def test_capture_is_local_and_analysis_is_bound_without_chart_write(service):
controller, repo = service
assert repo.calls == []
request_id = str(uuid4())
controller.analyze(request_id, URL)
assert controller.wait(3)
result = controller.take_result()
assert result["ok"] and result["requestId"] == request_id
assert result["data"]["analysis"] == {
"image_quality": "unusable", "quality_note": "未见清晰舌体。", "features": [], "limitations": ["请重新截图。"],
"tcm_diagnosis": {"status": "insufficient", "summary": "无法根据此图辨证。", "candidates": [],
"missing_information": ["清晰舌象、症状与脉象"]}}
assert repo.calls == [(71, JPEG, request_id)]
controller.analyze(request_id, URL)
assert len(repo.calls) == 1 and controller.take_result() is None
@pytest.mark.parametrize("data_url", ["https://test.invalid/image.jpg", "data:image/png;base64,AAAA",
"data:image/jpeg;base64,@@@@", "data:image/jpeg;base64,AAAA",
URL + "AAAA"])
def test_arbitrary_or_changed_image_never_reaches_service(service, data_url):
controller, repo = service
controller.analyze(str(uuid4()), data_url)
assert controller.take_result()["ok"] is False
assert not repo.calls
def test_permission_disabled_does_not_submit():
repo = Repo()
controller = tongue.TongueScreenshotController(repo, diagnosis_id=71, enabled=False)
controller.register_capture(URL)
controller.analyze(str(uuid4()), URL)
assert controller.take_result()["ok"] is False and not repo.calls
controller.close()
@pytest.mark.parametrize("finish", ["cancel", "new_capture", "clear", "close"])
def test_late_result_cannot_replace_current_preview(service, finish):
controller, repo = service
repo.release.clear()
request_id = str(uuid4())
controller.analyze(request_id, URL)
assert repo.started.wait(2)
if finish == "cancel":
controller.cancel(request_id)
elif finish == "new_capture":
controller.register_capture(URL)
elif finish == "clear":
controller.clear_capture()
else:
controller.close()
repo.release.set()
assert controller.wait(3) and controller.take_result() is None
@pytest.mark.parametrize("change", [
lambda value: {**value, "diagnosis_id": 72},
lambda value: {**value, "request_id": str(uuid4())},
lambda value: {**value, "image_sha256": "a" * 64},
lambda value: {**value, "analysis": {**value["analysis"], "image_quality": "perfect"}},
lambda value: {**value, "analysis": {**value["analysis"], "features": [{"name": "舌苔", "observation": "白"}]}},
lambda value: {**value, "analysis": {**value["analysis"], "limitations": [123]}},
])
def test_invalid_identity_or_contradictory_findings_rejected(service, change):
controller, repo = service
repo.change = change
controller.analyze(str(uuid4()), URL)
assert controller.wait(3)
assert controller.take_result()["ok"] is False
def test_timeout_and_raw_error_do_not_disclose_payload(service):
controller, repo = service
repo.error = ApiTimeoutError("private image/body/credential")
controller.analyze(str(uuid4()), URL)
assert controller.wait(3)
result = controller.take_result()
assert "超时" in result["message"] and "private" not in str(result)
def test_global_concurrency_is_bounded(service, monkeypatch):
controller, repo = service
monkeypatch.setattr(tongue, "_SLOTS", BoundedSemaphore(0))
controller.analyze(str(uuid4()), URL)
assert "稍后" in controller.take_result()["message"] and not repo.calls
@pytest.mark.parametrize("model", ["qwen", "openai"])
def test_repository_uses_single_authenticated_temporary_multipart_request(model):
requests = []
request_id = str(uuid4())
def handler(request):
requests.append(request)
return httpx.Response(200, json={"code": 1, "data": response(request_id, model=model)})
with ApiClient("https://synthetic.test", token="synthetic-token", transport=httpx.MockTransport(handler)) as client:
result = RemoteDoctorRepository(client).analyze_tongue_screenshot(71, JPEG, request_id=request_id, model=model)
assert result["request_id"] == request_id and len(requests) == 1
request = requests[0]
assert request.url.path == "/adminapi/tcm.diagnosis/aiTongueScreenshot"
assert request.headers["token"] == "synthetic-token"
assert request.headers["content-type"].startswith("multipart/form-data;")
assert JPEG in request.content and request_id.encode() in request.content
assert model.encode() in request.content
assert request.extensions["timeout"]["read"] == 60.0
@pytest.mark.parametrize("changes", [{"diagnosis_id": True}, {"diagnosis_id": 0}, {"request_id": "bad"},
{"content": b"not-jpeg"}, {"content": b"\xff\xd8" + b"a" * tongue.MAX_IMAGE_BYTES},
{"model": "unknown"}, {"model": ["qwen"]}])
def test_repository_invalid_input_never_sends(changes):
args = {"diagnosis_id": 71, "content": JPEG, "request_id": str(uuid4()), **changes}
repo = RemoteDoctorRepository(SimpleNamespace())
with pytest.raises(ValueError):
repo.analyze_tongue_screenshot(**args)
def test_bridge_has_dedicated_image_slot_and_trusted_document_gate():
messages = []
bridge = window._QtVideoBridge(messages.append, lambda _region: URL)
request_id = str(uuid4())
bridge.analyzeTongueScreenshot(request_id, URL)
assert messages == [{"source": "doctor-call", "event": "tongue-screenshot-analyze",
"requestId": request_id, "dataUrl": URL}]
calls = []
host = SimpleNamespace(_closing=False, _media_active=True, _start_requested=True, _call_cycle_closed=False,
_tongue_ai=SimpleNamespace(analyze=lambda *args: calls.append(args)),
_im_ai_context_is_trusted=lambda: False)
window._EmbeddedVideoWindow._handle_bridge_message(host, messages[0])
assert not calls
host._im_ai_context_is_trusted = lambda: True
window._EmbeddedVideoWindow._handle_bridge_message(host, messages[0])
assert calls == [(request_id, URL, "qwen")]
host._call_cycle_closed = True
window._EmbeddedVideoWindow._handle_bridge_message(host, messages[0])
assert len(calls) == 1
def test_result_projection_discards_unexpected_fields():
request_id = str(uuid4())
value = response(request_id)
value["raw_model"] = "private"
value["analysis"]["diagnosis"] = "unsupported"
clean = tongue.validated_result(deepcopy(value), 71, request_id, hashlib.sha256(JPEG).hexdigest())
assert "private" not in str(clean) and "unsupported" not in str(clean)
class DualRepo:
def __init__(self):
self.started = {model: Event() for model in ("qwen", "openai")}
self.release = {model: Event() for model in self.started}
self.calls = []
self.errors = {}
def analyze_tongue_screenshot(self, diagnosis_id, content, *, request_id, model="qwen"):
self.calls.append((model, request_id, content))
self.started[model].set()
assert self.release[model].wait(3)
if model in self.errors:
raise self.errors[model]
return response(request_id, content, model)
@pytest.fixture
def dual_service(monkeypatch):
monkeypatch.setattr(tongue, "_SLOTS", BoundedSemaphore(4))
repo = DualRepo()
controller = tongue.TongueScreenshotController(repo, diagnosis_id=71, enabled=True)
controller.register_capture(URL)
yield controller, repo
controller.close()
for event in repo.release.values():
event.set()
assert controller.wait(3)
def test_both_models_run_concurrently_and_fast_result_arrives_while_other_waits(dual_service):
controller, repo = dual_service
ids = {model: str(uuid4()) for model in repo.started}
for model, request_id in ids.items():
controller.analyze(request_id, URL, model)
assert all(event.wait(1) for event in repo.started.values())
repo.release["openai"].set()
assert not controller.wait(0.2), "qwen is still waiting, GPT must not wait for it"
fast = controller.take_result()
assert fast["ok"] and fast["data"]["model"] == "openai"
assert fast["requestId"] == ids["openai"] and controller.take_result() is None
repo.release["qwen"].set()
assert controller.wait(2)
assert controller.take_result()["data"]["model"] == "qwen"
assert all(content == JPEG for _, _, content in repo.calls)
def test_cancel_or_retry_one_model_retains_the_other_model_result(dual_service):
controller, repo = dual_service
qwen, gpt = str(uuid4()), str(uuid4())
controller.analyze(qwen, URL, "qwen")
controller.analyze(gpt, URL, "openai")
assert all(event.wait(1) for event in repo.started.values())
controller.cancel(qwen)
for event in repo.release.values():
event.set()
assert controller.wait(2)
retry = str(uuid4())
controller.analyze(retry, URL, "qwen")
assert controller.wait(2)
results = [controller.take_result(), controller.take_result()]
assert {item["requestId"] for item in results} == {gpt, retry}
assert all(item["ok"] for item in results)
assert controller.take_result() is None
def test_one_model_failure_does_not_replace_other_success(dual_service):
controller, repo = dual_service
repo.errors["qwen"] = ApiTimeoutError("private failure body")
for event in repo.release.values():
event.set()
for model in repo.started:
controller.analyze(str(uuid4()), URL, model)
assert controller.wait(2)
results = {item["model"]: item for item in (controller.take_result(), controller.take_result())}
assert results["qwen"]["ok"] is False and "private" not in str(results["qwen"])
assert results["openai"]["ok"] is True
@pytest.mark.parametrize("end", ["clear_capture", "close"])
def test_replacing_or_closing_capture_discards_both_late_model_results(dual_service, end):
controller, repo = dual_service
for model in repo.started:
controller.analyze(str(uuid4()), URL, model)
assert all(event.wait(1) for event in repo.started.values())
getattr(controller, end)()
for event in repo.release.values():
event.set()
assert controller.wait(2) and controller.take_result() is None
def test_swapped_model_identity_is_rejected(service):
controller, repo = service
repo.change = lambda value: {**value, "model": "qwen"}
controller.analyze(str(uuid4()), URL, "openai")
assert controller.wait(2)
assert controller.take_result()["ok"] is False
def possible_pattern(request_id):
value = response(request_id)
value["analysis"].update({"image_quality": "limited", "features": [
{"name": "舌苔颜色", "observation": "合成白色示例"}], "tcm_diagnosis": {
"status": "possible_patterns", "summary": "合成辨證參考,需四診核實。",
"candidates": [{"name": "待核實的示例證候", "basis": ["舌苔颜色"], "verify": ["待詢問症狀與脈象"]}],
"missing_information": ["主訴、症狀與脈象"]}})
return value
def test_tcm_reference_preserves_visible_feature_links_and_converts_to_simplified():
request_id = str(uuid4())
clean = tongue.validated_result(possible_pattern(request_id), 71, request_id, hashlib.sha256(JPEG).hexdigest())
diagnosis = clean["analysis"]["tcm_diagnosis"]
assert diagnosis["candidates"][0]["basis"] == ["舌苔颜色"]
assert diagnosis["summary"] == "合成辨证参考,需四诊核实。"
assert diagnosis["candidates"][0]["name"] == "待核实的示例证候"
@pytest.mark.parametrize("change", [
lambda a: a.pop("tcm_diagnosis"),
lambda a: a.update(image_quality="unusable"),
lambda a: a["tcm_diagnosis"].update(status="confirmed"),
lambda a: a["tcm_diagnosis"].update(status="insufficient"),
lambda a: a["tcm_diagnosis"].update(candidates=[]),
lambda a: a["tcm_diagnosis"].update(missing_information=[]),
lambda a: a["tcm_diagnosis"]["candidates"][0].update(basis=["未观察到的舌体颜色"]),
lambda a: a["tcm_diagnosis"]["candidates"][0].update(basis=[]),
lambda a: a["tcm_diagnosis"]["candidates"][0].update(verify=[]),
])
def test_incomplete_unsupported_or_unobservable_tcm_references_fail_closed(change):
request_id = str(uuid4())
value = possible_pattern(request_id)
change(value["analysis"])
with pytest.raises(ValueError):
tongue.validated_result(value, 71, request_id, hashlib.sha256(JPEG).hexdigest())
def test_model_bridge_accepts_only_configured_model_keys_and_forwards_identity():
messages = []
bridge = window._QtVideoBridge(messages.append, lambda _region: URL)
request_id = str(uuid4())
for model in ("unknown", None, ["qwen"]):
bridge.analyzeTongueScreenshotModel(request_id, URL, model)
assert messages == []
bridge.analyzeTongueScreenshotModel(request_id, URL, "openai")
assert messages == [{"source": "doctor-call", "event": "tongue-screenshot-analyze", "requestId": request_id,
"dataUrl": URL, "model": "openai"}]
@pytest.mark.parametrize("message,visible", [
("GPT 模型接口配置异常,请管理员检查 Dify 中的模型 API 地址。", True),
("API upstream secret private patient detail", False),
])
def test_only_allowlisted_configuration_failure_is_exposed(service, message, visible):
controller, repo = service
repo.error = ApiBusinessError(message)
controller.analyze(str(uuid4()), URL, "openai")
assert controller.wait(2)
result = controller.take_result()
assert result["ok"] is False and (result["message"] == message) is visible
@pytest.mark.parametrize("server_message,expected", [
("截图分析超时,请稍后重试", "舌象分析超时,请重试。"),
("截图分析结果格式无效,请重新截图后重试", "模型返回的舌象结果格式不符合要求,请重试此模型。"),
("截图分析服务配置不完整", "舌象分析服务配置不完整,请管理员检查现有 AI 配置。"),
("权限不足,无法使用诊单 AI 助手", "当前账号没有舌象分析权限。"),
("upstream sensitive credential and patient text", "舌象分析未完成,请稍后重试。"),
])
def test_real_business_error_envelope_retains_safe_failure_category(monkeypatch, server_message, expected):
monkeypatch.setattr(tongue, "_SLOTS", BoundedSemaphore(2))
client = ApiClient("https://fixture.test", token="synthetic-token", transport=httpx.MockTransport(
lambda request: httpx.Response(200, json={"code": 0, "msg": server_message, "data": []})))
controller = tongue.TongueScreenshotController(RemoteDoctorRepository(client), diagnosis_id=71, enabled=True)
try:
controller.register_capture(URL)
controller.analyze(str(uuid4()), URL, "qwen")
assert controller.wait(2)
result = controller.take_result()
assert result["ok"] is False and result["message"] == expected
finally:
controller.close()
client.close()