add comparators

ate/response.py

@@ -92,13 +92,13 @@ class ResponseObject(object):
             except KeyError:
                 raise exception.ParamsError("invalid validator %s" % validator_key)
 
-            difference_exist = utils.compare(
+            match_expected = utils.match_expected(
                 value,
                 validator_dict["expected"],
                 validator_dict["comparator"]
             )
 
-            if difference_exist:
+            if not match_expected:
                 diff_content_dict[validator_key] = validator_dict
 
         self.success = False if diff_content_dict else True

ate/utils.py

@@ -181,24 +181,36 @@ def query_json(json_content, query, delimiter='.'):
 
     return json_content
 
-def diff_json(current_json, expected_json):
+def match_expected(value, expected, comparator="eq"):
-    json_diff = {}
+    """ check if value matches expected value.
-
+    @param value: value that get from response.
-    for key, expected_value in expected_json.items():
+    @param expected: expected result described in testcase
-        value = current_json.get(key, None)
+    @param comparator: compare method
-        if str(value) != str(expected_value):
+    """
-            json_diff[key] = {
-                'value': value,
-                'expected': expected_value
-            }
-
-    return json_diff
-
-def compare(value, expected, comparator="eq"):
     try:
-        if comparator in ["eq", "=="]:
+        if comparator in ["eq", "equals", "=="]:
             assert value == expected
+        elif comparator in ["str_eq", "string_equals"]:
+            assert str(value) == str(expected)
+        elif comparator in ["ne", "not_equals"]:
+            assert value != expected
+        elif comparator in ["len_eq", "length_equal", "count_eq"]:
+            assert len(value) == len(expected)
+        elif comparator in ["lt", "less_than"]:
+            assert value < expected
+        elif comparator in ["le", "less_than_or_equals"]:
+            assert value <= expected
+        elif comparator in ["gt", "greater_than"]:
+            assert value > expected
+        elif comparator in ["ge", "greater_than_or_equals"]:
+            assert value >= expected
+        elif comparator in ["contains"]:
+            assert expected in value
+        elif comparator in ["contained_by"]:
+            assert value in expected
+        elif comparator in ["regex"]:
+            assert re.match(expected, value)
 
-        return False
-    except AssertionError:
         return True
+    except AssertionError:
+        return False

test/test_utils.py

@@ -178,9 +178,23 @@ class TestUtils(ApiServerUnittest):
         self.assertEqual(result, "Leo")
 
     def test_compare(self):
-        self.assertEqual(utils.compare(1, 1, "eq"), False)
+        self.assertTrue(utils.match_expected(1, 1, "eq"))
-        self.assertEqual(utils.compare("abc", "abc", "eq"), False)
+        self.assertTrue(utils.match_expected("abc", "abc", "eq"))
-        self.assertEqual(utils.compare("abc", "abc"), False)
+        self.assertTrue(utils.match_expected("abc", "abc"))
+        self.assertFalse(utils.match_expected(123, "123", "eq"))
+        self.assertFalse(utils.match_expected(123, "123"))
 
-        self.assertEqual(utils.compare(123, "123", "eq"), True)
+        self.assertTrue(utils.match_expected("123", "345", "len_eq"))
-        self.assertEqual(utils.compare(123, "123"), True)
+        self.assertTrue(utils.match_expected(123, "123", "str_eq"))
+        self.assertTrue(utils.match_expected(123, "123", "ne"))
+
+        self.assertTrue(utils.match_expected(1, 2, "lt"))
+        self.assertTrue(utils.match_expected(1, 1, "le"))
+        self.assertTrue(utils.match_expected(2, 1, "gt"))
+        self.assertTrue(utils.match_expected(1, 1, "ge"))
+
+        self.assertTrue(utils.match_expected("123abc456", "3ab", "contains"))
+        self.assertTrue(utils.match_expected("3ab", "123abc456", "contained_by"))
+
+        self.assertTrue(utils.match_expected("123abc456", "^123.*456$", "regex"))
+        self.assertFalse(utils.match_expected("123abc456", "^12b.*456$", "regex"))