Regex Check Type implementation (#17)

* draft regex base function

* fix file import

* draft regex implementation

* fix logic into regex result

* remove assertion

* add match/no-match logic

* add assertion for check option

Author: lvrfrc87

netcompare/check_type.py

@@ -1,6 +1,6 @@
 """CheckType Implementation."""
 from typing import Mapping, Tuple, List, Dict, Any
-from .evaluator import diff_generator, parameter_evaluator
+from .evaluator import diff_generator, parameter_evaluator, regex_evaluator
 from .runner import extract_values_from_output
 
 
@@ -24,7 +24,8 @@ def init(*args):
             return ToleranceType(*args)
         if check_type == "parameter_match":
             return ParameterMatchType(*args)
-
+        if check_type == "regex":
+            return RegexType(*args)
         raise NotImplementedError
 
     @staticmethod
@@ -101,10 +102,46 @@ def evaluate(self, reference_value: Mapping, value_to_compare: Mapping) -> Tuple
             parameter = value_to_compare[1]
         except IndexError as error:
             raise f"Evaluating parameter must be defined as dict at index 1. You have: {value_to_compare}" from error
+        if not isinstance(parameter, dict):
+            raise TypeError("check_option must be of type dict()")
+
         diff = parameter_evaluator(reference_value, parameter)
         return diff, not diff
 
 
+class RegexType(CheckType):
+    """Regex Match class implementation."""
+
+    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)]):
+            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:
+            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"]:
+            raise ValueError(
+                "Regex check-type requires check-option. Example: dict(regex='.*UNDERLAY.*', mode='no-match')."
+            )
+
+        diff = regex_evaluator(reference_value, parameter)
+        return diff, not diff
+
+
 # TODO: compare is no longer the entry point, we should use the libary as:
 #   netcompare_check = CheckType.init(check_type_info, options)
 #   pre_result = netcompare_check.get_value(pre_obj, path)

netcompare/evaluator.py

@@ -131,3 +131,28 @@ def parameter_evaluator(values: Mapping, parameter: Mapping) -> Dict:
             result[inner_key] = temp_dict
 
     return result
+
+
+def regex_evaluator(values: Mapping, parameter: Mapping) -> 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():
+                match_result = re.search(regex_expression, value)
+                # Fail if there is not regex match
+                if mode == "match" and not match_result:
+                    result.update(item)
+                # Fail if there is regex match
+                elif mode == "no-match" and match_result:
+                    result.update(item)
+
+    return result

tests/test_type_check.py

@@ -228,3 +228,48 @@ def test_param_match(filename, check_args, path, expected_result):
     assert actual_results == expected_result, ASSERT_FAIL_MESSAGE.format(
         output=actual_results, expected_output=expected_result
     )
+
+
+regex_match_include = (
+    "pre.json",
+    ("regex", {"regex": ".*UNDERLAY.*", "mode": "match"}),
+    "result[0].vrfs.default.peerList[*].[$peerAddress$,peerGroup]",
+    (
+        {
+            "7.7.7.7": {"peerGroup": "EVPN-OVERLAY-SPINE"},
+        },
+        False,
+    ),
+)
+
+regex_match_exclude = (
+    "pre.json",
+    ("regex", {"regex": ".*UNDERLAY.*", "mode": "no-match"}),
+    "result[0].vrfs.default.peerList[*].[$peerAddress$,peerGroup]",
+    (
+        {
+            "10.1.0.0": {"peerGroup": "IPv4-UNDERLAY-SPINE"},
+            "10.2.0.0": {"peerGroup": "IPv4-UNDERLAY-SPINE"},
+            "10.64.207.255": {"peerGroup": "IPv4-UNDERLAY-MLAG-PEER"},
+        },
+        False,
+    ),
+)
+
+regex_match = [
+    regex_match_include,
+    regex_match_exclude,
+]
+
+
+@pytest.mark.parametrize("filename, check_args, path, expected_result", regex_match)
+def test_regex_match(filename, check_args, path, expected_result):
+    """Validate regex check type."""
+    check = CheckType.init(*check_args)
+    # 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)
+    assert actual_results == expected_result, ASSERT_FAIL_MESSAGE.format(
+        output=actual_results, expected_output=expected_result
+    )