Support non-strict matching of samples

- assert_matches_sample includes an optional argument to skip matching
  certain response fields

Author: txels

.travis.yml

@@ -8,4 +8,4 @@ python:
 install: pip install -r test-requirements.txt
 script:
     - python -m unittest discover || python -m unittest
-    - flake8 abe
+    - flake8 abe tests

abe/unittest.py

@@ -1,7 +1,7 @@
 import os
 
 from .mocks import AbeMock
-from .utils import to_unicode
+from .utils import normalize, subkeys
 
 
 class AbeTestMixin(object):
@@ -33,53 +33,69 @@ def get_sample_request(self, path, label):
         sample_request = sample.examples[label].request
         return sample_request.body
 
-    def assert_data_equal(self, data1, data2):
+    def assert_item_matches(self, real, sample):
+        """
+        A primitive value matches the sample.
+
+        If the sample represents a parameter, then do simple pattern matching.
+
+        """
+        real = normalize(real)
+        sample = normalize(sample)
+        self.assertEqual(real, sample)
+
+    def assert_data_equal(self, real, sample, ignore=None):
         """
         Two elements are recursively equal
+
+        :param ignore:
+            Names of fields to ignore
         """
+        ignore = ignore or []
         try:
-            if isinstance(data1, list):
-                self.assertIsInstance(data2, list)
-                self.assert_data_list_equal(data1, data2)
-            elif isinstance(data1, dict):
-                self.assertIsInstance(data2, dict)
-                self.assert_data_dict_equal(data1, data2)
+            if isinstance(real, list):
+                self.assertIsInstance(sample, list)
+                self.assert_data_list_equal(real, sample, ignore)
+            elif isinstance(real, dict):
+                self.assertIsInstance(sample, dict)
+                self.assert_data_dict_equal(real, sample, ignore)
             else:
-                data1 = to_unicode(data1)
-                data2 = to_unicode(data2)
-                self.assertIsInstance(data2, data1.__class__)
-                self.assertEqual(data1, data2)
+                self.assert_item_matches(real, sample)
         except AssertionError as exc:
-            message = str(exc) + '\n{}\n{}\n\n'.format(data1, data2)
+            message = str(exc) + '\n{}\n{}\n\n'.format(real, sample)
             raise type(exc)(message)
 
-    def assert_data_dict_equal(self, data1, data2):
+    def assert_data_dict_equal(self, real, sample, ignore=None):
         """
         Two dicts are recursively equal without taking order into account
         """
+        ignore = ignore or []
         self.assertEqual(
-            len(data1), len(data2),
+            len(real), len(sample),
             msg='Number of elements mismatch: {} != {}\n'.format(
-                data1.keys(), data2.keys())
+                real.keys(), sample.keys())
         )
-        for key in data1:
-            self.assertIn(key, data2)
-            self.assert_data_equal(data1[key], data2[key])
+        for key in real:
+            if key not in ignore:
+                self.assertIn(key, sample)
+                inner_ignore = subkeys(ignore, key)
+                self.assert_data_equal(real[key], sample[key], inner_ignore)
 
-    def assert_data_list_equal(self, data1, data2):
+    def assert_data_list_equal(self, real, sample, ignore=None):
         """
         Two lists are recursively equal, including ordering.
         """
+        ignore = ignore or []
         self.assertEqual(
-            len(data1), len(data2),
+            len(real), len(sample),
             msg='Number of elements mismatch: {} {}'.format(
-                data1, data2)
+                real, sample)
         )
 
         exceptions = []
-        for element, element2 in zip(data1, data2):
+        for real_item, sample_item in zip(real, sample):
             try:
-                self.assert_data_equal(element, element2)
+                self.assert_data_equal(real_item, sample_item, ignore)
             except AssertionError as exc:
                 exceptions.append(exc)
 
@@ -123,16 +139,19 @@ def assert_matches_request(self, sample_request, wsgi_request):
         if 'body' in sample_request:
             self.assert_data_equal(wsgi_request.POST, sample_request['body'])
 
-    def assert_matches_response(self, sample_response, wsgi_response):
+    def assert_matches_response(self, sample_response, wsgi_response,
+                                ignore=None):
         """
         Check that the sample response and wsgi response match.
         """
+        ignore = ignore or []
         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)
+            self.assert_data_equal(
+                response_parsed, sample_response.body, ignore)
 
-    def assert_matches_sample(self, path, label, response):
+    def assert_matches_sample(self, path, label, response, ignore=None):
         """
         Check a URL and response against a sample.
 
@@ -143,10 +162,15 @@ def assert_matches_sample(self, path, label, response):
         :param response:
             The actual API response we want to match with the sample.
             It is assumed to be a Django Rest Framework response object
+        :param ignore:
+            List of fields that will not be checked for strict matching.
+            You can use this to include server-generated fields whose exact
+            value you don't care about in your test, like ids, dates, etc.
         """
+        ignore = ignore or []
         sample = self.load_sample(path)
         sample_request = sample.examples[label].request
         sample_response = sample.examples[label].response
 
-        self.assert_matches_response(sample_response, response)
+        self.assert_matches_response(sample_response, response, ignore=ignore)
         self.assert_matches_request(sample_request, response.wsgi_request)

abe/utils.py

@@ -16,15 +16,23 @@ def datetime_to_string(value):
     return representation
 
 
