Merge pull request #10 from p1c2u/feature/responses-validation

Responses validation

Author: p1c2u

README.rst

@@ -103,6 +103,31 @@ or specify request wrapper class for shortcuts
    validated_body = validate_body(
        spec, request, wrapper_class=FlaskOpenAPIRequest)
 
+You can also validate responses
+
+.. code-block:: python
+
+   from openapi_core.validators import ResponseValidator
+
+   validator = ResponseValidator(spec)
+   result = validator.validate(request, response)
+
+   # raise errors if response invalid
+   result.raise_for_errors()
+
+   # get list of errors
+   errors = result.errors
+
+and unmarshal response data from validation result
+
+.. code-block:: python
+
+   # get headers
+   validated_headers = result.headers
+
+   # get data
+   validated_data = result.data
+
 Related projects
 ================
 * `openapi-spec-validator <https://github.com/p1c2u/openapi-spec-validator>`__

openapi_core/exceptions.py

@@ -69,5 +69,9 @@ class InvalidContentType(OpenAPIBodyError):
     pass
 
 
+class InvalidResponse(OpenAPIMappingError):
+    pass
+
+
 class InvalidValue(OpenAPIMappingError):
     pass

openapi_core/operations.py

@@ -5,8 +5,10 @@
 
 from six import iteritems
 
+from openapi_core.exceptions import InvalidResponse
 from openapi_core.parameters import ParametersGenerator
 from openapi_core.request_bodies import RequestBodyFactory
+from openapi_core.responses import ResponsesGenerator
 
 log = logging.getLogger(__name__)
 
@@ -15,10 +17,11 @@ class Operation(object):
     """Represents an OpenAPI Operation."""
 
     def __init__(
-            self, http_method, path_name, parameters, request_body=None,
-            deprecated=False, operation_id=None):
+            self, http_method, path_name, responses, parameters,
+            request_body=None, deprecated=False, operation_id=None):
         self.http_method = http_method
         self.path_name = path_name
+        self.responses = dict(responses)
         self.parameters = dict(parameters)
         self.request_body = request_body
         self.deprecated = deprecated
