Added exception tests + refactor in arguments. (#30)

* Added exception tests + refactor in arguments.

* remove test print()

Co-authored-by: Patryk Szulczewski <patryk.szulczewski@networktocode.com>

Author: pszulczewski

netcompare/check_types.py

@@ -121,10 +121,13 @@ def __init__(self, *args):
         super().__init__()
 
         try:
-            tolerance = args[1]
+            tolerance = float(args[1])
         except IndexError as error:
-            raise ValueError(f"Tolerance parameter must be defined as float at index 1. You have: {args}") from error
-        self.tolerance_factor = float(tolerance) / 100
+            raise IndexError(f"Tolerance parameter must be defined as float at index 1. You have: {args}") from error
+        except ValueError as error:
+            raise ValueError(f"Argument must be convertible to float. You have: {args[1]}") from error
+
+        self.tolerance_factor = tolerance / 100
 
     def evaluate(self, reference_value: Mapping, value_to_compare: Mapping) -> Tuple[Dict, bool]:
         """Returns the difference between values and the boolean. Overwrites method in base class."""
@@ -155,16 +158,10 @@ class ParameterMatchType(CheckType):
 
     def evaluate(self, reference_value: Mapping, value_to_compare: Mapping) -> Tuple[Dict, bool]:
         """Parameter Match evaluator implementation."""
-        try:
-            parameter = value_to_compare[1]
-        except IndexError as error:
-            raise ValueError(
-                f"Evaluating parameter must be defined as dict at index 1. You have: {value_to_compare}"
-            ) from error
-        if not isinstance(parameter, dict):
+        if not isinstance(value_to_compare, dict):
             raise TypeError("check_option must be of type dict()")
 
-        evaluation_result = parameter_evaluator(reference_value, parameter)
+        evaluation_result = parameter_evaluator(reference_value, value_to_compare)
         return evaluation_result, not evaluation_result
 
 
@@ -173,29 +170,21 @@ class RegexType(CheckType):
 
     def evaluate(self, reference_value: Mapping, value_to_compare: Mapping) -> Tuple[Mapping, bool]:
         """Regex Match evaluator implementation."""
-        # Assert that check parameters are at index 1.
-        try:
-            parameter = value_to_compare[1]
-        except IndexError as error:
-            raise IndexError(
-                f"Evaluating parameter must be defined as dict at index 1. You have: {value_to_compare}"
-            ) from error
-
-        # Assert that check parameters are at index 1.
-        if not all([isinstance(parameter, dict)]):
+        # Check that check value_to_compare is dict.
+        if not isinstance(value_to_compare, dict):
             raise TypeError("check_option must be of type dict().")
 
-        # Assert that check option has 'regex' and 'mode' dict keys.
-        if "regex" not in parameter and "mode" not in parameter:
+        # Check that value_to_compare has 'regex' and 'mode' dict keys.
+        if any(key not in value_to_compare.keys() for key in ("regex", "mode")):
             raise KeyError(
                 "Regex check-type requires check-option. Example: dict(regex='.*UNDERLAY.*', mode='no-match')."
             )
 
         # Assert that check option has 'regex' and 'mode' dict keys.\
-        if parameter["mode"] not in ["match", "no-match"]:
+        if value_to_compare["mode"] not in ["match", "no-match"]:
             raise ValueError(
                 "Regex check-type requires check-option. Example: dict(regex='.*UNDERLAY.*', mode='no-match')."
             )
 
-        diff = regex_evaluator(reference_value, parameter)
+        diff = regex_evaluator(reference_value, value_to_compare)
         return diff, not diff

netcompare/evaluators.py

@@ -85,7 +85,7 @@ def regex_evaluator(values: Mapping, parameter: Mapping) -> Dict:
     # parameter: {'regex': '.*UNDERLAY.*', 'mode': 'include'}
     result = {}
     if not isinstance(values, list):
-        raise TypeError("Something went wrong during JMSPath parsing. values must be of type list.")
+        raise TypeError("Something went wrong during JMSPath parsing. 'values' must be of type List.")
 
     regex_expression = parameter["regex"]
     mode = parameter["mode"]

tests/test_type_checks.py

@@ -13,10 +13,39 @@ def test_check_init(args, expected_class):
     assert isinstance(CheckType.init(*args), expected_class)
 
 
-def test_check_type_raises_not_implemented_error_for_invalid_check_type():
-    """Validate that CheckType raises a NotImplementedError when passed a non-existant check_type."""
-    with pytest.raises(NotImplementedError):
-        CheckType.init("does_not_exist")
+exception_tests_init = [
+    (("does_not_exist",), NotImplementedError, ""),
+    (("tolerance",), IndexError, "parameter"),
+    (("tolerance", "non-float"), ValueError, "non-float"),
+]
+
+
+@pytest.mark.parametrize("check_type_args, exception_type, expected_in_output", exception_tests_init)
+def tests_exceptions_init(check_type_args, exception_type, expected_in_output):
+    """Tests exceptions when check object is initialized."""
+    with pytest.raises(exception_type) as error:
+        CheckType.init(*check_type_args)
+    assert expected_in_output in error.value.__str__()
+
+
+exception_tests_eval = [
+    ("parameter_match", ([{}], "not-dict"), TypeError, "dict()"),
+    ("parameter_match", ({}, {}), TypeError, "'values' must be of type List"),
+    ("regex", ([{}], "not-dict"), TypeError, "dict()"),
+    ("regex", ([{}], {"mode": "match"}), KeyError, "check-option"),
+    ("regex", ([{}], {"mode": "regex"}), KeyError, "check-option"),
+    ("regex", ([{}], {"regex": "", "mode": "unknown"}), ValueError, "check-option"),
+    ("regex", ({}, {"regex": "", "mode": "match"}), TypeError, "'values' must be of type List"),
+]
+
+
+@pytest.mark.parametrize("check_type, args, exception_type, expected_in_output", exception_tests_eval)
+def tests_exceptions_eval(check_type, args, exception_type, expected_in_output):
+    """Tests exceptions when calling .evaluate() method."""
+    with pytest.raises(exception_type) as error:
+        check = CheckType.init(check_type)
+        check.evaluate(*args)
+    assert expected_in_output in error.value.__str__()
 
 
 exact_match_test_values_no_change = (
@@ -187,12 +216,10 @@ def test_check_type_results(check_type_args, folder_name, path, expected_results
 ]
 
 
-@pytest.mark.parametrize("folder_name, check_args, path, expected_result", check_tests)
-def test_checks(folder_name, check_args, path, expected_result):
+@pytest.mark.parametrize("folder_name, check_type_args, path, expected_result", check_tests)
+def test_checks(folder_name, check_type_args, path, expected_result):
     """Validate multiple checks on the same data to catch corner cases."""
-    pre_data, post_data = load_mocks(folder_name)
-
-    check = CheckType.init(*check_args)
+    check = CheckType.init(*check_type_args)
     pre_data, post_data = load_mocks(folder_name)
     pre_value = check.get_value(pre_data, path)
     post_value = check.get_value(post_data, path)
@@ -217,14 +244,14 @@ def test_checks(folder_name, check_args, path, expected_result):
 )
 
 
-@pytest.mark.parametrize("filename, check_args, path, expected_result", [parameter_match_api])
-def test_param_match(filename, check_args, path, expected_result):
+@pytest.mark.parametrize("filename, check_type_args, path, expected_result", [parameter_match_api])
+def test_param_match(filename, check_type_args, path, expected_result):
     """Validate parameter_match check type."""
-    check = CheckType.init(*check_args)
+    check = CheckType.init(check_type_args[0])
     # There is not concept of "pre" and "post" in parameter_match.
     data = load_json_file("parameter_match", filename)
     value = check.get_value(data, path)
-    actual_results = check.evaluate(value, check_args)
+    actual_results = check.evaluate(value, check_type_args[1])
     assert actual_results == expected_result, ASSERT_FAIL_MESSAGE.format(
         output=actual_results, expected_output=expected_result
     )
@@ -262,14 +289,14 @@ def test_param_match(filename, check_args, path, expected_result):
 ]
 
 
-@pytest.mark.parametrize("filename, check_args, path, expected_result", regex_match)
-def test_regex_match(filename, check_args, path, expected_result):
+@pytest.mark.parametrize("filename, check_type_args, path, expected_result", regex_match)
+def test_regex_match(filename, check_type_args, path, expected_result):
     """Validate regex check type."""
-    check = CheckType.init(*check_args)
+    check = CheckType.init(check_type_args[0])
     # There is not concept of "pre" and "post" in parameter_match.
     data = load_json_file("api", filename)
     value = check.get_value(data, path)
-    actual_results = check.evaluate(value, check_args)
+    actual_results = check.evaluate(value, check_type_args[1])
     assert actual_results == expected_result, ASSERT_FAIL_MESSAGE.format(
         output=actual_results, expected_output=expected_result
     )