| from __future__ import annotations |
|
|
| import json |
| import unittest |
|
|
| from barbet_bgd.serializers_v2 import ( |
| REQUEST_SCHEMA_V2, |
| SERIALIZERS_V2, |
| SerializationV2Error, |
| build_messages_v2, |
| canonicalize_payload, |
| parse_request_message_v2, |
| parse_target_v2, |
| roundtrip_target_v2, |
| serialize_target_v2, |
| ) |
|
|
|
|
| def _complex_target() -> dict: |
| return { |
| "decision": "通過", |
| "evidence": ["src:w01", "doc:p03:region07"], |
| "confidence_target": 0.975, |
| "errors": [], |
| "action": { |
| "tool": "EXTRACT", |
| "arguments": { |
| "巢狀": [ |
| None, |
| True, |
| False, |
| 17, |
| -2.5, |
| { |
| "原文": "臺灣的繁體中文：<標籤> & & 符號", |
| "escaping": '引號 "、反斜線 \\、換行\n及 </payload>', |
| }, |
| ] |
| }, |
| }, |
| } |
|
|
|
|
| def _record(serializer: str = "JSON") -> dict: |
| return { |
| "record_id": "bgd_tw_v2_0000000", |
| "primitive": "EXTRACT", |
| "task_family": "FORM_EXTRACTION", |
| "task_spec": { |
| "instruction": "請抽取指定欄位。", |
| "query": "案件的承辦單位為何？", |
| "requested_schema": { |
| "type": "object", |
| "properties": {"承辦單位": {"type": "string"}}, |
| }, |
| "allowed_labels": [], |
| }, |
| "inputs": [ |
| { |
| "id": "src", |
| "type": "reference_text", |
| "units": [{"id": "src:w01", "text": "承辦單位為臺北市政府。"}], |
| } |
| ], |
| "target": _complex_target(), |
| "presentation": {"serializer": serializer}, |
| } |
|
|
|
|
| class SerializerV2RoundTripTests(unittest.TestCase): |
| def test_all_formats_roundtrip_losslessly(self): |
| target = _complex_target() |
| for serializer in SERIALIZERS_V2: |
| with self.subTest(serializer=serializer): |
| rendered = serialize_target_v2(target, serializer) |
| parsed = parse_target_v2(rendered, serializer) |
| self.assertEqual(parsed, canonicalize_payload(target)) |
| self.assertTrue(roundtrip_target_v2(target, serializer)) |
| self.assertIn("繁體中文", rendered) |
|
|
| def test_rendering_is_deterministic_across_input_key_order(self): |
| target = _complex_target() |
| reordered = {key: target[key] for key in reversed(tuple(target))} |
| for serializer in SERIALIZERS_V2: |
| self.assertEqual( |
| serialize_target_v2(target, serializer), |
| serialize_target_v2(reordered, serializer), |
| ) |
|
|
| def test_numeric_json_types_are_preserved(self): |
| for number in (0, -7, 1.0, -0.0, 1.25, 10**40): |
| target = {"decision": "PASS", "number": number} |
| for serializer in SERIALIZERS_V2: |
| parsed = parse_target_v2(serialize_target_v2(target, serializer), serializer) |
| self.assertIs(type(parsed["number"]), type(number)) |
|
|
| def test_serialization_does_not_mutate_input(self): |
| target = _complex_target() |
| before = json.dumps(target, ensure_ascii=False, sort_keys=False) |
| for serializer in SERIALIZERS_V2: |
| serialize_target_v2(target, serializer) |
| self.assertEqual(json.dumps(target, ensure_ascii=False, sort_keys=False), before) |
|
|
|
|
| class MessageV2Tests(unittest.TestCase): |
| def test_build_messages_exposes_complete_request_without_target_leakage(self): |
| record = _record("COMPACT_TAGS") |
| record["target"]["private_gold_marker"] = "不得出現在使用者訊息-GOLD-8f31" |
| messages = build_messages_v2(record) |
| self.assertEqual([message["role"] for message in messages], ["system", "user", "assistant"]) |
|
|
| request = parse_request_message_v2(messages[1]["content"]) |
| self.assertEqual(request["schema"], REQUEST_SCHEMA_V2) |
| self.assertEqual(request["task_spec"], canonicalize_payload(record["task_spec"])) |
| self.assertEqual(request["inputs"], canonicalize_payload(record["inputs"])) |
| self.assertIn("query", request["task_spec"]) |
| self.assertIn("requested_schema", request["task_spec"]) |
| self.assertNotIn("不得出現在使用者訊息-GOLD-8f31", messages[1]["content"]) |
| self.assertEqual( |
| parse_target_v2(messages[2]["content"], "COMPACT_TAGS"), |
| canonicalize_payload(record["target"]), |
| ) |
|
|
| def test_null_query_and_empty_requested_schema_are_valid(self): |
| record = _record() |
| record["task_spec"]["query"] = None |
| record["task_spec"]["requested_schema"] = {} |
| request = parse_request_message_v2(build_messages_v2(record)[1]["content"]) |
| self.assertIsNone(request["task_spec"]["query"]) |
| self.assertEqual(request["task_spec"]["requested_schema"], {}) |
|
|
| def test_missing_model_visible_task_fields_are_rejected(self): |
| for missing in ("query", "requested_schema"): |
| record = _record() |
| del record["task_spec"][missing] |
| with self.subTest(missing=missing), self.assertRaises(SerializationV2Error): |
| build_messages_v2(record) |
|
|
|
|
| class SerializerV2MalformedInputTests(unittest.TestCase): |
| def test_unknown_serializer_is_rejected(self): |
| with self.assertRaises(SerializationV2Error): |
| serialize_target_v2({}, "YAML") |
| with self.assertRaises(SerializationV2Error): |
| parse_target_v2("{}", "YAML") |
|
|
| def test_bad_values_are_rejected_without_coercion(self): |
| bad_values = ( |
| {"bad": float("nan")}, |
| {"bad": float("inf")}, |
| {"bad": (1, 2)}, |
| {1: "non-string key"}, |
| {"bad": "\ud800"}, |
| ) |
| for target in bad_values: |
| with self.subTest(target=repr(target)), self.assertRaises(SerializationV2Error): |
| serialize_target_v2(target, "JSON") |
|
|
| def test_json_duplicate_keys_trailing_data_and_wrong_envelopes_are_rejected(self): |
| malformed = ( |
| '{"schema":"barbet.bgd.target/v2","target":{"x":1,"x":2}}', |
| '{"schema":"barbet.bgd.target/v2","target":{}} trailing', |
| '{"schema":"barbet.bgd.target/v1","target":{}}', |
| '{"schema":"barbet.bgd.target/v2","target":{},"extra":true}', |
| '[]', |
| '{"schema":"barbet.bgd.target/v2","target":null}', |
| '{"schema":"barbet.bgd.target/v2","target":{"x":NaN}}', |
| '{"schema":"barbet.bgd.target/v2","target":{"x":1e999}}', |
| ) |
| for rendered in malformed: |
| with self.subTest(rendered=rendered), self.assertRaises(SerializationV2Error): |
| parse_target_v2(rendered, "JSON") |
|
|
| def test_malformed_function_calls_are_rejected(self): |
| valid = serialize_target_v2({"decision": "PASS"}, "FUNCTION_CALL") |
| malformed = ( |
| " " + valid, |
| valid + " ", |
| valid[:-1], |
| valid.replace("BGD_RESULT_V2", "OTHER", 1), |
| "BGD_RESULT_V2(payload={})extra", |
| ) |
| for rendered in malformed: |
| with self.subTest(rendered=rendered), self.assertRaises(SerializationV2Error): |
| parse_target_v2(rendered, "FUNCTION_CALL") |
|
|
| def test_malformed_compact_tags_and_escaping_are_rejected(self): |
| valid = serialize_target_v2({"decision": "<通過>&"}, "COMPACT_TAGS") |
| malformed = ( |
| valid.replace("<通過>", "<通過>", 1), |
| valid.replace("&", "&bogus;", 1), |
| valid.replace("</payload>", "</result>", 1), |
| " " + valid, |
| ) |
| for rendered in malformed: |
| with self.subTest(rendered=rendered), self.assertRaises(SerializationV2Error): |
| parse_target_v2(rendered, "COMPACT_TAGS") |
|
|
| def test_malformed_key_value_is_rejected(self): |
| valid = serialize_target_v2({"decision": "PASS"}, "KEY_VALUE") |
| malformed = ( |
| valid.replace("schema:", "schema=", 1), |
| valid.replace("payload: ", "payload:\n", 1), |
| valid + "\nextra: true", |
| " " + valid, |
| ) |
| for rendered in malformed: |
| with self.subTest(rendered=rendered), self.assertRaises(SerializationV2Error): |
| parse_target_v2(rendered, "KEY_VALUE") |
|
|
| def test_malformed_request_message_is_rejected(self): |
| valid = build_messages_v2(_record())[1]["content"] |
| malformed = ( |
| valid + " ", |
| valid.replace("barbet.bgd.request/v2", "barbet.bgd.request/v1", 1), |
| valid.replace('"inputs":', '"unknown":0,"inputs":', 1), |
| valid.replace('"query":', '"query":null,"query":', 1), |
| ) |
| for content in malformed: |
| with self.subTest(content=content), self.assertRaises(SerializationV2Error): |
| parse_request_message_v2(content) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
