Merge pull request #69 from jawu/#52-helper-function-for-assertion-wi…

…th-matchers

solves #52 added get_generated_values

pact/matchers.py

@@ -198,3 +198,30 @@ def from_term(term):
         return term.generate()
     else:
         raise ValueError('Unknown type: %s' % type(term))
+
+
+def get_generated_values(input):
+    """
+    Resolve (nested) Matchers to their generated values for assertion.
+
+    :param input: The input to be resolved to its generated values.
+    :type input: None, list, dict, int, float, bool, str, unicode, Matcher
+    :return: The input resolved to its generated value(s)
+    :rtype: None, list, dict, int, float, bool, str, unicode, Matcher
+    """
+    if input is None:
+        return input
+    if isinstance(input, (six.string_types, int, float, bool)):
+        return input
+    if isinstance(input, dict):
+        return {k: get_generated_values(v) for k, v in input.items()}
+    if isinstance(input, list):
+        return [get_generated_values(t) for i, t in enumerate(input)]
+    elif isinstance(input, Like):
+        return get_generated_values(input.matcher)
+    elif isinstance(input, EachLike):
+        return [get_generated_values(input.matcher)] * input.minimum
+    elif isinstance(input, Term):
+        return input.generate()['data']['generate']
+    else:
+        raise ValueError('Unknown type: %s' % type(input))

pact/test/test_matchers.py

@@ -1,6 +1,7 @@
 from unittest import TestCase
 
-from ..matchers import EachLike, Like, Matcher, SomethingLike, Term, from_term
+from ..matchers import EachLike, Like, Matcher, SomethingLike, \
+    Term, from_term, get_generated_values
 
 
 class MatcherTestCase(TestCase):
@@ -118,7 +119,6 @@ def test_regex(self):
 class FromTermTestCase(TestCase):
     def test_dict(self):
         expected = {'administrator': False, 'id': 123, 'username': 'user'}
-
         self.assertEqual(from_term(expected), expected)
 
     def test_none(self):
@@ -184,3 +184,57 @@ def test_nested(self):
     def test_unknown_type(self):
         with self.assertRaises(ValueError):
             from_term(set())
+
+
+class GetGeneratedValuesTestCase(TestCase):
+    def test_none(self):
+        self.assertIsNone(get_generated_values(None))
+
+    def test_bool(self):
+        self.assertFalse(get_generated_values(False))
+
+    def test_unicode(self):
+        self.assertEqual(get_generated_values(u'testing'), 'testing')
+
+    def test_int(self):
+        self.assertEqual(get_generated_values(123), 123)
+
+    def test_float(self):
+        self.assertEqual(get_generated_values(3.14), 3.14)
+
+    def test_list(self):
+        term = [1, 123, 'sample']
+        self.assertEqual(get_generated_values(term), term)
+
+    def test_dict(self):
+        expected = {'administrator': False, 'id': 123, 'username': 'user'}
+        self.assertEqual(get_generated_values(expected), expected)
+
+    def test_each_like(self):
+        self.assertEqual(
+            get_generated_values(EachLike({'a': 1})), [{'a': 1}])
+
+    def test_each_like_minimum(self):
+        self.assertEqual(get_generated_values(EachLike({'a': 1}, minimum=5)),
+                         [{'a': 1}] * 5)
+
+    def test_something_like(self):
+        self.assertEqual(
+            get_generated_values(SomethingLike(123)), 123)
+
+    def test_term(self):
+        self.assertEqual(
+            get_generated_values(Term('[a-f0-9]+', 'abc123')), 'abc123')
+
+    def test_nested(self):
+        input = [
+            EachLike({
+                'username': Term('[a-zA-Z]+', 'firstlast'),
+                'id': SomethingLike(123)})]
+        self.assertEqual(
+            get_generated_values(input),
+            [[{'username': 'firstlast', 'id': 123}]])
+
+    def test_unknown_type(self):
+        with self.assertRaises(ValueError):
+            get_generated_values(set())