Path patterns finder

openapi_core/contrib/flask/handlers.py

@@ -3,13 +3,17 @@
 from flask.json import dumps
 
 from openapi_core.schema.media_types.exceptions import InvalidContentType
-from openapi_core.schema.servers.exceptions import InvalidServer
+from openapi_core.templating.paths.exceptions import (
+    ServerNotFound, OperationNotFound, PathNotFound,
+)
 
 
 class FlaskOpenAPIErrorsHandler(object):
 
     OPENAPI_ERROR_STATUS = {
-        InvalidServer: 500,
+        ServerNotFound: 400,
+        OperationNotFound: 405,
+        PathNotFound: 404,
         InvalidContentType: 415,
     }
 

openapi_core/schema/servers/models.py

@@ -1,5 +1,6 @@
 """OpenAPI core servers models module"""
 from six import iteritems
+from six.moves.urllib.parse import urljoin
 
 
 class Server(object):
@@ -25,6 +26,15 @@ def get_url(self, **variables):
             variables = self.default_variables
         return self.url.format(**variables)
 
+    @staticmethod
+    def is_absolute(url):
+        return url.startswith('//') or '://' in url
+
+    def get_absolute_url(self, base_url=None):
+        if base_url is not None and not self.is_absolute(self.url):
+            return urljoin(base_url, self.url)
+        return self.url
+
 
 class ServerVariable(object):
 

openapi_core/templating/datatypes.py

@@ -0,0 +1,13 @@
+import attr
+
+
+@attr.s
+class TemplateResult(object):
+    pattern = attr.ib(default=None)
+    variables = attr.ib(default=None)
+
+    @property
+    def resolved(self):
+        if not self.variables:
+            return self.pattern
+        return self.pattern.format(**self.variables)

openapi_core/templating/paths/exceptions.py

@@ -0,0 +1,36 @@
+import attr
+
+from openapi_core.exceptions import OpenAPIError
+
+
+class PathError(OpenAPIError):
+    """Path error"""
+
+
+@attr.s(hash=True)
+class PathNotFound(PathError):
+    """Find path error"""
+    url = attr.ib()
+
+    def __str__(self):
+        return "Path not found for {0}".format(self.url)
+
+
+@attr.s(hash=True)
+class OperationNotFound(PathError):
+    """Find path operation error"""
+    url = attr.ib()
+    method = attr.ib()
+
+    def __str__(self):
+        return "Operation {0} not found for {1}".format(
+            self.method, self.url)
+
+
+@attr.s(hash=True)
+class ServerNotFound(PathError):
+    """Find server error"""
+    url = attr.ib()
+
+    def __str__(self):
+        return "Server not found for {0}".format(self.url)

openapi_core/templating/paths/finders.py

@@ -0,0 +1,85 @@
+"""OpenAPI core templating paths finders module"""
+from more_itertools import peekable
+from six import iteritems
+
+from openapi_core.templating.datatypes import TemplateResult
+from openapi_core.templating.util import parse, search
+from openapi_core.templating.paths.exceptions import (
+    PathNotFound, OperationNotFound, ServerNotFound,
+)
+
+
+class PathFinder(object):
+
+    def __init__(self, spec, base_url=None):
+        self.spec = spec
+        self.base_url = base_url
+
+    def find(self, request):
+        paths_iter = self._get_paths_iter(request.full_url_pattern)
+        paths_iter_peek = peekable(paths_iter)
+
+        if not paths_iter_peek:
+            raise PathNotFound(request.full_url_pattern)
+
+        operations_iter = self._get_operations_iter(
+            request.method, paths_iter_peek)
+        operations_iter_peek = peekable(operations_iter)
+
+        if not operations_iter_peek:
+            raise OperationNotFound(request.full_url_pattern, request.method)
+
+        servers_iter = self._get_servers_iter(
+            request.full_url_pattern, operations_iter_peek)
+
+        try:
+            return next(servers_iter)
+        except StopIteration:
+            raise ServerNotFound(request.full_url_pattern)
+
+    def _get_paths_iter(self, full_url_pattern):
+        for path_pattern, path in iteritems(self.spec.paths):
+            # simple path
+            if full_url_pattern.endswith(path_pattern):
+                path_result = TemplateResult(path_pattern, {})
+                yield (path, path_result)
+            # template path
+            else:
+                result = search(path_pattern, full_url_pattern)
+                if result:
+                    path_result = TemplateResult(path_pattern, result.named)
+                    yield (path, path_result)
+
+    def _get_operations_iter(self, request_method, paths_iter):
+        for path, path_result in paths_iter:
+            if request_method not in path.operations:
+                continue
+            operation = path.operations[request_method]
+            yield (path, operation, path_result)
+
+    def _get_servers_iter(self, full_url_pattern, ooperations_iter):
+        for path, operation, path_result in ooperations_iter:
+            servers = path.servers or operation.servers or self.spec.servers
+            for server in servers:
+                server_url_pattern = full_url_pattern.rsplit(
+                    path_result.resolved, 1)[0]
+                server_url = server.get_absolute_url(self.base_url)
+                if server_url.endswith('/'):
+                    server_url = server_url[:-1]
+                # simple path
+                if server_url_pattern.startswith(server_url):
+                    server_result = TemplateResult(server.url, {})
+                    yield (
+                        path, operation, server,
+                        path_result, server_result,
+                    )
+                # template path
+                else:
+                    result = parse(server.url, server_url_pattern)
+                    if result:
+                        server_result = TemplateResult(
+                            server.url, result.named)
+                        yield (
+                            path, operation, server,
+                            path_result, server_result,
+                        )

openapi_core/templating/util.py

