Merge pull request #1 from networktocode-llc/library-api

API entry point refactor proposal

Author: lvrfrc87

netcompare/check_type.py

@@ -1,6 +1,7 @@
 """CheckType Implementation."""
-from typing import Mapping, Iterable, Tuple
+from typing import Mapping, Iterable, Tuple, Union, List
 from .evaluator import diff_generator
+from .runner import extract_values_from_output
 
 
 class CheckType:
@@ -21,24 +22,28 @@ def init(*args):
         else:
             raise NotImplementedError
 
-    def evaluate(self, pre_value: Mapping, post_value: Mapping, path: Mapping) -> Tuple[Mapping, bool]:
-        """Return a diff of the comparison and a boolean True if it passes or False otherwise."""
-        self.diff = diff_generator(pre_value, post_value, path)
-        # self.diff may get modified by a child class when self.check_logic is called.
-        logic_check = self.check_logic()
-        return (self.diff, logic_check)
+    @staticmethod
+    def extract_value_from_json_path(
+        value: Mapping, path: Mapping, exclude: List = list()
+    ) -> Union[Mapping, List, int, str, bool]:
+        """Return the value contained into a Mapping for a defined path."""
+        return extract_values_from_output(value, path, exclude)
+
+    def evaluate(self, reference_value: Mapping, value_to_compare: Mapping) -> Tuple[Mapping, bool]:
+        """Return the result of the evaluation and a boolean True if it passes it or False otherwise.
 
-    def check_logic(self) -> bool:
-        """docstring placeholder."""
+        This method is the one that each CheckType has to implement.
+        """
         raise NotImplementedError
 
 
 class ExactMatchType(CheckType):
     """Exact Match class docstring."""
 
-    def check_logic(self) -> bool:
-        """Return True if diff is empty indicating an exact match."""
-        return not self.diff
+    def evaluate(self, reference_value: Mapping, value_to_compare: Mapping) -> Tuple[Mapping, bool]:
+        """Returns the difference between values and the boolean."""
+        diff = diff_generator(reference_value, value_to_compare)
+        return diff, not diff
 
 
 class ToleranceType(CheckType):
@@ -49,16 +54,17 @@ def __init__(self, *args):
         self.tolerance_factor = float(args[1]) / 100
         super().__init__()
 
-    def check_logic(self) -> bool:
-        """Return True if the changed values are within tolerance."""
-        self.diff = self._get_outliers()
-        return not self.diff
+    def evaluate(self, reference_value: Mapping, value_to_compare: Mapping) -> Tuple[Mapping, bool]:
+        """Returns the difference between values and the boolean."""
+        diff = diff_generator(reference_value, value_to_compare)
+        diff = self._get_outliers(diff)
+        return diff, not diff
 
-    def _get_outliers(self) -> Mapping:
+    def _get_outliers(self, diff: Mapping) -> Mapping:
         """Return a mapping of values outside the tolerance threshold."""
         result = {
             key: {sub_key: values for sub_key, values in obj.items() if not self._within_tolerance(**values)}
-            for key, obj in self.diff.items()
+            for key, obj in diff.items()
         }
         return {key: obj for key, obj in result.items() if obj}
 
@@ -68,20 +74,26 @@ def _within_tolerance(self, *, old_value: float, new_value: float) -> bool:
         return (old_value - max_diff) < new_value < (old_value + max_diff)
 
 
-def compare(
-    pre_obj: Mapping, post_obj: Mapping, path: Mapping, type_info: Iterable, options: Mapping
-) -> Tuple[Mapping, bool]:
-    """Entry point function.
+# 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.extract_value_from_json_path(pre_obj, path)
+#   post_result = netcompare_check.extract_value_from_json_path(post_obj, path)
+#   netcompare_check.evaluate(pre_result, post_result)
+#
+# def compare(
+#     pre_obj: Mapping, post_obj: Mapping, path: Mapping, type_info: Iterable, options: Mapping
+# ) -> Tuple[Mapping, bool]:
+#     """Entry point function.
 
