Adapt schema validation to openapi 3.1

This will allow to also consume openapi schema produced with version
3.1.1.

Author: mdellweg

.ci/run_container.sh

@@ -72,6 +72,7 @@ export PULP_CONTENT_ORIGIN
 "${CONTAINER_RUNTIME}" \
   run ${RM:+--rm} \
   --env S6_KEEP_ENV=1 \
+  ${OAS_VERSION:+--env PULP_SPECTACULAR_SETTINGS__OAS_VERSION="${OAS_VERSION}"} \
   ${PULP_HTTPS:+--env PULP_HTTPS} \
   ${PULP_OAUTH2:+--env PULP_OAUTH2} \
   ${PULP_API_ROOT:+--env PULP_API_ROOT} \

.github/workflows/test.yml

@@ -51,6 +51,7 @@ jobs:
           - image_tag: "latest"
             python: "3.11"
             upper_bounds: true
+            oas_version: "3.1.1"
           - image_tag: "3.63"
             pulp_https: "true"
             pulp_oauth2: "true"
@@ -106,6 +107,7 @@ jobs:
           PULP_HTTPS: "${{ matrix.pulp_https }}"
           PULP_OAUTH2: "${{ matrix.pulp_oauth2 }}"
           PULP_API_ROOT: "${{ matrix.pulp_api_root }}"
+          OAS_VERSION: "${{ matrix.oas_version }}"
         run: |
           .ci/run_container.sh make livetest
 ...

CHANGES/pulp-glue/+openapi_3_1.feature

@@ -0,0 +1 @@
+Improved validation to consume openapi 3.1 schemata also.

pulp-glue/pulp_glue/common/schema.py

@@ -99,16 +99,31 @@ def validate(schema: t.Any, name: str, value: t.Any, components: t.Dict[str, t.A
         return
 
     if value is None:
+        # This seems to be the openapi 3.0.3 way.
+        # in 3.1.* they use `"type": ["string", "null"]` instead.
         if schema.get("nullable", False):
             return
 
     if (schema_type := schema.get("type")) is not None:
-        if (typed_transform := _TYPED_VALIDATORS.get(schema_type)) is not None:
-            value = typed_transform(schema, name, value, components)
+        if isinstance(schema_type, list):
+            if len(schema_type) == 0:
+                raise SchemaError(_("{name} specified an empty type array").format(name=name))
+            errors = []
+            for stype in schema_type:
+                try:
+                    _validate_type(stype, schema, name, value, components)
+                    break
+                except ValidationError as e:
+                    errors.append(f"{stype}: {e}")
+            else:
+                raise ValidationError(
+                    _("{name} did not match any of the types: {errors}").format(
+                        name=name, errors="\n".join(errors)
+                    )
+                )
+
         else:
-            raise NotImplementedError(
-                _("Type `{schema_type}` is not implemented yet.").format(schema_type=schema_type)
-            )
+            _validate_type(schema_type, schema, name, value, components)
 
     # allOf etc allow for composition, but the spec isn't particularly clear about that.
     if (all_of := schema.get("allOf")) is not None:
@@ -133,6 +148,17 @@ def validate(schema: t.Any, name: str, value: t.Any, components: t.Dict[str, t.A
             )
 
 
+def _validate_type(
+    schema_type: str, schema: t.Any, name: str, value: t.Any, components: t.Dict[str, t.Any]
+) -> None:
+    if (typed_validator := _TYPED_VALIDATORS.get(schema_type)) is not None:
+        typed_validator(schema, name, value, components)
+    else:
+        raise NotImplementedError(
+            _("Type `{schema_type}` is not implemented yet.").format(schema_type=schema_type)
+        )
+
+
 def _validate_ref(schema_ref: str, name: str, value: t.Any, components: t.Dict[str, t.Any]) -> None:
     if not schema_ref.startswith("#/components/schemas/"):
         raise SchemaError(_("'{name}' contains an invalid reference.").format(name=name))
@@ -185,6 +211,11 @@ def _validate_integer(
             )
 
 
+def _validate_null(schema: t.Any, name: str, value: t.Any, components: t.Dict[str, t.Any]) -> None:
+    if value is not None:
+        raise ValidationError(_("'{name}' is expected to be a null").format(name=name))
+
+
 def _validate_number(
     schema: t.Any, name: str, value: t.Any, components: t.Dict[str, t.Any]
 ) -> None:
@@ -252,6 +283,7 @@ def _validate_string(
     "array": _validate_array,
     "boolean": _validate_boolean,
     "integer": _validate_integer,
+    "null": _validate_null,
     "number": _validate_number,
     "object": _validate_object,
     "string": _validate_string,

pulp-glue/tests/test_schema.py

@@ -153,6 +153,8 @@
             {"a": datetime.date(2000, 1, 1), "b": datetime.date(2000, 1, 2)},
             id="any_of_matches_one",
         ),
+        pytest.param({"type": ["string", "null"]}, "test_string", id="type_array_matches_string"),
+        pytest.param({"type": ["string", "null"]}, None, id="type_array_matches_null"),
     ],
 )
 def test_validates(schema: t.Any, value: t.Any) -> None:
@@ -309,6 +311,9 @@ def test_validates(schema: t.Any, value: t.Any) -> None:
             None,
             id="fails_validate_none_matched",
         ),
+        pytest.param(
+            {"type": ["string", "null"]}, 1, "did not match any", id="type_array_matches_string"
+        ),
     ],
 )
 def test_validation_failed(schema: t.Any, value: t.Any, match: t.Optional[str]) -> None:
@@ -322,6 +327,7 @@ def test_validation_failed(schema: t.Any, value: t.Any, match: t.Optional[str])
         pytest.param({"type": "blubb"}, 1, NotImplementedError, id="unknown_type"),
         pytest.param({"$ref": "blubb"}, 1, SchemaError, id="invalid_reference"),
         pytest.param({"$ref": "#/components/schemas/notHere"}, 1, KeyError, id="missing_reference"),
+        pytest.param({"type": []}, 1, SchemaError, id="type_array_matches_string"),
     ],
 )
 def test_invalid_schema_raises(schema: t.Any, value: t.Any, exc_type: t.Type[Exception]) -> None: