fix schema validator skipping object/array checks on union types

the type gate handled a list like ["object","null"] fine but the
required/properties and items checks only ran when type was exactly
"object"/"array", so a union-typed schema silently passed malformed
args straight through to the capability handler. gate the structural
checks on the value's actual type plus union membership instead.

Author: Zawwarsami16

tests/test_validate_union_types.py

@@ -0,0 +1,61 @@
+"""Union-type ("type": ["object", "null"]) structural validation.
+
+The validator advertises that `type` may be a list of types. The primitive
+type gate handled that, but the structural checks (required/properties for
+objects, items for arrays) only fired for a bare "object"/"array" string, so
+a union-typed schema silently skipped them and malformed args slipped through
+to the capability handler. These cases pin the union path.
+"""
+
+from zhub.validate import validate
+
+
+def test_union_object_reports_missing_required():
+    schema = {
+        "type": ["object", "null"],
+        "required": ["city"],
+        "properties": {"city": {"type": "string"}},
+    }
+    errs = validate({}, schema)
+    assert any("city" in e for e in errs), errs
+
+
+def test_union_object_reports_bad_nested_type():
+    schema = {
+        "type": ["object", "null"],
+        "required": ["city"],
+        "properties": {"city": {"type": "string"}},
+    }
+    errs = validate({"city": 42}, schema)
+    assert any("city" in e and "string" in e for e in errs), errs
+
+
+def test_union_object_accepts_valid_and_null():
+    schema = {
+        "type": ["object", "null"],
+        "required": ["city"],
+        "properties": {"city": {"type": "string"}},
+    }
+    assert validate({"city": "x"}, schema) == []
+    # null is a permitted member of the union; it has no properties to check
+    assert validate(None, schema) == []
+
+
+def test_union_array_reports_bad_items():
+    schema = {"type": ["array", "null"], "items": {"type": "string"}}
+    errs = validate([1, 2], schema)
+    assert len(errs) == 2, errs
+    assert validate(["a", "b"], schema) == []
+
+
+def test_single_type_and_untyped_unchanged():
+    # regression guard for the non-union paths
+    assert validate({}, {"type": "object", "required": ["city"]}) == [
+        "<root>: missing required field 'city'"
+    ]
+    assert validate("x", {"type": "string"}) == []
+    assert validate(5, {"type": "string"}) == ["<root>: expected string, got integer"]
+    # untyped schema still infers structure from the value
+    assert validate({"city": 42}, {"properties": {"city": {"type": "string"}}}) == [
+        "city: expected string, got integer"
+    ]

zhub/validate.py

@@ -42,6 +42,7 @@ def validate(value: Any, schema: dict[str, Any], path: str = "") -> list[str]:
     errors: list[str] = []
 
     expected_type = schema.get("type")
+    types = None
     if expected_type is not None:
         types = expected_type if isinstance(expected_type, list) else [expected_type]
         if not any(_TYPE_CHECKS.get(t, lambda _v: True)(value) for t in types):
@@ -50,25 +51,28 @@ def validate(value: Any, schema: dict[str, Any], path: str = "") -> list[str]:
             errors.append(f"{path or '<root>'}: expected {joined}, got {actual}")
             return errors  # short-circuit; downstream checks assume the type matches
 
-    if expected_type == "object" or (expected_type is None and isinstance(value, dict)):
-        if isinstance(value, dict):
-            required = schema.get("required") or []
-            for field in required:
-                if field not in value:
-                    errors.append(f"{path or '<root>'}: missing required field '{field}'")
-            properties = schema.get("properties") or {}
-            for k, sub_schema in properties.items():
-                if k in value:
-                    sub_path = f"{path}.{k}" if path else k
-                    errors.extend(validate(value[k], sub_schema, sub_path))
-
-    if expected_type == "array" or (expected_type is None and isinstance(value, list)):
-        if isinstance(value, list):
-            item_schema = schema.get("items")
-            if isinstance(item_schema, dict):
-                for i, item in enumerate(value):
-                    sub_path = f"{path}[{i}]" if path else f"[{i}]"
-                    errors.extend(validate(item, item_schema, sub_path))
+    # Structural checks run whenever the value is actually a dict/list and the
+    # schema permits that type. `types is None` covers untyped schemas; the
+    # `"object"/"array" in types` membership covers both a bare "object" string
+    # and a union like ["object", "null"] — the list form was silently skipping
+    # required/properties/items before.
+    if isinstance(value, dict) and (types is None or "object" in types):
+        required = schema.get("required") or []
+        for field in required:
+            if field not in value:
+                errors.append(f"{path or '<root>'}: missing required field '{field}'")
+        properties = schema.get("properties") or {}
+        for k, sub_schema in properties.items():
+            if k in value:
+                sub_path = f"{path}.{k}" if path else k
+                errors.extend(validate(value[k], sub_schema, sub_path))
+
+    if isinstance(value, list) and (types is None or "array" in types):
+        item_schema = schema.get("items")
+        if isinstance(item_schema, dict):
+            for i, item in enumerate(value):
+                sub_path = f"{path}[{i}]" if path else f"[{i}]"
+                errors.extend(validate(item, item_schema, sub_path))
 
     return errors