-    Returns a diff object and the boolean of the comparison.
-    """
+#     Returns a diff object and the boolean of the comparison.
+#     """
 
-    type_info = type_info.lower()
+#     type_info = type_info.lower()
 
-    try:
-        type_obj = CheckType.init(type_info, options)
-    except Exception:
-        # We will be here if we can't infer the type_obj
-        raise
+#     try:
+#         type_obj = CheckType.init(type_info, options)
+#     except Exception:
+#         # We will be here if we can't infer the type_obj
+#         raise
 
-    return type_obj.evaluate(pre_obj, post_obj, path)
+#     return type_obj.evaluate(pre_obj, post_obj, path)

netcompare/runner.py

@@ -1,17 +1,15 @@
 #!/ur/bin/env python3
 import re
 import jmespath
-from typing import Mapping, List, Generator
+from typing import Mapping, List, Generator, Union
 
 
-def extract_values_from_output(check_definition: Mapping, output: Mapping) -> List:
+def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) -> Union[Mapping, List, int, str, bool]:
     """Return data from output depending on the check path. See unit text for complete example.
 
     Args:
-        check_definition: {
-            "path": "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]",
-        }
-        output: {
+        path: "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]",
+        value: {
             "jsonrpc": "2.0",
             "id": "EapiExplorer-1",
             "result": [
@@ -20,23 +18,26 @@ def extract_values_from_output(check_definition: Mapping, output: Mapping) -> Li
                     "default": {
                     "peerList": [
                         { ...
+        exclude: [...]
+
+    TODO: This function should be able to return a list, or a Dict, or a Integer, or a Boolean or a String
     Return:
         [{'7.7.7.7': {'prefixesReceived': 101}}, {'10.1.0.0': {'prefixesReceived': 120}}, ...
     """
 
-    if check_definition.get("path"):
-        found_values = jmespath.search(jmspath_value_parser(check_definition["path"]), output)
+    if path:
+        found_values = jmespath.search(jmspath_value_parser(path), value)
     else:
-        found_values = output
+        found_values = value
 
-    if "exclude" in check_definition:
-        my_value_exclude_cleaner(found_values, check_definition["exclude"])
+    if exclude:
+        my_value_exclude_cleaner(found_values, exclude)
         my_meaningful_values = found_values
     else:
-        my_meaningful_values = get_meaningful_values(check_definition, found_values)
+        my_meaningful_values = get_meaningful_values(path, found_values)
 
-    if check_definition.get("path") and re.search(r"\$.*\$", check_definition["path"]):
-        wanted_reference_keys = jmespath.search(jmspath_refkey_parser(check_definition["path"]), output)
+    if path and re.search(r"\$.*\$", path):
+        wanted_reference_keys = jmespath.search(jmspath_refkey_parser(path), value)
         list_of_reference_keys = keys_cleaner(wanted_reference_keys)
         return keys_values_zipper(list_of_reference_keys, my_meaningful_values)
     else:
@@ -89,13 +90,13 @@ def jmspath_refkey_parser(path):
     return ".".join(splitted_jmspath)
 
 
-def get_meaningful_values(check_definition, found_values):
-    if check_definition.get("path"):
+def get_meaningful_values(path, found_values):
+    if path:
         # check if list of lists
         if not any(isinstance(i, list) for i in found_values):
             raise TypeError(
                 "Catching value must be defined as list in jmespath expression i.e. result[*].state -> result[*].[state]. You have {}'.".format(
-                    check_definition["path"]
+                    path
                 )
             )
         for element in found_values:
@@ -110,7 +111,7 @@ def get_meaningful_values(check_definition, found_values):
                     found_values = flatten_list(found_values)
                     break
 
-        my_meaningful_values = associate_key_of_my_value(jmspath_value_parser(check_definition["path"]), found_values)
+        my_meaningful_values = associate_key_of_my_value(jmspath_value_parser(path), found_values)
     else:
         my_meaningful_values = found_values
     return my_meaningful_values