Validation result datatypes

openapi_core/validation/models.py → openapi_core/validation/datatypes.py

@@ -1,10 +1,10 @@
-"""OpenAPI core validation models module"""
+"""OpenAPI core validation datatypes module"""
+import attr
 
 
+@attr.s
 class BaseValidationResult(object):
-
-    def __init__(self, errors):
-        self.errors = errors
+    errors = attr.ib(factory=list)
 
     def raise_for_errors(self):
         for error in self.errors:

openapi_core/validation/request/datatypes.py

@@ -0,0 +1,21 @@
+"""OpenAPI core validation request datatypes module"""
+import attr
+
+from openapi_core.validation.datatypes import BaseValidationResult
+
+
+@attr.s
+class RequestParameters(object):
+    path = attr.ib(factory=dict)
+    query = attr.ib(factory=dict)
+    header = attr.ib(factory=dict)
+    cookie = attr.ib(factory=dict)
+
+    def __getitem__(self, location):
+        return getattr(self, location)
+
+
+@attr.s
+class RequestValidationResult(BaseValidationResult):
+    body = attr.ib(default=None)
+    parameters = attr.ib(factory=RequestParameters)

openapi_core/validation/request/validators.py

@@ -4,7 +4,7 @@
 
 from openapi_core.schema.exceptions import OpenAPIMappingError
 from openapi_core.schema.parameters.exceptions import MissingParameter
