unmarshaller finders refactor

p1c2u · p1c2u · commit b05e84695f93 · 2022-12-20T14:02:03.000Z
diff --git a/openapi_core/unmarshalling/schemas/unmarshallers.py b/openapi_core/unmarshalling/schemas/unmarshallers.py
@@ -185,6 +185,57 @@ def __init__(
         self.unmarshallers_factory = unmarshallers_factory
         self.context = context
 
+    def _get_one_of_schema_unmarshaller(
+        self, value: Any
+    ) -> Optional[BaseSchemaUnmarshaller]:
+        if "oneOf" not in self.schema:
+            return None
+
+        one_of_schemas = self.schema / "oneOf"
+        for subschema in one_of_schemas:
+            unmarshaller = self.unmarshallers_factory.create(subschema)
+            try:
+                unmarshaller.validate(value)
+            except ValidateError:
+                continue
+            else:
+                return unmarshaller
+        return None
+
+    def _iter_any_of_schema_unmarshallers(
+        self, value: Any
+    ) -> Iterator[BaseSchemaUnmarshaller]:
+        if "anyOf" not in self.schema:
+            return
+
+        any_of_schemas = self.schema / "anyOf"
+        for subschema in any_of_schemas:
+            unmarshaller = self.unmarshallers_factory.create(subschema)
+            try:
+                unmarshaller.validate(value)
+            except ValidateError:
+                continue
+            else:
+                yield unmarshaller
+
+    def _iter_all_of_schema_unmarshallers(
+        self, value: Any
+    ) -> Iterator[BaseSchemaUnmarshaller]:
+        if "allOf" not in self.schema:
+            return
+
+        all_of_schemas = self.schema / "allOf"
+        for subschema in all_of_schemas:
+            if "type" not in subschema:
+                continue
+            unmarshaller = self.unmarshallers_factory.create(subschema)
+            try:
+                unmarshaller.validate(value)
+            except ValidateError:
+                continue
+            else:
+                yield unmarshaller
+
 
 class ArrayUnmarshaller(ComplexUnmarshaller):
 
@@ -221,52 +272,41 @@ def unmarshal(self, value: Any) -> Any:
 
         return object_class(**properties)
 
-    def format(self, value: Any) -> Any:
+    def format(self, value: Any, schema_only: bool = False) -> Any:
         formatted = super().format(value)
-        return self._unmarshal_properties(formatted)
+        return self._unmarshal_properties(formatted, schema_only=schema_only)
 
     def _clone(self, schema: Spec) -> "ObjectUnmarshaller":
         return cast(
             "ObjectUnmarshaller",
             self.unmarshallers_factory.create(schema, "object"),
         )
 
-    def _unmarshal_properties(self, value: Any) -> Any:
+    def _unmarshal_properties(
+        self, value: Any, schema_only: bool = False
+    ) -> Any:
         properties = {}
 
-        if "oneOf" in self.schema:
-            one_of_properties = None
-            for one_of_schema in self.schema / "oneOf":
-                try:
-                    unmarshalled = self._clone(one_of_schema).format(value)
-                except (UnmarshalError, ValueError):
-                    pass
-                else:
-                    if one_of_properties is not None:
-                        log.warning("multiple valid oneOf schemas found")
-                        continue
-                    one_of_properties = unmarshalled
-
-            if one_of_properties is None:
-                log.warning("valid oneOf schema not found")
-            else:
-                properties.update(one_of_properties)
-
-        elif "anyOf" in self.schema:
-            any_of_properties = None
-            for any_of_schema in self.schema / "anyOf":
-                try:
-                    unmarshalled = self._clone(any_of_schema).format(value)
-                except (UnmarshalError, ValueError):
-                    pass
-                else:
-                    any_of_properties = unmarshalled
-                    break
-
-            if any_of_properties is None:
-                log.warning("valid anyOf schema not found")
-            else:
-                properties.update(any_of_properties)
+        one_of_unmarshaller = self._get_one_of_schema_unmarshaller(value)
+        if one_of_unmarshaller is not None:
+            one_of_properties = one_of_unmarshaller.format(
+                value, schema_only=True
+            )
+            properties.update(one_of_properties)
+
+        any_of_unmarshallers = self._iter_any_of_schema_unmarshallers(value)
+        for any_of_unmarshaller in any_of_unmarshallers:
+            any_of_properties = any_of_unmarshaller.format(
+                value, schema_only=True
+            )
+            properties.update(any_of_properties)
+
+        all_of_unmarshallers = self._iter_all_of_schema_unmarshallers(value)
+        for all_of_unmarshaller in all_of_unmarshallers:
+            all_of_properties = all_of_unmarshaller.format(
+                value, schema_only=True
+            )
+            properties.update(all_of_properties)
 
         for prop_name, prop in get_all_properties(self.schema).items():
             read_only = prop.getkey("readOnly", False)
@@ -286,6 +326,9 @@ def _unmarshal_properties(self, value: Any) -> Any:
                 prop_value
             )
 
