coverage for choice

Signed-off-by: Clemens Vasters <clemens@vasters.com>

Author: clemensv

samples/py/json_structure_instance_validator.py

@@ -167,7 +167,7 @@ def validate_instance(self, instance, schema=None, path="#", meta=None):
             return self.errors
 
         # Process $extends. [Metaschema: $extends in ObjectType/TupleType]
-        if "$extends" in schema:
+        if schema_type != "choice" and "$extends" in schema:
             base = self._resolve_ref(schema["$extends"])
             if base is None:
                 self.errors.append(f"Cannot resolve $extends {schema['$extends']} at {path}")
@@ -181,6 +181,7 @@ def validate_instance(self, instance, schema=None, path="#", meta=None):
             merged = dict(base)
             merged.update(schema)
             merged.pop("$extends", None)
+            merged.pop("abstract", None)
             schema = merged
 
         # Reject abstract schemas. [Metaschema: abstract property]
@@ -359,6 +360,39 @@ def validate_instance(self, instance, schema=None, path="#", meta=None):
                 else:
                     for (prop, prop_schema), item in zip(props.items(), instance):
                         self.validate_instance(item, prop_schema, f"{path}/{prop}")
+        elif schema_type == "choice":
+            if not isinstance(instance, dict):
+                self.errors.append(f"Expected choice object at {path}, got {type(instance).__name__}")
+            else:
+                choices = schema.get("choices", {})
+                extends = schema.get("$extends")
+                selector = schema.get("selector")
+                if extends is None:
+                    # Tagged union: exactly one property matching a choice key
+                    if len(instance) != 1:
+                        self.errors.append(f"Tagged union at {path} must have a single property")
+                    else:
+                        key, value = next(iter(instance.items()))
+                        if key not in choices:
+                            self.errors.append(f"Property '{key}' at {path} not one of choices {list(choices.keys())}")
+                        else:
+                            self.validate_instance(value, choices[key], f"{path}/{key}")
+                else:
+                    # Inline union: must have selector property
+                    if selector is None:
+                        self.errors.append(f"Inline union at {path} missing 'selector' in schema")
+                    else:
+                        sel_val = instance.get(selector)
+                        if not isinstance(sel_val, str):
+                            self.errors.append(f"Selector '{selector}' at {path} must be a string")
+                        elif sel_val not in choices:
+                            self.errors.append(f"Selector '{sel_val}' at {path} not one of choices {list(choices.keys())}")
+                        else:
+                            # validate remaining properties against chosen variant
+                            variant = choices[sel_val]
+                            inst_copy = dict(instance)
+                            inst_copy.pop(selector, None)
+                            self.validate_instance(inst_copy, variant, path)
         else:
             self.errors.append(f"Unsupported type '{schema_type}' at {path}")
 

samples/py/json_structure_schema_validator.py

@@ -44,7 +44,7 @@ class JSONStructureSchemaCoreValidator:
         "datetime", "time", "duration", "uuid", "uri", "binary", "jsonpointer",
         "any"
     }
-    COMPOUND_TYPES = {"object", "array", "set", "map", "tuple"}
+    COMPOUND_TYPES = {"object", "array", "set", "map", "tuple", "choice"}
 
     def __init__(self, allow_dollar=False, allow_import=False, import_map=None):
         """
@@ -318,6 +318,8 @@ def _validate_schema(self, schema_obj, is_root=False, path="", name_in_namespace
                             self._check_map_schema(schema_obj, path)
                         elif tval == "tuple":
                             self._check_tuple_schema(schema_obj, path)
+                        elif tval == "choice":
+                            self._check_choice_schema(schema_obj, path)
                         else:
                             self._check_primitive_schema(schema_obj, path)
         if "required" in schema_obj:
@@ -435,6 +437,27 @@ def _check_tuple_schema(self, obj, path):
                     else:
                         self._err(f"Tuple property '{prop_name}' must be an object (a schema).", path + f"/properties/{prop_name}")
 
+    def _check_choice_schema(self, obj, path):
+        """
+        Checks constraints for a 'choice' type (tagged or inline union).
+        """
+        if "choices" not in obj:
+            self._err("Choice type must have 'choices'.", path + "/choices")
+        else:
+            choices = obj["choices"]
+            if not isinstance(choices, dict):
+                self._err("'choices' must be an object (map).", path + "/choices")
+            else:
+                for name, choice_schema in choices.items():
+                    if not isinstance(name, str):
+                        self._err(f"Choice key '{name}' must be a string.", path + f"/choices/{name}")
+                    if isinstance(choice_schema, dict):
+                        self._validate_schema(choice_schema, is_root=False, path=f"{path}/choices/{name}")
+                    else:
+                        self._err(f"Choice value for '{name}' must be an object (schema).", path + f"/choices/{name}")
+        if "selector" in obj and not isinstance(obj.get("selector"), str):
+            self._err("'selector' must be a string.", path + "/selector")
+
     def _check_primitive_schema(self, obj, path):
         """
         Checks constraints for a recognized primitive type.

