Add Flask response wrapper

Author: smizell

hypermedia_resource/wrappers.py

@@ -1,6 +1,11 @@
 from negotiator import ContentNegotiator, AcceptParameters, ContentType
 from .resource import HypermediaResource
 
+try:
+    from flask import Response
+except:
+    pass
+
 class HypermediaResponse(object):
 
     def __init__(self, media_type, resource):
@@ -20,3 +25,51 @@ def build(self, resource, accept):
         if negotiate:
             return HypermediaResponse(str(negotiate.content_type), resource)
         return HypermediaResponse(self.default_type, resource)
+
+class APIResource(object):
+
+    def default_type(self):
+        return "application/hal+json"
+
+    def available_actions(self):
+        return [action for action in self.actions().values()
+            if hasattr(self, action)]
+
+    def available_methods(self):
+        return [method for method, action in self.actions().items()
+            if action in self.available_actions()]
+
+    def method_override(self):
+        return "_method"
+
+    def actions(self):
+        """Defaults Actions"""
+        return {
+            'GET': 'read',
+            'POST': 'process',
+            'PATCH': 'partial',
+            'PUT': 'save',
+            'DELETE': 'remove'
+        }
+
+    def build_response(self, resource, accepts):
+        response_builder = ResponseBuilder(self.default_type())
+        return response_builder.build(resource, accepts)
+
+class FlaskAPIResource(APIResource):
+
+    def get_method(self, request):
+        if request.method != "POST":
+            return request.method
+        method_override = self.method_override()
+        if request.form.has_key(method_override) and request.method == "POST":
+            return request.form[method_override]
+        return request.method
+
+    def response_for(self, request):
+        method = self.get_method(request)
+        action_name = self.actions()[method]
+        action = getattr(self, action_name)
+        resource = action(request)
+        response = self.build_response(resource, request.headers.get('Accept'))
+        return Response(response.body, mimetype=response.media_type)

tests/wrappers_test.py

@@ -1,7 +1,8 @@
 import unittest
-from mock import Mock
+from mock import Mock, patch
 from hypermedia_resource import HypermediaResource
 from hypermedia_resource.wrappers import HypermediaResponse, ResponseBuilder
+from hypermedia_resource.wrappers import APIResource, FlaskAPIResource
 
 def adapter():
     adapter = Mock()
@@ -10,6 +11,15 @@ def adapter():
     adapter.build.return_value = "built"
     return adapter
 
+def request(method='GET', data={}):
+    request = Mock()
+    request.method = method
+    request.data = data
+    request.headers = Mock()
+    request.headers.get = Mock()
+    request.headers.get.return_value = "application/hal+json"
+    return request
+
 class TestHypermediaResponse(unittest.TestCase):
 
     def test(self):
@@ -29,3 +39,64 @@ def test(self):
         response = response_builder.build(resource, accept)
         self.assertEqual(response.media_type, "application/hal+json")
         self.assertEqual(response.body, "built")
+
+class TestAPIResource(unittest.TestCase):
+
+    def setUp(self):
+        HypermediaResource.adapters.add(adapter())
+        self.resource = APIResource()
+
+    def test_available_actions(self):
+        self.resource.read = Mock()
+        actions = self.resource.available_actions()
+        self.assertTrue('read' in actions)
+        self.assertFalse('missing' in actions)
+
+    def test_available_methods(self):
+        self.resource.read = Mock()
+        methods = self.resource.available_methods()
+        self.assertTrue('GET' in methods)
+        self.assertFalse('POST' in methods)
+
+    def test_response(self):
+        resource = HypermediaResource()
+        self.resource.read = Mock()
+        self.resource.read.return_value = resource
+        accepts = "application/hal+json"
+        response = self.resource.build_response(resource, accepts)
+        self.assertEqual(response.body, "built")
+
+class TestFlaskAPIResource(unittest.TestCase):
+
+    def setUp(self):
+        self.resource = FlaskAPIResource()
+
+    def test_get_method(self):
+        method = self.resource.get_method(request("GET"))
+        self.assertEqual(method, "GET")
+
+    def test_get_method_override(self):
+        method = self.resource.get_method(request("POST", { "_method": "PUT"}))
+        self.assertEqual(method, "PUT")
+
+    @patch('hypermedia_resource.wrappers.Response')
+    def test_response_for(self, mock_method):
+        resource = HypermediaResource()
+
+        # Response
+        response = Mock()
+        response.body = "body"
+        response.media_type = "media_type"
+
+        # Read action
+        self.resource.read = Mock()
+        self.resource.read.return_value = resource
+
+        # Mock build response
+        self.resource.build_response = Mock()
+        self.resource.build_response.return_value = response
+
+        self.resource.response_for(request())
+        self.resource.build_response.assert_called_with(resource, "application/hal+json")
+        mock_method.assert_called_with(response.body, mimetype=response.media_type)
+