@@ -27,6 +30,21 @@ def __init__(
     def __getitem__(self, name):
         return self.parameters[name]
 
+    def get_response(self, http_status='default'):
+        try:
+            return self.responses[http_status]
+        except KeyError:
+            # try range
+            http_status_range = '{0}XX'.format(http_status[0])
+            if http_status_range in self.responses:
+                return self.responses[http_status_range]
+
+            if 'default' not in self.responses:
+                raise InvalidResponse(
+                    "Unknown response http status {0}".format(http_status))
+
+            return self.responses['default']
+
 
 class OperationsGenerator(object):
     """Represents an OpenAPI Operation in a service."""
@@ -42,9 +60,12 @@ def generate(self, path_name, path):
                 continue
 
             operation_deref = self.dereferencer.dereference(operation)
+            responses_spec = operation_deref['responses']
+            responses = self.responses_generator.generate(responses_spec)
             deprecated = operation_deref.get('deprecated', False)
             parameters_list = operation_deref.get('parameters', [])
-            parameters = self.parameters_generator.generate(parameters_list)
+            parameters = self.parameters_generator.generate_from_list(
+                parameters_list)
 
             request_body = None
             if 'requestBody' in operation_deref:
@@ -55,11 +76,16 @@ def generate(self, path_name, path):
             yield (
                 http_method,
                 Operation(
-                    http_method, path_name, list(parameters),
+                    http_method, path_name, responses, list(parameters),
                     request_body=request_body, deprecated=deprecated,
                 ),
             )
 
+    @property
+    @lru_cache()
+    def responses_generator(self):
+        return ResponsesGenerator(self.dereferencer, self.schemas_registry)
+
     @property
     @lru_cache()
     def parameters_generator(self):

openapi_core/parameters.py

@@ -2,6 +2,8 @@
 import logging
 import warnings
 
+from six import iteritems
+
 from openapi_core.exceptions import (
     EmptyValue, InvalidValueType, InvalidParameterValue,
 )
@@ -54,10 +56,36 @@ def __init__(self, dereferencer, schemas_registry):
         self.dereferencer = dereferencer
         self.schemas_registry = schemas_registry
 
-    def generate(self, paramters):
-        for parameter in paramters:
+    def generate(self, parameters):
+        for parameter_name, parameter in iteritems(parameters):
+            parameter_deref = self.dereferencer.dereference(parameter)
+
+            parameter_in = parameter_deref.get('in', 'header')
+
+            allow_empty_value = parameter_deref.get('allowEmptyValue')
+            required = parameter_deref.get('required', False)
+
+            schema_spec = parameter_deref.get('schema', None)
+            schema = None
+            if schema_spec:
+                schema, _ = self.schemas_registry.get_or_create(schema_spec)
+
+            yield (
+                parameter_name,
+                Parameter(
+                    parameter_name, parameter_in,
+                    schema=schema, required=required,
+                    allow_empty_value=allow_empty_value,
+                ),
+            )
+
+    def generate_from_list(self, parameters_list):
+        for parameter in parameters_list:
             parameter_deref = self.dereferencer.dereference(parameter)
 
+            parameter_name = parameter_deref['name']
+            parameter_in = parameter_deref.get('in', 'header')
+
             allow_empty_value = parameter_deref.get('allowEmptyValue')
             required = parameter_deref.get('required', False)
 
@@ -67,9 +95,9 @@ def generate(self, paramters):
                 schema, _ = self.schemas_registry.get_or_create(schema_spec)
 
             yield (
-                parameter_deref['name'],
+                parameter_name,
                 Parameter(
-                    parameter_deref['name'], parameter_deref['in'],
+                    parameter_name, parameter_in,
                     schema=schema, required=required,
                     allow_empty_value=allow_empty_value,
                 ),

openapi_core/responses.py

@@ -0,0 +1,62 @@
+"""OpenAPI core responses module"""
+from functools import lru_cache
+
+from six import iteritems
+
+from openapi_core.exceptions import InvalidContentType
+from openapi_core.media_types import MediaTypeGenerator
+from openapi_core.parameters import ParametersGenerator
+
+
+class Response(object):
+
+    def __init__(
+            self, http_status, description, headers=None, content=None,
+            links=None):
+        self.http_status = http_status
+        self.description = description
+        self.headers = headers and dict(headers) or {}
+        self.content = content and dict(content) or {}
+        self.links = links and dict(links) or {}
+
+    def __getitem__(self, mimetype):
+        try:
+            return self.content[mimetype]
+        except KeyError:
+            raise InvalidContentType(
+                "Invalid mime type `{0}`".format(mimetype))
+
+
+class ResponsesGenerator(object):
+
+    def __init__(self, dereferencer, schemas_registry):
+        self.dereferencer = dereferencer
+        self.schemas_registry = schemas_registry
+
+    def generate(self, responses):
+        for http_status, response in iteritems(responses):
+            description = response['description']
+            headers = response.get('headers')
+            content = response.get('content')
+
+            media_types = None
+            if content:
+                media_types = self.media_types_generator.generate(content)
+
+            parameters = None
+            if headers:
+                parameters = self.parameters_generator.generate(headers)
+
+            yield http_status, Response(
+                http_status, description,
+                content=media_types, headers=parameters)
+
+    @property
+    @lru_cache()
+    def media_types_generator(self):
+        return MediaTypeGenerator(self.dereferencer, self.schemas_registry)
+
+    @property
+    @lru_cache()
+    def parameters_generator(self):
+        return ParametersGenerator(self.dereferencer, self.schemas_registry)

openapi_core/validators.py

@@ -2,7 +2,7 @@
 from six import iteritems
 
 from openapi_core.exceptions import (
-    OpenAPIMappingError, MissingParameter, MissingBody,
+    OpenAPIMappingError, MissingParameter, MissingBody, InvalidResponse,
 )
 
 
@@ -43,6 +43,14 @@ def __init__(self, errors, body=None, parameters=None):
         self.parameters = parameters or RequestParameters()
 
 
+class ResponseValidationResult(BaseValidationResult):
+
+    def __init__(self, errors, data=None, headers=None):
+        super(ResponseValidationResult, self).__init__(errors)
+        self.data = data
+        self.headers = headers
+
+
 class RequestValidator(object):
 
     def __init__(self, spec):
@@ -120,3 +128,63 @@ def _get_raw_body(self, request):
             raise MissingBody("Missing required request body")
 
         return request.body
+
+
+class ResponseValidator(object):
+
+    def __init__(self, spec):
+        self.spec = spec
+
+    def validate(self, request, response):
+        errors = []
+        data = None
+        headers = {}
+
+        try:
+            server = self.spec.get_server(request.full_url_pattern)
+        # don't process if server errors
+        except OpenAPIMappingError as exc:
+            errors.append(exc)
+            return ResponseValidationResult(errors, data, headers)
+
+        operation_pattern = request.full_url_pattern.replace(
+            server.default_url, '')
+
+        try:
+            operation = self.spec.get_operation(
+                operation_pattern, request.method)
+        # don't process if operation errors
+        except OpenAPIMappingError as exc:
+            errors.append(exc)
+            return ResponseValidationResult(errors, data, headers)
+
+        try:
+            operation_response = operation.get_response(str(response.status))
+        # don't process if invalid response status code
+        except InvalidResponse as exc:
+            errors.append(exc)
+            return ResponseValidationResult(errors, data, headers)
+
+        if operation_response.content:
+            try:
+                media_type = operation_response[response.mimetype]
+            except OpenAPIMappingError as exc:
+                errors.append(exc)
+            else:
+                try:
+                    raw_data = self._get_raw_data(response)
+                except MissingBody as exc:
+                    errors.append(exc)
+                else:
+                    try:
+                        data = media_type.unmarshal(raw_data)
+                    except OpenAPIMappingError as exc:
+                        errors.append(exc)
+
+        return ResponseValidationResult(errors, data, headers)
+
+    def _get_raw_data(self, response):
+        if not response.data:
+            raise MissingBody("Missing required response data")
+
+        return response.data

openapi_core/wrappers.py

@@ -104,3 +104,38 @@ def body(self):
     @property
     def mimetype(self):
         return self.request.mimetype
+
+
+class BaseOpenAPIResponse(object):
+
+    body = NotImplemented
+    status = NotImplemented
+
+    mimetype = NotImplemented
+
+
+class MockResponse(BaseOpenAPIRequest):
+
+    def __init__(self, data, status=200, mimetype='application/json'):
+        self.data = data
+
+        self.status = status
+        self.mimetype = mimetype
+
+
+class FlaskOpenAPIResponse(BaseOpenAPIResponse):
+
+    def __init__(self, response):
+        self.response = response
+
+    @property
+    def data(self):
+        return self.response.data
+
+    @property
+    def status(self):
+        return self.response.status
+
+    @property
+    def mimetype(self):
+        return self.response.mimetype

tests/integration/data/v3.0/petstore.yaml

@@ -61,12 +61,6 @@ paths:
             application/json:    
               schema:
                 $ref: "#/components/schemas/Pets"
-        default:
-          description: unexpected error
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/Error"
     post:
       summary: Create a pet
       operationId: createPets
@@ -164,9 +158,12 @@ components:
         position:
           $ref: "#/components/schemas/Position"
     Pets:
-      type: array
-      items:
-        $ref: "#/components/schemas/Pet"
+      type: object
+      properties:
+        data:
+          type: array
+          items:
+            $ref: "#/components/schemas/Pet"
     Error:
       type: object
       required: