411 lines
23 KiB
Python
411 lines
23 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""Patient-order proxy security checks using persisted conversation bindings."""
|
|
|
|
from unittest import TestCase, main, mock
|
|
|
|
import test_archive_api as archive_tests
|
|
|
|
|
|
SUMMARY_PATH = "/api/v2/archive/desktop/patient-orders/summary"
|
|
|
|
class ZytOrderApiTest(TestCase):
|
|
# Reuse fixture helpers without inheriting and re-running the archive suite.
|
|
setUp = archive_tests.ArchiveApiTest.setUp
|
|
tearDown = archive_tests.ArchiveApiTest.tearDown
|
|
login = archive_tests.ArchiveApiTest.login
|
|
desktop_login = archive_tests.ArchiveApiTest.desktop_login
|
|
sample_payload = staticmethod(archive_tests.ArchiveApiTest.sample_payload)
|
|
patient_search_error = None
|
|
|
|
def search_zyt_patients(self, token, keyword, page_no, page_size):
|
|
# Set patient_search_error after binding to make the ZYT patient check
|
|
# inside the order routes fail.
|
|
if self.patient_search_error is not None:
|
|
raise self.patient_search_error
|
|
return archive_tests.ArchiveApiTest.search_zyt_patients(token, keyword, page_no, page_size)
|
|
|
|
@staticmethod
|
|
def verify_zyt(token):
|
|
identity = archive_tests.ArchiveApiTest.verify_zyt(token)
|
|
if token == "zyt-user-list-only":
|
|
identity["permissions"].append("firstvisit.myPatient/orders")
|
|
elif token != "zyt-no-patient":
|
|
identity["permissions"] += [
|
|
"firstvisit.myPatient/orders", "firstvisit.myPatient/orderDetail",
|
|
"tcm.prescriptionOrder/detail", "tcm.prescriptionOrder/logisticsTrace",
|
|
]
|
|
return identity
|
|
|
|
def prepare_conversation(self, *, bind=True):
|
|
session = self.desktop_login()
|
|
payload = self.sample_payload()
|
|
imported = self.client.post(
|
|
"/api/v2/archive/desktop/imports/messages",
|
|
headers=session["headers"], json=payload,
|
|
)
|
|
self.assertEqual(imported.status_code, 200, imported.text)
|
|
params = {
|
|
"external_account_id": payload["source_account"]["external_account_id"],
|
|
"conversation_external_id": payload["messages"][0]["conversation"]["external_id"],
|
|
}
|
|
context = self.client.get(
|
|
"/api/v2/archive/desktop/patient-context",
|
|
headers=session["headers"], params=params,
|
|
)
|
|
self.assertEqual(context.status_code, 200, context.text)
|
|
person_id = context.json()["person"]["id"]
|
|
params["person_id"] = person_id
|
|
binding = None
|
|
if bind:
|
|
searched = self.client.get(
|
|
"/api/v2/archive/desktop/patients/search",
|
|
headers=session["headers"], params={"keyword": "张三"},
|
|
)
|
|
self.assertEqual(searched.status_code, 200, searched.text)
|
|
response = self.client.put(
|
|
"/api/v2/archive/desktop/patient-binding",
|
|
headers=session["headers"],
|
|
json={**params, "patient_id": 9001, "diagnosis_id": 9101},
|
|
)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
binding = response.json()["binding"]
|
|
return session, params, binding
|
|
|
|
@staticmethod
|
|
def sample_order(**overrides):
|
|
return {
|
|
"id": 321, "order_no": "ZYT202609220321", "diagnosis_id": 9101,
|
|
"create_time": "2026-09-22 10:20:00", "fulfillment_status": 5,
|
|
"prescription_audit_status": 1, "payment_slip_audit_status": 1,
|
|
"express_company": "顺丰", "tracking_number": "SF1234567899",
|
|
"recipient_name": "张三", "recipient_phone": "13800138000",
|
|
"recipient_address": "不应向模型公开的住址", "prescription": {"private": True},
|
|
**overrides,
|
|
}
|
|
|
|
def order_paths(self):
|
|
return (
|
|
"/api/v2/archive/desktop/patient-orders",
|
|
"/api/v2/archive/desktop/patient-orders/321",
|
|
"/api/v2/archive/desktop/patient-orders/321/tracking",
|
|
"/api/v2/archive/desktop/patient-orders/321/audit-status",
|
|
)
|
|
|
|
def test_unbound_conversation_never_queries_orders(self):
|
|
session, params, _ = self.prepare_conversation(bind=False)
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
for path in self.order_paths():
|
|
with self.subTest(path=path):
|
|
response = self.client.get(path, headers=session["headers"], params=params)
|
|
self.assertEqual(response.status_code, 409, response.text)
|
|
self.assertEqual(response.json()["detail"]["code"], "patient_binding_required")
|
|
client.assert_not_called()
|
|
|
|
def test_order_from_other_diagnosis_is_rejected_before_tracking(self):
|
|
session, params, _ = self.prepare_conversation()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.get_order_detail.return_value = self.sample_order(diagnosis_id=9999)
|
|
for path in self.order_paths()[1:]:
|
|
with self.subTest(path=path):
|
|
response = self.client.get(path, headers=session["headers"], params=params)
|
|
self.assertEqual(response.status_code, 404, response.text)
|
|
self.assertNotIn("ZYT202609220321", response.text)
|
|
client.return_value.get_tracking.assert_not_called()
|
|
|
|
def test_persisted_forged_diagnosis_binding_never_queries_orders(self):
|
|
session, params, binding = self.prepare_conversation()
|
|
with self.database.connect() as db:
|
|
db.execute(
|
|
"UPDATE archive_patient_binding SET diagnosis_id=? WHERE id=?",
|
|
(9999, binding["id"]),
|
|
)
|
|
db.commit()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
for path in self.order_paths():
|
|
with self.subTest(path=path):
|
|
response = self.client.get(path, headers=session["headers"], params=params)
|
|
self.assertEqual(response.status_code, 409, response.text)
|
|
self.assertEqual(response.json()["detail"]["code"], "patient_binding_invalid")
|
|
client.assert_not_called()
|
|
|
|
def test_other_tenant_cannot_reuse_conversation_or_person_binding(self):
|
|
_, params, _ = self.prepare_conversation()
|
|
other = self.desktop_login("zyt-user-2", "desktop-device-02")
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
for path in self.order_paths():
|
|
with self.subTest(path=path):
|
|
response = self.client.get(path, headers=other["headers"], params=params)
|
|
self.assertEqual(response.status_code, 409, response.text)
|
|
self.assertEqual(response.json()["detail"]["code"], "patient_binding_required")
|
|
client.assert_not_called()
|
|
|
|
def test_missing_order_permission_blocks_before_upstream_query(self):
|
|
session = self.desktop_login("zyt-no-patient")
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
for path in self.order_paths():
|
|
with self.subTest(path=path):
|
|
response = self.client.get(path, headers=session["headers"], params={
|
|
"external_account_id": "wxwork-account-01",
|
|
"conversation_external_id": "S:external-user-01",
|
|
})
|
|
self.assertEqual(response.status_code, 403, response.text)
|
|
client.assert_not_called()
|
|
|
|
def test_list_filters_other_patient_and_masks_private_fields(self):
|
|
session, params, _ = self.prepare_conversation()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.list_orders.return_value = {
|
|
"items": [self.sample_order(), self.sample_order(id=322, diagnosis_id=9999)],
|
|
"total": 2,
|
|
}
|
|
response = self.client.get(self.order_paths()[0], headers=session["headers"], params=params)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
result = response.json()
|
|
self.assertEqual([item["order_id"] for item in result["items"]], [321])
|
|
self.assertEqual(result["total"], 1)
|
|
self.assertEqual(result["items"][0]["tracking_number_masked"], "SF****7899")
|
|
self.assertEqual(client.return_value.list_orders.call_args.kwargs["diagnosis_id"], 9101)
|
|
self.assertNotIn("13800138000", response.text)
|
|
self.assertNotIn("SF1234567899", response.text)
|
|
self.assertNotIn("recipient_address", response.text)
|
|
self.assertNotIn("private", response.text)
|
|
|
|
def test_allowed_detail_contains_only_sanitized_order_facts(self):
|
|
session, params, _ = self.prepare_conversation()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.get_order_detail.return_value = self.sample_order()
|
|
response = self.client.get(self.order_paths()[1], headers=session["headers"], params=params)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
order = response.json()["order"]
|
|
self.assertEqual(order["order_id"], 321)
|
|
self.assertEqual(order["tracking_number_masked"], "SF****7899")
|
|
self.assertEqual(order["fulfillment_status"], "已发货")
|
|
self.assertNotIn("SF1234567899", response.text)
|
|
self.assertNotIn("13800138000", response.text)
|
|
self.assertNotIn("recipient_address", response.text)
|
|
client.return_value.get_order_detail.assert_called_once_with(321)
|
|
|
|
def test_single_order_list_brings_tracking_inline(self):
|
|
session, params, _ = self.prepare_conversation()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.list_orders.return_value = {"items": [self.sample_order()], "total": 1}
|
|
client.return_value.get_tracking.return_value = {
|
|
"state_text": "运输中",
|
|
"traces": [{"accept_time": "2026-09-22 09:42:00", "remark": "快件已到达中转站"}],
|
|
}
|
|
response = self.client.get(self.order_paths()[0], headers=session["headers"], params=params)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
result = response.json()
|
|
self.assertEqual(result["order_count"], 1)
|
|
self.assertFalse(result["selection_required"])
|
|
self.assertEqual(result["single_order_id"], 321)
|
|
self.assertEqual(result["latest_tracking"]["status"], "运输中")
|
|
self.assertEqual(result["latest_tracking"]["description"], "快件已到达中转站")
|
|
self.assertEqual(client.return_value.get_tracking.call_args.kwargs["phone_tail"], "8000")
|
|
|
|
def test_multiple_orders_require_customer_selection_and_skip_tracking(self):
|
|
session, params, _ = self.prepare_conversation()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.list_orders.return_value = {
|
|
"items": [self.sample_order(), self.sample_order(id=322, order_no="ZYT202609100322")],
|
|
"total": 2,
|
|
}
|
|
response = self.client.get(self.order_paths()[0], headers=session["headers"], params=params)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
result = response.json()
|
|
self.assertEqual(result["order_count"], 2)
|
|
self.assertTrue(result["selection_required"])
|
|
self.assertEqual(result["single_order_id"], 0)
|
|
self.assertIsNone(result["latest_tracking"])
|
|
self.assertIn("确认", result["hint"])
|
|
client.return_value.get_tracking.assert_not_called()
|
|
|
|
def test_single_order_without_tracking_number_reports_missing(self):
|
|
session, params, _ = self.prepare_conversation()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.list_orders.return_value = {
|
|
"items": [self.sample_order(tracking_number="", fulfillment_status=2)], "total": 1,
|
|
}
|
|
client.return_value.get_order_detail.return_value = self.sample_order(tracking_number="", fulfillment_status=2)
|
|
listed = self.client.get(self.order_paths()[0], headers=session["headers"], params=params)
|
|
self.assertEqual(listed.status_code, 200, listed.text)
|
|
self.assertIsNone(listed.json()["latest_tracking"])
|
|
self.assertEqual(listed.json()["tracking_error"]["code"], "tracking_number_missing")
|
|
tracked = self.client.get(self.order_paths()[2], headers=session["headers"], params=params)
|
|
self.assertEqual(tracked.status_code, 409, tracked.text)
|
|
self.assertEqual(tracked.json()["detail"]["code"], "tracking_number_missing")
|
|
client.return_value.get_tracking.assert_not_called()
|
|
|
|
def test_tracking_provider_failure_never_returns_a_status(self):
|
|
from zyt_order_client import ZytOrderError
|
|
session, params, _ = self.prepare_conversation()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.get_order_detail.return_value = self.sample_order()
|
|
client.return_value.get_tracking.side_effect = ZytOrderError("快递100 暂不可用")
|
|
response = self.client.get(self.order_paths()[2], headers=session["headers"], params=params)
|
|
self.assertEqual(response.status_code, 502, response.text)
|
|
self.assertEqual(response.json()["detail"]["code"], "tracking_unavailable")
|
|
self.assertNotIn("运输中", response.text)
|
|
self.assertNotIn("SF1234567899", response.text)
|
|
|
|
def test_ip_pinning_rejection_is_reported_on_every_order_path(self):
|
|
from zyt_order_client import ZytOrderIpRestricted
|
|
session, params, _ = self.prepare_conversation()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.list_orders.side_effect = ZytOrderIpRestricted("synthetic")
|
|
client.return_value.get_order_detail.side_effect = ZytOrderIpRestricted("synthetic")
|
|
for path in self.order_paths():
|
|
with self.subTest(path=path):
|
|
response = self.client.get(path, headers=session["headers"], params=params)
|
|
self.assertEqual(response.status_code, 409, response.text)
|
|
self.assertEqual(response.json()["detail"]["code"], "zyt_ip_restricted")
|
|
self.assertNotIn("过期", response.text)
|
|
|
|
def test_ip_pinning_rejection_on_tracking_is_not_disguised_as_logistics(self):
|
|
from zyt_order_client import ZytOrderIpRestricted
|
|
session, params, _ = self.prepare_conversation()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.get_order_detail.return_value = self.sample_order()
|
|
client.return_value.get_tracking.side_effect = ZytOrderIpRestricted("synthetic")
|
|
response = self.client.get(self.order_paths()[2], headers=session["headers"], params=params)
|
|
self.assertEqual(response.status_code, 409, response.text)
|
|
self.assertEqual(response.json()["detail"]["code"], "zyt_ip_restricted")
|
|
|
|
def assert_neutral_ip_rejection(self, response, staff_prefix):
|
|
# zyt_order_mcp forwards detail.code/detail.message to the model verbatim;
|
|
# the "whitelist the server IP" advice is for staff only.
|
|
import archive_api
|
|
self.assertEqual(response.status_code, 409, response.text)
|
|
detail = response.json()["detail"]
|
|
self.assertEqual(detail["code"], "zyt_ip_restricted")
|
|
self.assertEqual(detail["message"], archive_api.ORDER_IP_RESTRICTED_MESSAGE)
|
|
self.assertIn("正在核实", detail["message"])
|
|
for word in ("IP", "管理员", "服务器", "过期"):
|
|
self.assertNotIn(word, detail["message"])
|
|
self.assertTrue(detail["staff_message"].startswith(staff_prefix), detail["staff_message"])
|
|
self.assertIn("IP", detail["staff_message"])
|
|
self.assertIn("管理员", detail["staff_message"])
|
|
|
|
def assert_staff_ip_rejection(self, response, staff_prefix):
|
|
self.assertEqual(response.status_code, 409, response.text)
|
|
detail = response.json()["detail"]
|
|
self.assertEqual(detail["code"], "zyt_ip_restricted")
|
|
self.assertTrue(detail["message"].startswith(staff_prefix), detail["message"])
|
|
self.assertIn("IP", detail["message"])
|
|
self.assertNotIn("staff_message", detail)
|
|
|
|
def test_ip_pinning_rejection_reaches_the_model_only_as_a_neutral_message(self):
|
|
from zyt_order_client import ZytOrderIpRestricted
|
|
session, params, _ = self.prepare_conversation()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.list_orders.side_effect = ZytOrderIpRestricted("synthetic")
|
|
client.return_value.get_order_detail.side_effect = ZytOrderIpRestricted("synthetic")
|
|
for path in self.order_paths():
|
|
with self.subTest(path=path):
|
|
response = self.client.get(path, headers=session["headers"], params=params)
|
|
self.assert_neutral_ip_rejection(response, "订单信息暂时查不到")
|
|
# 概览只给客服面板用(订单 MCP 不调),保留完整说明,旧桌面端直接显示 message
|
|
self.assert_staff_ip_rejection(self.client.get(SUMMARY_PATH, headers=session["headers"], params=params),
|
|
"订单信息暂时查不到")
|
|
|
|
def test_patient_ip_rejection_during_order_binding_check_is_also_neutral(self):
|
|
from zyt_patient_client import ZytPatientIpRestricted
|
|
session, params, _ = self.prepare_conversation()
|
|
self.patient_search_error = ZytPatientIpRestricted("synthetic")
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
for path in self.order_paths():
|
|
with self.subTest(path=path):
|
|
response = self.client.get(path, headers=session["headers"], params=params)
|
|
self.assert_neutral_ip_rejection(response, "患者信息暂时查不到")
|
|
self.assert_staff_ip_rejection(self.client.get(SUMMARY_PATH, headers=session["headers"], params=params),
|
|
"患者信息暂时查不到")
|
|
client.assert_not_called()
|
|
|
|
def test_missing_order_returns_not_found_code(self):
|
|
from zyt_order_client import ZytOrderNotFound
|
|
session, params, _ = self.prepare_conversation()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.get_order_detail.side_effect = ZytOrderNotFound("订单不存在")
|
|
for path in self.order_paths()[1:]:
|
|
with self.subTest(path=path):
|
|
response = self.client.get(path, headers=session["headers"], params=params)
|
|
self.assertEqual(response.status_code, 404, response.text)
|
|
self.assertEqual(response.json()["detail"]["code"], "order_not_found")
|
|
|
|
def test_list_only_permission_cannot_read_detail_or_tracking(self):
|
|
_, params, _ = self.prepare_conversation()
|
|
limited = self.desktop_login("zyt-user-list-only")
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.list_orders.return_value = {"items": [self.sample_order()], "total": 1}
|
|
listed = self.client.get(self.order_paths()[0], headers=limited["headers"], params=params)
|
|
self.assertEqual(listed.status_code, 200, listed.text)
|
|
# Without the ZYT logistics permission the single-order shortcut must not query tracking.
|
|
self.assertIsNone(listed.json()["latest_tracking"])
|
|
client.return_value.get_tracking.assert_not_called()
|
|
for path in self.order_paths()[1:]:
|
|
with self.subTest(path=path):
|
|
response = self.client.get(path, headers=limited["headers"], params=params)
|
|
self.assertEqual(response.status_code, 403, response.text)
|
|
client.return_value.get_order_detail.assert_not_called()
|
|
|
|
def test_summary_for_unbound_conversation_explains_without_querying(self):
|
|
session, params, _ = self.prepare_conversation(bind=False)
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
response = self.client.get(
|
|
"/api/v2/archive/desktop/patient-orders/summary", headers=session["headers"], params=params,
|
|
)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
summary = response.json()
|
|
self.assertFalse(summary["capability"]["enabled"])
|
|
self.assertFalse(summary["capability"]["bound"])
|
|
self.assertEqual(summary["capability"]["code"], "patient_binding_required")
|
|
self.assertEqual(summary["recent_orders"], [])
|
|
client.assert_not_called()
|
|
|
|
def test_summary_for_bound_conversation_returns_orders_tracking_and_logs(self):
|
|
session, params, _ = self.prepare_conversation()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.list_orders.return_value = {
|
|
"items": [
|
|
self.sample_order(id=322, order_no="ZYT202609200322", tracking_number="", fulfillment_status=2),
|
|
self.sample_order(),
|
|
self.sample_order(id=300, diagnosis_id=9999),
|
|
],
|
|
"total": 3,
|
|
}
|
|
client.return_value.get_order_detail.return_value = self.sample_order()
|
|
client.return_value.get_tracking.return_value = {"state_text": "派送中", "traces": []}
|
|
detail = self.client.get(self.order_paths()[1], headers=session["headers"], params=params)
|
|
self.assertEqual(detail.status_code, 200, detail.text)
|
|
response = self.client.get(
|
|
"/api/v2/archive/desktop/patient-orders/summary", headers=session["headers"], params=params,
|
|
)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
summary = response.json()
|
|
self.assertTrue(summary["capability"]["enabled"])
|
|
self.assertEqual([item["order_id"] for item in summary["recent_orders"]], [322, 321])
|
|
self.assertEqual(summary["latest_tracking"]["status"], "派送中")
|
|
self.assertEqual(summary["latest_tracking"]["order_id"], 321)
|
|
self.assertNotIn("13800138000", response.text)
|
|
self.assertNotIn("SF1234567899", response.text)
|
|
labels = [entry["label"] for entry in summary["logs"]]
|
|
self.assertIn("查询订单详情", labels)
|
|
self.assertIn("刷新订单概览", labels)
|
|
self.assertEqual(client.return_value.get_tracking.call_args.args[0], 321)
|
|
|
|
def test_summary_logs_are_scoped_to_the_conversation(self):
|
|
session, params, _ = self.prepare_conversation()
|
|
with mock.patch("archive_api.ZytOrderClient") as client:
|
|
client.return_value.get_order_detail.return_value = self.sample_order()
|
|
self.client.get(self.order_paths()[1], headers=session["headers"], params=params)
|
|
other = dict(params, conversation_external_id="S:someone-else")
|
|
response = self.client.get(
|
|
"/api/v2/archive/desktop/patient-orders/summary", headers=session["headers"], params=other,
|
|
)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
self.assertEqual(response.json()["logs"], [])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|