Add checks for request body and method.

Author: alexcouper

abe/mocks.py

@@ -5,16 +5,11 @@
 
 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)
-
         # map JSON fields to attributes
         self.__dict__ = data
 
@@ -25,6 +20,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/test_assertions.py

@@ -1,5 +1,7 @@
 from unittest import TestCase
+from mock import Mock
 
+from abe.mocks import AbeMock
 from abe.unittest import AbeTestMixin
 
 
@@ -71,3 +73,64 @@ 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
+            )