proposal

Author: chadell

netcompare/arguments.py

@@ -1,75 +1,79 @@
+"""Classes for argument validation."""
+
+# pylint: disable=too-few-public-methods
+
+
 class CheckArguments:
-    def __init__(self, *args, **kwargs):
+    """Class to validate arguments."""
+
+    @staticmethod
+    def validate(**kwargs):
+        """Method to validate arguments."""
         raise NotImplementedError
 
 
 class CheckArgumentsExactMatch(CheckArguments):
-    def __init__(self, *args, **kwargs):
-        self.reference_data = getattr(kwargs, "raw_data")
+    """Class to validate arguments."""
+
+    @staticmethod
+    def validate(**kwargs):
+        """Method to validate arguments."""
+        # reference_data = getattr(kwargs, "reference_data")
 
 
 class CheckArgumentsToleranceMatch(CheckArguments):
-    def __init__(self, *args, **kwargs):
-        self.reference_data = getattr(kwargs, "raw_data")
-        self.tolerance = getattr(kwargs, "tolerance")
-        if not self.tolerance:
+    """Class to validate arguments."""
+
+    @staticmethod
+    def validate(**kwargs):
+        """Method to validate arguments."""
+        # reference_data = getattr(kwargs, "reference_data")
+        tolerance = getattr(kwargs, "tolerance")
+        if not tolerance:
             raise ValueError("Tolerance argument is mandatory for Tolerance Check Type.")
-        if not isinstance(int, self.tolerance):
-            raise ValueError(f"Tolerance argument must be an integer, and it's {type(self.tolerance)}.")
+        if not isinstance(int, tolerance):
+            raise ValueError(f"Tolerance argument must be an integer, and it's {type(tolerance)}.")
 
 
 class CheckArgumentsParameterMatch(CheckArguments):
-    MODE_OPTIONS = ["match", "no-match"]
-
-    def __init__(self, *args, **kwargs):
-        self.params = getattr(kwargs, "params")
-        if not self.params:
+    """Class to validate arguments."""
+
+    @staticmethod
+    def validate(**kwargs):
+        """Method to validate arguments."""
+        mode_options = ["match", "no-match"]
+        params = getattr(kwargs, "params")
+        if not params:
             raise ValueError("Params argument is mandatory for ParameterMatch Check Type.")
-        if not isinstance(dict, self.params):
-            raise ValueError(f"Params argument must be a dict, and it's {type(self.params)}.")
+        if not isinstance(dict, params):
+            raise ValueError(f"Params argument must be a dict, and it's {type(params)}.")
 
-        self.mode = getattr(kwargs, "mode")
-        if not self.mode:
+        mode = getattr(kwargs, "mode")
+        if not mode:
             raise ValueError("Mode argument is mandatory for ParameterMatch Check Type.")
-        if not isinstance(str, self.mode):
-            raise ValueError(f"Mode argument must be a string, and it's {type(self.mode)}.")
-        if self.mode not in self.MODE_OPTIONS:
-            raise ValueError(f"Mode argument should be {self.MODE_OPTIONS}, and it's {self.mode}")
+        if not isinstance(str, mode):
+            raise ValueError(f"Mode argument must be a string, and it's {type(mode)}.")
+        if mode not in mode_options:
+            raise ValueError(f"Mode argument should be {mode_options}, and it's {mode}")
 
 
 class CheckArgumentsRegexMatch(CheckArguments):
-    MODE_OPTIONS = ["match", "no-match"]
-
-    def __init__(self, *args, **kwargs):
-        self.params = getattr(kwargs, "params")
-        if not self.params:
-            raise ValueError("Params argument is mandatory for Regex Match Check Type.")
-        if not isinstance(str, self.params):
-            raise ValueError(f"Params argument must be a string, and it's {type(self.params)}.")
-
-        self.mode = getattr(kwargs, "mode")
-        if not self.mode:
-            raise ValueError("Mode argument is mandatory for Regex Match Check Type.")
-        if not isinstance(str, self.mode):
-            raise ValueError(f"Mode argument must be a string, and it's {type(self.mode)}.")
-        if self.mode not in self.MODE_OPTIONS:
-            raise ValueError(f"Mode argument should be {self.MODE_OPTIONS}, and it's {self.mode}")
-
-
-class CheckArgumentsOptionsMatch(CheckArguments):
-    MODE_OPTIONS = ["is-in", "???"]
-
-    def __init__(self, *args, **kwargs):
-        self.params = getattr(kwargs, "params")
-        if not self.params:
+    """Class to validate arguments."""
+
+    @staticmethod
+    def validate(**kwargs):
+        """Method to validate arguments."""
+        mode_options = ["match", "no-match"]
+        regex = getattr(kwargs, "regex")
+        if not regex:
             raise ValueError("Params argument is mandatory for Regex Match Check Type.")
