fix: OAS 3.1 multi type (cast/deserialize)

Author: litteratum

openapi_core/casting/schemas/casters.py

@@ -235,7 +235,7 @@ def cast(self, value: Any) -> Any:
         ):
             return value
 
-        schema_type = (self.schema / "type").read_str(None)
+        schema_type = (self.schema / "type").read_str_or_list(None)
         type_caster = self.get_type_caster(schema_type)
 
         if value is None:

openapi_core/deserializing/styles/factories.py

@@ -28,7 +28,7 @@ def create(
     ) -> StyleDeserializer:
         deserialize_callable = self.style_deserializers.get(style)
         caster = self.schema_casters_factory.create(spec, schema)
-        schema_type = (schema / "type").read_str("")
+        schema_type = (schema / "type").read_str_or_list("")
         return StyleDeserializer(
             style, explode, name, schema_type, caster, deserialize_callable
         )

tests/unit/casting/test_schema_casters.py

@@ -67,6 +67,26 @@ def test_array_invalid_value(self, value, caster_factory):
         ):
             caster_factory(schema).cast(value)
 
+    @pytest.mark.parametrize(
+        "schema_types,value",
+        [
+            (["string", "number", "boolean"], "12567"),
+            (["integer", "string"], "42"),
+            (["number", "string"], "3.14"),
+            (["boolean", "string"], "true"),
+        ],
+    )
+    def test_oas31_multi_type(self, caster_factory, schema_types, value):
+        """Test OAS 3.1 list-style `type`."""
+        spec = {
+            "type": schema_types,
+        }
+        schema = SchemaPath.from_dict(spec)
+
+        result = caster_factory(schema).cast(value)
+
+        assert result == value
+
     @pytest.mark.parametrize(
         "composite_type,schema_type,value,expected",
         [

tests/unit/deserializing/test_styles_deserializers.py

@@ -444,6 +444,34 @@ def test_pipe_delimited_valid(
 
         assert result == expected
 
+    @pytest.mark.parametrize(
+        "schema_types,value,expected",
+        [
+            (["string", "number", "boolean"], "12567", "12567"),
+            (["integer", "string"], "42", "42"),
+        ],
+    )
+    def test_oas31_multi_type_form(
+        self, deserializer_factory, schema_types, value, expected
+    ):
+        """Test OAS 3.1 multi-type support for form style parameters."""
+        name = "param"
+        spec = {
+            "name": name,
+            "in": "query",
+            "explode": True,
+            "schema": {
+                "type": schema_types,
+            },
+        }
+        param = SchemaPath.from_dict(spec)
+        deserializer = deserializer_factory(param)
+        location = {name: value}
+
+        result = deserializer.deserialize(location)
+
+        assert result == expected
+
     def test_deep_object_valid(self, deserializer_factory):
         name = "param"
         spec = {