Merge pull request #11 from alexcouper/alex/check-post

Alex/check post

Author: txels

abe/mocks.py

@@ -1,19 +1,23 @@
 import json
+import warnings
 
 from supermutes.dot import dotify
 
 
 class AbeMock(object):
 
-    def __init__(self, filename):
+    def __init__(self, data):
         """
         Initialise an ABE mock from data.
 
-        filename is expected to be the path to an ABE file.
-
         """
-        with open(filename, 'r') as f:
-            data = json.load(f)
+        if not isinstance(data, dict):
+            msg = ('Instanciating an AbeMock by filename is deprecated and '
+                   'will be removed in an upcoming release. '
+                   'Use AbeMock.from_filename instead'.format(data))
+            warnings.warn(msg, DeprecationWarning)
+            with open(data, 'r') as f:
+                data = json.load(f)
 
         # map JSON fields to attributes
         self.__dict__ = data
@@ -25,6 +29,18 @@ def __init__(self, filename):
             self._feed_inherited_fields(value, 'request', ['url', 'method'])
             self.examples[key] = dotify(value)
 
+    @classmethod
+    def from_filename(cls, filename):
+        """
+        Initialise an ABE mock from a spec file.
+
+        filename is expected to be the path to an ABE file.
+
+        """
+        with open(filename, 'r') as f:
+            data = json.load(f)
+        return AbeMock(data)
+
     def _feed_inherited_fields(self, value, where, inheritable):
         """
         If missing in request or response, some fields are inherited.

abe/unittest.py

@@ -21,8 +21,8 @@ def load_sample(self, sample_path):
         """
         Load a sample file into an AbeMock object.
         """
-        sample_file = os.path.join(self.samples_root, sample_path)
-        return AbeMock(sample_file)
+        sample_filename = os.path.join(self.samples_root, sample_path)
+        return AbeMock.from_filename(sample_filename)
 
     def get_sample_request(self, path, label):
         """
@@ -107,16 +107,39 @@ def assert_headers_contain(self, response_data, spec_data):
                 "header {0}".format(expected_header)
             )
 
