Rename ignore to non_strict

Author: txels

abe/unittest.py

@@ -44,48 +44,50 @@ def assert_item_matches(self, real, sample):
         sample = normalize(sample)
         self.assertEqual(real, sample)
 
-    def assert_data_equal(self, real, sample, ignore=None):
+    def assert_data_equal(self, real, sample, non_strict=None):
         """
         Two elements are recursively equal
 
-        :param ignore:
-            Names of fields to ignore
+        :param non_strict:
+            Names of fields to match non-strictly. In current implementation,
+            only check for field presence.
         """
-        ignore = ignore or []
+        non_strict = non_strict or []
         try:
             if isinstance(real, list):
                 self.assertIsInstance(sample, list)
-                self.assert_data_list_equal(real, sample, ignore)
+                self.assert_data_list_equal(real, sample, non_strict)
             elif isinstance(real, dict):
                 self.assertIsInstance(sample, dict)
-                self.assert_data_dict_equal(real, sample, ignore)
+                self.assert_data_dict_equal(real, sample, non_strict)
             else:
                 self.assert_item_matches(real, sample)
         except AssertionError as exc:
             message = str(exc) + '\n{}\n{}\n\n'.format(real, sample)
             raise type(exc)(message)
 
-    def assert_data_dict_equal(self, real, sample, ignore=None):
+    def assert_data_dict_equal(self, real, sample, non_strict=None):
         """
         Two dicts are recursively equal without taking order into account
         """
-        ignore = ignore or []
+        non_strict = non_strict or []
         self.assertEqual(
             len(real), len(sample),
             msg='Number of elements mismatch: {} != {}\n'.format(
                 real.keys(), sample.keys())
         )
         for key in real:
-            if key not in ignore:
+            if key not in non_strict:
                 self.assertIn(key, sample)
-                inner_ignore = subkeys(ignore, key)
-                self.assert_data_equal(real[key], sample[key], inner_ignore)
+                inner_non_strict = subkeys(non_strict, key)
+                self.assert_data_equal(
+                    real[key], sample[key], inner_non_strict)
 
-    def assert_data_list_equal(self, real, sample, ignore=None):
+    def assert_data_list_equal(self, real, sample, non_strict=None):
         """
         Two lists are recursively equal, including ordering.
         """
-        ignore = ignore or []
+        non_strict = non_strict or []
         self.assertEqual(
             len(real), len(sample),
             msg='Number of elements mismatch: {} {}'.format(
@@ -95,7 +97,7 @@ def assert_data_list_equal(self, real, sample, ignore=None):
         exceptions = []
         for real_item, sample_item in zip(real, sample):
             try:
-                self.assert_data_equal(real_item, sample_item, ignore)
+                self.assert_data_equal(real_item, sample_item, non_strict)
             except AssertionError as exc:
                 exceptions.append(exc)
 
@@ -123,35 +125,44 @@ def assert_headers_contain(self, response_data, spec_data):
                 "header {0}".format(expected_header)
             )
 
-    def assert_matches_request(self, sample_request, wsgi_request):
+    def assert_matches_request(self, sample_request, wsgi_request,
+                               non_strict=None):
         """
         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'])
+        non_strict = non_strict or []
 
-        if 'headers' in sample_request:
+        if 'url' not in non_strict:
+            self.assertEqual(wsgi_request.META['PATH_INFO'],
+                             sample_request['url'])
+        if 'method' not in non_strict:
+            self.assertEqual(wsgi_request.META['REQUEST_METHOD'],
+                             sample_request['method'])
+
+        if 'headers' in sample_request and 'headers' not in non_strict:
             self.assert_headers_contain(
                 wsgi_request.META, sample_request['headers']
             )
 
-        if 'body' in sample_request:
+        if 'body' in sample_request and 'body' not in non_strict:
             self.assert_data_equal(wsgi_request.POST, sample_request['body'])
 
     def assert_matches_response(self, sample_response, wsgi_response,
-                                ignore=None):
+                                non_strict=None):
         """
         Check that the sample response and wsgi response match.
         """
-        ignore = ignore or []
+        non_strict = non_strict 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, ignore)
+                response_parsed, sample_response.body, non_strict)
 
-    def assert_matches_sample(self, path, label, response, ignore=None):
+    def assert_matches_sample(
+        self, path, label, response, non_strict_response=None,
+        non_strict_request=None
+    ):
         """
         Check a URL and response against a sample.
 
@@ -162,15 +173,19 @@ def assert_matches_sample(self, path, label, response, ignore=None):
         :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:
+        :param non_strict:
             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 []
+        non_strict_response = non_strict_response or []
+        non_strict_request = non_strict_request 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, ignore=ignore)
-        self.assert_matches_request(sample_request, response.wsgi_request)
+        self.assert_matches_response(
+            sample_response, response, non_strict=non_strict_response)
+        self.assert_matches_request(
+            sample_request, response.wsgi_request,
+            non_strict=non_strict_request)

abe/utils.py

@@ -32,7 +32,15 @@ def normalize(data):
     return data
 
 
-def subkeys(ignore, key):
-    new_keys = filter(lambda s: s.startswith(key + '.'), ignore)
+def subkeys(original, key):
+    """
+    Takes a list of dot-hierarchical values and keeps only matching subkeys.
+
+    Example:
+
+    >>> subkeys(['one.two', 'one.three', 'four'], 'one')
+    ['two', 'three']
+    """
+    new_keys = filter(lambda s: s.startswith(key + '.'), original)
     new_keys = list(map(lambda s: s[len(key) + 1:], new_keys))
     return new_keys

tests/test_assertions.py

@@ -223,7 +223,8 @@ def test_non_strict_response_matches(self):
         }
 
         self.assert_matches_response(
-            self.sample_response, response, ignore=['id', 'url', 'author.url']
+            self.sample_response, response,
+            non_strict=['id', 'url', 'author.url']
         )
 
     def test_non_strict_list_value_matches(self):
@@ -255,7 +256,7 @@ def test_non_strict_list_value_matches(self):
         }
 
         self.assert_matches_response(
-            sample, response, ignore=['contributors.id']
+            sample, response, non_strict=['contributors.id']
         )