Fix tests.

Author: Patryk Szulczewski

netcompare/check_types.py

@@ -129,7 +129,7 @@ def evaluate(self, *args, **kwargs) -> Tuple[Dict, bool]:
 
     @staticmethod
     @abstractmethod
-    def _validate(**kwargs) -> None:
+    def _validate(*args) -> None:
         """Method to validate arguments that raises proper exceptions."""
 
     @staticmethod
@@ -141,13 +141,13 @@ def result(evaluation_result) -> Tuple[Dict, bool]:
 class ExactMatchType(CheckType):
     """Exact Match class docstring."""
 
-    def _validate(referece_data):
+    @staticmethod
+    def _validate(reference_data):
         # No need for _validate method as exact-match does not take any specific arguments.
         pass
 
     def evaluate(self, value_to_compare: Any, reference_data: Any) -> Tuple[Dict, bool]:  # type: ignore[override]
         """Returns the difference between values and the boolean."""
-        
         evaluation_result = diff_generator(reference_data, value_to_compare)
         return self.result(evaluation_result)
 
@@ -156,7 +156,7 @@ class ToleranceType(CheckType):
     """Tolerance class docstring."""
 
     @staticmethod
-    def _validate(tolerance) -> None:
+    def _validate(tolerance) -> None:  # type: ignore[override]
         """Method to validate arguments."""
         # reference_data = getattr(kwargs, "reference_data")
         if not tolerance:
@@ -204,7 +204,7 @@ class ParameterMatchType(CheckType):
     """Parameter Match class implementation."""
 
     @staticmethod
-    def _validate(params, mode) -> None:
+    def _validate(params, mode) -> None:  # type: ignore[override]
         """Method to validate arguments."""
         mode_options = ["match", "no-match"]
         if not params:
@@ -231,7 +231,7 @@ class RegexType(CheckType):
     """Regex Match class implementation."""
 
     @staticmethod
-    def _validate(regex, mode) -> None:
+    def _validate(regex, mode) -> None:  # type: ignore[override]
         """Method to validate arguments."""
         mode_options = ["match", "no-match"]
         if not regex:
@@ -255,7 +255,7 @@ class OperatorType(CheckType):
     """Operator class implementation."""
 
     @staticmethod
-    def _validate(params) -> None:
+    def _validate(params) -> None:  # type: ignore[override]
         """Validate operator parameters."""
         in_operators = ("is-in", "not-in", "in-range", "not-range")
         bool_operators = ("all-same",)
@@ -273,8 +273,8 @@ def _validate(params) -> None:
         if not params or list(params.keys())[0] != "params":
             raise ValueError(f"'params' argument must be provided. You have: {list(params.keys())[0]}.")
 
-        params_key = params.get("mode")
-        params_value = params.get("operator_data")
+        params_key = params.get("params", {}).get("mode")
+        params_value = params.get("params", {}).get("operator_data")
 
         if not params_key or not params_value:
             raise ValueError(

tasks.py

@@ -171,6 +171,6 @@ def tests(context, path=".", local=INVOKE_LOCAL):
     yamllint(context, path, local)
     pydocstyle(context, path, local)
     bandit(context, path, local)
-    pytest(context, local)
     mypy(context, path, local)
+    pytest(context, local)
     print("All tests have passed!")

tests/test_type_checks.py

@@ -26,7 +26,7 @@ class CheckTypeChild(CheckType):
         """Test Class."""
 
         @staticmethod
-        def _validate(**kwargs):
+        def _validate(*args):
             return None
 
         def evaluate(self, *args, **kwargs):

tests/test_validates.py

@@ -122,18 +122,18 @@
 
 
 @pytest.mark.parametrize("check_type_str, evaluate_args, expected_results", all_tests)
-def test_tolerance_key_name(check_type_str, evaluate_args, expected_results):
+def test_validate_arguments(check_type_str, evaluate_args, expected_results):
     """Test CheckType validate method for each check-type."""
     check = CheckType.init(check_type_str)
 
     with pytest.raises(ValueError) as exc_info:
-        if check_type_str == 'tolerance':
-            check._validate(tolerance=evaluate_args)
-        elif check_type_str == 'parameter':
-            check._validate(params=evaluate_args['params'], mode=evaluate_args['mode'])
-        elif check_type_str == 'regex':
-            check._validate(regex=evaluate_args['regex'], mode=evaluate_args['mode'])
-        elif check_type_str == 'operator':
-            check._validate(params=evaluate_args)
- 
+        if check_type_str == "tolerance":
+            check._validate(evaluate_args.get("tolerance"))
+        elif check_type_str == "parameter_match":
+            check._validate(params=evaluate_args.get("params"), mode=evaluate_args.get("mode"))
+        elif check_type_str == "regex":
+            check._validate(regex=evaluate_args.get("regex"), mode=evaluate_args.get("mode"))
+        elif check_type_str == "operator":
+            check._validate(evaluate_args)
+
     assert exc_info.type is ValueError and exc_info.value.args[0] == expected_results