Path pattern finder

Author: p1c2u

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

@@ -1,27 +1,85 @@
 """OpenAPI core templating paths finders module"""
-from openapi_core.templating.paths.util import get_operation_pattern
+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):
+    def __init__(self, spec, base_url=None):
         self.spec = spec
+        self.base_url = base_url
 
     def find(self, request):
-        operation_pattern = self._get_operation_pattern(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)
 
-        path = self.spec[operation_pattern]
-        path_variables = {}
-        operation = self.spec.get_operation(operation_pattern, request.method)
-        servers = path.servers or operation.servers or self.spec.servers
-        server = servers[0]
-        server_variables = {}
+        try:
+            return next(servers_iter)
+        except StopIteration:
+            raise ServerNotFound(request.full_url_pattern)
 
-        return path, operation, server, path_variables, server_variables
+    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_operation_pattern(self, request):
-        server = self.spec.get_server(request.full_url_pattern)
+    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)
 
-        return get_operation_pattern(
-            server.default_url, request.full_url_pattern
-        )
+    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/paths/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/templating/util.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,
@@ -30,7 +28,7 @@ def validate(self, request):
         try:
             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:
@@ -53,7 +51,7 @@ def validate(self, request):
     def _validate_parameters(self, request):
         try:
             path, operation, _, _, _ = self._find_path(request)
-        except (InvalidServer, InvalidPath, InvalidOperation) as exc:
+        except PathError as exc:
             return RequestValidationResult([exc, ], None, None)
 
         params, params_errors = self._get_parameters(
@@ -67,7 +65,7 @@ def _validate_parameters(self, request):
     def _validate_body(self, request):
         try:
             _, operation, _, _, _ = self._find_path(request)
-        except (InvalidServer, InvalidOperation) as exc:
+        except PathError as exc:
             return RequestValidationResult([exc, ], None, None)
 
         body, body_errors = self._get_body(request, operation)

openapi_core/validation/request/validators.py

@@ -1,13 +1,11 @@
 """OpenAPI core validation response validators module"""
 from openapi_core.casting.schemas.exceptions import CastError
 from openapi_core.deserializing.exceptions import DeserializeError
-from openapi_core.schema.operations.exceptions import InvalidOperation
 from openapi_core.schema.media_types.exceptions import InvalidContentType
-from openapi_core.schema.paths.exceptions import InvalidPath
 from openapi_core.schema.responses.exceptions import (
     InvalidResponse, MissingResponseContent,
 )
-from openapi_core.schema.servers.exceptions import InvalidServer
+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,
@@ -22,7 +20,7 @@ def validate(self, request, response):
         try:
             _, operation, _, _, _ = self._find_path(request)
         # don't process if operation errors
-        except (InvalidServer, InvalidPath, InvalidOperation) as exc:
+        except PathError as exc:
             return ResponseValidationResult([exc, ], None, None)
 
         try:
@@ -47,7 +45,7 @@ def _validate_data(self, request, response):
         try:
             _, operation, _, _, _ = self._find_path(request)
         # don't process if operation errors
-        except (InvalidServer, InvalidPath, InvalidOperation) as exc:
+        except PathError as exc:
             return ResponseValidationResult([exc, ], None, None)
 
         try:

openapi_core/validation/response/validators.py

@@ -5,15 +5,17 @@ class BaseValidator(object):
 
     def __init__(
             self, spec,
+            base_url=None,
             custom_formatters=None, custom_media_type_deserializers=None,
     ):
         self.spec = spec
+        self.base_url = base_url
         self.custom_formatters = custom_formatters
         self.custom_media_type_deserializers = custom_media_type_deserializers
 
     def _find_path(self, request):
         from openapi_core.templating.paths.finders import PathFinder
-        finder = PathFinder(self.spec)
+        finder = PathFinder(self.spec, base_url=self.base_url)
         return finder.find(request)
 
     def _deserialise_media_type(self, media_type, value):

openapi_core/validation/validators.py

@@ -4,3 +4,5 @@ lazy-object-proxy
 strict_rfc3339
 isodate
 attrs
+parse==1.14.0
+more-itertools>=5.0.0

requirements.txt

@@ -6,3 +6,4 @@ backports.functools-partialmethod
 enum34
 strict_rfc3339
 attrs
+more-itertools==5.0.0

requirements_2.7.txt

@@ -30,6 +30,8 @@ install_requires =
     isodate
     attrs
     werkzeug
+    parse
+    more-itertools
     backports.functools-lru-cache; python_version<"3.0"
     backports.functools-partialmethod; python_version<"3.0"
 tests_require =