+        if schema_only:
+            return properties
+
         additional_properties = self.schema.getkey(
             "additionalProperties", True
         )
@@ -359,63 +402,30 @@ def type(self) -> List[str]:
         return self.SCHEMA_TYPES_ORDER
 
     def unmarshal(self, value: Any) -> Any:
-        one_of_schema = self._get_one_of_schema(value)
-        if one_of_schema:
-            return self.unmarshallers_factory.create(one_of_schema)(value)
+        one_of_schema_unmarshaller = self._get_one_of_schema_unmarshaller(
+            value
+        )
+        if one_of_schema_unmarshaller:
+            return one_of_schema_unmarshaller(value)
 
-        any_of_schema = self._get_any_of_schema(value)
-        if any_of_schema:
-            return self.unmarshallers_factory.create(any_of_schema)(value)
+        any_of_schema_unmarshallers = self._iter_any_of_schema_unmarshallers(
+            value
+        )
+        try:
+            any_of_schema_unmarshaller = next(any_of_schema_unmarshallers)
+        except StopIteration:
+            pass
+        else:
+            return any_of_schema_unmarshaller(value)
 
-        all_of_schema = self._get_all_of_schema(value)
-        if all_of_schema:
-            return self.unmarshallers_factory.create(all_of_schema)(value)
+        all_of_schema_unmarshallers = self._iter_all_of_schema_unmarshallers(
+            value
+        )
+        try:
+            all_of_schema_unmarshaller = next(all_of_schema_unmarshallers)
+        except StopIteration:
+            pass
+        else:
+            return all_of_schema_unmarshaller(value)
 
         return super().unmarshal(value)
-
-    def _get_one_of_schema(self, value: Any) -> Optional[Spec]:
-        if "oneOf" not in self.schema:
-            return None
-
-        one_of_schemas = self.schema / "oneOf"
-        for subschema in one_of_schemas:
-            unmarshaller = self.unmarshallers_factory.create(subschema)
-            try:
-                unmarshaller.validate(value)
-            except ValidateError:
-                continue
-            else:
-                return subschema
-        return None
-
-    def _get_any_of_schema(self, value: Any) -> Optional[Spec]:
-        if "anyOf" not in self.schema:
-            return None
-
-        any_of_schemas = self.schema / "anyOf"
-        for subschema in any_of_schemas:
-            unmarshaller = self.unmarshallers_factory.create(subschema)
-            try:
-                unmarshaller.validate(value)
-            except ValidateError:
-                continue
-            else:
-                return subschema
-        return None
-
-    def _get_all_of_schema(self, value: Any) -> Optional[Spec]:
-        if "allOf" not in self.schema:
-            return None
-
-        all_of_schemas = self.schema / "allOf"
-        for subschema in all_of_schemas:
-            if "type" not in subschema:
-                continue
-            unmarshaller = self.unmarshallers_factory.create(subschema)
-            try:
-                unmarshaller.validate(value)
-            except ValidateError:
-                continue
-            else:
-                return subschema
-        return None
diff --git a/tests/integration/contrib/django/data/v3.0/djangoproject/pets/views.py b/tests/integration/contrib/django/data/v3.0/djangoproject/pets/views.py
@@ -39,9 +39,13 @@ def post(self, request):
             "api-key": "12345",
         }
         assert request.openapi.body.__class__.__name__ == "PetCreate"
