Files
kefu/wechat_rpa/test_zyt_order_api.py
T
2026-09-30 19:28:13 +08:00

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()