-def to_unicode(data):
+def normalize(data):
     """
     Ensure that dates, Decimals and strings become unicode
+
+    Integers, on the other hand, are not converted.
     """
     if isinstance(data, datetime):
         data = datetime_to_string(data)
-    else:
+    elif not isinstance(data, int):
         data = str(data)
 
     if not _PY3 and isinstance(data, str):
         data = unicode(data)
     return data
+
+
+def subkeys(ignore, key):
+    new_keys = filter(lambda s: s.startswith(key + '.'), ignore)
+    new_keys = map(lambda s: s[len(key) + 1:], new_keys)
+    return new_keys

ep.yml

@@ -4,7 +4,7 @@ dependencies:
       version: ">=2.6.0"
       file: test-requirements.txt
 run:
-  - flake8 abe
+  - flake8 abe tests
   - coverage erase
   - coverage run --omit="*/tests/*","*$VIRTUAL_ENV*" -m unittest discover
   - coverage html

test-requirements.txt

@@ -2,3 +2,4 @@
 
 flake8
 coverage
+mock

tests/test_assertions.py

@@ -10,9 +10,35 @@
 DATA_DIR = join(dirname(abspath(__file__)), 'data')
 
 
-class TestDataListEqual(TestCase, AbeTestMixin):
+class TestAssertDataEqual(TestCase, AbeTestMixin):
+
+    def test_int_value_matches(self):
+        self.assert_data_equal(3, 3)
+
+    def test_int_value_mismatch(self):
+        self.assertRaises(
+            AssertionError,
+            self.assert_data_equal, 3, 33
+        )
+
+    def test_int_vs_string_value_mismatch(self):
+        self.assertRaises(
+            AssertionError,
+            self.assert_data_equal, 3, "3"
+        )
+
+    def test_string_value_matches(self):
+        self.assert_data_equal("hello", "hello")
+
+    def test_string_value_mismatch(self):
+        self.assertRaises(
+            AssertionError,
+            self.assert_data_equal, "hell", "hello"
+        )
 
 
+class TestDataListEqual(TestCase, AbeTestMixin):
+
     def test_simple_list_equality(self):
         self.assert_data_list_equal([1, 2], [1, 2])
 
@@ -141,6 +167,98 @@ def test_assertion_error_if_post_data_mismatch(self):
             )
 
 
+class TestAssertMatchesResponse(TestCase, AbeTestMixin):
+
+    def setUp(self):
+        abe_mock = AbeMock({
+            "method": "POST",
+            "url": "/resource/",
+            "examples": {
+                "OK": {
+                    "response": {
+                        "status": 201,
+                        "body": {
+                            "id": 12,
+                            "name": "My Resource",
+                            "url": "http://example.com/resource/12",
+                            "author": {
+                                "name": "Slough",
+                                "url": "http://example.com/user/25"
+                            }
+                        }
+                    }
+                }
+            }
+        })
+        self.sample_response = abe_mock.examples['OK'].response
+
+    def test_response_matches_strictly(self):
+        response = Mock()
+        response.status_code = 201
+        response.data = {
+            "id": 12,
+            "name": "My Resource",
+            "url": "http://example.com/resource/12",
+            "author": {
+                "name": "Slough",
+                "url": "http://example.com/user/25"
+            }
+        }
+
+        self.assert_matches_response(
+            self.sample_response, response
+        )
+
+    def test_non_strict_response_matches(self):
+        response = Mock()
+        response.status_code = 201
+        response.data = {
+            "id": 25,
+            "name": "My Resource",
+            "url": "http://example.com/resource/12312",
+            "author": {
+                "name": "Slough",
+                "url": "http://testserver/25/"
+            }
+        }
+
+        self.assert_matches_response(
+            self.sample_response, response, ignore=['id', 'url', 'author.url']
+        )
+
+    def test_non_strict_list_value_matches(self):
+        abe_mock = AbeMock({
+            "url": "/resource/",
+            "method": "GET",
+            "examples": {
+                "OK": {
+                    "response": {
+                        "status": 200,
+                        "body": {
+                            "contributors": [
+                                {"name": "Jack", "id": 1},
+                                {"name": "Jill", "id": 2},
+                            ]
+                        }
+                    }
+                }
+            }
+        })
+        sample = abe_mock.examples['OK'].response
+        response = Mock()
+        response.status_code = 200
+        response.data = {
+            "contributors": [
+                {"name": "Jack", "id": 12},
+                {"name": "Jill", "id": 23},
+            ]
+        }
+
+        self.assert_matches_response(
+            sample, response, ignore=['contributors.id']
+        )
+
+
 class TestFilenameInstantiation(TestCase):
 
     def setUp(self):
@@ -150,10 +268,10 @@ def test_can_still_use_deprecated_instantiation(self):
         with warnings.catch_warnings(record=True) as w:
             warnings.simplefilter("always")
 
-            mock = AbeMock(self.filename)
+            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)
+        AbeMock.from_filename(self.filename)

tests/test_utils.py

@@ -0,0 +1,9 @@
+from unittest import TestCase
+
+from abe.utils import subkeys
+
+
+class TestSubkeys(TestCase):
+    def test_subkeys(self):
+        new_keys = subkeys(['key.one', 'key.two', 'hello', 'keyring'], 'key')
+        self.assertEqual(new_keys, ['one', 'two'])