add-adapter-and-tests (#8)

Author: keenangraham

.coveragerc

@@ -0,0 +1,3 @@
+[run]
+omit = 
+    */test*

setup.cfg

@@ -30,6 +30,7 @@ test =
     pytest-mock==2.0.0
     pytest-cov==2.8.1
     pyramid==1.10.4
+    Flask==1.1.2
 
 [options.packages.find]
 where = src

src/snosearch/adapters/exceptions.py

@@ -1,5 +1,49 @@
-from pyramid.httpexceptions import HTTPBadRequest
+def flask_exception_adapter(error):
+    def wrapper(explanation):
+        return error(explanation)
+    return wrapper
 
 
-def get_default_exception():
-    return HTTPBadRequest
+class BadRequestFactory():
+
+    def __init__(self, name=None):
+        self.name = name
+
+    def _get_exception_from_pyramid(self):
+        from pyramid.httpexceptions import HTTPBadRequest
+        return HTTPBadRequest
+
+    def _maybe_get_exception_from_pyramid(self):
+        try:
+            return self._get_exception_from_pyramid()
+        except ModuleNotFoundError:
+            return None
+
+    def _get_exception_from_flask(self):
+        from werkzeug.exceptions import BadRequest
+        return flask_exception_adapter(BadRequest)
+
+    def _maybe_get_exception_from_flask(self):
+        try:
+            return self._get_exception_from_flask()
+        except ModuleNotFoundError:
+            return None
+
+    def _get_exception_by_name(self):
+        if not self.name:
+            return None
+        if self.name == 'flask':
+            return self._get_exception_from_flask()
+        return self._get_exception_from_pyramid()
+
+    def _get_bad_request(self):
+        return (
+            self._get_exception_by_name()
+            or self._maybe_get_exception_from_pyramid()
+            or self._maybe_get_exception_from_flask()
+        )
+
+
+def get_default_exception(name=None):
+    br = BadRequestFactory(name)
+    return br._get_bad_request()

src/snosearch/adapters/flask/__init__.py

@@ -0,0 +1,68 @@
+class ArgsAdapter:
+
+    def __init__(self, args):
+        self.args = args
+
+    def __iter__(self):
+        return self.args.__iter__()
+
+    def items(self):
+        return self.args.items(multi=True)
+
+    def getall(self, key):
+        return self.args.getlist(key)
+
+
+class RequestAdapter:
+
+    __parent__ = None
+
+    def __init__(self, request):
+        self._request = request
+
+    @property
+    def params(self):
+        return ArgsAdapter(
+            self._request.args
+        )
+
+    def copy(self, environ=None):
+        return RequestAdapter(
+            self._request.__class__(
+                environ or self._request.environ.copy()
+            )
+        )
+
+    @property
+    def effective_principals(self):
+        return ['system.Everyone']
+
+    def has_permission(self, action):
+        return True
+
+    def route_path(self, context):
+        raise NotImplementedError
+
+    @property
+    def path_qs(self):
+        return self._request.full_path
+
+    @property
+    def path(self):
+        return self._request.path
+
+    @property
+    def query_string(self):
+        return self._request.query_string.decode('utf-8')
+
+    @query_string.setter
+    def query_string(self, query_string):
+        environ = self._request.environ.copy()
+        environ.update(
+            {
+                'QUERY_STRING': query_string,
+            }
+        )
+        self._request = self.copy(
+            environ=environ
+        )._request

src/snosearch/adapters/flask/requests.py

@@ -0,0 +1,20 @@
+from flask import Response
+
+
+class ResponseAdapter(Response):
+
+    @property
+    def status_code(self):
+        return super().status_code
+
+    @status_code.setter
+    def status_code(self, code):
+        self.status = code
+
+    @property
+    def app_iter(self):
+        return None
+
+    @app_iter.setter
+    def app_iter(self, generator):
+        self.response = generator

src/snosearch/adapters/flask/responses.py

@@ -1,5 +1,43 @@
-from pyramid.response import Response
+class ResponseFactory():
+    def __init__(self, name=None):
+        self.name = name
+
+    def _get_response_from_pyramid(self):
+        from pyramid.response import Response
+        return Response()
+
+    def _get_response_from_flask(self):
+        from flask import Response
+        from snosearch.adapters.flask.responses import ResponseAdapter
+        return ResponseAdapter()
+
+    def _maybe_get_response_from_pyramid(self):
+        try:
+            return self._get_response_from_pyramid()
+        except ModuleNotFoundError:
+            return None
+
+    def _maybe_get_response_from_flask(self):
+        try:
+            return self._get_response_from_flask()
+        except ModuleNotFoundError:
+            return None
+
+    def _get_response_by_name(self):
+        if not self.name:
+            return None
+        if self.name == 'flask':
+            return self._get_response_from_flask()
+        return self._get_response_from_pyramid()
+
+    def _get_response(self):
+        return (
+            self._get_response_by_name()
+            or self._maybe_get_response_from_pyramid()
+            or self._maybe_get_response_from_flask()
+        )
 
 
 def get_response():
-    return Response()
+    rf = ResponseFactory()
+    return rf._get_response()

src/snosearch/adapters/requests.py

@@ -24,13 +24,37 @@ def dummy_registry(testing_types, testing_configs):
 
 
 @pytest.fixture
-def dummy_request(dummy_registry):
-    from snosearch.adapters.requests import DummyRequest
-    dummy_request = DummyRequest({}).blank('/dummy')
+def pyramid_dummy_request(dummy_registry):
+    from snosearch.tests.dummy_requests import PyramidDummyRequest
+    dummy_request = PyramidDummyRequest({}).blank('/dummy')
     dummy_request.registry = dummy_registry
     return dummy_request
 
 
+@pytest.fixture
+def flask_dummy_request(dummy_registry):
+    from snosearch.tests.dummy_requests import FlaskDummyRequestAdapter
+    from flask import Request
+    from flask import Response
+    dummy_request = FlaskDummyRequestAdapter(
+        Request(
+            {
+                'PATH_INFO': '/dummy'
+            }
+        )
+    )
+    dummy_request.registry = dummy_registry
+    dummy_request.response = Response()
+    return dummy_request
+
+
+@pytest.fixture
+def dummy_request(request, pyramid_dummy_request, flask_dummy_request):
+    if hasattr(request, 'param') and request.param == 'flask':
+        return flask_dummy_request
+    return pyramid_dummy_request
+
+
 @pytest.fixture
 def testing_search_schema_type():
     return {

src/snosearch/adapters/responses.py

@@ -0,0 +1,67 @@
+from pyramid.request import Request
+from snosearch.adapters.flask.requests import RequestAdapter
+from snosearch.interfaces import JSONLD_CONTEXT
+from werkzeug.datastructures import ImmutableOrderedMultiDict
+
+
+class FlaskDummyRequestAdapter(RequestAdapter):
+
+    def __setitem__(self, key, value):
+        self._request.__class__.parameter_storage_class = ImmutableOrderedMultiDict
+        environ = self._request.environ.copy()
+        environ.update({key: value})
+        self._request = self._request.__class__(environ)
+
+    def __getitem__(self, key):
+        return self._request.environ[key]
+
+    @property
+    def environ(self):
+        return self
+
+    @property
+    def effective_principals(self):
+        if self._request.environ.get('REMOTE_USER') == 'TEST_SUBMITTER':
+            return ['group.submitter']
+        return super().effective_principals
+
+    def has_permission(self, action):
+        principals = self.effective_principals
+        acls = getattr(
+            self.context,
+            '__acl__',
+            lambda: []
+        )
+        for principal in principals:
+            for acl in acls():
+                if acl[1] == principal and acl[2] == action:
+                    return acl[0]
+                return False
+
+
+class PyramidDummyRequest(Request):
+
+        __parent__ = None
+    
+        @property
+        def effective_principals(self):
+            if self.environ.get('REMOTE_USER') == 'TEST_SUBMITTER':
+                return ['group.submitter']
+            return super().effective_principals
+
+        def has_permission(self, action):
+            principals = self.effective_principals
+            acls = getattr(
+                self.context,
+                '__acl__',
+                lambda: []
+            )
+            for principal in principals:
+                for acl in acls():
+                    if acl[1] == principal and acl[2] == action:
+                        return acl[0]
+            return False
+
+        def route_path(self, context):
+            if context == JSONLD_CONTEXT:
+                    return '/terms/'