From d120639aec7e6a15df8a07c5b221cfe7540c6c06 Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Fri, 19 Nov 2021 14:02:35 +0100
Subject: [PATCH 01/26] move jmesparser under utils

---
 netcompare/runner.py                          | 148 ++++--------------
 netcompare/utils/jmspath/__init__.py          |   0
 netcompare/utils/jmspath/parsers.py           |  86 ++++++++++
 netcompare/utils/jmspath/tests/__init__.py    |   0
 .../utils/jmspath/tests/test_parsers.py       | 109 +++++++++++++
 tests/test_diff_generator.py                  |  18 +--
 6 files changed, 238 insertions(+), 123 deletions(-)
 create mode 100644 netcompare/utils/jmspath/__init__.py
 create mode 100644 netcompare/utils/jmspath/parsers.py
 create mode 100644 netcompare/utils/jmspath/tests/__init__.py
 create mode 100644 netcompare/utils/jmspath/tests/test_parsers.py

diff --git a/netcompare/runner.py b/netcompare/runner.py
index 089f2c6..c7ed341 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -2,7 +2,9 @@
 import re
 import jmespath
 from typing import Mapping, List, Generator, Union
+from .utils.jmspath.parsers import jmspath_value_parser, jmspath_refkey_parser, exclude_filter
 
+import pdb
 
 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.
