refactor: decompose ultra receipt validator semantics

tests/test_ultra_evaluation_receipt.py

@@ -359,5 +359,144 @@ def test_cli_rejects_overflowed_json_number(self) -> None:
         self.assertIn("overflowed JSON number", overflow.stderr)
 
 
+class HelperUnitTests(unittest.TestCase):
+    """Direct unit tests for decomposed helper functions."""
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.schema = load_json(SCHEMA_PATH)
+
+    def test_json_type_matches_all_types(self) -> None:
+        self.assertTrue(VALIDATOR._json_type_matches({}, "object"))
+        self.assertTrue(VALIDATOR._json_type_matches([], "array"))
+        self.assertTrue(VALIDATOR._json_type_matches("x", "string"))
+        self.assertTrue(VALIDATOR._json_type_matches(True, "boolean"))
+        self.assertTrue(VALIDATOR._json_type_matches(None, "null"))
+        self.assertTrue(VALIDATOR._json_type_matches(1, "integer"))
+        self.assertTrue(VALIDATOR._json_type_matches(1.0, "number"))
+        self.assertFalse(VALIDATOR._json_type_matches(True, "integer"))
+        self.assertFalse(VALIDATOR._json_type_matches(1, "boolean"))
+        self.assertFalse(VALIDATOR._json_type_matches({}, "string"))
+
+    def test_validate_ref_non_string_ref(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_ref({}, {"$ref": 123}, {}, "$", errors)
+        self.assertIn("$ref must be a string", "\n".join(errors))
+
+    def test_validate_ref_unresolvable(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_ref({}, {"$ref": "#/nonexistent"}, {}, "$", errors)
+        self.assertTrue(errors)
+
+    def test_validate_oneof_empty_branches(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_oneof({}, {"oneOf": []}, {}, "$", errors)
+        self.assertIn("non-empty array", "\n".join(errors))
+
+    def test_validate_oneof_multiple_matches(self) -> None:
+        errors: list[str] = []
+        schema = {"oneOf": [{"type": "string"}, {"type": "string"}]}
+        VALIDATOR._validate_oneof("x", schema, {}, "$", errors)
+        self.assertIn("more than one", "\n".join(errors))
+
+    def test_validate_type_non_string_entries(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_type("x", {"type": [123]}, "$", errors)
+        self.assertIn("must contain strings", "\n".join(errors))
+
+    def test_validate_array_keywords_not_list(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_array_keywords("not-list", {}, {}, "$", errors)
+        self.assertEqual([], errors)
+
+    def test_validate_string_keywords_not_string(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_string_keywords(123, {}, "$", errors)
+        self.assertEqual([], errors)
+
+    def test_validate_number_keywords_not_number(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_number_keywords("x", {}, "$", errors)
+        self.assertEqual([], errors)
+
+    def test_validate_number_keywords_bool_excluded(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_number_keywords(True, {"minimum": 5}, "$", errors)
+        self.assertEqual([], errors)
+
+    def test_validate_schema_subset_non_dict_schema(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_schema_subset("x", "not-a-dict", {}, "$", errors)
+        self.assertIn("must be an object", "\n".join(errors))
+
+    def test_validate_schema_identity_version_mismatch(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_schema_identity(
+            {"schema_id": "ultra_evaluation_receipt.v0.1", "schema_version": "0.2"},
+            errors,
+        )
+        self.assertIn("schema_version", "\n".join(errors))
+
+    def test_validate_telemetry_semantics_non_dict(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_telemetry_semantics({"telemetry": "not-dict"}, errors)
+        self.assertEqual([], errors)
+
+    def test_validate_delegation_lanes_semantics_non_list(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_delegation_lanes_semantics(
+            {"delegation_lanes": "not-list"}, errors
+        )
+        self.assertEqual([], errors)
+
+    def test_validate_outcome_semantics_non_dict(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_outcome_semantics(
+            {"outcome_improvement": "not-dict"}, errors
+        )
+        self.assertEqual([], errors)
+
+    def test_validate_routing_semantics_non_dict(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_routing_semantics(
+            {"model": "not-dict", "routing_decision": "not-dict"}, errors
+        )
+        self.assertEqual([], errors)
+
+    def test_validate_receipt_semantics_non_dict(self) -> None:
+        errors: list[str] = []
+        VALIDATOR._validate_receipt_semantics("not-a-dict", errors)
+        self.assertEqual([], errors)
+
+    def test_validate_receipt_non_dict_schema(self) -> None:
+        errors = VALIDATOR.validate_receipt({}, "not-a-dict")
+        self.assertIn("$schema", "\n".join(errors))
+
+    def test_validate_receipt_wrong_meta_schema(self) -> None:
+        errors = VALIDATOR.validate_receipt({}, {"$schema": "wrong", "$id": "wrong"})
+        self.assertTrue(errors)
+
+    def test_property_path_special_chars(self) -> None:
+        self.assertEqual(
+            '$["weird key"]', VALIDATOR._property_path("$", "weird key")
+        )
+        self.assertEqual("$.normal", VALIDATOR._property_path("$", "normal"))
+
+    def test_resolve_local_ref_non_local(self) -> None:
+        with self.assertRaises(ValueError):
+            VALIDATOR._resolve_local_ref({}, "http://example.com/schema")
+
+    def test_resolve_local_ref_unresolvable(self) -> None:
+        with self.assertRaises(ValueError):
+            VALIDATOR._resolve_local_ref({}, "#/nonexistent")
+
+    def test_parse_date_time_non_string(self) -> None:
+        self.assertIsNone(VALIDATOR._parse_date_time(123))
+        self.assertIsNone(VALIDATOR._parse_date_time(None))
+
+    def test_parse_date_time_leap_second_wrong_minute(self) -> None:
+        self.assertIsNone(VALIDATOR._parse_date_time("2026-07-11T05:00:60Z"))
+
+
 if __name__ == "__main__":
     unittest.main()