-        if not isinstance(list, self.params):
-            raise ValueError(f"Params argument must be a list, and it's {type(self.params)}.")
+        if not isinstance(str, regex):
+            raise ValueError(f"Params argument must be a string, and it's {type(regex)}.")
 
-        self.mode = getattr(kwargs, "mode")
-        if not self.mode:
+        mode = getattr(kwargs, "mode")
+        if not mode:
             raise ValueError("Mode argument is mandatory for Regex Match Check Type.")
-        if not isinstance(str, self.mode):
-            raise ValueError(f"Mode argument must be a string, and it's {type(self.mode)}.")
-        if self.mode not in self.MODE_OPTIONS:
-            raise ValueError(f"Mode argument should be {self.MODE_OPTIONS}, and it's {self.mode}")
+        if not isinstance(str, mode):
+            raise ValueError(f"Mode argument must be a string, and it's {type(mode)}.")
+        if mode not in mode_options:
+            raise ValueError(f"Mode argument should be {mode_options}, and it's {mode}")

netcompare/check_types.py

@@ -6,8 +6,8 @@
 from netcompare.arguments import (
     CheckArguments,
     CheckArgumentsExactMatch,
-    CheckArgumentsParameterMatch,
     CheckArgumentsRegexMatch,
+    CheckArgumentsParameterMatch,
     CheckArgumentsToleranceMatch,
 )
 
@@ -20,23 +20,21 @@
 )
 from .utils.data_normalization import exclude_filter, flatten_list
 from .evaluators import diff_generator, parameter_evaluator, regex_evaluator
-from .check_types import *
+
+# pylint: disable=arguments-differ
 
 
 class CheckType:
     """Check Type Class."""
 
     class_args = CheckArguments
 
-    def __init__(self, *args):
-        """Check Type init method."""
-
     @staticmethod
     def init(check_type):
         """Factory pattern to get the appropriate CheckType implementation.
 
         Args:
-            *args: Variable length argument list.
+            check_type: String to define the type of check.
         """
         if check_type == "exact_match":
             return ExactMatchType()
@@ -99,58 +97,42 @@ def get_value(output: Union[Mapping, List], path: str, exclude: List = None) ->
 
         return values
 
-    def hook_evaluate(self, reference_value: CheckArguments, value_to_compare: Any) -> Tuple[Dict, bool]:
+    def evaluate(self, value_to_compare: Any, **kwargs) -> Tuple[Dict, bool]:
         """Return the result of the evaluation and a boolean True if it passes it or False otherwise.
 
         This method is the one that each CheckType has to implement.
 
         Args:
-            reference_value: Can be any structured data or just a simple value.
             value_to_compare: Similar value as above to perform comparison.
 
         Returns:
             tuple: Dictionary representing check result, bool indicating if differences are found.
         """
         raise NotImplementedError
 
-    def evaluate(self, reference_value: dict, value_to_compare: Any) -> Tuple[Dict, bool]:
-
-        return self.hook_evaluate(self.args_class(reference_value), value_to_compare)
-
 
 class ExactMatchType(CheckType):
     """Exact Match class docstring."""
 
-    args_class = CheckArgumentsExactMatch
+    validator_class = CheckArgumentsExactMatch
 
-    def evaluate(self, reference_value: CheckArgumentsExactMatch, value_to_compare: Any) -> Tuple[Dict, bool]:
+    def evaluate(self, value_to_compare: Any, reference_data: Any) -> Tuple[Dict, bool]:
         """Returns the difference between values and the boolean."""
-        evaluation_result = diff_generator(reference_value.reference_data, value_to_compare)
+        self.validator_class.validate(reference_data=reference_data)
+        evaluation_result = diff_generator(reference_data, value_to_compare)
         return evaluation_result, not evaluation_result
 
 
 class ToleranceType(CheckType):
     """Tolerance class docstring."""
 
-    def __init__(self, *args):
-        """Tolerance init method."""
-        super().__init__()
+    validator_class = CheckArgumentsToleranceMatch
 
-        try:
-            tolerance = float(args[1])
-        except IndexError as error:
-            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 hook_evaluate(
-        self, reference_value: CheckArgumentsToleranceMatch, value_to_compare: Mapping
-    ) -> Tuple[Dict, bool]:
+    def evaluate(self, value_to_compare: Any, reference_data: Any, tolerance: int) -> Tuple[Dict, bool]:
         """Returns the difference between values and the boolean. Overwrites method in base class."""
-        diff = diff_generator(reference_value.reference_data, value_to_compare)
-        self._remove_within_tolerance(diff, reference_value.tolerance)
+        self.validator_class.validate(reference_data=reference_data, tolerance=tolerance)
+        diff = diff_generator(reference_data, value_to_compare)
+        self._remove_within_tolerance(diff, tolerance)
         return diff, not diff
 
     def _remove_within_tolerance(self, diff: Dict, tolerance: int) -> None:
@@ -174,41 +156,23 @@ def _within_tolerance(*, old_value: float, new_value: float) -> bool:
 class ParameterMatchType(CheckType):
     """Parameter Match class implementation."""
 
-    def hook_evaluate(
-        self, reference_value: CheckArgumentsParameterMatch, value_to_compare: Mapping
-    ) -> Tuple[Dict, bool]:
-        """Parameter Match evaluator implementation."""
-        if not isinstance(value_to_compare, dict):
-            raise TypeError("check_option must be of type dict()")
+    validator_class = CheckArgumentsParameterMatch
 
-        # TODO: update this
-        evaluation_result = parameter_evaluator(reference_value, value_to_compare)
+    def evaluate(self, value_to_compare: Mapping, params: Dict, mode: str) -> Tuple[Dict, bool]:
+        """Parameter Match evaluator implementation."""
+        self.validator_class.validate(params=params, mode=mode)
+        # TODO: we don't use the mode?
+        evaluation_result = parameter_evaluator(value_to_compare, params)
         return evaluation_result, not evaluation_result
 
 
 class RegexType(CheckType):
     """Regex Match class implementation."""
 
-    def hook_evaluate(
-        self, reference_value: CheckArgumentsRegexMatch, value_to_compare: Mapping
-    ) -> Tuple[Mapping, bool]:
+    validator_class = CheckArgumentsRegexMatch
+
+    def evaluate(self, value_to_compare: Mapping, regex: str, mode: str) -> Tuple[Mapping, bool]:
         """Regex Match evaluator implementation."""
-        # Check that check value_to_compare is dict.
-        if not isinstance(value_to_compare, dict):
-            raise TypeError("check_option must be of type dict().")
-
-        # 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 value_to_compare["mode"] not in ["match", "no-match"]:
-            raise ValueError(
-                "Regex check-type requires check-option. Example: dict(regex='.*UNDERLAY.*', mode='no-match')."
-            )
-
-        # TODO: update this
-        diff = regex_evaluator(reference_value, value_to_compare)
+        self.validator_class.validate(regex=regex, mode=mode)
+        diff = regex_evaluator(value_to_compare, regex, mode)
         return diff, not diff

netcompare/evaluators.py

@@ -79,17 +79,14 @@ def parameter_evaluator(values: Mapping, parameters: Mapping) -> Dict:
     return result
 
 
-def regex_evaluator(values: Mapping, parameter: Mapping) -> Dict:
+def regex_evaluator(values: Mapping, regex_expression: str, mode: str) -> Dict:
     """Regex Match evaluator engine."""
     # values: [{'7.7.7.7': {'peerGroup': 'EVPN-OVERLAY-SPINE'}}]
     # 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.")
 
-    regex_expression = parameter["regex"]
-    mode = parameter["mode"]
-
     for item in values:
         for founded_value in item.values():
             for value in founded_value.values():