OpenAPI request and response datatypes

Author: p1c2u

openapi_core/testing/__init__.py

@@ -0,0 +1,10 @@
+"""OpenAPI core testing module"""
+from openapi_core.testing.mock import MockRequestFactory, MockResponseFactory
+
+# backward compatibility
+MockRequest = MockRequestFactory.create
+MockResponse = MockResponseFactory.create
+
+__all__ = [
+    'MockRequestFactory', 'MockResponseFactory', 'MockRequest', 'MockResponse',
+]

openapi_core/testing/mock.py

@@ -1,36 +1,45 @@
-"""OpenAPI core wrappers module"""
+"""OpenAPI core testing mock module"""
 from werkzeug.datastructures import ImmutableMultiDict
 
-from openapi_core.wrappers.base import BaseOpenAPIRequest, BaseOpenAPIResponse
+from openapi_core.validation.request.datatypes import (
+    RequestParameters, OpenAPIRequest,
+)
+from openapi_core.validation.response.datatypes import OpenAPIResponse
 
 
-class MockRequest(BaseOpenAPIRequest):
+class MockRequestFactory(object):
 
-    def __init__(
-            self, host_url, method, path, path_pattern=None, args=None,
+    @classmethod
+    def create(
+            cls, host_url, method, path, path_pattern=None, args=None,
             view_args=None, headers=None, cookies=None, data=None,
             mimetype='application/json'):
-        self.host_url = host_url
-        self.path = path
-        self.path_pattern = path_pattern or path
-        self.method = method.lower()
-
-        self.parameters = {
-            'path': view_args or {},
-            'query': ImmutableMultiDict(args or []),
-            'header': headers or {},
-            'cookie': cookies or {},
-        }
-
-        self.body = data or ''
-
-        self.mimetype = mimetype
-
-
-class MockResponse(BaseOpenAPIResponse):
-
-    def __init__(self, data, status_code=200, mimetype='application/json'):
-        self.data = data
-
-        self.status_code = status_code
-        self.mimetype = mimetype
+        parameters = RequestParameters(
+            path=view_args or {},
+            query=ImmutableMultiDict(args or []),
+            header=headers or {},
+            cookie=cookies or {},
+        )
+        path_pattern = path_pattern or path
+        method = method.lower()
+        body = data or ''
+        return OpenAPIRequest(
+            host_url=host_url,
+            path=path,
+            path_pattern=path_pattern,
+            method=method,
+            parameters=parameters,
+            body=body,
+            mimetype=mimetype,
+        )
+
+
+class MockResponseFactory(object):
+
+    @classmethod
+    def create(cls, data, status_code=200, mimetype='application/json'):
+        return OpenAPIResponse(
+            data=data,
+            status_code=status_code,
+            mimetype=mimetype,
+        )

openapi_core/validation/request/datatypes.py

@@ -1,20 +1,43 @@
 """OpenAPI core validation request datatypes module"""
 import attr
+from werkzeug.datastructures import ImmutableMultiDict
 
 from openapi_core.validation.datatypes import BaseValidationResult
 
 
+from six.moves.urllib.parse import urljoin
+
+
 @attr.s
 class RequestParameters(object):
     path = attr.ib(factory=dict)
-    query = attr.ib(factory=dict)
+    query = attr.ib(factory=ImmutableMultiDict)
     header = attr.ib(factory=dict)
     cookie = attr.ib(factory=dict)
 
     def __getitem__(self, location):
         return getattr(self, location)
 
 
+@attr.s
+class OpenAPIRequest(object):
+
+    host_url = attr.ib()
+    path = attr.ib()
+    path_pattern = attr.ib()
+    method = attr.ib()
+
+    body = attr.ib()
+
+    mimetype = attr.ib()
+
+    parameters = attr.ib(factory=RequestParameters)
+
+    @property
+    def full_url_pattern(self):
+        return urljoin(self.host_url, self.path_pattern)
+
+
 @attr.s
 class RequestValidationResult(BaseValidationResult):
     body = attr.ib(default=None)

openapi_core/validation/request/validators.py

@@ -50,7 +50,7 @@ def validate(self, request):
     def _get_parameters(self, request, params):
         errors = []
         seen = set()
-        parameters = RequestParameters()
+        locations = {}
         for param_name, param in params:
             if (param_name, param.location.value) in seen:
                 # skip parameter already seen
@@ -79,9 +79,10 @@ def _get_parameters(self, request, params):
             except OpenAPIMappingError as exc:
                 errors.append(exc)
             else:
-                parameters[param.location.value][param_name] = unmarshalled
+                locations.setdefault(param.location.value, {})
+                locations[param.location.value][param_name] = unmarshalled
 
-        return parameters, errors
+        return RequestParameters(**locations), errors
 
     def _get_body(self, request, operation):
         errors = []

openapi_core/validation/response/datatypes.py

@@ -4,6 +4,15 @@
 from openapi_core.validation.datatypes import BaseValidationResult
 
 
+@attr.s
+class OpenAPIResponse(object):
+
+    data = attr.ib()
+    status_code = attr.ib()
+
+    mimetype = attr.ib()
+
+
 @attr.s
 class ResponseValidationResult(BaseValidationResult):
     data = attr.ib(default=None)

tests/integration/validation/test_minimal.py

@@ -3,7 +3,7 @@
 from openapi_core.schema.operations.exceptions import InvalidOperation
 from openapi_core.schema.paths.exceptions import InvalidPath
 from openapi_core.shortcuts import create_spec
-from openapi_core.testing.mock import MockRequest
+from openapi_core.testing import MockRequest
 from openapi_core.validation.request.validators import RequestValidator