samples/py/test_json_structure_instance_validator.py

@@ -1136,6 +1136,129 @@ def test_not_fail():
     errors = validator.validate_instance(instance)
     assert any("should not validate against 'not' schema" in err for err in errors)
 
+# -------------------------------------------------------------------
+# Choice Type Tests
+# -------------------------------------------------------------------
+
+def test_choice_tagged_valid():
+    schema = {
+        "$schema": "https://json-structure.org/meta/core/v0/#",
+        "$id": "dummy",
+        "name": "MyChoice",
+        "type": "choice",
+        "choices": {
+            "a": {"type": "string"},
+            "b": {"type": "number"}
+        }
+    }
+    instance = {"a": "hello"}
+    validator = JSONStructureInstanceValidator(schema)
+    errors = validator.validate_instance(instance)
+    assert errors == []
+
+
+def test_choice_tagged_invalid_multiple_properties():
+    schema = {
+        "$schema": "https://json-structure.org/meta/core/v0/#",
+        "$id": "dummy",
+        "name": "MyChoice",
+        "type": "choice",
+        "choices": {
+            "a": {"type": "string"},
+            "b": {"type": "number"}
+        }
+    }
+    instance = {"a": "x", "b": 1}
+    validator = JSONStructureInstanceValidator(schema)
+    errors = validator.validate_instance(instance)
+    assert any("must have a single property" in err for err in errors)
+
+
+def test_choice_tagged_invalid_key():
+    schema = {
+        "$schema": "https://json-structure.org/meta/core/v0/#",
+        "$id": "dummy",
+        "name": "MyChoice",
+        "type": "choice",
+        "choices": {
+            "a": {"type": "string"},
+            "b": {"type": "number"}
+        }
+    }
+    instance = {"c": "oops"}
+    validator = JSONStructureInstanceValidator(schema)
+    errors = validator.validate_instance(instance)
+    assert any("not one of choices" in err for err in errors)
+
+
+def test_choice_inline_valid():
+    schema = {
+        "$schema": "https://json-structure.org/meta/core/v0/#",
+        "$id": "dummy",
+        "name": "InlineChoice",
+        "type": "choice",
+        "$extends": "#/definitions/Base",
+        "selector": "type",
+        "choices": {
+            "X": {"$ref": "#/definitions/X"},
+            "Y": {"$ref": "#/definitions/Y"}
+        },
+        "definitions": {
+            "Base": {
+                "name": "Base",
+                "abstract": True,
+                "type": "object",
+                "properties": {"common": {"type": "string"}}
+            },
+            "X": {
+                "type": "object",
+                "$extends": "#/definitions/Base",
+                "properties": {"x": {"type": "number"}}
+            },
+            "Y": {
+                "type": "object",
+                "$extends": "#/definitions/Base",
+                "properties": {"y": {"type": "boolean"}}
+            }
+        }
+    }
+    instance = {"type": "X", "x": 123}
+    validator = JSONStructureInstanceValidator(schema)
+    errors = validator.validate_instance(instance)
+    assert errors == []
+
+
+def test_choice_inline_missing_selector():
+    schema = {
+        "$schema": "https://json-structure.org/meta/core/v0/#",
+        "$id": "dummy",
+        "name": "InlineChoice",
+        "type": "choice",
+        "$extends": "#/definitions/Base",
+        "choices": {"A": {"type": "string"}},
+        "definitions": {"Base": {"name": "Base", "abstract": True, "type": "object", "properties": {}}}
+    }
+    instance = {"A": "value"}
+    validator = JSONStructureInstanceValidator(schema)
+    errors = validator.validate_instance(instance)
+    assert any("missing 'selector'" in err for err in errors)
+
+
+def test_choice_inline_invalid_selector_value():
+    schema = {
+        "$schema": "https://json-structure.org/meta/core/v0/#",
+        "$id": "dummy",
+        "name": "InlineChoice",
+        "type": "choice",
+        "$extends": "#/definitions/Base",
+        "selector": "kind",
+        "choices": {"A": {"type": "string"}},
+        "definitions": {"Base": {"name": "Base", "abstract": True, "type": "object", "properties": {}}}
+    }
+    instance = {"kind": "B", "B": "oops"}
+    validator = JSONStructureInstanceValidator(schema)
+    errors = validator.validate_instance(instance)
+    assert any("not one of choices" in err for err in errors)
 
 # -------------------------------------------------------------------
 # End of tests.