@@ -18,142 +20,60 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
                     "default": {
                     "peerList": [
                         { ...
-        exclude: [...]
+        exclude: ["interfaceStatistics", "interfaceCounters"]
 
-    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}}, ...
     """
-
+    # Get the wanted values to be evaluated if jmspath expression is defined.
     if path:
-        found_values = jmespath.search(jmspath_value_parser(path), value)
+        wanted_value = jmespath.search(jmspath_value_parser(path), value)
+    # Take all the entir output if jmespath is not defined in check. This cover the "raw" diff type.
     else:
-        found_values = value
+        wanted_value = value
 
+    # Exclude filter implementation.
     if exclude:
-        my_value_exclude_cleaner(found_values, exclude)
-        my_meaningful_values = found_values
-    else:
-        my_meaningful_values = get_meaningful_values(path, found_values)
+        # Update list in place but assign to a new var for name consistency.
+        exclude_filter(wanted_value, exclude)
+        filtered_value = wanted_value
+
+    pdb.set_trace()
+    filtered_value = get_meaningful_values(path, wanted_value)
 
     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)
+        return keys_values_zipper(list_of_reference_keys, filtered_value)
     else:
-        return my_meaningful_values
-
-
-def jmspath_value_parser(path):
-    """
-    Get the JMSPath  value path from 'path'.
-
-    Args:
-        path: "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]"
-    Return:
-        "result[0].vrfs.default.peerList[*].[prefixesReceived]"
-    """
-    regex_match_value = re.search(r"\$.*\$\.|\$.*\$,|,\$.*\$", path)
-
-    if regex_match_value:
-        # $peers$. --> peers
-        regex_normalized_value = re.search(r"\$.*\$", regex_match_value.group())
-        if regex_normalized_value:
-            normalized_value = regex_match_value.group().split("$")[1]
-        value_path = path.replace(regex_normalized_value.group(), normalized_value)
-    else:
-        value_path = path
-
-    return value_path
-
-
-def jmspath_refkey_parser(path):
-    """
-    Get the JMSPath reference key path from 'path'.
-
-    Args:
-        path: "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]"
-    Return:
-        "result[0].vrfs.default.peerList[*].[$peerAddress$]"
-    """
-    splitted_jmspath = path.split(".")
-
-    for n, i in enumerate(splitted_jmspath):
-        regex_match_anchor = re.search(r"\$.*\$", i)
-
-        if regex_match_anchor:
-            splitted_jmspath[n] = regex_match_anchor.group().replace("$", "")
+        return filtered_value
 
-        if regex_match_anchor and not i.startswith("[") and not i.endswith("]"):
-            splitted_jmspath = splitted_jmspath[: n + 1]
 
-    return ".".join(splitted_jmspath)
-
-
-def get_meaningful_values(path, found_values):
+def get_meaningful_values(path: Mapping, wanted_value):
     if path:
         # check if list of lists
-        if not any(isinstance(i, list) for i in found_values):
+        if not any(isinstance(i, list) for i in wanted_value):
             raise TypeError(
                 "Catching value must be defined as list in jmespath expression i.e. result[*].state -> result[*].[state]. You have {}'.".format(
                     path
                 )
             )
-        for element in found_values:
+        for element in wanted_value:
             for item in element:
                 if isinstance(item, dict):
                     raise TypeError(
                         'Must be list of lists i.e. [["Idle", 75759616], ["Idle", 75759620]]. You have {}\'.'.format(
-                            found_values
+                            wanted_value
                         )
                     )
                 elif isinstance(item, list):
-                    found_values = flatten_list(found_values)
+                    wanted_value = flatten_list(wanted_value)
                     break
 
-        my_meaningful_values = associate_key_of_my_value(jmspath_value_parser(path), found_values)
+        filtered_value = associate_key_of_my_value(jmspath_value_parser(path), wanted_value)
     else:
-        my_meaningful_values = found_values
-    return my_meaningful_values
-
-
-def my_value_exclude_cleaner(data: Mapping, exclude: List):
-    """
-    Recusively look through all dict keys and pop out the one defined in "exclude".
-
-    Update in place existing dictionary. Look into unit test for example.
-
-    Args:
-        data: {
-                "interfaces": {
-                "Management1": {
-                    "name": "Management1",
-                    "interfaceStatus": "connected",
-                    "autoNegotiate": "success",
-                    "interfaceStatistics": {
-                        "inBitsRate": 3403.4362520883615,
-                        "inPktsRate": 3.7424095978179257,
-                        "outBitsRate": 16249.69114419833,
-                        "updateInterval": 300,
-                        "outPktsRate": 2.1111866059750692
-                    },...
-        exclude: ["interfaceStatistics", "interfaceCounters"]
-    """
-    if isinstance(data, dict):
-        for exclude_element in exclude:
-            try:
-                data.pop(exclude_element)
-            except KeyError:
-                pass
-
-        for key in data:
-            if isinstance(data[key], dict) or isinstance(data[key], list):
-                my_value_exclude_cleaner(data[key], exclude)
-
-    elif isinstance(data, list):
-        for element in data:
-            if isinstance(element, dict) or isinstance(element, list):
-                my_value_exclude_cleaner(element, exclude)
+        filtered_value = wanted_value
+    return filtered_value
 
 
 def flatten_list(my_list: List) -> List:
@@ -192,13 +112,13 @@ def is_flat_list(obj: List) -> bool:
     return isinstance(obj, list) and not any(isinstance(i, list) for i in obj)
 
 
-def associate_key_of_my_value(paths: Mapping, found_values: List) -> List:
+def associate_key_of_my_value(paths: Mapping, wanted_value: List) -> List:
     """
     Associate each key defined in path to every value found in output.
 
     Args:
         paths: {"path": "global.peers.*.[is_enabled,is_up]"}
-        found_values: [[True, False], [True, False], [True, False], [True, False]]
+        wanted_value: [[True, False], [True, False], [True, False], [True, False]]
 
     Return:
         [{'is_enabled': True, 'is_up': False}, ...
@@ -206,7 +126,7 @@ def associate_key_of_my_value(paths: Mapping, found_values: List) -> List:
     Example:
         >>> from runner import associate_key_of_my_value
         >>> path = {"path": "global.peers.*.[is_enabled,is_up]"}
-        >>> found_values = [[True, False], [True, False], [True, False], [True, False]]
+        >>> wanted_value = [[True, False], [True, False], [True, False], [True, False]]
         {'is_enabled': True, 'is_up': False}, {'is_enabled': True, 'is_up': False}, ...
     """
 
@@ -223,7 +143,7 @@ def associate_key_of_my_value(paths: Mapping, found_values: List) -> List:
 
     final_list = list()
 
-    for items in found_values:
+    for items in wanted_value:
         temp_dict = dict()
 
         if len(items) != len(my_key_value_list):
@@ -264,13 +184,13 @@ def keys_cleaner(wanted_reference_keys: Mapping) -> list:
         return my_keys_list
 
 
-def keys_values_zipper(list_of_reference_keys: List, found_values_with_key: List) -> List:
+def keys_values_zipper(list_of_reference_keys: List, wanted_value_with_key: List) -> List:
     """
     Build dictionary zipping keys with relative values.
 
     Args:
         list_of_reference_keys: ['10.1.0.0', '10.2.0.0', '10.64.207.255', '7.7.7.7']
-        found_values_with_key: [{'is_enabled': True, 'is_up': False}, ...
+        wanted_value_with_key: [{'is_enabled': True, 'is_up': False}, ...
 
     Return:
         [{'10.1.0.0': {'is_enabled': True, 'is_up': False}}, , ...
@@ -278,16 +198,16 @@ def keys_values_zipper(list_of_reference_keys: List, found_values_with_key: List
     Example:
         >>> from runner import keys_values_zipper
         >>> list_of_reference_keys = ['10.1.0.0']
-        >>> found_values_with_key = [{'is_enabled': True, 'is_up': False}]
-        >>> keys_values_zipper(list_of_reference_keys, found_values_with_key)
+        >>> wanted_value_with_key = [{'is_enabled': True, 'is_up': False}]
+        >>> keys_values_zipper(list_of_reference_keys, wanted_value_with_key)
         [{'10.1.0.0': {'is_enabled': True, 'is_up': False}}]
     """
     final_result = list()
 
-    if len(list_of_reference_keys) != len(found_values_with_key):
+    if len(list_of_reference_keys) != len(wanted_value_with_key):
         raise ValueError("Keys len != from Values len")
 
     for my_index, my_key in enumerate(list_of_reference_keys):
-        final_result.append({my_key: found_values_with_key[my_index]})
+        final_result.append({my_key: wanted_value_with_key[my_index]})
 
     return final_result
diff --git a/netcompare/utils/jmspath/__init__.py b/netcompare/utils/jmspath/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/jmspath/parsers.py b/netcompare/utils/jmspath/parsers.py
new file mode 100644
index 0000000..cd4a65b
--- /dev/null
+++ b/netcompare/utils/jmspath/parsers.py
@@ -0,0 +1,86 @@
+import re
+from typing import Mapping, List
+
+def jmspath_value_parser(path: Mapping):
+    """
+    Get the JMSPath  value path from 'path'.
+
+    Args:
+        path: "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]"
+    Return:
+        "result[0].vrfs.default.peerList[*].[prefixesReceived]"
+    """
+    regex_match_value = re.search(r"\$.*\$\.|\$.*\$,|,\$.*\$", path)
+
+    if regex_match_value:
+        # $peers$. --> peers
+        regex_normalized_value = re.search(r"\$.*\$", regex_match_value.group())
+        if regex_normalized_value:
+            normalized_value = regex_match_value.group().split("$")[1]
+        value_path = path.replace(regex_normalized_value.group(), normalized_value)
+    else:
+        value_path = path
+
+    return value_path
+
+
+def jmspath_refkey_parser(path: Mapping):
+    """
+    Get the JMSPath reference key path from 'path'.
+
+    Args:
+        path: "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]"
+    Return:
+        "result[0].vrfs.default.peerList[*].[$peerAddress$]"
+    """
+    splitted_jmspath = path.split(".")
+
+    for n, i in enumerate(splitted_jmspath):
+        regex_match_anchor = re.search(r"\$.*\$", i)
+
+        if regex_match_anchor:
+            splitted_jmspath[n] = regex_match_anchor.group().replace("$", "")
+
+        if regex_match_anchor and not i.startswith("[") and not i.endswith("]"):
+            splitted_jmspath = splitted_jmspath[: n + 1]
+
+    return ".".join(splitted_jmspath)
+
+
+def exclude_filter(data: Mapping, exclude: List):
+    """
+    Recusively look through all dict keys and pop out the one defined in "exclude".
+
+    Update in place existing dictionary. Look into unit test for example.
+
+    Args:
+        data: {
+                "interfaces": {
+                "Management1": {
+                    "name": "Management1",
+                    "interfaceStatus": "connected",
+                    "autoNegotiate": "success",
+                    "interfaceStatistics": {
+                        "inBitsRate": 3403.4362520883615,
+                        "inPktsRate": 3.7424095978179257,
+                        "outBitsRate": 16249.69114419833,
+                        "updateInterval": 300,
+                        "outPktsRate": 2.1111866059750692
+                    },...
+        exclude: ["interfaceStatistics", "interfaceCounters"]
+    """
+    if isinstance(data, dict):
+        for exclude_element in exclude:
+            try:
+                data.pop(exclude_element)
+            except KeyError:
+                pass
+
+        for key in data:
+            if isinstance(data[key], dict) or isinstance(data[key], list):
+                exclude_filter(data[key], exclude)
+
+    elif isinstance(data, list):
+        for element in data:
+            if isinstance(element, dict) or isinstance(element, list):
+                exclude_filter(element, exclude)
\ No newline at end of file
diff --git a/netcompare/utils/jmspath/tests/__init__.py b/netcompare/utils/jmspath/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/jmspath/tests/test_parsers.py b/netcompare/utils/jmspath/tests/test_parsers.py
new file mode 100644
index 0000000..da95bc0
--- /dev/null
+++ b/netcompare/utils/jmspath/tests/test_parsers.py
@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+
+import pytest
+import sys
+from ..parsers import jmspath_value_parser, jmspath_refkey_parser, exclude_filter
+sys.path.append("..")
+
+
+assertion_failed_message = """Test output is different from expected output.
+output: {output}
+expected output: {expected_output}
+"""
+
+value_parser_case_1 = (
+    "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]",
+    "result[0].vrfs.default.peerList[*].[peerAddress,prefixesReceived]",
+)
+value_parser_case_2 = (
+    "result[0].vrfs.default.peerList[*].[peerAddress,$prefixesReceived$]",
+    "result[0].vrfs.default.peerList[*].[peerAddress,prefixesReceived]",
+)
+value_parser_case_3 = (
+    "result[0].vrfs.default.peerList[*].[interfaceCounters,$peerAddress$,prefixesReceived]",
+    "result[0].vrfs.default.peerList[*].[interfaceCounters,peerAddress,prefixesReceived]",
+)
+value_parser_case_4 = (
+    "result[0].$vrfs$.default.peerList[*].[peerAddress,prefixesReceived]",
+    "result[0].vrfs.default.peerList[*].[peerAddress,prefixesReceived]",
+)
+
+keyref_parser_case_1 = (
+    "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]",
+    "result[0].vrfs.default.peerList[*].peerAddress",
+)
+keyref_parser_case_2 = (
+    "result[0].vrfs.default.peerList[*].[peerAddress,$prefixesReceived$]",
+    "result[0].vrfs.default.peerList[*].prefixesReceived",
+)
+keyref_parser_case_3 = (
+    "result[0].vrfs.default.peerList[*].[interfaceCounters,$peerAddress$,prefixesReceived]",
+    "result[0].vrfs.default.peerList[*].peerAddress",
+)
+keyref_parser_case_4 = (
+    "result[0].$vrfs$.default.peerList[*].[peerAddress,prefixesReceived]",
+    "result[0].vrfs",
+)
+
+exclude_filter_case_1 = (
+    ["interfaceStatistics"],
+    {
+        "interfaces": {
+        "Management1": {
+            "name": "Management1",
+            "interfaceStatus": "connected",
+            "autoNegotiate": "success",
+            "interfaceStatistics": {
+                "inBitsRate": 3403.4362520883615,
+                "inPktsRate": 3.7424095978179257,
+                "outBitsRate": 16249.69114419833,
+                "updateInterval": 300,
+                "outPktsRate": 2.1111866059750692
+                }
+            }
+        }
+    },
+    {
+        "interfaces": {
+        "Management1": {
+            "name": "Management1",
+            "interfaceStatus": "connected",
+            "autoNegotiate": "success"
+            }
+        }
+    }
+)
+
+value_parser_tests = [
+    value_parser_case_1,
+    value_parser_case_2,
+    value_parser_case_3,
+    value_parser_case_4,
+]
+
+keyref_parser_tests = [
+    keyref_parser_case_1,
+    keyref_parser_case_2,
+    keyref_parser_case_3,
+    keyref_parser_case_4,
+]
+
+exclude_filter_tests = [
+    exclude_filter_case_1,
+]
+
+
+@pytest.mark.parametrize("path, expected_output", value_parser_tests)
+def test_value_parser(path, expected_output):
+    output = jmspath_value_parser(path)
+    assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
+
+@pytest.mark.parametrize("path, expected_output", keyref_parser_tests)
+def test_keyref_parser(path, expected_output):
+    output = jmspath_refkey_parser(path)
+    assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
+
+@pytest.mark.parametrize("exclude, data, expected_output", exclude_filter_tests)
+def test_exclude_filter(exclude, data, expected_output):
+    exclude_filter(data, exclude)
+    assert expected_output == data, assertion_failed_message.format(output=data, expected_output=expected_output)
diff --git a/tests/test_diff_generator.py b/tests/test_diff_generator.py
index c13bb56..2e3ed1e 100644
--- a/tests/test_diff_generator.py
+++ b/tests/test_diff_generator.py
@@ -78,15 +78,15 @@
 
 eval_tests = [
     exact_match_of_global_peers_via_napalm_getter,
-    exact_match_of_bgpPeerCaps_via_api,
-    exact_match_of_bgp_neigh_via_textfsm,
-    raw_diff_of_interface_ma1_via_api_value_exclude,
-    raw_diff_of_interface_ma1_via_api_novalue_exclude,
-    raw_diff_of_interface_ma1_via_api_novalue_noexclude,
-    exact_match_missing_item,
-    exact_match_additional_item,
-    exact_match_changed_item,
-    exact_match_multi_nested_list,
+    # exact_match_of_bgpPeerCaps_via_api,
+    # exact_match_of_bgp_neigh_via_textfsm,
+    # raw_diff_of_interface_ma1_via_api_value_exclude,
+    # raw_diff_of_interface_ma1_via_api_novalue_exclude,
+    # raw_diff_of_interface_ma1_via_api_novalue_noexclude,
+    # exact_match_missing_item,
+    # exact_match_additional_item,
+    # exact_match_changed_item,
+    # exact_match_multi_nested_list,
 ]
 
 

From bc4d9e5d038a2bd920b15bac9b62eb1afcf19bd3 Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Fri, 19 Nov 2021 14:07:03 +0100
Subject: [PATCH 02/26] remove unused import

---
 netcompare/runner.py | 1 -
 tasks.py             | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/netcompare/runner.py b/netcompare/runner.py
index c7ed341..475e027 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -4,7 +4,6 @@
 from typing import Mapping, List, Generator, Union
 from .utils.jmspath.parsers import jmspath_value_parser, jmspath_refkey_parser, exclude_filter
 
-import pdb
 
 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.
diff --git a/tasks.py b/tasks.py
index e77216f..cf03298 100644
--- a/tasks.py
+++ b/tasks.py
@@ -160,9 +160,9 @@ def tests(context, local=INVOKE_LOCAL):
     """Run all tests for this repository."""
     black(context, local)
     flake8(context, local)
-    # pylint(context, local)
+    pylint(context, local)
     yamllint(context, local)
-    # pydocstyle(context, local)
+    pydocstyle(context, local)
     bandit(context, local)
     pytest(context, local)
 

From 7f6208013f6664d2907c2f067f896c6086ba150e Mon Sep 17 00:00:00 2001
From: Christian Adell <chadell@gmail.com>
Date: Fri, 19 Nov 2021 14:20:00 +0100
Subject: [PATCH 03/26] pending changes

---
 .travis.yml             |  8 ++++----
 netcompare/evaluator.py | 10 +++-------
 2 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index e5c077a..38e874c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,7 +4,7 @@ stages:
   - "lint"
   - "test"
 
-if: "type IN (pull_request)"  # Add in "branch" as an option if desired for branch testing as well
+if: "type IN (pull_request)" # Add in "branch" as an option if desired for branch testing as well
 language: "python"
 services:
   - "docker"
@@ -30,8 +30,8 @@ jobs:
         - "pip install invoke toml"
       script:
         - "invoke black"
-        - "invoke bandit"  # Bandit fails to function on > Py3.8 https://github.com/PyCQA/bandit/issues/639
-        - "invoke pydocstyle"
+        - "invoke bandit" # Bandit fails to function on > Py3.8 https://github.com/PyCQA/bandit/issues/639
+        # - "invoke pydocstyle"
         - "invoke flake8"
         - "invoke yamllint"
-        - "invoke pylint"
+        # - "invoke pylint"
diff --git a/netcompare/evaluator.py b/netcompare/evaluator.py
index 5f459f5..5023945 100644
--- a/netcompare/evaluator.py
+++ b/netcompare/evaluator.py
@@ -12,14 +12,13 @@
 sys.path.append(".")
 
 
-def diff_generator(pre_data: Mapping, post_data: Mapping, check_definition: Mapping) -> Mapping:
+def diff_generator(pre_result: Mapping, post_result: Mapping) -> Mapping:
     """
     Generates diff between pre and post data based on check definition.
 
     Args:
-        pre_data: pre data result.
-        post_data: post data result.
-        check_definition: check definitions.
+        pre_result: pre data result.
+        post_result: post data result.
 
     Return:
         output: diff between pre and post data.
@@ -32,9 +31,6 @@ def diff_generator(pre_data: Mapping, post_data: Mapping, check_definition: Mapp
         >>> print(diff_generator(check_definition, post_data, check_definition))
         {'10.17.254.2': {'state': {'new_value': 'Up', 'old_value': 'Idle'}}}
     """
-    pre_result = extract_values_from_output(check_definition, pre_data)
-    post_result = extract_values_from_output(check_definition, post_data)
-
     diff_result = DeepDiff(pre_result, post_result)
 
     result = diff_result.get("values_changed", {})

From 05f9bdb94290b98b94ba3d1deb28c7daaac3e9b6 Mon Sep 17 00:00:00 2001
From: Christian Adell <chadell@gmail.com>
Date: Fri, 19 Nov 2021 14:33:28 +0100
Subject: [PATCH 04/26] Fixed type_check test

---
 netcompare/__init__.py   |  4 +--
 netcompare/check_type.py |  2 +-
 netcompare/evaluator.py  |  1 -
 tests/test_type_check.py | 61 ++++++++++++----------------------------
 4 files changed, 21 insertions(+), 47 deletions(-)

diff --git a/netcompare/__init__.py b/netcompare/__init__.py
index 9358ec3..b64dae0 100644
--- a/netcompare/__init__.py
+++ b/netcompare/__init__.py
@@ -1,5 +1,5 @@
 """Pre/Post Check library."""
-from .check_type import compare
+# from .check_type import compare
 
 
-__all__ = ["compare"]
+# __all__ = ["compare"]
diff --git a/netcompare/check_type.py b/netcompare/check_type.py
index 1ba3f24..e48f7be 100644
--- a/netcompare/check_type.py
+++ b/netcompare/check_type.py
@@ -1,5 +1,5 @@
 """CheckType Implementation."""
-from typing import Mapping, Iterable, Tuple, Union, List
+from typing import Mapping, Tuple, Union, List
 from .evaluator import diff_generator
 from .runner import extract_values_from_output
 
diff --git a/netcompare/evaluator.py b/netcompare/evaluator.py
index 5023945..4f32822 100644
--- a/netcompare/evaluator.py
+++ b/netcompare/evaluator.py
@@ -7,7 +7,6 @@
 from functools import partial
 from typing import Mapping, List
 
-from .runner import extract_values_from_output
 
 sys.path.append(".")
 
diff --git a/tests/test_type_check.py b/tests/test_type_check.py
index 325b811..3f63857 100644
--- a/tests/test_type_check.py
+++ b/tests/test_type_check.py
@@ -21,29 +21,17 @@ def test_CheckType_raises_NotImplementedError_for_invalid_check_type():
         CheckType.init("does_not_exist")
 
 
-def test_CheckType_raises_NotImplementedError_when_calling_check_logic_method():
-    """Validate that CheckType raises a NotImplementedError when passed a non-existant check_type."""
-    with pytest.raises(NotImplementedError):
-        CheckType().check_logic()
-
-
 exact_match_test_values_no_change = (
     ("exact_match",),
     "api.json",
-    {
-        "path": "result[0].vrfs.default.peerList[*].[$peerAddress$,establishedTransitions]",
-        # "reference_key_path": "result[0].vrfs.default.peerList[*].peerAddress",
-    },
+    "result[0].vrfs.default.peerList[*].[$peerAddress$,establishedTransitions]",
     ({}, True),
 )
 
 exact_match_test_values_changed = (
     ("exact_match",),
     "api.json",
-    {
-        "path": "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesSent]",
-        # "reference_key_path": "result[0].vrfs.default.peerList[*].peerAddress",
-    },
+    "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesSent]",
     (
         {
             "10.1.0.0": {"prefixesSent": {"new_value": 52, "old_value": 50}},
@@ -56,30 +44,21 @@ def test_CheckType_raises_NotImplementedError_when_calling_check_logic_method():
 tolerance_test_values_no_change = (
     ("tolerance", 10),
     "api.json",
-    {
-        "path": "result[0].vrfs.default.peerList[*].[$peerAddress$,establishedTransitions]",
-        # "reference_key_path": "result[0].vrfs.default.peerList[*].peerAddress",
-    },
+    "result[0].vrfs.default.peerList[*].[$peerAddress$,establishedTransitions]",
     ({}, True),
 )
 
 tolerance_test_values_within_threshold = (
     ("tolerance", 10),
     "api.json",
-    {
-        "path": "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesSent]",
-        # "reference_key_path": "result[0].vrfs.default.peerList[*].peerAddress",
-    },
+    "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesSent]",
     ({}, True),
 )
 
 tolerance_test_values_beyond_threshold = (
     ("tolerance", 10),
     "api.json",
-    {
-        "path": "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]",
-        # "reference_key_path": "result[0].vrfs.default.peerList[*].peerAddress",
-    },
+    "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]",
     (
         {
             "10.1.0.0": {"prefixesReceived": {"new_value": 120, "old_value": 100}},
@@ -104,41 +83,34 @@ def test_check_type_results(check_type_args, filename, path, expected_results):
     check = CheckType.init(*check_type_args)
     pre_data = load_json_file("pre", filename)
     post_data = load_json_file("post", filename)
-    actual_results = check.evaluate(pre_data, post_data, path)
+    pre_value = check.extract_value_from_json_path(pre_data, path)
+    post_value = check.extract_value_from_json_path(post_data, path)
+    actual_results = check.evaluate(pre_value, post_value)
     assert actual_results == expected_results
 
 
 napalm_bgp_neighbor_status = (
     "napalm_get_bgp_neighbors.json",
     ("exact_match",),
-    {
-        "path": "global.$peers$.*.[is_enabled,is_up]",
-        # "reference_key_path": "global.peers"
-    },
+    "global.$peers$.*.[is_enabled,is_up]",
     0,
 )
 
 napalm_bgp_neighbor_prefixes_ipv4 = (
     "napalm_get_bgp_neighbors.json",
     ("tolerance", 10),
-    {
-        "path": "global.$peers$.*.*.ipv4.[accepted_prefixes,received_prefixes,sent_prefixes]",
-        # "reference_key_path": "global.peers",
-    },
+    "global.$peers$.*.*.ipv4.[accepted_prefixes,received_prefixes,sent_prefixes]",
     1,
 )
 
 napalm_bgp_neighbor_prefixes_ipv6 = (
     "napalm_get_bgp_neighbors.json",
     ("tolerance", 10),
-    {
-        "path": "global.$peers$.*.*.ipv6.[accepted_prefixes,received_prefixes,sent_prefixes]",
-        # "reference_key_path": "global.peers",
-    },
+    "global.$peers$.*.*.ipv6.[accepted_prefixes,received_prefixes,sent_prefixes]",
     2,
 )
 
-napalm_get_lldp_neighbors_exact_raw = ("napalm_get_lldp_neighbors.json", ("exact_match",), {}, 0)
+napalm_get_lldp_neighbors_exact_raw = ("napalm_get_lldp_neighbors.json", ("exact_match",), None, 0)
 
 check_tests = [
     napalm_bgp_neighbor_status,
@@ -151,10 +123,13 @@ def test_check_type_results(check_type_args, filename, path, expected_results):
 @pytest.mark.parametrize("filename, check_args, path, result_index", check_tests)
 def test_checks(filename, check_args, path, result_index):
     """Validate multiple checks on the same data to catch corner cases."""
+    check = CheckType.init(*check_args)
     pre_data = load_json_file("pre", filename)
     post_data = load_json_file("post", filename)
     result = load_json_file("results", filename)
 
-    check = CheckType.init(*check_args)
-    check_output = check.evaluate(pre_data, post_data, path)
-    assert list(check_output) == result[result_index]
+    pre_value = check.extract_value_from_json_path(pre_data, path)
+    post_value = check.extract_value_from_json_path(post_data, path)
+    actual_results = check.evaluate(pre_value, post_value)
+
+    assert list(actual_results) == result[result_index]

From 7aae0339f067d82279fc8a870b0495109ce293b6 Mon Sep 17 00:00:00 2001
From: Christian Adell <chadell@gmail.com>
Date: Fri, 19 Nov 2021 14:39:56 +0100
Subject: [PATCH 05/26] Fix tests

---
 tests/test_diff_generator.py | 65 +++++++++++-------------------------
 1 file changed, 20 insertions(+), 45 deletions(-)

diff --git a/tests/test_diff_generator.py b/tests/test_diff_generator.py
index c13bb56..21dddc2 100644
--- a/tests/test_diff_generator.py
+++ b/tests/test_diff_generator.py
@@ -4,6 +4,7 @@
 import sys
 from .utility import load_json_file
 from netcompare.evaluator import diff_generator
+from netcompare.runner import extract_values_from_output
 
 sys.path.append("..")
 
@@ -13,67 +14,40 @@
 expected output: {expected_output}
 """
 
-exact_match_of_global_peers_via_napalm_getter = (
-    "napalm_getter.json",
-    {
-        "check_type": "exact_match",
-        "path": "global.$peers$.*.[is_enabled,is_up]",
-        # "reference_key_path": "global.peers",
-    },
-)
+exact_match_of_global_peers_via_napalm_getter = ("napalm_getter.json", "global.$peers$.*.[is_enabled,is_up]", [])
 
 exact_match_of_bgpPeerCaps_via_api = (
     "api.json",
-    {
-        "check_type": "exact_match",
-        "path": "result[0].vrfs.default.peerList[*].[$peerAddress$,state,bgpPeerCaps]",
-        # "reference_key_path": "result[0].vrfs.default.peerList[*].peerAddress",
-    },
+    "result[0].vrfs.default.peerList[*].[$peerAddress$,state,bgpPeerCaps]",
+    [],
 )
 
-exact_match_of_bgp_neigh_via_textfsm = (
-    "textfsm.json",
-    {
-        "check_type": "exact_match",
-        "path": "result[*].[$bgp_neigh$,state]",
-        # "reference_key_path": "result[*].bgp_neigh"
-    },
-)
+exact_match_of_bgp_neigh_via_textfsm = ("textfsm.json", "result[*].[$bgp_neigh$,state]", [])
 
 raw_diff_of_interface_ma1_via_api_value_exclude = (
     "raw_value_exclude.json",
-    {"check_type": "exact_match", "path": "result[*]", "exclude": ["interfaceStatistics", "interfaceCounters"]},
+    "result[*]",
+    ["interfaceStatistics", "interfaceCounters"],
 )
 
 raw_diff_of_interface_ma1_via_api_novalue_exclude = (
     "raw_novalue_exclude.json",
-    {"check_type": "exact_match", "exclude": ["interfaceStatistics", "interfaceCounters"]},
+    None,
+    ["interfaceStatistics", "interfaceCounters"],
 )
 
-raw_diff_of_interface_ma1_via_api_novalue_noexclude = (
-    "raw_novalue_noexclude.json",
-    {"check_type": "exact_match"},
-)
+raw_diff_of_interface_ma1_via_api_novalue_noexclude = ("raw_novalue_noexclude.json", None, [])
 
-exact_match_missing_item = (
-    "napalm_getter_missing_peer.json",
-    {"check_type": "exact_match"},
-)
+exact_match_missing_item = ("napalm_getter_missing_peer.json", None, [])
 
-exact_match_additional_item = ("napalm_getter_additional_peer.json", {"check_type": "exact_match"})
+exact_match_additional_item = ("napalm_getter_additional_peer.json", None, [])
 
-exact_match_changed_item = (
-    "napalm_getter_changed_peer.json",
-    {"check_type": "exact_match"},
-)
+exact_match_changed_item = ("napalm_getter_changed_peer.json", None, [])
 
 exact_match_multi_nested_list = (
     "exact_match_nested.json",
-    {
-        "check_type": "exact_match",
-        "path": "global.$peers$.*.*.ipv4.[accepted_prefixes,received_prefixes]",
-        # "reference_key_path": "global.peers",
-    },
+    "global.$peers$.*.*.ipv4.[accepted_prefixes,received_prefixes]",
+    [],
 )
 
 eval_tests = [
@@ -90,13 +64,14 @@
 ]
 
 
-@pytest.mark.parametrize("filename, path", eval_tests)
-def test_eval(filename, path):
+@pytest.mark.parametrize("filename, path, exclude", eval_tests)
+def test_eval(filename, path, exclude):
 
     pre_data = load_json_file("pre", filename)
     post_data = load_json_file("post", filename)
     expected_output = load_json_file("results", filename)
-
-    output = diff_generator(pre_data, post_data, path)
+    pre_value = extract_values_from_output(pre_data, path, exclude)
+    post_value = extract_values_from_output(post_data, path, exclude)
+    output = diff_generator(pre_value, post_value)
 
     assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)

From e48ca3a7f17a5a1855efa85e1d9a9dfedbc2e53e Mon Sep 17 00:00:00 2001
From: Christian Adell <chadell@gmail.com>
Date: Fri, 19 Nov 2021 14:40:25 +0100
Subject: [PATCH 06/26] commnet

---
 netcompare/check_type.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/netcompare/check_type.py b/netcompare/check_type.py
index e48f7be..ee0e30e 100644
--- a/netcompare/check_type.py
+++ b/netcompare/check_type.py
@@ -29,6 +29,7 @@ def extract_value_from_json_path(
         """Return the value contained into a Mapping for a defined path."""
         return extract_values_from_output(value, path, exclude)
 
+    # TODO: Refine this typing
     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.
 

From 5049eba0fff4e52053d9635c069b1d7a318221ad Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Fri, 19 Nov 2021 15:10:05 +0100
Subject: [PATCH 07/26] move flatten funcs under utils

---
 netcompare/runner.py                          | 67 +-----------------
 netcompare/utils/data/__init__.py             |  0
 netcompare/utils/data/parsers.py              | 69 +++++++++++++++++++
 netcompare/utils/data/tests/__init__.py       |  0
 netcompare/utils/data/tests/test_parsers.py   | 51 ++++++++++++++
 netcompare/utils/jmspath/parsers.py           | 38 ----------
 .../utils/jmspath/tests/test_parsers.py       | 39 +----------
 netcompare/utils/list/__init__.py             |  0
 netcompare/utils/list/flatten.py              | 37 ++++++++++
 netcompare/utils/list/tests/__init__.py       |  0
 netcompare/utils/list/tests/test_flatten.py   | 27 ++++++++
 11 files changed, 188 insertions(+), 140 deletions(-)
 create mode 100644 netcompare/utils/data/__init__.py
 create mode 100644 netcompare/utils/data/parsers.py
 create mode 100644 netcompare/utils/data/tests/__init__.py
 create mode 100644 netcompare/utils/data/tests/test_parsers.py
 create mode 100644 netcompare/utils/list/__init__.py
 create mode 100644 netcompare/utils/list/flatten.py
 create mode 100644 netcompare/utils/list/tests/__init__.py
 create mode 100644 netcompare/utils/list/tests/test_flatten.py

diff --git a/netcompare/runner.py b/netcompare/runner.py
index 475e027..f68bf00 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -2,7 +2,8 @@
 import re
 import jmespath
 from typing import Mapping, List, Generator, Union
-from .utils.jmspath.parsers import jmspath_value_parser, jmspath_refkey_parser, exclude_filter
+from .utils.jmspath.parsers import jmspath_value_parser, jmspath_refkey_parser
+from .utils.data.parsers import  exclude_filter, get_values
 
 
 def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) -> Union[Mapping, List, int, str, bool]:
@@ -37,8 +38,7 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
         exclude_filter(wanted_value, exclude)
         filtered_value = wanted_value
 
-    pdb.set_trace()
-    filtered_value = get_meaningful_values(path, wanted_value)
+    filtered_value = get_values(path, wanted_value)
 
     if path and re.search(r"\$.*\$", path):
         wanted_reference_keys = jmespath.search(jmspath_refkey_parser(path), value)
@@ -48,67 +48,6 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
         return filtered_value
 
 
-def get_meaningful_values(path: Mapping, wanted_value):
-    if path:
-        # check if list of lists
-        if not any(isinstance(i, list) for i in wanted_value):
-            raise TypeError(
-                "Catching value must be defined as list in jmespath expression i.e. result[*].state -> result[*].[state]. You have {}'.".format(
-                    path
-                )
-            )
-        for element in wanted_value:
-            for item in element:
-                if isinstance(item, dict):
-                    raise TypeError(
-                        'Must be list of lists i.e. [["Idle", 75759616], ["Idle", 75759620]]. You have {}\'.'.format(
-                            wanted_value
-                        )
-                    )
-                elif isinstance(item, list):
-                    wanted_value = flatten_list(wanted_value)
-                    break
-
-        filtered_value = associate_key_of_my_value(jmspath_value_parser(path), wanted_value)
-    else:
-        filtered_value = wanted_value
-    return filtered_value
-
-
-def flatten_list(my_list: List) -> List:
-    """
-    Flatten a multi level nested list and returns a list of lists.
-
-    Args:
-        my_list: nested list to be flattened.
-
-    Return:
-        [[-1, 0], [-1, 0], [-1, 0], ...]
-
-    Example:
-        >>> my_list = [[[[-1, 0], [-1, 0]]]]
-        >>> flatten_list(my_list)
-        [[-1, 0], [-1, 0]]
-    """
-    if not isinstance(my_list, list):
-        raise ValueError(f"Argument provided must be a list. You passed a {type(my_list)}")
-    if is_flat_list(my_list):
-        return my_list
-    return list(iter_flatten_list(my_list))
-
-
-def iter_flatten_list(my_list: List) -> Generator[List, None, None]:
-    """Recursively yield all flat lists within a given list."""
-    if is_flat_list(my_list):
-        yield my_list
-    else:
-        for item in my_list:
-            yield from iter_flatten_list(item)
-
-
-def is_flat_list(obj: List) -> bool:
-    """Return True is obj is a list that does not contain any lists as its first order elements."""
-    return isinstance(obj, list) and not any(isinstance(i, list) for i in obj)
 
 
 def associate_key_of_my_value(paths: Mapping, wanted_value: List) -> List:
diff --git a/netcompare/utils/data/__init__.py b/netcompare/utils/data/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/data/parsers.py b/netcompare/utils/data/parsers.py
new file mode 100644
index 0000000..7f96512
--- /dev/null
+++ b/netcompare/utils/data/parsers.py
@@ -0,0 +1,69 @@
+from typing import Mapping, List
+from ..jmspath.parsers import jmspath_value_parser
+from ..list.flatten import flatten_list
+from ...runner import associate_key_of_my_value
+
+def exclude_filter(data: Mapping, exclude: List):
+    """
+    Recusively look through all dict keys and pop out the one defined in "exclude".
+
+    Update in place existing dictionary. Look into unit test for example.
+
+    Args:
+        data: {
+                "interfaces": {
+                "Management1": {
+                    "name": "Management1",
+                    "interfaceStatus": "connected",
+                    "autoNegotiate": "success",
+                    "interfaceStatistics": {
+                        "inBitsRate": 3403.4362520883615,
+                        "inPktsRate": 3.7424095978179257,
+                        "outBitsRate": 16249.69114419833,
+                        "updateInterval": 300,
+                        "outPktsRate": 2.1111866059750692
+                    },...
+        exclude: ["interfaceStatistics", "interfaceCounters"]
+    """
+    if isinstance(data, dict):
+        for exclude_element in exclude:
+            try:
+                data.pop(exclude_element)
+            except KeyError:
+                pass
+
+        for key in data:
+            if isinstance(data[key], dict) or isinstance(data[key], list):
+                exclude_filter(data[key], exclude)
+
+    elif isinstance(data, list):
+        for element in data:
+            if isinstance(element, dict) or isinstance(element, list):
+                exclude_filter(element, exclude)
+
+
+def get_values(path: Mapping, wanted_value):
+    if path:
+        # check if list of lists
+        if not any(isinstance(i, list) for i in wanted_value):
+            raise TypeError(
+                "Catching value must be defined as list in jmespath expression i.e. result[*].state -> result[*].[state]. You have {}'.".format(
+                    path
+                )
+            )
+        for element in wanted_value:
+            for item in element:
+                if isinstance(item, dict):
+                    raise TypeError(
+                        'Must be list of lists i.e. [["Idle", 75759616], ["Idle", 75759620]]. You have {}\'.'.format(
+                            wanted_value
+                        )
+                    )
+                elif isinstance(item, list):
+                    wanted_value = flatten_list(wanted_value)
+                    break
+
+        filtered_value = associate_key_of_my_value(jmspath_value_parser(path), wanted_value)
+    else:
+        filtered_value = wanted_value
+    return filtered_value
\ No newline at end of file
diff --git a/netcompare/utils/data/tests/__init__.py b/netcompare/utils/data/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/data/tests/test_parsers.py b/netcompare/utils/data/tests/test_parsers.py
new file mode 100644
index 0000000..63db196
--- /dev/null
+++ b/netcompare/utils/data/tests/test_parsers.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+
+import pytest
+import sys
+from ..parsers import exclude_filter
+sys.path.append("..")
+
+
+assertion_failed_message = """Test output is different from expected output.
+output: {output}
+expected output: {expected_output}
+"""
+
+exclude_filter_case_1 = (
+    ["interfaceStatistics"],
+    {
+        "interfaces": {
+        "Management1": {
+            "name": "Management1",
+            "interfaceStatus": "connected",
+            "autoNegotiate": "success",
+            "interfaceStatistics": {
+                "inBitsRate": 3403.4362520883615,
+                "inPktsRate": 3.7424095978179257,
+                "outBitsRate": 16249.69114419833,
+                "updateInterval": 300,
+                "outPktsRate": 2.1111866059750692
+                }
+            }
+        }
+    },
+    {
+        "interfaces": {
+        "Management1": {
+            "name": "Management1",
+            "interfaceStatus": "connected",
+            "autoNegotiate": "success"
+            }
+        }
+    }
+)
+
+exclude_filter_tests = [
+    exclude_filter_case_1,
+]
+
+
+@pytest.mark.parametrize("exclude, data, expected_output", exclude_filter_tests)
+def test_exclude_filter(exclude, data, expected_output):
+    exclude_filter(data, exclude)
+    assert expected_output == data, assertion_failed_message.format(output=data, expected_output=expected_output)
diff --git a/netcompare/utils/jmspath/parsers.py b/netcompare/utils/jmspath/parsers.py
index cd4a65b..d553a13 100644
--- a/netcompare/utils/jmspath/parsers.py
+++ b/netcompare/utils/jmspath/parsers.py
@@ -46,41 +46,3 @@ def jmspath_refkey_parser(path: Mapping):
 
     return ".".join(splitted_jmspath)
 
-
-def exclude_filter(data: Mapping, exclude: List):
-    """
-    Recusively look through all dict keys and pop out the one defined in "exclude".
-
-    Update in place existing dictionary. Look into unit test for example.
-
-    Args:
-        data: {
-                "interfaces": {
-                "Management1": {
-                    "name": "Management1",
-                    "interfaceStatus": "connected",
-                    "autoNegotiate": "success",
-                    "interfaceStatistics": {
-                        "inBitsRate": 3403.4362520883615,
-                        "inPktsRate": 3.7424095978179257,
-                        "outBitsRate": 16249.69114419833,
-                        "updateInterval": 300,
-                        "outPktsRate": 2.1111866059750692
-                    },...
-        exclude: ["interfaceStatistics", "interfaceCounters"]
-    """
-    if isinstance(data, dict):
-        for exclude_element in exclude:
-            try:
-                data.pop(exclude_element)
-            except KeyError:
-                pass
-
-        for key in data:
-            if isinstance(data[key], dict) or isinstance(data[key], list):
-                exclude_filter(data[key], exclude)
-
-    elif isinstance(data, list):
-        for element in data:
-            if isinstance(element, dict) or isinstance(element, list):
-                exclude_filter(element, exclude)
\ No newline at end of file
diff --git a/netcompare/utils/jmspath/tests/test_parsers.py b/netcompare/utils/jmspath/tests/test_parsers.py
index da95bc0..f73567f 100644
--- a/netcompare/utils/jmspath/tests/test_parsers.py
+++ b/netcompare/utils/jmspath/tests/test_parsers.py
@@ -2,7 +2,7 @@
 
 import pytest
 import sys
-from ..parsers import jmspath_value_parser, jmspath_refkey_parser, exclude_filter
+from ..parsers import jmspath_value_parser, jmspath_refkey_parser
 sys.path.append("..")
 
 
@@ -45,34 +45,6 @@
     "result[0].vrfs",
 )
 
-exclude_filter_case_1 = (
-    ["interfaceStatistics"],
-    {
-        "interfaces": {
-        "Management1": {
-            "name": "Management1",
-            "interfaceStatus": "connected",
-            "autoNegotiate": "success",
-            "interfaceStatistics": {
-                "inBitsRate": 3403.4362520883615,
-                "inPktsRate": 3.7424095978179257,
-                "outBitsRate": 16249.69114419833,
-                "updateInterval": 300,
-                "outPktsRate": 2.1111866059750692
-                }
-            }
-        }
-    },
-    {
-        "interfaces": {
-        "Management1": {
-            "name": "Management1",
-            "interfaceStatus": "connected",
-            "autoNegotiate": "success"
-            }
-        }
-    }
-)
 
 value_parser_tests = [
     value_parser_case_1,
@@ -88,10 +60,6 @@
     keyref_parser_case_4,
 ]
 
-exclude_filter_tests = [
-    exclude_filter_case_1,
-]
-
 
 @pytest.mark.parametrize("path, expected_output", value_parser_tests)
 def test_value_parser(path, expected_output):
@@ -102,8 +70,3 @@ def test_value_parser(path, expected_output):
 def test_keyref_parser(path, expected_output):
     output = jmspath_refkey_parser(path)
     assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
-
-@pytest.mark.parametrize("exclude, data, expected_output", exclude_filter_tests)
-def test_exclude_filter(exclude, data, expected_output):
-    exclude_filter(data, exclude)
-    assert expected_output == data, assertion_failed_message.format(output=data, expected_output=expected_output)
diff --git a/netcompare/utils/list/__init__.py b/netcompare/utils/list/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/list/flatten.py b/netcompare/utils/list/flatten.py
new file mode 100644
index 0000000..b4b7462
--- /dev/null
+++ b/netcompare/utils/list/flatten.py
@@ -0,0 +1,37 @@
+from typing import Mapping, List, Generator, Union
+
+def flatten_list(my_list: List) -> List:
+    """
+    Flatten a multi level nested list and returns a list of lists.
+
+    Args:
+        my_list: nested list to be flattened.
+
+    Return:
+        [[-1, 0], [-1, 0], [-1, 0], ...]
+
+    Example:
+        >>> my_list = [[[[-1, 0], [-1, 0]]]]
+        >>> flatten_list(my_list)
+        [[[[-1, 0], [-1, 0]]]]
+    """
+    def iter_flatten_list(my_list: List) -> Generator[List, None, None]:
+        """Recursively yield all flat lists within a given list."""
+        if is_flat_list(my_list):
+            yield my_list
+        else:
+            for item in my_list:
+                yield from iter_flatten_list(item)
+
+
+    def is_flat_list(obj: List) -> bool:
+        """Return True is obj is a list that does not contain any lists as its first order elements."""
+        return isinstance(obj, list) and not any(isinstance(i, list) for i in obj)
+
+    if not isinstance(my_list, list):
+        raise ValueError(f"Argument provided must be a list. You passed a {type(my_list)}")
+    if is_flat_list(my_list):
+        return my_list
+    return list(iter_flatten_list(my_list))
+
+
diff --git a/netcompare/utils/list/tests/__init__.py b/netcompare/utils/list/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/list/tests/test_flatten.py b/netcompare/utils/list/tests/test_flatten.py
new file mode 100644
index 0000000..6c13295
--- /dev/null
+++ b/netcompare/utils/list/tests/test_flatten.py
@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+
+import pytest
+import sys
+import pdb
+from ..flatten import flatten_list
+sys.path.append("..")
+
+
+assertion_failed_message = """Test output is different from expected output.
+output: {output}
+expected output: {expected_output}
+"""
+
+flatten_list_case_1 = (
+    [[[[-1, 0], [-1, 0]]]],
+    [[-1, 0], [-1, 0]],
+)
+
+flatten_list_tests = [
+    flatten_list_case_1,
+]
+
+@pytest.mark.parametrize("data, expected_output", flatten_list_tests)
+def test_value_parser(data, expected_output):
+    output = flatten_list(data)
+    assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)

From 5aed5c00c0ed04ed74fa41cafeb1558a2199a261 Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Fri, 19 Nov 2021 14:02:35 +0100
Subject: [PATCH 08/26] move jmesparser under utils

---
 netcompare/runner.py                          | 148 ++++--------------
 netcompare/utils/jmspath/__init__.py          |   0
 netcompare/utils/jmspath/parsers.py           |  86 ++++++++++
 netcompare/utils/jmspath/tests/__init__.py    |   0
 .../utils/jmspath/tests/test_parsers.py       | 109 +++++++++++++
 tests/test_diff_generator.py                  |  18 +--
 6 files changed, 238 insertions(+), 123 deletions(-)
 create mode 100644 netcompare/utils/jmspath/__init__.py
 create mode 100644 netcompare/utils/jmspath/parsers.py
 create mode 100644 netcompare/utils/jmspath/tests/__init__.py
 create mode 100644 netcompare/utils/jmspath/tests/test_parsers.py

diff --git a/netcompare/runner.py b/netcompare/runner.py
index 089f2c6..c7ed341 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -2,7 +2,9 @@
 import re
 import jmespath
 from typing import Mapping, List, Generator, Union
+from .utils.jmspath.parsers import jmspath_value_parser, jmspath_refkey_parser, exclude_filter
 
+import pdb
 
 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.
@@ -18,142 +20,60 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
                     "default": {
                     "peerList": [
                         { ...
-        exclude: [...]
+        exclude: ["interfaceStatistics", "interfaceCounters"]
 
-    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}}, ...
     """
-
+    # Get the wanted values to be evaluated if jmspath expression is defined.
     if path:
-        found_values = jmespath.search(jmspath_value_parser(path), value)
+        wanted_value = jmespath.search(jmspath_value_parser(path), value)
+    # Take all the entir output if jmespath is not defined in check. This cover the "raw" diff type.
     else:
-        found_values = value
+        wanted_value = value
 
+    # Exclude filter implementation.
     if exclude:
-        my_value_exclude_cleaner(found_values, exclude)
-        my_meaningful_values = found_values
-    else:
-        my_meaningful_values = get_meaningful_values(path, found_values)
+        # Update list in place but assign to a new var for name consistency.
+        exclude_filter(wanted_value, exclude)
+        filtered_value = wanted_value
+
+    pdb.set_trace()
+    filtered_value = get_meaningful_values(path, wanted_value)
 
     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)
+        return keys_values_zipper(list_of_reference_keys, filtered_value)
     else:
-        return my_meaningful_values
-
-
-def jmspath_value_parser(path):
-    """
-    Get the JMSPath  value path from 'path'.
-
-    Args:
-        path: "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]"
-    Return:
-        "result[0].vrfs.default.peerList[*].[prefixesReceived]"
-    """
-    regex_match_value = re.search(r"\$.*\$\.|\$.*\$,|,\$.*\$", path)
-
-    if regex_match_value:
-        # $peers$. --> peers
-        regex_normalized_value = re.search(r"\$.*\$", regex_match_value.group())
-        if regex_normalized_value:
-            normalized_value = regex_match_value.group().split("$")[1]
-        value_path = path.replace(regex_normalized_value.group(), normalized_value)
-    else:
-        value_path = path
-
-    return value_path
-
-
-def jmspath_refkey_parser(path):
-    """
-    Get the JMSPath reference key path from 'path'.
-
-    Args:
-        path: "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]"
-    Return:
-        "result[0].vrfs.default.peerList[*].[$peerAddress$]"
-    """
-    splitted_jmspath = path.split(".")
-
-    for n, i in enumerate(splitted_jmspath):
-        regex_match_anchor = re.search(r"\$.*\$", i)
-
-        if regex_match_anchor:
-            splitted_jmspath[n] = regex_match_anchor.group().replace("$", "")
+        return filtered_value
 
-        if regex_match_anchor and not i.startswith("[") and not i.endswith("]"):
-            splitted_jmspath = splitted_jmspath[: n + 1]
 
-    return ".".join(splitted_jmspath)
-
-
-def get_meaningful_values(path, found_values):
+def get_meaningful_values(path: Mapping, wanted_value):
     if path:
         # check if list of lists
-        if not any(isinstance(i, list) for i in found_values):
+        if not any(isinstance(i, list) for i in wanted_value):
             raise TypeError(
                 "Catching value must be defined as list in jmespath expression i.e. result[*].state -> result[*].[state]. You have {}'.".format(
                     path
                 )
             )
-        for element in found_values:
+        for element in wanted_value:
             for item in element:
                 if isinstance(item, dict):
                     raise TypeError(
                         'Must be list of lists i.e. [["Idle", 75759616], ["Idle", 75759620]]. You have {}\'.'.format(
-                            found_values
+                            wanted_value
                         )
                     )
                 elif isinstance(item, list):
-                    found_values = flatten_list(found_values)
+                    wanted_value = flatten_list(wanted_value)
                     break
 
-        my_meaningful_values = associate_key_of_my_value(jmspath_value_parser(path), found_values)
+        filtered_value = associate_key_of_my_value(jmspath_value_parser(path), wanted_value)
     else:
-        my_meaningful_values = found_values
-    return my_meaningful_values
-
-
-def my_value_exclude_cleaner(data: Mapping, exclude: List):
-    """
-    Recusively look through all dict keys and pop out the one defined in "exclude".
-
-    Update in place existing dictionary. Look into unit test for example.
-
-    Args:
-        data: {
-                "interfaces": {
-                "Management1": {
-                    "name": "Management1",
-                    "interfaceStatus": "connected",
-                    "autoNegotiate": "success",
-                    "interfaceStatistics": {
-                        "inBitsRate": 3403.4362520883615,
-                        "inPktsRate": 3.7424095978179257,
-                        "outBitsRate": 16249.69114419833,
-                        "updateInterval": 300,
-                        "outPktsRate": 2.1111866059750692
-                    },...
-        exclude: ["interfaceStatistics", "interfaceCounters"]
-    """
-    if isinstance(data, dict):
-        for exclude_element in exclude:
-            try:
-                data.pop(exclude_element)
-            except KeyError:
-                pass
-
-        for key in data:
-            if isinstance(data[key], dict) or isinstance(data[key], list):
-                my_value_exclude_cleaner(data[key], exclude)
-
-    elif isinstance(data, list):
-        for element in data:
-            if isinstance(element, dict) or isinstance(element, list):
-                my_value_exclude_cleaner(element, exclude)
+        filtered_value = wanted_value
+    return filtered_value
 
 
 def flatten_list(my_list: List) -> List:
@@ -192,13 +112,13 @@ def is_flat_list(obj: List) -> bool:
     return isinstance(obj, list) and not any(isinstance(i, list) for i in obj)
 
 
-def associate_key_of_my_value(paths: Mapping, found_values: List) -> List:
+def associate_key_of_my_value(paths: Mapping, wanted_value: List) -> List:
     """
     Associate each key defined in path to every value found in output.
 
     Args:
         paths: {"path": "global.peers.*.[is_enabled,is_up]"}
-        found_values: [[True, False], [True, False], [True, False], [True, False]]
+        wanted_value: [[True, False], [True, False], [True, False], [True, False]]
 
     Return:
         [{'is_enabled': True, 'is_up': False}, ...
@@ -206,7 +126,7 @@ def associate_key_of_my_value(paths: Mapping, found_values: List) -> List:
     Example:
         >>> from runner import associate_key_of_my_value
         >>> path = {"path": "global.peers.*.[is_enabled,is_up]"}
-        >>> found_values = [[True, False], [True, False], [True, False], [True, False]]
+        >>> wanted_value = [[True, False], [True, False], [True, False], [True, False]]
         {'is_enabled': True, 'is_up': False}, {'is_enabled': True, 'is_up': False}, ...
     """
 
@@ -223,7 +143,7 @@ def associate_key_of_my_value(paths: Mapping, found_values: List) -> List:
 
     final_list = list()
 
-    for items in found_values:
+    for items in wanted_value:
         temp_dict = dict()
 
         if len(items) != len(my_key_value_list):
@@ -264,13 +184,13 @@ def keys_cleaner(wanted_reference_keys: Mapping) -> list:
         return my_keys_list
 
 
-def keys_values_zipper(list_of_reference_keys: List, found_values_with_key: List) -> List:
+def keys_values_zipper(list_of_reference_keys: List, wanted_value_with_key: List) -> List:
     """
     Build dictionary zipping keys with relative values.
 
     Args:
         list_of_reference_keys: ['10.1.0.0', '10.2.0.0', '10.64.207.255', '7.7.7.7']
-        found_values_with_key: [{'is_enabled': True, 'is_up': False}, ...
+        wanted_value_with_key: [{'is_enabled': True, 'is_up': False}, ...
 
     Return:
         [{'10.1.0.0': {'is_enabled': True, 'is_up': False}}, , ...
@@ -278,16 +198,16 @@ def keys_values_zipper(list_of_reference_keys: List, found_values_with_key: List
     Example:
         >>> from runner import keys_values_zipper
         >>> list_of_reference_keys = ['10.1.0.0']
-        >>> found_values_with_key = [{'is_enabled': True, 'is_up': False}]
-        >>> keys_values_zipper(list_of_reference_keys, found_values_with_key)
+        >>> wanted_value_with_key = [{'is_enabled': True, 'is_up': False}]
+        >>> keys_values_zipper(list_of_reference_keys, wanted_value_with_key)
         [{'10.1.0.0': {'is_enabled': True, 'is_up': False}}]
     """
     final_result = list()
 
-    if len(list_of_reference_keys) != len(found_values_with_key):
+    if len(list_of_reference_keys) != len(wanted_value_with_key):
         raise ValueError("Keys len != from Values len")
 
     for my_index, my_key in enumerate(list_of_reference_keys):
-        final_result.append({my_key: found_values_with_key[my_index]})
+        final_result.append({my_key: wanted_value_with_key[my_index]})
 
     return final_result
diff --git a/netcompare/utils/jmspath/__init__.py b/netcompare/utils/jmspath/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/jmspath/parsers.py b/netcompare/utils/jmspath/parsers.py
new file mode 100644
index 0000000..cd4a65b
--- /dev/null
+++ b/netcompare/utils/jmspath/parsers.py
@@ -0,0 +1,86 @@
+import re
+from typing import Mapping, List
+
+def jmspath_value_parser(path: Mapping):
+    """
+    Get the JMSPath  value path from 'path'.
+
+    Args:
+        path: "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]"
+    Return:
+        "result[0].vrfs.default.peerList[*].[prefixesReceived]"
+    """
+    regex_match_value = re.search(r"\$.*\$\.|\$.*\$,|,\$.*\$", path)
+
+    if regex_match_value:
+        # $peers$. --> peers
+        regex_normalized_value = re.search(r"\$.*\$", regex_match_value.group())
+        if regex_normalized_value:
+            normalized_value = regex_match_value.group().split("$")[1]
+        value_path = path.replace(regex_normalized_value.group(), normalized_value)
+    else:
+        value_path = path
+
+    return value_path
+
+
+def jmspath_refkey_parser(path: Mapping):
+    """
+    Get the JMSPath reference key path from 'path'.
+
+    Args:
+        path: "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]"
+    Return:
+        "result[0].vrfs.default.peerList[*].[$peerAddress$]"
+    """
+    splitted_jmspath = path.split(".")
+
+    for n, i in enumerate(splitted_jmspath):
+        regex_match_anchor = re.search(r"\$.*\$", i)
+
+        if regex_match_anchor:
+            splitted_jmspath[n] = regex_match_anchor.group().replace("$", "")
+
+        if regex_match_anchor and not i.startswith("[") and not i.endswith("]"):
+            splitted_jmspath = splitted_jmspath[: n + 1]
+
+    return ".".join(splitted_jmspath)
+
+
+def exclude_filter(data: Mapping, exclude: List):
+    """
+    Recusively look through all dict keys and pop out the one defined in "exclude".
+
+    Update in place existing dictionary. Look into unit test for example.
+
+    Args:
+        data: {
+                "interfaces": {
+                "Management1": {
+                    "name": "Management1",
+                    "interfaceStatus": "connected",
+                    "autoNegotiate": "success",
+                    "interfaceStatistics": {
+                        "inBitsRate": 3403.4362520883615,
+                        "inPktsRate": 3.7424095978179257,
+                        "outBitsRate": 16249.69114419833,
+                        "updateInterval": 300,
+                        "outPktsRate": 2.1111866059750692
+                    },...
+        exclude: ["interfaceStatistics", "interfaceCounters"]
+    """
+    if isinstance(data, dict):
+        for exclude_element in exclude:
+            try:
+                data.pop(exclude_element)
+            except KeyError:
+                pass
+
+        for key in data:
+            if isinstance(data[key], dict) or isinstance(data[key], list):
+                exclude_filter(data[key], exclude)
+
+    elif isinstance(data, list):
+        for element in data:
+            if isinstance(element, dict) or isinstance(element, list):
+                exclude_filter(element, exclude)
\ No newline at end of file
diff --git a/netcompare/utils/jmspath/tests/__init__.py b/netcompare/utils/jmspath/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/jmspath/tests/test_parsers.py b/netcompare/utils/jmspath/tests/test_parsers.py
new file mode 100644
index 0000000..da95bc0
--- /dev/null
+++ b/netcompare/utils/jmspath/tests/test_parsers.py
@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+
+import pytest
+import sys
+from ..parsers import jmspath_value_parser, jmspath_refkey_parser, exclude_filter
+sys.path.append("..")
+
+
+assertion_failed_message = """Test output is different from expected output.
+output: {output}
+expected output: {expected_output}
+"""
+
+value_parser_case_1 = (
+    "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]",
+    "result[0].vrfs.default.peerList[*].[peerAddress,prefixesReceived]",
+)
+value_parser_case_2 = (
+    "result[0].vrfs.default.peerList[*].[peerAddress,$prefixesReceived$]",
+    "result[0].vrfs.default.peerList[*].[peerAddress,prefixesReceived]",
+)
+value_parser_case_3 = (
+    "result[0].vrfs.default.peerList[*].[interfaceCounters,$peerAddress$,prefixesReceived]",
+    "result[0].vrfs.default.peerList[*].[interfaceCounters,peerAddress,prefixesReceived]",
+)
+value_parser_case_4 = (
+    "result[0].$vrfs$.default.peerList[*].[peerAddress,prefixesReceived]",
+    "result[0].vrfs.default.peerList[*].[peerAddress,prefixesReceived]",
+)
+
+keyref_parser_case_1 = (
+    "result[0].vrfs.default.peerList[*].[$peerAddress$,prefixesReceived]",
+    "result[0].vrfs.default.peerList[*].peerAddress",
+)
+keyref_parser_case_2 = (
+    "result[0].vrfs.default.peerList[*].[peerAddress,$prefixesReceived$]",
+    "result[0].vrfs.default.peerList[*].prefixesReceived",
+)
+keyref_parser_case_3 = (
+    "result[0].vrfs.default.peerList[*].[interfaceCounters,$peerAddress$,prefixesReceived]",
+    "result[0].vrfs.default.peerList[*].peerAddress",
+)
+keyref_parser_case_4 = (
+    "result[0].$vrfs$.default.peerList[*].[peerAddress,prefixesReceived]",
+    "result[0].vrfs",
+)
+
+exclude_filter_case_1 = (
+    ["interfaceStatistics"],
+    {
+        "interfaces": {
+        "Management1": {
+            "name": "Management1",
+            "interfaceStatus": "connected",
+            "autoNegotiate": "success",
+            "interfaceStatistics": {
+                "inBitsRate": 3403.4362520883615,
+                "inPktsRate": 3.7424095978179257,
+                "outBitsRate": 16249.69114419833,
+                "updateInterval": 300,
+                "outPktsRate": 2.1111866059750692
+                }
+            }
+        }
+    },
+    {
+        "interfaces": {
+        "Management1": {
+            "name": "Management1",
+            "interfaceStatus": "connected",
+            "autoNegotiate": "success"
+            }
+        }
+    }
+)
+
+value_parser_tests = [
+    value_parser_case_1,
+    value_parser_case_2,
+    value_parser_case_3,
+    value_parser_case_4,
+]
+
+keyref_parser_tests = [
+    keyref_parser_case_1,
+    keyref_parser_case_2,
+    keyref_parser_case_3,
+    keyref_parser_case_4,
+]
+
+exclude_filter_tests = [
+    exclude_filter_case_1,
+]
+
+
+@pytest.mark.parametrize("path, expected_output", value_parser_tests)
+def test_value_parser(path, expected_output):
+    output = jmspath_value_parser(path)
+    assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
+
+@pytest.mark.parametrize("path, expected_output", keyref_parser_tests)
+def test_keyref_parser(path, expected_output):
+    output = jmspath_refkey_parser(path)
+    assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
+
+@pytest.mark.parametrize("exclude, data, expected_output", exclude_filter_tests)
+def test_exclude_filter(exclude, data, expected_output):
+    exclude_filter(data, exclude)
+    assert expected_output == data, assertion_failed_message.format(output=data, expected_output=expected_output)
diff --git a/tests/test_diff_generator.py b/tests/test_diff_generator.py
index 21dddc2..f8b3d35 100644
--- a/tests/test_diff_generator.py
+++ b/tests/test_diff_generator.py
@@ -52,15 +52,15 @@
 
 eval_tests = [
     exact_match_of_global_peers_via_napalm_getter,
-    exact_match_of_bgpPeerCaps_via_api,
-    exact_match_of_bgp_neigh_via_textfsm,
-    raw_diff_of_interface_ma1_via_api_value_exclude,
-    raw_diff_of_interface_ma1_via_api_novalue_exclude,
-    raw_diff_of_interface_ma1_via_api_novalue_noexclude,
-    exact_match_missing_item,
-    exact_match_additional_item,
-    exact_match_changed_item,
-    exact_match_multi_nested_list,
+    # exact_match_of_bgpPeerCaps_via_api,
+    # exact_match_of_bgp_neigh_via_textfsm,
+    # raw_diff_of_interface_ma1_via_api_value_exclude,
+    # raw_diff_of_interface_ma1_via_api_novalue_exclude,
+    # raw_diff_of_interface_ma1_via_api_novalue_noexclude,
+    # exact_match_missing_item,
+    # exact_match_additional_item,
+    # exact_match_changed_item,
+    # exact_match_multi_nested_list,
 ]
 
 

From 2c46df4c4817a63163d8180b96fb3a2d3c5cda1a Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Fri, 19 Nov 2021 14:07:03 +0100
Subject: [PATCH 09/26] remove unused import

---
 netcompare/runner.py | 1 -
 tasks.py             | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/netcompare/runner.py b/netcompare/runner.py
index c7ed341..475e027 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -4,7 +4,6 @@
 from typing import Mapping, List, Generator, Union
 from .utils.jmspath.parsers import jmspath_value_parser, jmspath_refkey_parser, exclude_filter
 
-import pdb
 
 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.
diff --git a/tasks.py b/tasks.py
index e77216f..cf03298 100644
--- a/tasks.py
+++ b/tasks.py
@@ -160,9 +160,9 @@ def tests(context, local=INVOKE_LOCAL):
     """Run all tests for this repository."""
     black(context, local)
     flake8(context, local)
-    # pylint(context, local)
+    pylint(context, local)
     yamllint(context, local)
-    # pydocstyle(context, local)
+    pydocstyle(context, local)
     bandit(context, local)
     pytest(context, local)
 

From 49af479b442fb4ca036ef38fdcc49fe0e6431958 Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Fri, 19 Nov 2021 15:10:05 +0100
Subject: [PATCH 10/26] move flatten funcs under utils

---
 netcompare/runner.py                          | 67 +-----------------
 netcompare/utils/data/__init__.py             |  0
 netcompare/utils/data/parsers.py              | 69 +++++++++++++++++++
 netcompare/utils/data/tests/__init__.py       |  0
 netcompare/utils/data/tests/test_parsers.py   | 51 ++++++++++++++
 netcompare/utils/jmspath/parsers.py           | 38 ----------
 .../utils/jmspath/tests/test_parsers.py       | 39 +----------
 netcompare/utils/list/__init__.py             |  0
 netcompare/utils/list/flatten.py              | 37 ++++++++++
 netcompare/utils/list/tests/__init__.py       |  0
 netcompare/utils/list/tests/test_flatten.py   | 27 ++++++++
 11 files changed, 188 insertions(+), 140 deletions(-)
 create mode 100644 netcompare/utils/data/__init__.py
 create mode 100644 netcompare/utils/data/parsers.py
 create mode 100644 netcompare/utils/data/tests/__init__.py
 create mode 100644 netcompare/utils/data/tests/test_parsers.py
 create mode 100644 netcompare/utils/list/__init__.py
 create mode 100644 netcompare/utils/list/flatten.py
 create mode 100644 netcompare/utils/list/tests/__init__.py
 create mode 100644 netcompare/utils/list/tests/test_flatten.py

diff --git a/netcompare/runner.py b/netcompare/runner.py
index 475e027..f68bf00 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -2,7 +2,8 @@
 import re
 import jmespath
 from typing import Mapping, List, Generator, Union
-from .utils.jmspath.parsers import jmspath_value_parser, jmspath_refkey_parser, exclude_filter
+from .utils.jmspath.parsers import jmspath_value_parser, jmspath_refkey_parser
+from .utils.data.parsers import  exclude_filter, get_values
 
 
 def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) -> Union[Mapping, List, int, str, bool]:
@@ -37,8 +38,7 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
         exclude_filter(wanted_value, exclude)
         filtered_value = wanted_value
 
-    pdb.set_trace()
-    filtered_value = get_meaningful_values(path, wanted_value)
+    filtered_value = get_values(path, wanted_value)
 
     if path and re.search(r"\$.*\$", path):
         wanted_reference_keys = jmespath.search(jmspath_refkey_parser(path), value)
@@ -48,67 +48,6 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
         return filtered_value
 
 
-def get_meaningful_values(path: Mapping, wanted_value):
-    if path:
-        # check if list of lists
-        if not any(isinstance(i, list) for i in wanted_value):
-            raise TypeError(
-                "Catching value must be defined as list in jmespath expression i.e. result[*].state -> result[*].[state]. You have {}'.".format(
-                    path
-                )
-            )
-        for element in wanted_value:
-            for item in element:
-                if isinstance(item, dict):
-                    raise TypeError(
-                        'Must be list of lists i.e. [["Idle", 75759616], ["Idle", 75759620]]. You have {}\'.'.format(
-                            wanted_value
-                        )
-                    )
-                elif isinstance(item, list):
-                    wanted_value = flatten_list(wanted_value)
-                    break
-
-        filtered_value = associate_key_of_my_value(jmspath_value_parser(path), wanted_value)
-    else:
-        filtered_value = wanted_value
-    return filtered_value
-
-
-def flatten_list(my_list: List) -> List:
-    """
-    Flatten a multi level nested list and returns a list of lists.
-
-    Args:
-        my_list: nested list to be flattened.
-
-    Return:
-        [[-1, 0], [-1, 0], [-1, 0], ...]
-
-    Example:
-        >>> my_list = [[[[-1, 0], [-1, 0]]]]
-        >>> flatten_list(my_list)
-        [[-1, 0], [-1, 0]]
-    """
-    if not isinstance(my_list, list):
-        raise ValueError(f"Argument provided must be a list. You passed a {type(my_list)}")
-    if is_flat_list(my_list):
-        return my_list
-    return list(iter_flatten_list(my_list))
-
-
-def iter_flatten_list(my_list: List) -> Generator[List, None, None]:
-    """Recursively yield all flat lists within a given list."""
-    if is_flat_list(my_list):
-        yield my_list
-    else:
-        for item in my_list:
-            yield from iter_flatten_list(item)
-
-
-def is_flat_list(obj: List) -> bool:
-    """Return True is obj is a list that does not contain any lists as its first order elements."""
-    return isinstance(obj, list) and not any(isinstance(i, list) for i in obj)
 
 
 def associate_key_of_my_value(paths: Mapping, wanted_value: List) -> List:
diff --git a/netcompare/utils/data/__init__.py b/netcompare/utils/data/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/data/parsers.py b/netcompare/utils/data/parsers.py
new file mode 100644
index 0000000..7f96512
--- /dev/null
+++ b/netcompare/utils/data/parsers.py
@@ -0,0 +1,69 @@
+from typing import Mapping, List
+from ..jmspath.parsers import jmspath_value_parser
+from ..list.flatten import flatten_list
+from ...runner import associate_key_of_my_value
+
+def exclude_filter(data: Mapping, exclude: List):
+    """
+    Recusively look through all dict keys and pop out the one defined in "exclude".
+
+    Update in place existing dictionary. Look into unit test for example.
+
+    Args:
+        data: {
+                "interfaces": {
+                "Management1": {
+                    "name": "Management1",
+                    "interfaceStatus": "connected",
+                    "autoNegotiate": "success",
+                    "interfaceStatistics": {
+                        "inBitsRate": 3403.4362520883615,
+                        "inPktsRate": 3.7424095978179257,
+                        "outBitsRate": 16249.69114419833,
+                        "updateInterval": 300,
+                        "outPktsRate": 2.1111866059750692
+                    },...
+        exclude: ["interfaceStatistics", "interfaceCounters"]
+    """
+    if isinstance(data, dict):
+        for exclude_element in exclude:
+            try:
+                data.pop(exclude_element)
+            except KeyError:
+                pass
+
+        for key in data:
+            if isinstance(data[key], dict) or isinstance(data[key], list):
+                exclude_filter(data[key], exclude)
+
+    elif isinstance(data, list):
+        for element in data:
+            if isinstance(element, dict) or isinstance(element, list):
+                exclude_filter(element, exclude)
+
+
+def get_values(path: Mapping, wanted_value):
+    if path:
+        # check if list of lists
+        if not any(isinstance(i, list) for i in wanted_value):
+            raise TypeError(
+                "Catching value must be defined as list in jmespath expression i.e. result[*].state -> result[*].[state]. You have {}'.".format(
+                    path
+                )
+            )
+        for element in wanted_value:
+            for item in element:
+                if isinstance(item, dict):
+                    raise TypeError(
+                        'Must be list of lists i.e. [["Idle", 75759616], ["Idle", 75759620]]. You have {}\'.'.format(
+                            wanted_value
+                        )
+                    )
+                elif isinstance(item, list):
+                    wanted_value = flatten_list(wanted_value)
+                    break
+
+        filtered_value = associate_key_of_my_value(jmspath_value_parser(path), wanted_value)
+    else:
+        filtered_value = wanted_value
+    return filtered_value
\ No newline at end of file
diff --git a/netcompare/utils/data/tests/__init__.py b/netcompare/utils/data/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/data/tests/test_parsers.py b/netcompare/utils/data/tests/test_parsers.py
new file mode 100644
index 0000000..63db196
--- /dev/null
+++ b/netcompare/utils/data/tests/test_parsers.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+
+import pytest
+import sys
+from ..parsers import exclude_filter
+sys.path.append("..")
+
+
+assertion_failed_message = """Test output is different from expected output.
+output: {output}
+expected output: {expected_output}
+"""
+
+exclude_filter_case_1 = (
+    ["interfaceStatistics"],
+    {
+        "interfaces": {
+        "Management1": {
+            "name": "Management1",
+            "interfaceStatus": "connected",
+            "autoNegotiate": "success",
+            "interfaceStatistics": {
+                "inBitsRate": 3403.4362520883615,
+                "inPktsRate": 3.7424095978179257,
+                "outBitsRate": 16249.69114419833,
+                "updateInterval": 300,
+                "outPktsRate": 2.1111866059750692
+                }
+            }
+        }
+    },
+    {
+        "interfaces": {
+        "Management1": {
+            "name": "Management1",
+            "interfaceStatus": "connected",
+            "autoNegotiate": "success"
+            }
+        }
+    }
+)
+
+exclude_filter_tests = [
+    exclude_filter_case_1,
+]
+
+
+@pytest.mark.parametrize("exclude, data, expected_output", exclude_filter_tests)
+def test_exclude_filter(exclude, data, expected_output):
+    exclude_filter(data, exclude)
+    assert expected_output == data, assertion_failed_message.format(output=data, expected_output=expected_output)
diff --git a/netcompare/utils/jmspath/parsers.py b/netcompare/utils/jmspath/parsers.py
index cd4a65b..d553a13 100644
--- a/netcompare/utils/jmspath/parsers.py
+++ b/netcompare/utils/jmspath/parsers.py
@@ -46,41 +46,3 @@ def jmspath_refkey_parser(path: Mapping):
 
     return ".".join(splitted_jmspath)
 
-
-def exclude_filter(data: Mapping, exclude: List):
-    """
-    Recusively look through all dict keys and pop out the one defined in "exclude".
-
-    Update in place existing dictionary. Look into unit test for example.
-
-    Args:
-        data: {
-                "interfaces": {
-                "Management1": {
-                    "name": "Management1",
-                    "interfaceStatus": "connected",
-                    "autoNegotiate": "success",
-                    "interfaceStatistics": {
-                        "inBitsRate": 3403.4362520883615,
-                        "inPktsRate": 3.7424095978179257,
-                        "outBitsRate": 16249.69114419833,
-                        "updateInterval": 300,
-                        "outPktsRate": 2.1111866059750692
-                    },...
-        exclude: ["interfaceStatistics", "interfaceCounters"]
-    """
-    if isinstance(data, dict):
-        for exclude_element in exclude:
-            try:
-                data.pop(exclude_element)
-            except KeyError:
-                pass
-
-        for key in data:
-            if isinstance(data[key], dict) or isinstance(data[key], list):
-                exclude_filter(data[key], exclude)
-
-    elif isinstance(data, list):
-        for element in data:
-            if isinstance(element, dict) or isinstance(element, list):
-                exclude_filter(element, exclude)
\ No newline at end of file
diff --git a/netcompare/utils/jmspath/tests/test_parsers.py b/netcompare/utils/jmspath/tests/test_parsers.py
index da95bc0..f73567f 100644
--- a/netcompare/utils/jmspath/tests/test_parsers.py
+++ b/netcompare/utils/jmspath/tests/test_parsers.py
@@ -2,7 +2,7 @@
 
 import pytest
 import sys
-from ..parsers import jmspath_value_parser, jmspath_refkey_parser, exclude_filter
+from ..parsers import jmspath_value_parser, jmspath_refkey_parser
 sys.path.append("..")
 
 
@@ -45,34 +45,6 @@
     "result[0].vrfs",
 )
 
-exclude_filter_case_1 = (
-    ["interfaceStatistics"],
-    {
-        "interfaces": {
-        "Management1": {
-            "name": "Management1",
-            "interfaceStatus": "connected",
-            "autoNegotiate": "success",
-            "interfaceStatistics": {
-                "inBitsRate": 3403.4362520883615,
-                "inPktsRate": 3.7424095978179257,
-                "outBitsRate": 16249.69114419833,
-                "updateInterval": 300,
-                "outPktsRate": 2.1111866059750692
-                }
-            }
-        }
-    },
-    {
-        "interfaces": {
-        "Management1": {
-            "name": "Management1",
-            "interfaceStatus": "connected",
-            "autoNegotiate": "success"
-            }
-        }
-    }
-)
 
 value_parser_tests = [
     value_parser_case_1,
@@ -88,10 +60,6 @@
     keyref_parser_case_4,
 ]
 
-exclude_filter_tests = [
-    exclude_filter_case_1,
-]
-
 
 @pytest.mark.parametrize("path, expected_output", value_parser_tests)
 def test_value_parser(path, expected_output):
@@ -102,8 +70,3 @@ def test_value_parser(path, expected_output):
 def test_keyref_parser(path, expected_output):
     output = jmspath_refkey_parser(path)
     assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
-
-@pytest.mark.parametrize("exclude, data, expected_output", exclude_filter_tests)
-def test_exclude_filter(exclude, data, expected_output):
-    exclude_filter(data, exclude)
-    assert expected_output == data, assertion_failed_message.format(output=data, expected_output=expected_output)
diff --git a/netcompare/utils/list/__init__.py b/netcompare/utils/list/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/list/flatten.py b/netcompare/utils/list/flatten.py
new file mode 100644
index 0000000..b4b7462
--- /dev/null
+++ b/netcompare/utils/list/flatten.py
@@ -0,0 +1,37 @@
+from typing import Mapping, List, Generator, Union
+
+def flatten_list(my_list: List) -> List:
+    """
+    Flatten a multi level nested list and returns a list of lists.
+
+    Args:
+        my_list: nested list to be flattened.
+
+    Return:
+        [[-1, 0], [-1, 0], [-1, 0], ...]
+
+    Example:
+        >>> my_list = [[[[-1, 0], [-1, 0]]]]
+        >>> flatten_list(my_list)
+        [[[[-1, 0], [-1, 0]]]]
+    """
+    def iter_flatten_list(my_list: List) -> Generator[List, None, None]:
+        """Recursively yield all flat lists within a given list."""
+        if is_flat_list(my_list):
+            yield my_list
+        else:
+            for item in my_list:
+                yield from iter_flatten_list(item)
+
+
+    def is_flat_list(obj: List) -> bool:
+        """Return True is obj is a list that does not contain any lists as its first order elements."""
+        return isinstance(obj, list) and not any(isinstance(i, list) for i in obj)
+
+    if not isinstance(my_list, list):
+        raise ValueError(f"Argument provided must be a list. You passed a {type(my_list)}")
+    if is_flat_list(my_list):
+        return my_list
+    return list(iter_flatten_list(my_list))
+
+
diff --git a/netcompare/utils/list/tests/__init__.py b/netcompare/utils/list/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/list/tests/test_flatten.py b/netcompare/utils/list/tests/test_flatten.py
new file mode 100644
index 0000000..6c13295
--- /dev/null
+++ b/netcompare/utils/list/tests/test_flatten.py
@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+
+import pytest
+import sys
+import pdb
+from ..flatten import flatten_list
+sys.path.append("..")
+
+
+assertion_failed_message = """Test output is different from expected output.
+output: {output}
+expected output: {expected_output}
+"""
+
+flatten_list_case_1 = (
+    [[[[-1, 0], [-1, 0]]]],
+    [[-1, 0], [-1, 0]],
+)
+
+flatten_list_tests = [
+    flatten_list_case_1,
+]
+
+@pytest.mark.parametrize("data, expected_output", flatten_list_tests)
+def test_value_parser(data, expected_output):
+    output = flatten_list(data)
+    assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)

From 5361ac970c4ef0b2ea3ee53625613cc112470da9 Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Fri, 19 Nov 2021 15:34:42 +0100
Subject: [PATCH 11/26] fix some style errors

---
 netcompare/evaluator.py                       |  2 +-
 netcompare/runner.py                          |  6 ++--
 netcompare/utils/data/parsers.py              |  3 +-
 netcompare/utils/data/tests/test_parsers.py   | 33 +++++++++----------
 netcompare/utils/jmspath/parsers.py           |  4 +--
 .../utils/jmspath/tests/test_parsers.py       |  2 ++
 netcompare/utils/list/flatten.py              |  7 ++--
 netcompare/utils/list/tests/test_flatten.py   |  3 +-
 8 files changed, 29 insertions(+), 31 deletions(-)

diff --git a/netcompare/evaluator.py b/netcompare/evaluator.py
index 4f32822..f4b47cd 100644
--- a/netcompare/evaluator.py
+++ b/netcompare/evaluator.py
@@ -1,11 +1,11 @@
 """Diff evaluator."""
 import re
 import sys
-from deepdiff import DeepDiff
 from collections import defaultdict
 from collections.abc import Mapping as DictMapping
 from functools import partial
 from typing import Mapping, List
+from deepdiff import DeepDiff
 
 
 sys.path.append(".")
diff --git a/netcompare/runner.py b/netcompare/runner.py
index f68bf00..b82aa74 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -1,9 +1,9 @@
 #!/ur/bin/env python3
 import re
 import jmespath
-from typing import Mapping, List, Generator, Union
+from typing import Mapping, List, Union
 from .utils.jmspath.parsers import jmspath_value_parser, jmspath_refkey_parser
-from .utils.data.parsers import  exclude_filter, get_values
+from .utils.data.parsers import exclude_filter, get_values
 
 
 def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) -> Union[Mapping, List, int, str, bool]:
@@ -48,8 +48,6 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
         return filtered_value
 
 
-
-
 def associate_key_of_my_value(paths: Mapping, wanted_value: List) -> List:
     """
     Associate each key defined in path to every value found in output.
diff --git a/netcompare/utils/data/parsers.py b/netcompare/utils/data/parsers.py
index 7f96512..bc2dd43 100644
--- a/netcompare/utils/data/parsers.py
+++ b/netcompare/utils/data/parsers.py
@@ -3,6 +3,7 @@
 from ..list.flatten import flatten_list
 from ...runner import associate_key_of_my_value
 
+
 def exclude_filter(data: Mapping, exclude: List):
     """
     Recusively look through all dict keys and pop out the one defined in "exclude".
@@ -66,4 +67,4 @@ def get_values(path: Mapping, wanted_value):
         filtered_value = associate_key_of_my_value(jmspath_value_parser(path), wanted_value)
     else:
         filtered_value = wanted_value
-    return filtered_value
\ No newline at end of file
+    return filtered_value
diff --git a/netcompare/utils/data/tests/test_parsers.py b/netcompare/utils/data/tests/test_parsers.py
index 63db196..cfba606 100644
--- a/netcompare/utils/data/tests/test_parsers.py
+++ b/netcompare/utils/data/tests/test_parsers.py
@@ -1,8 +1,9 @@
 #!/usr/bin/env python3
 
-import pytest
 import sys
+import pytest
 from ..parsers import exclude_filter
+
 sys.path.append("..")
 
 
@@ -15,29 +16,25 @@
     ["interfaceStatistics"],
     {
         "interfaces": {
-        "Management1": {
-            "name": "Management1",
-            "interfaceStatus": "connected",
-            "autoNegotiate": "success",
-            "interfaceStatistics": {
-                "inBitsRate": 3403.4362520883615,
-                "inPktsRate": 3.7424095978179257,
-                "outBitsRate": 16249.69114419833,
-                "updateInterval": 300,
-                "outPktsRate": 2.1111866059750692
-                }
+            "Management1": {
+                "name": "Management1",
+                "interfaceStatus": "connected",
+                "autoNegotiate": "success",
+                "interfaceStatistics": {
+                    "inBitsRate": 3403.4362520883615,
+                    "inPktsRate": 3.7424095978179257,
+                    "outBitsRate": 16249.69114419833,
+                    "updateInterval": 300,
+                    "outPktsRate": 2.1111866059750692,
+                },
             }
         }
     },
     {
         "interfaces": {
-        "Management1": {
-            "name": "Management1",
-            "interfaceStatus": "connected",
-            "autoNegotiate": "success"
-            }
+            "Management1": {"name": "Management1", "interfaceStatus": "connected", "autoNegotiate": "success"}
         }
-    }
+    },
 )
 
 exclude_filter_tests = [
diff --git a/netcompare/utils/jmspath/parsers.py b/netcompare/utils/jmspath/parsers.py
index d553a13..d26fb10 100644
--- a/netcompare/utils/jmspath/parsers.py
+++ b/netcompare/utils/jmspath/parsers.py
@@ -1,5 +1,6 @@
 import re
-from typing import Mapping, List
+from typing import Mapping
+
 
 def jmspath_value_parser(path: Mapping):
     """
@@ -45,4 +46,3 @@ def jmspath_refkey_parser(path: Mapping):
             splitted_jmspath = splitted_jmspath[: n + 1]
 
     return ".".join(splitted_jmspath)
-
diff --git a/netcompare/utils/jmspath/tests/test_parsers.py b/netcompare/utils/jmspath/tests/test_parsers.py
index f73567f..76acea6 100644
--- a/netcompare/utils/jmspath/tests/test_parsers.py
+++ b/netcompare/utils/jmspath/tests/test_parsers.py
@@ -3,6 +3,7 @@
 import pytest
 import sys
 from ..parsers import jmspath_value_parser, jmspath_refkey_parser
+
 sys.path.append("..")
 
 
@@ -66,6 +67,7 @@ def test_value_parser(path, expected_output):
     output = jmspath_value_parser(path)
     assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
 
+
 @pytest.mark.parametrize("path, expected_output", keyref_parser_tests)
 def test_keyref_parser(path, expected_output):
     output = jmspath_refkey_parser(path)
diff --git a/netcompare/utils/list/flatten.py b/netcompare/utils/list/flatten.py
index b4b7462..6baa6c3 100644
--- a/netcompare/utils/list/flatten.py
+++ b/netcompare/utils/list/flatten.py
@@ -1,4 +1,5 @@
-from typing import Mapping, List, Generator, Union
+from typing import List, Generator
+
 
 def flatten_list(my_list: List) -> List:
     """
@@ -15,6 +16,7 @@ def flatten_list(my_list: List) -> List:
         >>> flatten_list(my_list)
         [[[[-1, 0], [-1, 0]]]]
     """
+
     def iter_flatten_list(my_list: List) -> Generator[List, None, None]:
         """Recursively yield all flat lists within a given list."""
         if is_flat_list(my_list):
@@ -23,7 +25,6 @@ def iter_flatten_list(my_list: List) -> Generator[List, None, None]:
             for item in my_list:
                 yield from iter_flatten_list(item)
 
-
     def is_flat_list(obj: List) -> bool:
         """Return True is obj is a list that does not contain any lists as its first order elements."""
         return isinstance(obj, list) and not any(isinstance(i, list) for i in obj)
@@ -33,5 +34,3 @@ def is_flat_list(obj: List) -> bool:
     if is_flat_list(my_list):
         return my_list
     return list(iter_flatten_list(my_list))
-
-
diff --git a/netcompare/utils/list/tests/test_flatten.py b/netcompare/utils/list/tests/test_flatten.py
index 6c13295..2df491d 100644
--- a/netcompare/utils/list/tests/test_flatten.py
+++ b/netcompare/utils/list/tests/test_flatten.py
@@ -2,8 +2,8 @@
 
 import pytest
 import sys
-import pdb
 from ..flatten import flatten_list
+
 sys.path.append("..")
 
 
@@ -21,6 +21,7 @@
     flatten_list_case_1,
 ]
 
+
 @pytest.mark.parametrize("data, expected_output", flatten_list_tests)
 def test_value_parser(data, expected_output):
     output = flatten_list(data)

From a892d15597b792666755cac353b9dc771b3aaf8a Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Fri, 19 Nov 2021 15:34:51 +0100
Subject: [PATCH 12/26] update path in test task

---
 tasks.py | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/tasks.py b/tasks.py
index cf03298..dcc089d 100644
--- a/tasks.py
+++ b/tasks.py
@@ -107,44 +107,44 @@ def pytest(context, local=INVOKE_LOCAL):
 
 
 @task(help={"local": "Run locally or within the Docker container"})
-def black(context, local=INVOKE_LOCAL):
+def black(context, path=".", local=INVOKE_LOCAL):
     """Run black to check that Python files adherence to black standards."""
-    exec_cmd = "black --check --diff ."
+    exec_cmd = "black {path}".format(path=path)
     run_cmd(context, exec_cmd, local)
 
 
 @task(help={"local": "Run locally or within the Docker container"})
-def flake8(context, local=INVOKE_LOCAL):
+def flake8(context, path=".", local=INVOKE_LOCAL):
     """Run flake8 code analysis."""
-    exec_cmd = "flake8 ."
+    exec_cmd = "flake8 {path}".format(path=path)
     run_cmd(context, exec_cmd, local)
 
 
 @task(help={"local": "Run locally or within the Docker container"})
-def pylint(context, local=INVOKE_LOCAL):
+def pylint(context, path=".", local=INVOKE_LOCAL):
     """Run pylint code analysis."""
-    exec_cmd = 'find . -name "*.py" | xargs pylint'
+    exec_cmd = 'find {path} -name "*.py" | xargs pylint'.format(path=path)
     run_cmd(context, exec_cmd, local)
 
 
 @task(help={"local": "Run locally or within the Docker container"})
-def yamllint(context, local=INVOKE_LOCAL):
+def yamllint(context, path=".", local=INVOKE_LOCAL):
     """Run yamllint to validate formatting adheres to NTC defined YAML standards."""
-    exec_cmd = "yamllint ."
+    exec_cmd = "yamllint {path}".format(path=path)
     run_cmd(context, exec_cmd, local)
 
 
 @task(help={"local": "Run locally or within the Docker container"})
-def pydocstyle(context, local=INVOKE_LOCAL):
+def pydocstyle(context, path=".", local=INVOKE_LOCAL):
     """Run pydocstyle to validate docstring formatting adheres to NTC defined standards."""
-    exec_cmd = "pydocstyle ."
+    exec_cmd = "pydocstyle {path}".format(path=path)
     run_cmd(context, exec_cmd, local)
 
 
 @task(help={"local": "Run locally or within the Docker container"})
-def bandit(context, local=INVOKE_LOCAL):
+def bandit(context, path=".", local=INVOKE_LOCAL):
     """Run bandit to validate basic static code security analysis."""
-    exec_cmd = "bandit --recursive ./ --configfile .bandit.yml"
+    exec_cmd = "bandit --recursive ./{path} --configfile .bandit.yml".format(path=path)
     run_cmd(context, exec_cmd, local)
 
 
@@ -156,14 +156,14 @@ def cli(context):
 
 
 @task(help={"local": "Run locally or within the Docker container"})
-def tests(context, local=INVOKE_LOCAL):
+def tests(context, path=".", local=INVOKE_LOCAL):
     """Run all tests for this repository."""
-    black(context, local)
-    flake8(context, local)
-    pylint(context, local)
-    yamllint(context, local)
-    pydocstyle(context, local)
-    bandit(context, local)
-    pytest(context, local)
+    black(context, path, local)
+    flake8(context, path, local)
+    pylint(context, path, local)
+    yamllint(context, path, local)
+    pydocstyle(context, path, local)
+    bandit(context, path, local)
+    pytest(context, path, local)
 
     print("All tests have passed!")

From 1a481cef738742c556e1a2f11d7c3f42f2533f99 Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Fri, 19 Nov 2021 15:56:29 +0100
Subject: [PATCH 13/26] move key utils under utils

---
 netcompare/runner.py                      | 57 +---------------------
 netcompare/utils/refkey/__init__.py       |  0
 netcompare/utils/refkey/tests/__init__.py |  0
 netcompare/utils/refkey/utils.py          | 58 +++++++++++++++++++++++
 4 files changed, 59 insertions(+), 56 deletions(-)
 create mode 100644 netcompare/utils/refkey/__init__.py
 create mode 100644 netcompare/utils/refkey/tests/__init__.py
 create mode 100644 netcompare/utils/refkey/utils.py

diff --git a/netcompare/runner.py b/netcompare/runner.py
index b82aa74..aae061f 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -4,6 +4,7 @@
 from typing import Mapping, List, Union
 from .utils.jmspath.parsers import jmspath_value_parser, jmspath_refkey_parser
 from .utils.data.parsers import exclude_filter, get_values
+from .utils.refkey.utils import keys_cleaner, keys_values_zipper
 
 
 def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) -> Union[Mapping, List, int, str, bool]:
@@ -91,59 +92,3 @@ def associate_key_of_my_value(paths: Mapping, wanted_value: List) -> List:
 
     return final_list
 
-
-def keys_cleaner(wanted_reference_keys: Mapping) -> list:
-    """
-    Get every required reference key from output.
-
-    Args:
-        wanted_reference_keys: {'10.1.0.0': {'address_family': {'ipv4': ...
-
-    Return:
-        ['10.1.0.0', '10.2.0.0', '10.64.207.255', '7.7.7.7']
-
-    Example:
-        >>> from runner import keys_cleaner
-        >>> wanted_reference_keys = {'10.1.0.0': {'address_family': 'ipv4'}}
-        >>> keys_cleaner(wanted_reference_keys)
-        ['10.1.0.0', '10.2.0.0', '10.64.207.255', '7.7.7.7']
-    """
-    if isinstance(wanted_reference_keys, list):
-        return wanted_reference_keys
-
-    elif isinstance(wanted_reference_keys, dict):
-        my_keys_list = list()
-
-        for key in wanted_reference_keys.keys():
-            my_keys_list.append(key)
-
-        return my_keys_list
-
-
-def keys_values_zipper(list_of_reference_keys: List, wanted_value_with_key: List) -> List:
-    """
-    Build dictionary zipping keys with relative values.
-
-    Args:
-        list_of_reference_keys: ['10.1.0.0', '10.2.0.0', '10.64.207.255', '7.7.7.7']
-        wanted_value_with_key: [{'is_enabled': True, 'is_up': False}, ...
-
-    Return:
-        [{'10.1.0.0': {'is_enabled': True, 'is_up': False}}, , ...
-
-    Example:
-        >>> from runner import keys_values_zipper
-        >>> list_of_reference_keys = ['10.1.0.0']
-        >>> wanted_value_with_key = [{'is_enabled': True, 'is_up': False}]
-        >>> keys_values_zipper(list_of_reference_keys, wanted_value_with_key)
-        [{'10.1.0.0': {'is_enabled': True, 'is_up': False}}]
-    """
-    final_result = list()
-
-    if len(list_of_reference_keys) != len(wanted_value_with_key):
-        raise ValueError("Keys len != from Values len")
-
-    for my_index, my_key in enumerate(list_of_reference_keys):
-        final_result.append({my_key: wanted_value_with_key[my_index]})
-
-    return final_result
diff --git a/netcompare/utils/refkey/__init__.py b/netcompare/utils/refkey/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/refkey/tests/__init__.py b/netcompare/utils/refkey/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/netcompare/utils/refkey/utils.py b/netcompare/utils/refkey/utils.py
new file mode 100644
index 0000000..0e0cab2
--- /dev/null
+++ b/netcompare/utils/refkey/utils.py
@@ -0,0 +1,58 @@
+from typing import Mapping, List
+
+
+def keys_cleaner(wanted_reference_keys: Mapping) -> list:
+    """
+    Get every required reference key from output.
+
+    Args:
+        wanted_reference_keys: {'10.1.0.0': {'address_family': {'ipv4': ...
+
+    Return:
+        ['10.1.0.0', '10.2.0.0', '10.64.207.255', '7.7.7.7']
+
+    Example:
+        >>> from runner import keys_cleaner
+        >>> wanted_reference_keys = {'10.1.0.0': {'address_family': 'ipv4'}}
+        >>> keys_cleaner(wanted_reference_keys)
+        ['10.1.0.0', '10.2.0.0', '10.64.207.255', '7.7.7.7']
+    """
+    if isinstance(wanted_reference_keys, list):
+        return wanted_reference_keys
+
+    elif isinstance(wanted_reference_keys, dict):
+        my_keys_list = list()
+
+        for key in wanted_reference_keys.keys():
+            my_keys_list.append(key)
+
+        return my_keys_list
+
+
+def keys_values_zipper(list_of_reference_keys: List, wanted_value_with_key: List) -> List:
+    """
+    Build dictionary zipping keys with relative values.
+
+    Args:
+        list_of_reference_keys: ['10.1.0.0', '10.2.0.0', '10.64.207.255', '7.7.7.7']
+        wanted_value_with_key: [{'is_enabled': True, 'is_up': False}, ...
+
+    Return:
+        [{'10.1.0.0': {'is_enabled': True, 'is_up': False}}, , ...
+
+    Example:
+        >>> from runner import keys_values_zipper
+        >>> list_of_reference_keys = ['10.1.0.0']
+        >>> wanted_value_with_key = [{'is_enabled': True, 'is_up': False}]
+        >>> keys_values_zipper(list_of_reference_keys, wanted_value_with_key)
+        [{'10.1.0.0': {'is_enabled': True, 'is_up': False}}]
+    """
+    final_result = list()
+
+    if len(list_of_reference_keys) != len(wanted_value_with_key):
+        raise ValueError("Keys len != from Values len")
+
+    for my_index, my_key in enumerate(list_of_reference_keys):
+        final_result.append({my_key: wanted_value_with_key[my_index]})
+
+    return final_result
\ No newline at end of file

From 640641aa258755ef4b6ab46770bbc1a8da32e5dc Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Mon, 22 Nov 2021 15:13:00 +0100
Subject: [PATCH 14/26] add tests for lib utils

---
 netcompare/check_type.py                      |  3 ++
 netcompare/runner.py                          | 47 ++--------------
 netcompare/utils/{data => }/__init__.py       |  0
 netcompare/utils/data/tests/__init__.py       |  0
 .../{data/parsers.py => filter_parsers.py}    |  6 +--
 .../{list/flatten.py => flatten_utils.py}     |  0
 netcompare/utils/jmspath/__init__.py          |  0
 netcompare/utils/jmspath/tests/__init__.py    |  0
 .../parsers.py => jmspath_parsers.py}         |  0
 netcompare/utils/list/__init__.py             |  0
 netcompare/utils/list/tests/__init__.py       |  0
 netcompare/utils/refkey/__init__.py           |  0
 netcompare/utils/refkey/tests/__init__.py     |  0
 .../{refkey/utils.py => refkey_utils.py}      | 46 +++++++++++++++-
 tests/test_diff_generator.py                  | 23 ++++----
 .../test_filter_parsers.py                    |  4 +-
 .../list/tests => tests}/test_flatten.py      |  7 +--
 .../test_jmspath_parsers.py                   |  7 +--
 tests/test_refkey.py                          | 53 +++++++++++++++++++
 19 files changed, 119 insertions(+), 77 deletions(-)
 rename netcompare/utils/{data => }/__init__.py (100%)
 delete mode 100644 netcompare/utils/data/tests/__init__.py
 rename netcompare/utils/{data/parsers.py => filter_parsers.py} (94%)
 rename netcompare/utils/{list/flatten.py => flatten_utils.py} (100%)
 delete mode 100644 netcompare/utils/jmspath/__init__.py
 delete mode 100644 netcompare/utils/jmspath/tests/__init__.py
 rename netcompare/utils/{jmspath/parsers.py => jmspath_parsers.py} (100%)
 delete mode 100644 netcompare/utils/list/__init__.py
 delete mode 100644 netcompare/utils/list/tests/__init__.py
 delete mode 100644 netcompare/utils/refkey/__init__.py
 delete mode 100644 netcompare/utils/refkey/tests/__init__.py
 rename netcompare/utils/{refkey/utils.py => refkey_utils.py} (55%)
 rename netcompare/utils/data/tests/test_parsers.py => tests/test_filter_parsers.py (95%)
 rename {netcompare/utils/list/tests => tests}/test_flatten.py (85%)
 rename netcompare/utils/jmspath/tests/test_parsers.py => tests/test_jmspath_parsers.py (94%)
 create mode 100644 tests/test_refkey.py

diff --git a/netcompare/check_type.py b/netcompare/check_type.py
index ee0e30e..9ff30d3 100644
--- a/netcompare/check_type.py
+++ b/netcompare/check_type.py
@@ -1,8 +1,11 @@
 """CheckType Implementation."""
+import sys
 from typing import Mapping, Tuple, Union, List
 from .evaluator import diff_generator
 from .runner import extract_values_from_output
 
+sys.path.append(".")
+
 
 class CheckType:
     """Check Type Class."""
diff --git a/netcompare/runner.py b/netcompare/runner.py
index aae061f..f0252ad 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -2,9 +2,9 @@
 import re
 import jmespath
 from typing import Mapping, List, Union
-from .utils.jmspath.parsers import jmspath_value_parser, jmspath_refkey_parser
-from .utils.data.parsers import exclude_filter, get_values
-from .utils.refkey.utils import keys_cleaner, keys_values_zipper
+from .utils.jmspath_parsers import jmspath_value_parser, jmspath_refkey_parser
+from .utils.filter_parsers import exclude_filter, get_values
+from .utils.refkey_utils import keys_cleaner, keys_values_zipper
 
 
 def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) -> Union[Mapping, List, int, str, bool]:
@@ -49,46 +49,5 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
         return filtered_value
 
 
-def associate_key_of_my_value(paths: Mapping, wanted_value: List) -> List:
-    """
-    Associate each key defined in path to every value found in output.
-
-    Args:
-        paths: {"path": "global.peers.*.[is_enabled,is_up]"}
-        wanted_value: [[True, False], [True, False], [True, False], [True, False]]
-
-    Return:
-        [{'is_enabled': True, 'is_up': False}, ...
-
-    Example:
-        >>> from runner import associate_key_of_my_value
-        >>> path = {"path": "global.peers.*.[is_enabled,is_up]"}
-        >>> wanted_value = [[True, False], [True, False], [True, False], [True, False]]
-        {'is_enabled': True, 'is_up': False}, {'is_enabled': True, 'is_up': False}, ...
-    """
-
-    # global.peers.*.[is_enabled,is_up] / result.[*].state
-    find_the_key_of_my_values = paths.split(".")[-1]
-
-    # [is_enabled,is_up]
-    if find_the_key_of_my_values.startswith("[") and find_the_key_of_my_values.endswith("]"):
-        # ['is_enabled', 'is_up']
-        my_key_value_list = find_the_key_of_my_values.strip("[]").split(",")
-    # state
-    else:
-        my_key_value_list = [find_the_key_of_my_values]
-
-    final_list = list()
-
-    for items in wanted_value:
-        temp_dict = dict()
-
-        if len(items) != len(my_key_value_list):
-            raise ValueError("Key's value len != from value len")
-
-        for my_index, my_value in enumerate(items):
-            temp_dict.update({my_key_value_list[my_index]: my_value})
-        final_list.append(temp_dict)
 
-    return final_list
 
diff --git a/netcompare/utils/data/__init__.py b/netcompare/utils/__init__.py
similarity index 100%
rename from netcompare/utils/data/__init__.py
rename to netcompare/utils/__init__.py
diff --git a/netcompare/utils/data/tests/__init__.py b/netcompare/utils/data/tests/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/netcompare/utils/data/parsers.py b/netcompare/utils/filter_parsers.py
similarity index 94%
rename from netcompare/utils/data/parsers.py
rename to netcompare/utils/filter_parsers.py
index bc2dd43..92bc3f1 100644
--- a/netcompare/utils/data/parsers.py
+++ b/netcompare/utils/filter_parsers.py
@@ -1,7 +1,7 @@
 from typing import Mapping, List
-from ..jmspath.parsers import jmspath_value_parser
-from ..list.flatten import flatten_list
-from ...runner import associate_key_of_my_value
+from .jmspath_parsers import jmspath_value_parser
+from .flatten_utils import flatten_list
+from .refkey_utils import associate_key_of_my_value
 
 
 def exclude_filter(data: Mapping, exclude: List):
diff --git a/netcompare/utils/list/flatten.py b/netcompare/utils/flatten_utils.py
similarity index 100%
rename from netcompare/utils/list/flatten.py
rename to netcompare/utils/flatten_utils.py
diff --git a/netcompare/utils/jmspath/__init__.py b/netcompare/utils/jmspath/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/netcompare/utils/jmspath/tests/__init__.py b/netcompare/utils/jmspath/tests/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/netcompare/utils/jmspath/parsers.py b/netcompare/utils/jmspath_parsers.py
similarity index 100%
rename from netcompare/utils/jmspath/parsers.py
rename to netcompare/utils/jmspath_parsers.py
diff --git a/netcompare/utils/list/__init__.py b/netcompare/utils/list/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/netcompare/utils/list/tests/__init__.py b/netcompare/utils/list/tests/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/netcompare/utils/refkey/__init__.py b/netcompare/utils/refkey/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/netcompare/utils/refkey/tests/__init__.py b/netcompare/utils/refkey/tests/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/netcompare/utils/refkey/utils.py b/netcompare/utils/refkey_utils.py
similarity index 55%
rename from netcompare/utils/refkey/utils.py
rename to netcompare/utils/refkey_utils.py
index 0e0cab2..67e8c87 100644
--- a/netcompare/utils/refkey/utils.py
+++ b/netcompare/utils/refkey_utils.py
@@ -55,4 +55,48 @@ def keys_values_zipper(list_of_reference_keys: List, wanted_value_with_key: List
     for my_index, my_key in enumerate(list_of_reference_keys):
         final_result.append({my_key: wanted_value_with_key[my_index]})
 
-    return final_result
\ No newline at end of file
+    return final_result
+
+
+def associate_key_of_my_value(paths: Mapping, wanted_value: List) -> List:
+    """
+    Associate each key defined in path to every value found in output.
+
+    Args:
+        paths: {"path": "global.peers.*.[is_enabled,is_up]"}
+        wanted_value: [[True, False], [True, False], [True, False], [True, False]]
+
+    Return:
+        [{'is_enabled': True, 'is_up': False}, ...
+
+    Example:
+        >>> from runner import associate_key_of_my_value
+        >>> path = {"path": "global.peers.*.[is_enabled,is_up]"}
+        >>> wanted_value = [[True, False], [True, False], [True, False], [True, False]]
+        {'is_enabled': True, 'is_up': False}, {'is_enabled': True, 'is_up': False}, ...
+    """
+
+    # global.peers.*.[is_enabled,is_up] / result.[*].state
+    find_the_key_of_my_values = paths.split(".")[-1]
+
+    # [is_enabled,is_up]
+    if find_the_key_of_my_values.startswith("[") and find_the_key_of_my_values.endswith("]"):
+        # ['is_enabled', 'is_up']
+        my_key_value_list = find_the_key_of_my_values.strip("[]").split(",")
+    # state
+    else:
+        my_key_value_list = [find_the_key_of_my_values]
+
+    final_list = list()
+
+    for items in wanted_value:
+        temp_dict = dict()
+
+        if len(items) != len(my_key_value_list):
+            raise ValueError("Key's value len != from value len")
+
+        for my_index, my_value in enumerate(items):
+            temp_dict.update({my_key_value_list[my_index]: my_value})
+        final_list.append(temp_dict)
+
+    return final_list
\ No newline at end of file
diff --git a/tests/test_diff_generator.py b/tests/test_diff_generator.py
index f8b3d35..6fc272a 100644
--- a/tests/test_diff_generator.py
+++ b/tests/test_diff_generator.py
@@ -1,13 +1,8 @@
-#!/usr/bin/env python3
-
 import pytest
-import sys
 from .utility import load_json_file
 from netcompare.evaluator import diff_generator
 from netcompare.runner import extract_values_from_output
 
-sys.path.append("..")
-
 
 assertion_failed_message = """Test output is different from expected output.
 output: {output}
@@ -52,15 +47,15 @@
 
 eval_tests = [
     exact_match_of_global_peers_via_napalm_getter,
-    # exact_match_of_bgpPeerCaps_via_api,
-    # exact_match_of_bgp_neigh_via_textfsm,
-    # raw_diff_of_interface_ma1_via_api_value_exclude,
-    # raw_diff_of_interface_ma1_via_api_novalue_exclude,
-    # raw_diff_of_interface_ma1_via_api_novalue_noexclude,
-    # exact_match_missing_item,
-    # exact_match_additional_item,
-    # exact_match_changed_item,
-    # exact_match_multi_nested_list,
+    exact_match_of_bgpPeerCaps_via_api,
+    exact_match_of_bgp_neigh_via_textfsm,
+    raw_diff_of_interface_ma1_via_api_value_exclude,
+    raw_diff_of_interface_ma1_via_api_novalue_exclude,
+    raw_diff_of_interface_ma1_via_api_novalue_noexclude,
+    exact_match_missing_item,
+    exact_match_additional_item,
+    exact_match_changed_item,
+    exact_match_multi_nested_list,
 ]
 
 
diff --git a/netcompare/utils/data/tests/test_parsers.py b/tests/test_filter_parsers.py
similarity index 95%
rename from netcompare/utils/data/tests/test_parsers.py
rename to tests/test_filter_parsers.py
index cfba606..30a321d 100644
--- a/netcompare/utils/data/tests/test_parsers.py
+++ b/tests/test_filter_parsers.py
@@ -1,8 +1,6 @@
-#!/usr/bin/env python3
-
 import sys
 import pytest
-from ..parsers import exclude_filter
+from netcompare.utils.filter_parsers import exclude_filter
 
 sys.path.append("..")
 
diff --git a/netcompare/utils/list/tests/test_flatten.py b/tests/test_flatten.py
similarity index 85%
rename from netcompare/utils/list/tests/test_flatten.py
rename to tests/test_flatten.py
index 2df491d..ef2312c 100644
--- a/netcompare/utils/list/tests/test_flatten.py
+++ b/tests/test_flatten.py
@@ -1,10 +1,5 @@
-#!/usr/bin/env python3
-
 import pytest
-import sys
-from ..flatten import flatten_list
-
-sys.path.append("..")
+from netcompare.utils.flatten_utils import flatten_list
 
 
 assertion_failed_message = """Test output is different from expected output.
diff --git a/netcompare/utils/jmspath/tests/test_parsers.py b/tests/test_jmspath_parsers.py
similarity index 94%
rename from netcompare/utils/jmspath/tests/test_parsers.py
rename to tests/test_jmspath_parsers.py
index 76acea6..03e04ec 100644
--- a/netcompare/utils/jmspath/tests/test_parsers.py
+++ b/tests/test_jmspath_parsers.py
@@ -1,10 +1,5 @@
-#!/usr/bin/env python3
-
 import pytest
-import sys
-from ..parsers import jmspath_value_parser, jmspath_refkey_parser
-
-sys.path.append("..")
+from netcompare.utils.jmspath_parsers import jmspath_value_parser, jmspath_refkey_parser
 
 
 assertion_failed_message = """Test output is different from expected output.
diff --git a/tests/test_refkey.py b/tests/test_refkey.py
new file mode 100644
index 0000000..08e27bf
--- /dev/null
+++ b/tests/test_refkey.py
@@ -0,0 +1,53 @@
+import pytest
+from netcompare.utils.refkey_utils import keys_cleaner, keys_values_zipper, associate_key_of_my_value
+
+
+assertion_failed_message = """Test output is different from expected output.
+output: {output}
+expected output: {expected_output}
+"""
+
+keys_cleaner_case_1 = (
+    {'10.1.0.0': {'address_family': 'ipv4'}},
+    ['10.1.0.0'],
+)
+
+keys_zipper_case_1 = (
+    ['10.1.0.0', '10.2.0.0'],
+    [{'is_enabled': False, 'is_up': False}, {'is_enabled': True, 'is_up': True}],
+    [{'10.1.0.0': {'is_enabled': False, 'is_up': False }}, {'10.2.0.0': {'is_enabled': True, 'is_up': True}}]
+)
+
+keys_association_case_1 = (
+    "global.peers.*.[is_enabled,is_up]",
+    [[True, False], [True, False]],
+    [{'is_enabled': True, 'is_up': False}, {'is_enabled': True, 'is_up': False}]
+)
+
+keys_cleaner_tests = [
+    keys_cleaner_case_1,
+]
+
+keys_zipper_tests = [
+    keys_zipper_case_1,
+]
+
+keys_association_test = [
+    keys_association_case_1,
+]
+
+
+@pytest.mark.parametrize("wanted_key, expected_output", keys_cleaner_tests)
+def test_value_parser(wanted_key, expected_output):
+    output = keys_cleaner(wanted_key)
+    assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
+
+@pytest.mark.parametrize("ref_keys, wanted_values, expected_output", keys_zipper_tests)
+def test_value_parser(ref_keys, wanted_values, expected_output):
+    output = keys_values_zipper(ref_keys, wanted_values)
+    assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
+
+@pytest.mark.parametrize("path, wanted_values, expected_output", keys_association_test)
+def test_value_parser(path, wanted_values, expected_output):
+    output = associate_key_of_my_value(path, wanted_values)
+    assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)

From 8069b8ef9962034df4cb10cfb9e506a421a68da2 Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Mon, 22 Nov 2021 15:15:01 +0100
Subject: [PATCH 15/26] black refactoring

---
 netcompare/runner.py             |  4 ----
 netcompare/utils/refkey_utils.py |  2 +-
 tests/test_refkey.py             | 14 ++++++++------
 3 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/netcompare/runner.py b/netcompare/runner.py
index f0252ad..8a86789 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -47,7 +47,3 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
         return keys_values_zipper(list_of_reference_keys, filtered_value)
     else:
         return filtered_value
-
-
-
-
diff --git a/netcompare/utils/refkey_utils.py b/netcompare/utils/refkey_utils.py
index 67e8c87..1cac0e2 100644
--- a/netcompare/utils/refkey_utils.py
+++ b/netcompare/utils/refkey_utils.py
@@ -99,4 +99,4 @@ def associate_key_of_my_value(paths: Mapping, wanted_value: List) -> List:
             temp_dict.update({my_key_value_list[my_index]: my_value})
         final_list.append(temp_dict)
 
-    return final_list
\ No newline at end of file
+    return final_list
diff --git a/tests/test_refkey.py b/tests/test_refkey.py
index 08e27bf..9f8f403 100644
--- a/tests/test_refkey.py
+++ b/tests/test_refkey.py
@@ -8,20 +8,20 @@
 """
 
 keys_cleaner_case_1 = (
-    {'10.1.0.0': {'address_family': 'ipv4'}},
-    ['10.1.0.0'],
+    {"10.1.0.0": {"address_family": "ipv4"}},
+    ["10.1.0.0"],
 )
 
 keys_zipper_case_1 = (
-    ['10.1.0.0', '10.2.0.0'],
-    [{'is_enabled': False, 'is_up': False}, {'is_enabled': True, 'is_up': True}],
-    [{'10.1.0.0': {'is_enabled': False, 'is_up': False }}, {'10.2.0.0': {'is_enabled': True, 'is_up': True}}]
+    ["10.1.0.0", "10.2.0.0"],
+    [{"is_enabled": False, "is_up": False}, {"is_enabled": True, "is_up": True}],
+    [{"10.1.0.0": {"is_enabled": False, "is_up": False}}, {"10.2.0.0": {"is_enabled": True, "is_up": True}}],
 )
 
 keys_association_case_1 = (
     "global.peers.*.[is_enabled,is_up]",
     [[True, False], [True, False]],
-    [{'is_enabled': True, 'is_up': False}, {'is_enabled': True, 'is_up': False}]
+    [{"is_enabled": True, "is_up": False}, {"is_enabled": True, "is_up": False}],
 )
 
 keys_cleaner_tests = [
@@ -42,11 +42,13 @@ def test_value_parser(wanted_key, expected_output):
     output = keys_cleaner(wanted_key)
     assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
 
+
 @pytest.mark.parametrize("ref_keys, wanted_values, expected_output", keys_zipper_tests)
 def test_value_parser(ref_keys, wanted_values, expected_output):
     output = keys_values_zipper(ref_keys, wanted_values)
     assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
 
+
 @pytest.mark.parametrize("path, wanted_values, expected_output", keys_association_test)
 def test_value_parser(path, wanted_values, expected_output):
     output = associate_key_of_my_value(path, wanted_values)

From a19a9142aafe0e8972a861c4712891059042a998 Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Mon, 6 Dec 2021 08:46:17 +0100
Subject: [PATCH 16/26] commit save

---
 netcompare/check_type.py                      |  2 -
 netcompare/runner.py                          | 50 +++++++++++++------
 netcompare/utils/filter_parsers.py            | 31 ------------
 .../utils/{flatten_utils.py => flatten.py}    |  0
 .../utils/{refkey_utils.py => refkey.py}      |  0
 tests/test_diff_generator.py                  | 18 +++----
 tests/test_refkey.py                          |  2 +-
 tests/test_type_check.py                      |  2 -
 8 files changed, 46 insertions(+), 59 deletions(-)
 rename netcompare/utils/{flatten_utils.py => flatten.py} (100%)
 rename netcompare/utils/{refkey_utils.py => refkey.py} (100%)

diff --git a/netcompare/check_type.py b/netcompare/check_type.py
index 9ff30d3..b580659 100644
--- a/netcompare/check_type.py
+++ b/netcompare/check_type.py
@@ -4,8 +4,6 @@
 from .evaluator import diff_generator
 from .runner import extract_values_from_output
 
-sys.path.append(".")
-
 
 class CheckType:
     """Check Type Class."""
diff --git a/netcompare/runner.py b/netcompare/runner.py
index 8a86789..c06501b 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -3,9 +3,10 @@
 import jmespath
 from typing import Mapping, List, Union
 from .utils.jmspath_parsers import jmspath_value_parser, jmspath_refkey_parser
-from .utils.filter_parsers import exclude_filter, get_values
-from .utils.refkey_utils import keys_cleaner, keys_values_zipper
-
+from .utils.filter_parsers import exclude_filter
+from .utils.refkey import keys_cleaner, keys_values_zipper, associate_key_of_my_value
+from .utils.flatten import flatten_list
+import pdb
 
 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.
@@ -26,24 +27,45 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
     Return:
         [{'7.7.7.7': {'prefixesReceived': 101}}, {'10.1.0.0': {'prefixesReceived': 120}}, ...
     """
-    # Get the wanted values to be evaluated if jmspath expression is defined.
+    # Get the wanted values to be evaluated if jmspath expression is defined, otherwise
+    # use the entire output if jmespath is not defined in check. This cover the "raw" diff type.
     if path:
-        wanted_value = jmespath.search(jmspath_value_parser(path), value)
-    # Take all the entir output if jmespath is not defined in check. This cover the "raw" diff type.
-    else:
-        wanted_value = value
+        value = jmespath.search(jmspath_value_parser(path), value)
 
     # Exclude filter implementation.
     if exclude:
-        # Update list in place but assign to a new var for name consistency.
-        exclude_filter(wanted_value, exclude)
-        filtered_value = wanted_value
+        exclude_filter(value, exclude)
+
 
-    filtered_value = get_values(path, wanted_value)
+    # check if list of lists
+    if not any(isinstance(i, list) for i in value):
+        raise TypeError(
+            "Catching value must be defined as list in jmespath expression i.e. result[*].state -> result[*].[state]. You have {}'.".format(
+                path
+            )
+        )
+
+    for element in value:
+        for item in element:
+            if isinstance(item, dict):
+                raise TypeError(
+                    'Must be list of lists i.e. [["Idle", 75759616], ["Idle", 75759620]]. You have {}\'.'.format(
+                        value
+                    )
+                )
+            elif isinstance(item, list):
+                flatten_list(value)
+                break
+    
+    if path:
+        paired_key_value = associate_key_of_my_value(jmspath_value_parser(path), value)
+    else:
+        paired_key_value = value
 
+    pdb.set_trace()
     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, filtered_value)
+        return keys_values_zipper(list_of_reference_keys, paired_key_value)
     else:
-        return filtered_value
+        return paired_key_value
diff --git a/netcompare/utils/filter_parsers.py b/netcompare/utils/filter_parsers.py
index 92bc3f1..e83d2b4 100644
--- a/netcompare/utils/filter_parsers.py
+++ b/netcompare/utils/filter_parsers.py
@@ -1,8 +1,4 @@
 from typing import Mapping, List
-from .jmspath_parsers import jmspath_value_parser
-from .flatten_utils import flatten_list
-from .refkey_utils import associate_key_of_my_value
-
 
 def exclude_filter(data: Mapping, exclude: List):
     """
@@ -41,30 +37,3 @@ def exclude_filter(data: Mapping, exclude: List):
         for element in data:
             if isinstance(element, dict) or isinstance(element, list):
                 exclude_filter(element, exclude)
-
-
-def get_values(path: Mapping, wanted_value):
-    if path:
-        # check if list of lists
-        if not any(isinstance(i, list) for i in wanted_value):
-            raise TypeError(
-                "Catching value must be defined as list in jmespath expression i.e. result[*].state -> result[*].[state]. You have {}'.".format(
-                    path
-                )
-            )
-        for element in wanted_value:
-            for item in element:
-                if isinstance(item, dict):
-                    raise TypeError(
-                        'Must be list of lists i.e. [["Idle", 75759616], ["Idle", 75759620]]. You have {}\'.'.format(
-                            wanted_value
-                        )
-                    )
-                elif isinstance(item, list):
-                    wanted_value = flatten_list(wanted_value)
-                    break
-
-        filtered_value = associate_key_of_my_value(jmspath_value_parser(path), wanted_value)
-    else:
-        filtered_value = wanted_value
-    return filtered_value
diff --git a/netcompare/utils/flatten_utils.py b/netcompare/utils/flatten.py
similarity index 100%
rename from netcompare/utils/flatten_utils.py
rename to netcompare/utils/flatten.py
diff --git a/netcompare/utils/refkey_utils.py b/netcompare/utils/refkey.py
similarity index 100%
rename from netcompare/utils/refkey_utils.py
rename to netcompare/utils/refkey.py
diff --git a/tests/test_diff_generator.py b/tests/test_diff_generator.py
index 6fc272a..f2adc25 100644
--- a/tests/test_diff_generator.py
+++ b/tests/test_diff_generator.py
@@ -47,15 +47,15 @@
 
 eval_tests = [
     exact_match_of_global_peers_via_napalm_getter,
-    exact_match_of_bgpPeerCaps_via_api,
-    exact_match_of_bgp_neigh_via_textfsm,
-    raw_diff_of_interface_ma1_via_api_value_exclude,
-    raw_diff_of_interface_ma1_via_api_novalue_exclude,
-    raw_diff_of_interface_ma1_via_api_novalue_noexclude,
-    exact_match_missing_item,
-    exact_match_additional_item,
-    exact_match_changed_item,
-    exact_match_multi_nested_list,
+    # exact_match_of_bgpPeerCaps_via_api,
+    # exact_match_of_bgp_neigh_via_textfsm,
+    # raw_diff_of_interface_ma1_via_api_value_exclude,
+    # raw_diff_of_interface_ma1_via_api_novalue_exclude,
+    # raw_diff_of_interface_ma1_via_api_novalue_noexclude,
+    # exact_match_missing_item,
+    # exact_match_additional_item,
+    # exact_match_changed_item,
+    # exact_match_multi_nested_list,
 ]
 
 
diff --git a/tests/test_refkey.py b/tests/test_refkey.py
index 9f8f403..8464025 100644
--- a/tests/test_refkey.py
+++ b/tests/test_refkey.py
@@ -1,5 +1,5 @@
 import pytest
-from netcompare.utils.refkey_utils import keys_cleaner, keys_values_zipper, associate_key_of_my_value
+from netcompare.utils.refkey import keys_cleaner, keys_values_zipper, associate_key_of_my_value
 
 
 assertion_failed_message = """Test output is different from expected output.
diff --git a/tests/test_type_check.py b/tests/test_type_check.py
index 3f63857..fab61bc 100644
--- a/tests/test_type_check.py
+++ b/tests/test_type_check.py
@@ -3,8 +3,6 @@
 from .utility import load_json_file
 from netcompare.check_type import CheckType, ExactMatchType, ToleranceType
 
-sys.path.append("..")
-
 
 @pytest.mark.parametrize(
     "args, expected_class",

From cffac0a44b6407b7fc68720dec2bef9b3e2593ae Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Mon, 6 Dec 2021 08:48:29 +0100
Subject: [PATCH 17/26] fix import

---
 tests/test_flatten.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_flatten.py b/tests/test_flatten.py
index ef2312c..2971b2d 100644
--- a/tests/test_flatten.py
+++ b/tests/test_flatten.py
@@ -1,5 +1,5 @@
 import pytest
-from netcompare.utils.flatten_utils import flatten_list
+from netcompare.utils.flatten import flatten_list
 
 
 assertion_failed_message = """Test output is different from expected output.

From 0cb20e1e4bd9c2cafda7300b805109b3e3721ef4 Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Mon, 6 Dec 2021 09:00:23 +0100
Subject: [PATCH 18/26] fix var name

---
 netcompare/runner.py | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/netcompare/runner.py b/netcompare/runner.py
index c06501b..a9a42e6 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -30,39 +30,37 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
     # Get the wanted values to be evaluated if jmspath expression is defined, otherwise
     # use the entire output if jmespath is not defined in check. This cover the "raw" diff type.
     if path:
-        value = jmespath.search(jmspath_value_parser(path), value)
+        wanted_value = jmespath.search(jmspath_value_parser(path), value)
 
     # Exclude filter implementation.
     if exclude:
-        exclude_filter(value, exclude)
-
+        exclude_filter(wanted_value, exclude)
 
     # check if list of lists
-    if not any(isinstance(i, list) for i in value):
+    if not any(isinstance(i, list) for i in wanted_value):
         raise TypeError(
             "Catching value must be defined as list in jmespath expression i.e. result[*].state -> result[*].[state]. You have {}'.".format(
                 path
             )
         )
 
-    for element in value:
+    for element in wanted_value:
         for item in element:
             if isinstance(item, dict):
                 raise TypeError(
                     'Must be list of lists i.e. [["Idle", 75759616], ["Idle", 75759620]]. You have {}\'.'.format(
-                        value
+                        wanted_value
                     )
                 )
             elif isinstance(item, list):
-                flatten_list(value)
+                flatten_list(wanted_value)
                 break
     
     if path:
-        paired_key_value = associate_key_of_my_value(jmspath_value_parser(path), value)
+        paired_key_value = associate_key_of_my_value(jmspath_value_parser(path), wanted_value)
     else:
         paired_key_value = value
 
-    pdb.set_trace()
     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)

From 62ba209ccb34c8bf515eabd74cf11bc582974616 Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Mon, 6 Dec 2021 09:15:48 +0100
Subject: [PATCH 19/26] fix raw compare

---
 netcompare/runner.py         |  3 +++
 tests/test_diff_generator.py | 12 ++++++------
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/netcompare/runner.py b/netcompare/runner.py
index a9a42e6..1743a0a 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -31,6 +31,9 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
     # use the entire output if jmespath is not defined in check. This cover the "raw" diff type.
     if path:
         wanted_value = jmespath.search(jmspath_value_parser(path), value)
+    # RAW diff mode
+    else:
+        return value
 
     # Exclude filter implementation.
     if exclude:
diff --git a/tests/test_diff_generator.py b/tests/test_diff_generator.py
index f2adc25..81d1aad 100644
--- a/tests/test_diff_generator.py
+++ b/tests/test_diff_generator.py
@@ -47,14 +47,14 @@
 
 eval_tests = [
     exact_match_of_global_peers_via_napalm_getter,
-    # exact_match_of_bgpPeerCaps_via_api,
-    # exact_match_of_bgp_neigh_via_textfsm,
+    exact_match_of_bgpPeerCaps_via_api,
+    exact_match_of_bgp_neigh_via_textfsm,
     # raw_diff_of_interface_ma1_via_api_value_exclude,
     # raw_diff_of_interface_ma1_via_api_novalue_exclude,
-    # raw_diff_of_interface_ma1_via_api_novalue_noexclude,
-    # exact_match_missing_item,
-    # exact_match_additional_item,
-    # exact_match_changed_item,
+    raw_diff_of_interface_ma1_via_api_novalue_noexclude,
+    exact_match_missing_item,
+    exact_match_additional_item,
+    exact_match_changed_item,
     # exact_match_multi_nested_list,
 ]
 

From 70c680a4dc24bbea58a3e95786fb1faeed368d8d Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Mon, 6 Dec 2021 10:00:23 +0100
Subject: [PATCH 20/26] fix dict return in jmespath

---
 netcompare/runner.py | 53 ++++++++++++++++++++------------------------
 1 file changed, 24 insertions(+), 29 deletions(-)

diff --git a/netcompare/runner.py b/netcompare/runner.py
index 1743a0a..bfe7ae0 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -6,8 +6,6 @@
 from .utils.filter_parsers import exclude_filter
 from .utils.refkey import keys_cleaner, keys_values_zipper, associate_key_of_my_value
 from .utils.flatten import flatten_list
-import pdb
-
 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.
 
@@ -29,38 +27,35 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
     """
     # Get the wanted values to be evaluated if jmspath expression is defined, otherwise
     # use the entire output if jmespath is not defined in check. This cover the "raw" diff type.
-    if path:
+    if path and not exclude:
+        wanted_value = jmespath.search(jmspath_value_parser(path), value)
+    
+    elif path and exclude:
         wanted_value = jmespath.search(jmspath_value_parser(path), value)
-    # RAW diff mode
-    else:
-        return value
-
-    # Exclude filter implementation.
-    if exclude:
         exclude_filter(wanted_value, exclude)
+    elif not path and exclude:
+        exclude_filter(value, exclude)
+        return value
 
-    # check if list of lists
-    if not any(isinstance(i, list) for i in wanted_value):
-        raise TypeError(
-            "Catching value must be defined as list in jmespath expression i.e. result[*].state -> result[*].[state]. You have {}'.".format(
-                path
-            )
-        )
+    # data type check
+    if path:
+        if not any(isinstance(i, list) for i in wanted_value):
+            return wanted_value
 
-    for element in wanted_value:
-        for item in element:
-            if isinstance(item, dict):
-                raise TypeError(
-                    'Must be list of lists i.e. [["Idle", 75759616], ["Idle", 75759620]]. You have {}\'.'.format(
-                        wanted_value
+        for element in wanted_value:
+            for item in element:
+                if isinstance(item, dict):
+                    raise TypeError(
+                        'Must be list of lists i.e. [["Idle", 75759616], ["Idle", 75759620]]. You have {}\'.'.format(
+                            wanted_value
+                        )
                     )
-                )
-            elif isinstance(item, list):
-                flatten_list(wanted_value)
-                break
-    
-    if path:
-        paired_key_value = associate_key_of_my_value(jmspath_value_parser(path), wanted_value)
+                elif isinstance(item, list):
+                    flatten_list(wanted_value)
+                    break
+        
+        
+            paired_key_value = associate_key_of_my_value(jmspath_value_parser(path), wanted_value)
     else:
         paired_key_value = value
 

From 4f124b3c14e057ef07c78d9961398e827af290fd Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Tue, 7 Dec 2021 09:46:14 +0100
Subject: [PATCH 21/26] commit save

---
 netcompare/check_type.py           |  2 --
 netcompare/runner.py               |  7 ++++---
 netcompare/utils/filter_parsers.py |  1 +
 tests/test_diff_generator.py       | 16 ++++++++--------
 tests/test_filter_parsers.py       |  4 +---
 tests/test_flatten.py              |  1 +
 tests/test_jmspath_parsers.py      |  1 +
 tests/test_refkey.py               |  7 ++++---
 tests/test_type_check.py           |  4 ++--
 9 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/netcompare/check_type.py b/netcompare/check_type.py
index b580659..baf6779 100644
--- a/netcompare/check_type.py
+++ b/netcompare/check_type.py
@@ -1,5 +1,4 @@
 """CheckType Implementation."""
-import sys
 from typing import Mapping, Tuple, Union, List
 from .evaluator import diff_generator
 from .runner import extract_values_from_output
@@ -10,7 +9,6 @@ class CheckType:
 
     def __init__(self, *args):
         """Check Type init method."""
-        pass
 
     @staticmethod
     def init(*args):
diff --git a/netcompare/runner.py b/netcompare/runner.py
index bfe7ae0..6ad604a 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -6,6 +6,8 @@
 from .utils.filter_parsers import exclude_filter
 from .utils.refkey import keys_cleaner, keys_values_zipper, associate_key_of_my_value
 from .utils.flatten import flatten_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.
 
@@ -29,7 +31,7 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
     # use the entire output if jmespath is not defined in check. This cover the "raw" diff type.
     if path and not exclude:
         wanted_value = jmespath.search(jmspath_value_parser(path), value)
-    
+
     elif path and exclude:
         wanted_value = jmespath.search(jmspath_value_parser(path), value)
         exclude_filter(wanted_value, exclude)
@@ -53,8 +55,7 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
                 elif isinstance(item, list):
                     flatten_list(wanted_value)
                     break
-        
-        
+
             paired_key_value = associate_key_of_my_value(jmspath_value_parser(path), wanted_value)
     else:
         paired_key_value = value
diff --git a/netcompare/utils/filter_parsers.py b/netcompare/utils/filter_parsers.py
index e83d2b4..aaf34f9 100644
--- a/netcompare/utils/filter_parsers.py
+++ b/netcompare/utils/filter_parsers.py
@@ -1,5 +1,6 @@
 from typing import Mapping, List
 
+
 def exclude_filter(data: Mapping, exclude: List):
     """
     Recusively look through all dict keys and pop out the one defined in "exclude".
diff --git a/tests/test_diff_generator.py b/tests/test_diff_generator.py
index 81d1aad..824d656 100644
--- a/tests/test_diff_generator.py
+++ b/tests/test_diff_generator.py
@@ -46,16 +46,16 @@
 )
 
 eval_tests = [
-    exact_match_of_global_peers_via_napalm_getter,
-    exact_match_of_bgpPeerCaps_via_api,
-    exact_match_of_bgp_neigh_via_textfsm,
+    # exact_match_of_global_peers_via_napalm_getter,
+    # exact_match_of_bgpPeerCaps_via_api,
+    # exact_match_of_bgp_neigh_via_textfsm,
     # raw_diff_of_interface_ma1_via_api_value_exclude,
     # raw_diff_of_interface_ma1_via_api_novalue_exclude,
-    raw_diff_of_interface_ma1_via_api_novalue_noexclude,
-    exact_match_missing_item,
-    exact_match_additional_item,
-    exact_match_changed_item,
-    # exact_match_multi_nested_list,
+    # raw_diff_of_interface_ma1_via_api_novalue_noexclude,
+    # exact_match_missing_item,
+    # exact_match_additional_item,
+    # exact_match_changed_item,
+    exact_match_multi_nested_list,
 ]
 
 
diff --git a/tests/test_filter_parsers.py b/tests/test_filter_parsers.py
index 30a321d..c38c9a8 100644
--- a/tests/test_filter_parsers.py
+++ b/tests/test_filter_parsers.py
@@ -1,9 +1,7 @@
-import sys
+"Filter parser unit tests."
 import pytest
 from netcompare.utils.filter_parsers import exclude_filter
 
-sys.path.append("..")
-
 
 assertion_failed_message = """Test output is different from expected output.
 output: {output}
diff --git a/tests/test_flatten.py b/tests/test_flatten.py
index 2971b2d..ab32404 100644
--- a/tests/test_flatten.py
+++ b/tests/test_flatten.py
@@ -1,3 +1,4 @@
+"Flatten list unit test"
 import pytest
 from netcompare.utils.flatten import flatten_list
 
diff --git a/tests/test_jmspath_parsers.py b/tests/test_jmspath_parsers.py
index 03e04ec..cd069bc 100644
--- a/tests/test_jmspath_parsers.py
+++ b/tests/test_jmspath_parsers.py
@@ -1,3 +1,4 @@
+"JMSPath parser unit tests."
 import pytest
 from netcompare.utils.jmspath_parsers import jmspath_value_parser, jmspath_refkey_parser
 
diff --git a/tests/test_refkey.py b/tests/test_refkey.py
index 8464025..7ab4ceb 100644
--- a/tests/test_refkey.py
+++ b/tests/test_refkey.py
@@ -1,3 +1,4 @@
+"Reference key unit tests."
 import pytest
 from netcompare.utils.refkey import keys_cleaner, keys_values_zipper, associate_key_of_my_value
 
@@ -38,18 +39,18 @@
 
 
 @pytest.mark.parametrize("wanted_key, expected_output", keys_cleaner_tests)
-def test_value_parser(wanted_key, expected_output):
+def test_keys_cleaner(wanted_key, expected_output):
     output = keys_cleaner(wanted_key)
     assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
 
 
 @pytest.mark.parametrize("ref_keys, wanted_values, expected_output", keys_zipper_tests)
-def test_value_parser(ref_keys, wanted_values, expected_output):
+def test_keys_zipper(ref_keys, wanted_values, expected_output):
     output = keys_values_zipper(ref_keys, wanted_values)
     assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
 
 
 @pytest.mark.parametrize("path, wanted_values, expected_output", keys_association_test)
-def test_value_parser(path, wanted_values, expected_output):
+def test_keys_association(path, wanted_values, expected_output):
     output = associate_key_of_my_value(path, wanted_values)
     assert expected_output == output, assertion_failed_message.format(output=output, expected_output=expected_output)
diff --git a/tests/test_type_check.py b/tests/test_type_check.py
index fab61bc..492050d 100644
--- a/tests/test_type_check.py
+++ b/tests/test_type_check.py
@@ -1,7 +1,7 @@
-import sys
+"Check Type unit tests."
 import pytest
-from .utility import load_json_file
 from netcompare.check_type import CheckType, ExactMatchType, ToleranceType
+from .utility import load_json_file
 
 
 @pytest.mark.parametrize(

From 1e336eef6336f826402e6826e135710c15abe8f7 Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Tue, 7 Dec 2021 09:53:31 +0100
Subject: [PATCH 22/26] fix flatten list

---
 netcompare/runner.py         |  2 +-
 tests/test_diff_generator.py | 18 +++++++++---------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/netcompare/runner.py b/netcompare/runner.py
index 6ad604a..4d6b27a 100644
--- a/netcompare/runner.py
+++ b/netcompare/runner.py
@@ -53,7 +53,7 @@ def extract_values_from_output(value: Mapping, path: Mapping, exclude: List) ->
                         )
                     )
                 elif isinstance(item, list):
-                    flatten_list(wanted_value)
+                    wanted_value = flatten_list(wanted_value)
                     break
 
             paired_key_value = associate_key_of_my_value(jmspath_value_parser(path), wanted_value)
diff --git a/tests/test_diff_generator.py b/tests/test_diff_generator.py
index 824d656..6fc272a 100644
--- a/tests/test_diff_generator.py
+++ b/tests/test_diff_generator.py
@@ -46,15 +46,15 @@
 )
 
 eval_tests = [
-    # exact_match_of_global_peers_via_napalm_getter,
-    # exact_match_of_bgpPeerCaps_via_api,
-    # exact_match_of_bgp_neigh_via_textfsm,
-    # raw_diff_of_interface_ma1_via_api_value_exclude,
-    # raw_diff_of_interface_ma1_via_api_novalue_exclude,
-    # raw_diff_of_interface_ma1_via_api_novalue_noexclude,
-    # exact_match_missing_item,
-    # exact_match_additional_item,
-    # exact_match_changed_item,
+    exact_match_of_global_peers_via_napalm_getter,
+    exact_match_of_bgpPeerCaps_via_api,
+    exact_match_of_bgp_neigh_via_textfsm,
+    raw_diff_of_interface_ma1_via_api_value_exclude,
+    raw_diff_of_interface_ma1_via_api_novalue_exclude,
+    raw_diff_of_interface_ma1_via_api_novalue_noexclude,
+    exact_match_missing_item,
+    exact_match_additional_item,
+    exact_match_changed_item,
     exact_match_multi_nested_list,
 ]
 

From 284acabec5d1cfe5dbb67edcbc30636d76f35faa Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Tue, 7 Dec 2021 16:45:31 +0100
Subject: [PATCH 23/26] add fefkey typeerror

---
 netcompare/utils/refkey.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/netcompare/utils/refkey.py b/netcompare/utils/refkey.py
index 1cac0e2..4ffd41b 100644
--- a/netcompare/utils/refkey.py
+++ b/netcompare/utils/refkey.py
@@ -23,9 +23,12 @@ def keys_cleaner(wanted_reference_keys: Mapping) -> list:
     elif isinstance(wanted_reference_keys, dict):
         my_keys_list = list()
 
-        for key in wanted_reference_keys.keys():
-            my_keys_list.append(key)
-
+        if isinstance(wanted_reference_keys, dict): 
+            for key in wanted_reference_keys.keys():
+                my_keys_list.append(key)
+        else:
+            raise TypeError(f'Must be a dictionary. You have type:{type(wanted_reference_keys)} output:{wanted_reference_keys}\'.')
+                    
         return my_keys_list
 
 

From a914b293f152ab2f7228e8d10ef25eeb55304dc2 Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Tue, 7 Dec 2021 16:48:02 +0100
Subject: [PATCH 24/26] fix example output

---
 netcompare/utils/flatten.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/netcompare/utils/flatten.py b/netcompare/utils/flatten.py
index 6baa6c3..73f70c4 100644
--- a/netcompare/utils/flatten.py
+++ b/netcompare/utils/flatten.py
@@ -14,7 +14,7 @@ def flatten_list(my_list: List) -> List:
     Example:
         >>> my_list = [[[[-1, 0], [-1, 0]]]]
         >>> flatten_list(my_list)
-        [[[[-1, 0], [-1, 0]]]]
+        [[-1, 0], [-1, 0]]
     """
 
     def iter_flatten_list(my_list: List) -> Generator[List, None, None]:

From 88ba66fbd27d6333946df43fa490daa7c778b649 Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Tue, 7 Dec 2021 17:12:39 +0100
Subject: [PATCH 25/26] improve type

---
 netcompare/utils/refkey.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/netcompare/utils/refkey.py b/netcompare/utils/refkey.py
index 4ffd41b..5a93b87 100644
--- a/netcompare/utils/refkey.py
+++ b/netcompare/utils/refkey.py
@@ -1,7 +1,7 @@
 from typing import Mapping, List
 
 
-def keys_cleaner(wanted_reference_keys: Mapping) -> list:
+def keys_cleaner(wanted_reference_keys: Mapping) -> List[Mapping]:
     """
     Get every required reference key from output.
 

From e9d5f2b4157d7f316cddd746a27454dff9859f8e Mon Sep 17 00:00:00 2001
From: Network to Code <federico.olivieri@networktocode.com>
Date: Wed, 8 Dec 2021 09:16:53 +0100
Subject: [PATCH 26/26] Integrate comments from PR

---
 netcompare/evaluator.py             |  9 ++++-----
 netcompare/utils/filter_parsers.py  |  2 +-
 netcompare/utils/jmspath_parsers.py | 23 ++++++++++-------------
 netcompare/utils/refkey.py          |  2 +-
 4 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/netcompare/evaluator.py b/netcompare/evaluator.py
index f4b47cd..df2052a 100644
--- a/netcompare/evaluator.py
+++ b/netcompare/evaluator.py
@@ -2,16 +2,15 @@
 import re
 import sys
 from collections import defaultdict
-from collections.abc import Mapping as DictMapping
 from functools import partial
-from typing import Mapping, List
+from typing import Mapping, List, Dict
 from deepdiff import DeepDiff
 
 
 sys.path.append(".")
 
 
-def diff_generator(pre_result: Mapping, post_result: Mapping) -> Mapping:
+def diff_generator(pre_result: Mapping, post_result: Mapping) -> Dict:
     """
     Generates diff between pre and post data based on check definition.
 
@@ -139,7 +138,7 @@ def group_value(tree_list: List, value: Mapping) -> Mapping:
     return value
 
 
-def dict_merger(original_dict: List, merged_dict: Mapping):
+def dict_merger(original_dict: Mapping, merged_dict: Mapping):
     """
     Merge dictionaries to build final result.
 
@@ -153,7 +152,7 @@ def dict_merger(original_dict: List, merged_dict: Mapping):
         {'10.17.254.2': {'state': {'new_value': 'Up', 'old_value': 'Idle'}}}
     """
     for key in merged_dict.keys():
-        if key in original_dict and isinstance(original_dict[key], dict) and isinstance(merged_dict[key], DictMapping):
+        if key in original_dict and isinstance(original_dict[key], dict) and isinstance(merged_dict[key], dict):
             dict_merger(original_dict[key], merged_dict[key])
         else:
             original_dict[key] = merged_dict[key]
diff --git a/netcompare/utils/filter_parsers.py b/netcompare/utils/filter_parsers.py
index aaf34f9..abdb189 100644
--- a/netcompare/utils/filter_parsers.py
+++ b/netcompare/utils/filter_parsers.py
@@ -31,7 +31,7 @@ def exclude_filter(data: Mapping, exclude: List):
                 pass
 
         for key in data:
-            if isinstance(data[key], dict) or isinstance(data[key], list):
+            if isinstance(data[key], (dict, list)):
                 exclude_filter(data[key], exclude)
 
     elif isinstance(data, list):
diff --git a/netcompare/utils/jmspath_parsers.py b/netcompare/utils/jmspath_parsers.py
index d26fb10..80dd48d 100644
--- a/netcompare/utils/jmspath_parsers.py
+++ b/netcompare/utils/jmspath_parsers.py
@@ -1,8 +1,7 @@
 import re
-from typing import Mapping
 
 
-def jmspath_value_parser(path: Mapping):
+def jmspath_value_parser(path: str):
     """
     Get the JMSPath  value path from 'path'.
 
@@ -13,19 +12,17 @@ def jmspath_value_parser(path: Mapping):
     """
     regex_match_value = re.search(r"\$.*\$\.|\$.*\$,|,\$.*\$", path)
 
-    if regex_match_value:
-        # $peers$. --> peers
-        regex_normalized_value = re.search(r"\$.*\$", regex_match_value.group())
-        if regex_normalized_value:
-            normalized_value = regex_match_value.group().split("$")[1]
-        value_path = path.replace(regex_normalized_value.group(), normalized_value)
-    else:
-        value_path = path
+    if not regex_match_value:
+        return path
+    # $peers$. --> peers
+    regex_normalized_value = re.search(r"\$.*\$", regex_match_value.group())
+    if regex_normalized_value:
+        normalized_value = regex_match_value.group().split("$")[1]
+        return path.replace(regex_normalized_value.group(), normalized_value)
+    else: return path
 
-    return value_path
 
-
-def jmspath_refkey_parser(path: Mapping):
+def jmspath_refkey_parser(path: str):
     """
     Get the JMSPath reference key path from 'path'.
 
diff --git a/netcompare/utils/refkey.py b/netcompare/utils/refkey.py
index 5a93b87..972a39c 100644
--- a/netcompare/utils/refkey.py
+++ b/netcompare/utils/refkey.py
@@ -61,7 +61,7 @@ def keys_values_zipper(list_of_reference_keys: List, wanted_value_with_key: List
     return final_result
 
 
-def associate_key_of_my_value(paths: Mapping, wanted_value: List) -> List:
+def associate_key_of_my_value(paths: str, wanted_value: List) -> List:
     """
     Associate each key defined in path to every value found in output.