-from openapi_core.validation.request.models import (
+from openapi_core.validation.request.datatypes import (
     RequestParameters, RequestValidationResult,
 )
 from openapi_core.validation.util import get_operation_pattern

openapi_core/validation/response/datatypes.py

@@ -0,0 +1,10 @@
+"""OpenAPI core validation response datatypes module"""
+import attr
+
+from openapi_core.validation.datatypes import BaseValidationResult
+
+
+@attr.s
+class ResponseValidationResult(BaseValidationResult):
+    data = attr.ib(default=None)
+    headers = attr.ib(factory=dict)

openapi_core/validation/response/validators.py

@@ -1,6 +1,6 @@
 """OpenAPI core validation response validators module"""
 from openapi_core.schema.exceptions import OpenAPIMappingError
-from openapi_core.validation.response.models import ResponseValidationResult
+from openapi_core.validation.response.datatypes import ResponseValidationResult
 from openapi_core.validation.util import get_operation_pattern
 
 

tests/integration/schema/test_spec.py

@@ -0,0 +1,191 @@
+import pytest
+from base64 import b64encode
+from six import iteritems, text_type
+
+from openapi_core.schema.media_types.models import MediaType
+from openapi_core.schema.operations.models import Operation
+from openapi_core.schema.parameters.models import Parameter
+from openapi_core.schema.paths.models import Path
+from openapi_core.schema.request_bodies.models import RequestBody
+from openapi_core.schema.responses.models import Response
+from openapi_core.schema.schemas.models import Schema
+from openapi_core.schema.servers.models import Server, ServerVariable
+from openapi_core.shortcuts import create_spec
+from openapi_core.validation.request.validators import RequestValidator
+from openapi_core.validation.response.validators import ResponseValidator
+
+
+class TestPetstore(object):
+
+    api_key = '12345'
+
+    @property
+    def api_key_encoded(self):
+        api_key_bytes = self.api_key.encode('utf8')
+        api_key_bytes_enc = b64encode(api_key_bytes)
+        return text_type(api_key_bytes_enc, 'utf8')
+
+    @pytest.fixture
+    def spec_uri(self):
+        return "file://tests/integration/data/v3.0/petstore.yaml"
+
+    @pytest.fixture
+    def spec_dict(self, factory):
+        return factory.spec_from_file("data/v3.0/petstore.yaml")
+
+    @pytest.fixture
+    def spec(self, spec_dict, spec_uri):
+        return create_spec(spec_dict, spec_uri)
+
+    @pytest.fixture
+    def request_validator(self, spec):
+        return RequestValidator(spec)
+
+    @pytest.fixture
+    def response_validator(self, spec):
+        return ResponseValidator(spec)
+
+    def test_spec(self, spec, spec_dict):
+        url = 'http://petstore.swagger.io/v1'
+        assert spec.info.title == spec_dict['info']['title']
+        assert spec.info.version == spec_dict['info']['version']
+
+        assert spec.get_server_url() == url
+
+        for idx, server in enumerate(spec.servers):
+            assert type(server) == Server
+
+            server_spec = spec_dict['servers'][idx]
+            assert server.url == server_spec['url']
+            assert server.default_url == url
+
+            for variable_name, variable in iteritems(server.variables):
+                assert type(variable) == ServerVariable
+                assert variable.name == variable_name
+
+                variable_spec = server_spec['variables'][variable_name]
+                assert variable.default == variable_spec['default']
+                assert variable.enum == variable_spec.get('enum')
+
+        for path_name, path in iteritems(spec.paths):
+            assert type(path) == Path
+            assert path.name == path_name
+
+            for http_method, operation in iteritems(path.operations):
+                operation_spec = spec_dict['paths'][path_name][http_method]
+
+                assert type(operation) == Operation
+                assert operation.path_name == path_name
+                assert operation.http_method == http_method
+                assert operation.operation_id is not None
+                assert operation.tags == operation_spec['tags']
+
+                responses_spec = operation_spec.get('responses')
+
+                for http_status, response in iteritems(operation.responses):
+                    assert type(response) == Response
+                    assert response.http_status == http_status
+
+                    response_spec = responses_spec[http_status]
+
+                    if not response_spec:
+                        continue
+
+                    # @todo: test with defererence
+                    if '$ref' in response_spec:
+                        continue
+
+                    description_spec = response_spec['description']
+
+                    assert response.description == description_spec
+
+                    for mimetype, media_type in iteritems(response.content):
+                        assert type(media_type) == MediaType
+                        assert media_type.mimetype == mimetype
+
+                        content_spec = response_spec['content'][mimetype]
+
+                        example_spec = content_spec.get('example')
+                        assert media_type.example == example_spec
+
+                        schema_spec = content_spec.get('schema')
+                        assert bool(schema_spec) == bool(media_type.schema)
+
+                        if not schema_spec:
+                            continue
+
+                        # @todo: test with defererence
+                        if '$ref' in schema_spec:
+                            continue
+
+                        assert type(media_type.schema) == Schema
+                        assert media_type.schema.type.value ==\
+                            schema_spec['type']
+                        assert media_type.schema.required == schema_spec.get(
+                            'required', [])
+
+                    for parameter_name, parameter in iteritems(
+                            response.headers):
+                        assert type(parameter) == Parameter
+                        assert parameter.name == parameter_name
+
+                        headers_spec = response_spec['headers']
+                        parameter_spec = headers_spec[parameter_name]
+                        schema_spec = parameter_spec.get('schema')
+                        assert bool(schema_spec) == bool(parameter.schema)
+
+                        if not schema_spec:
+                            continue
+
+                        # @todo: test with defererence
+                        if '$ref' in schema_spec:
+                            continue
+
+                        assert type(parameter.schema) == Schema
+                        assert parameter.schema.type.value ==\
+                            schema_spec['type']
+                        assert parameter.schema.format ==\
+                            schema_spec.get('format')
+                        assert parameter.schema.required == schema_spec.get(
+                            'required', [])
+
+                request_body_spec = operation_spec.get('requestBody')
+
+                assert bool(request_body_spec) == bool(operation.request_body)
+
+                if not request_body_spec:
+                    continue
+
+                assert type(operation.request_body) == RequestBody
+                assert bool(operation.request_body.required) ==\
+                    request_body_spec.get('required', False)
+
+                for mimetype, media_type in iteritems(
+                        operation.request_body.content):
+                    assert type(media_type) == MediaType
+                    assert media_type.mimetype == mimetype
+
+                    content_spec = request_body_spec['content'][mimetype]
+                    schema_spec = content_spec.get('schema')
+                    assert bool(schema_spec) == bool(media_type.schema)
+
+                    if not schema_spec:
+                        continue
+
+                    # @todo: test with defererence
+                    if '$ref' in schema_spec:
+                        continue
+
+                    assert type(media_type.schema) == Schema
+                    assert media_type.schema.type.value ==\
+                        schema_spec['type']
+                    assert media_type.schema.format ==\
+                        schema_spec.get('format')
+                    assert media_type.schema.required == schema_spec.get(
+                        'required', False)
+
+        if not spec.components:
+            return
+
+        for _, schema in iteritems(spec.components.schemas):
+            assert type(schema) == Schema

tests/integration/test_minimal.py → tests/integration/validation/test_minimal.py

@@ -47,7 +47,7 @@ def test_invalid_operation(self, factory, server, spec_path):
         assert len(result.errors) == 1
         assert isinstance(result.errors[0], InvalidOperation)
         assert result.body is None
-        assert result.parameters == {}
+        assert result.parameters is None
 
     @pytest.mark.parametrize("server", servers)
     @pytest.mark.parametrize("spec_path", spec_paths)
@@ -62,4 +62,4 @@ def test_invalid_path(self, factory, server, spec_path):
         assert len(result.errors) == 1
         assert isinstance(result.errors[0], InvalidPath)
         assert result.body is None
-        assert result.parameters == {}
+        assert result.parameters is None