@@ -0,0 +1,13 @@
+from parse import Parser
+
+
+def search(path_pattern, full_url_pattern):
+    p = Parser(path_pattern)
+    p._expression = p._expression + '$'
+    return p.search(full_url_pattern)
+
+
+def parse(server_url, server_url_pattern):
+    p = Parser(server_url)
+    p._expression = '^' + p._expression
+    return p.parse(server_url_pattern)

openapi_core/validation/request/validators.py

@@ -5,14 +5,12 @@
 from openapi_core.casting.schemas.exceptions import CastError
 from openapi_core.deserializing.exceptions import DeserializeError
 from openapi_core.schema.media_types.exceptions import InvalidContentType
-from openapi_core.schema.operations.exceptions import InvalidOperation
 from openapi_core.schema.parameters.exceptions import (
     MissingRequiredParameter, MissingParameter,
 )
-from openapi_core.schema.paths.exceptions import InvalidPath
 from openapi_core.schema.request_bodies.exceptions import MissingRequestBody
-from openapi_core.schema.servers.exceptions import InvalidServer
 from openapi_core.security.exceptions import SecurityError
+from openapi_core.templating.paths.exceptions import PathError
 from openapi_core.unmarshalling.schemas.enums import UnmarshalContext
 from openapi_core.unmarshalling.schemas.exceptions import (
     UnmarshalError, ValidateError,
@@ -21,25 +19,16 @@
 from openapi_core.validation.request.datatypes import (
     RequestParameters, RequestValidationResult,
 )
-from openapi_core.validation.util import get_operation_pattern
+from openapi_core.validation.validators import BaseValidator
 
 
-class RequestValidator(object):
-
-    def __init__(
-            self, spec,
-            custom_formatters=None, custom_media_type_deserializers=None,
-    ):
-        self.spec = spec
-        self.custom_formatters = custom_formatters
-        self.custom_media_type_deserializers = custom_media_type_deserializers
+class RequestValidator(BaseValidator):
 
     def validate(self, request):
         try:
-            path = self._get_path(request)
-            operation = self._get_operation(request)
+            path, operation, _, _, _ = self._find_path(request)
         # don't process if operation errors
-        except (InvalidServer, InvalidPath, InvalidOperation) as exc:
+        except PathError as exc:
             return RequestValidationResult([exc, ], None, None, None)
 
         try:
@@ -61,9 +50,8 @@ def validate(self, request):
 
     def _validate_parameters(self, request):
         try:
-            path = self._get_path(request)
-            operation = self._get_operation(request)
-        except (InvalidServer, InvalidPath, InvalidOperation) as exc:
+            path, operation, _, _, _ = self._find_path(request)
+        except PathError as exc:
             return RequestValidationResult([exc, ], None, None)
 
         params, params_errors = self._get_parameters(
@@ -76,30 +64,13 @@ def _validate_parameters(self, request):
 
     def _validate_body(self, request):
         try:
-            operation = self._get_operation(request)
-        except (InvalidServer, InvalidOperation) as exc:
+            _, operation, _, _, _ = self._find_path(request)
+        except PathError as exc:
             return RequestValidationResult([exc, ], None, None)
 
         body, body_errors = self._get_body(request, operation)
         return RequestValidationResult(body_errors, body, None, None)
 
-    def _get_operation_pattern(self, request):
-        server = self.spec.get_server(request.full_url_pattern)
-
-        return get_operation_pattern(
-            server.default_url, request.full_url_pattern
-        )
-
-    def _get_path(self, request):
-        operation_pattern = self._get_operation_pattern(request)
-
-        return self.spec[operation_pattern]
-
-    def _get_operation(self, request):
-        operation_pattern = self._get_operation_pattern(request)
-
-        return self.spec.get_operation(operation_pattern, request.method)
-
     def _get_security(self, request, operation):
         security = operation.security or self.spec.security
         if not security:
@@ -222,15 +193,6 @@ def _get_body_value(self, request_body, request):
             raise MissingRequestBody(request)
         return request.body
 
-    def _deserialise_media_type(self, media_type, value):
-        from openapi_core.deserializing.media_types.factories import (
-            MediaTypeDeserializersFactory,
-        )
-        deserializers_factory = MediaTypeDeserializersFactory(
-            self.custom_media_type_deserializers)
-        deserializer = deserializers_factory.create(media_type)
-        return deserializer(value)
-
     def _deserialise_parameter(self, param, value):
         from openapi_core.deserializing.parameters.factories import (
             ParameterDeserializersFactory,
@@ -239,27 +201,7 @@ def _deserialise_parameter(self, param, value):
         deserializer = deserializers_factory.create(param)
         return deserializer(value)
 
-    def _cast(self, param_or_media_type, value):
-        # return param_or_media_type.cast(value)
-        if not param_or_media_type.schema:
-            return value
-
-        from openapi_core.casting.schemas.factories import SchemaCastersFactory
-        casters_factory = SchemaCastersFactory()
-        caster = casters_factory.create(param_or_media_type.schema)
-        return caster(value)
-
     def _unmarshal(self, param_or_media_type, value):
-        if not param_or_media_type.schema:
-            return value
-
-        from openapi_core.unmarshalling.schemas.factories import (
-            SchemaUnmarshallersFactory,
-        )
-        unmarshallers_factory = SchemaUnmarshallersFactory(
-            self.spec._resolver, self.custom_formatters,
-            context=UnmarshalContext.REQUEST,
+        return super(RequestValidator, self)._unmarshal(
+            param_or_media_type, value, context=UnmarshalContext.REQUEST,
         )
-        unmarshaller = unmarshallers_factory.create(
-            param_or_media_type.schema)
-        return unmarshaller(value)