-    def assert_matches_sample(self, path, label, url, response):
+    def assert_matches_request(self, sample_request, wsgi_request):
+        """
+        Check that the sample request and wsgi request match.
+        """
+        self.assertEqual(wsgi_request.META['PATH_INFO'], sample_request['url'])
+        self.assertEqual(wsgi_request.META['REQUEST_METHOD'],
+                         sample_request['method'])
+
+        if 'headers' in sample_request:
+            self.assert_headers_contain(
+                wsgi_request.META, sample_request['headers']
+            )
+
+        if 'body' in sample_request:
+            self.assert_data_equal(wsgi_request.POST, sample_request['body'])
+
+    def assert_matches_response(self, sample_response, wsgi_response):
+        """
+        Check that the sample response and wsgi response match.
+        """
+        self.assertEqual(wsgi_response.status_code, sample_response.status)
+        if 'body' in sample_response:
+            response_parsed = wsgi_response.data
+            self.assert_data_equal(response_parsed, sample_response.body)
+
+    def assert_matches_sample(self, path, label, response):
         """
         Check a URL and response against a sample.
 
         :param sample_name:
             The name of the sample file, e.g. 'query.json'
         :param label:
             The label for a specific sample request/response, e.g. 'OK'
-        :param url:
-            The actual URL we want to compare with the sample
         :param response:
             The actual API response we want to match with the sample.
             It is assumed to be a Django Rest Framework response object
@@ -125,13 +148,5 @@ def assert_matches_sample(self, path, label, url, response):
         sample_request = sample.examples[label].request
         sample_response = sample.examples[label].response
 
-        self.assertEqual(url, sample_request.url)
-        if 'headers' in sample_request:
-            self.assert_headers_contain(
-                response.request, sample_request.headers
-            )
-
-        self.assertEqual(response.status_code, sample_response.status)
-        if 'body' in sample_response:
-            response_parsed = response.data
-            self.assert_data_equal(response_parsed, sample_response.body)
+        self.assert_matches_response(sample_response, response)
+        self.assert_matches_request(sample_request, response.wsgi_request)

tests/data/sample.json

@@ -0,0 +1,34 @@
+{
+    "description": "Retrieve profile of logged in user",
+    "url": "/accounts/me",
+    "method": "GET",
+    "examples": {
+        "OK": {
+            "request": {
+                "url": "/accounts/me"
+            },
+            "response": {
+                "status": 200,
+                "body": {
+                    "id": 1,
+                    "username": "user-0",
+                    "first_name": "",
+                    "last_name": "",
+                    "email": "[email protected]"
+                }
+            }
+        },
+        "unauthenticated": {
+            "description": "I am not logged in",
+            "request": {
+                "url": "/accounts/me"
+            },
+            "response": {
+                "status": 403,
+                "body": {
+                    "detail": "Authentication credentials were not provided."
+                }
+            }
+        }
+    }
+}

tests/test_assertions.py

@@ -1,7 +1,14 @@
+from os.path import abspath, dirname, join
 from unittest import TestCase
+import warnings
 
+from mock import Mock
+
+from abe.mocks import AbeMock
 from abe.unittest import AbeTestMixin
 
+DATA_DIR = join(dirname(abspath(__file__)), 'data')
+
 
 class TestDataListEqual(TestCase, AbeTestMixin):
 
@@ -71,3 +78,82 @@ def test_requires_key_and_value_match(self):
                 {'HTTP_THIS_CUSTOM': 'Foo'},
                 {'This-Custom-Header': 'Foo'},
             )
+
+
+class TestAssertMatchesRequest(TestCase, AbeTestMixin):
+
+    def setUp(self):
+        abe_mock = AbeMock({
+            "method": "POST",
+            "url": "/resource/",
+            "examples": {
+                "OK": {
+                    "request": {
+                        "queryParams": {},
+                        "body": {
+                            "name": "My Resource"
+                        },
+                        "headers": {
+                            "This-Custom-Header": 'Foo'
+                        }
+                    }
+                }
+            }
+        })
+        self.sample_request = abe_mock.examples['OK'].request
+
+        self.mock_wsgi_request = Mock(
+            POST={'name': 'My Resource'},
+            META={
+                'HTTP_THIS_CUSTOM_HEADER': 'Foo',
+                'REQUEST_METHOD': 'POST',
+                'PATH_INFO': '/resource/'
+            },
+        )
+
+    def test_success_case(self):
+        self.assert_matches_request(
+            self.sample_request, self.mock_wsgi_request
+        )
+
+    def test_assertion_error_if_url_mismatch(self):
+        self.mock_wsgi_request.META['PATH_INFO'] = '/resourceoops/'
+
+        with self.assertRaises(AssertionError):
+            self.assert_matches_request(
+                self.sample_request, self.mock_wsgi_request
+            )
+
+    def test_assertion_error_if_method_mismatch(self):
+        self.mock_wsgi_request.META['REQUEST_METHOD'] = 'PATCH'
+
+        with self.assertRaises(AssertionError):
+            self.assert_matches_request(
+                self.sample_request, self.mock_wsgi_request
+            )
+
+    def test_assertion_error_if_post_data_mismatch(self):
+        self.mock_wsgi_request.POST = {'a': 1}
+
+        with self.assertRaises(AssertionError):
+            self.assert_matches_request(
+                self.sample_request, self.mock_wsgi_request
+            )
+
+
+class TestFilenameInstantiation(TestCase):
+
+    def setUp(self):
+        self.filename = join(DATA_DIR, 'sample.json')
+
+    def test_can_still_use_deprecated_instantiation(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+
+            mock = AbeMock(self.filename)
+
+            self.assertEqual(len(w), 1)
+            self.assertTrue(issubclass(w[-1].category, DeprecationWarning))
+
+    def test_from_filename(self):
+        mock = AbeMock.from_filename(self.filename)