-        assert request.openapi.body.name == "Cat"
-        assert request.openapi.body.ears.__class__.__name__ == "Ears"
-        assert request.openapi.body.ears.healthy is True
+        assert request.openapi.body.name in ["Cat", "Bird"]
+        if request.openapi.body.name == "Cat":
+            assert request.openapi.body.ears.__class__.__name__ == "Ears"
+            assert request.openapi.body.ears.healthy is True
+        if request.openapi.body.name == "Bird":
+            assert request.openapi.body.wings.__class__.__name__ == "Wings"
+            assert request.openapi.body.wings.healthy is True
 
         django_response = HttpResponse(status=201)
         django_response["X-Rate-Limit"] = "12"
diff --git a/tests/integration/contrib/django/test_django_project.py b/tests/integration/contrib/django/test_django_project.py
@@ -225,16 +225,28 @@ def test_post_required_cookie_param_missing(self, client):
         assert response.status_code == 400
         assert response.json() == expected_data
 
-    def test_post_valid(self, client):
+    @pytest.mark.parametrize(
+        "data_json",
+        [
+            {
+                "id": 12,
+                "name": "Cat",
+                "ears": {
+                    "healthy": True,
+                },
+            },
+            {
+                "id": 12,
+                "name": "Bird",
+                "wings": {
+                    "healthy": True,
+                },
+            },
+        ],
+    )
+    def test_post_valid(self, client, data_json):
         client.cookies.load({"user": 1})
         content_type = "application/json"
-        data_json = {
-            "id": 12,
-            "name": "Cat",
-            "ears": {
-                "healthy": True,
-            },
-        }
         headers = {
             "HTTP_AUTHORIZATION": "Basic testuser",
             "HTTP_HOST": "staging.gigantic-server.com",
diff --git a/tests/integration/contrib/falcon/data/v3.0/falconproject/pets/resources.py b/tests/integration/contrib/falcon/data/v3.0/falconproject/pets/resources.py
@@ -38,9 +38,18 @@ def on_post(self, request, response):
             "api-key": "12345",
         }
         assert request.context.openapi.body.__class__.__name__ == "PetCreate"
-        assert request.context.openapi.body.name == "Cat"
-        assert request.context.openapi.body.ears.__class__.__name__ == "Ears"
-        assert request.context.openapi.body.ears.healthy is True
+        assert request.context.openapi.body.name in ["Cat", "Bird"]
+        if request.context.openapi.body.name == "Cat":
+            assert (
+                request.context.openapi.body.ears.__class__.__name__ == "Ears"
+            )
+            assert request.context.openapi.body.ears.healthy is True
+        if request.context.openapi.body.name == "Bird":
+            assert (
+                request.context.openapi.body.wings.__class__.__name__
+                == "Wings"
+            )
+            assert request.context.openapi.body.wings.healthy is True
 
         response.status = HTTP_201
         response.set_header("X-Rate-Limit", "12")
diff --git a/tests/integration/contrib/falcon/test_falcon_project.py b/tests/integration/contrib/falcon/test_falcon_project.py
@@ -210,16 +210,28 @@ def test_post_required_cookie_param_missing(self, client):
         assert response.status_code == 400
         assert response.json == expected_data
 
-    def test_post_valid(self, client):
+    @pytest.mark.parametrize(
+        "data_json",
+        [
+            {
+                "id": 12,
+                "name": "Cat",
+                "ears": {
+                    "healthy": True,
+                },
+            },
+            {
+                "id": 12,
+                "name": "Bird",
+                "wings": {
+                    "healthy": True,
+                },
+            },
+        ],
+    )
+    def test_post_valid(self, client, data_json):
         cookies = {"user": 1}
         content_type = "application/json"
-        data_json = {
-            "id": 12,
-            "name": "Cat",
-            "ears": {
-                "healthy": True,
-            },
-        }
         headers = {
             "Authorization": "Basic testuser",
             "Api-Key": self.api_key_encoded,
