deltafi 2.0rc1713530263087__py3-none-any.whl → 2.0rc1714076410617__py3-none-any.whl

deltafi/test_kit/compare_helpers.py

@@ -17,11 +17,12 @@
 #
 
 import json
+import re
 from abc import ABC
 from abc import abstractmethod
-from typing import List
+from itertools import repeat
 
-from deepdiff import DeepDiff
+from deepdiff import DeepDiff, DeepSearch
 
 from .assertions import *
 
@@ -38,13 +39,250 @@ class GenericCompareHelper(CompareHelper):
 
 
 class JsonCompareHelper(CompareHelper):
-    def __init__(self, regex_exclusion_list: List):
+    """Provides helper functions for comparing JSON/dict objects.
+
+            Are these two JSON/dict objects equivalent?
+                - compare(...)
+
+            Are these two lists equivalent?
+                - compare_lists(...)
+
+            Is this list a subset/superset of that list?
+                - compare_lists_subset(...)
+                - compare_lists_superset(...)
+
+            Select a list of values from an existing list and put them into a new list to facilitate list comparisons:
+                - create_list_from_list_using_filter_regex(...)
+
+            Is this value found (or not) in this JSON/dict object?
+                - is_found(...)
+                - is_not_found(...)
+        """
+
+    def __init__(self, regex_exclusion_list=None, ignore_order=True):
+        """Creates and configures a JsonCompareHelper object.  If the optional 'ignore_order' is true, then the order of
+                data is ignored when checking else order is enforced.  The optional 'regex_exclusion_list' excludes
+                paths within the object from comparison; if empty or not provided, then no excludes are applied."""
+        if regex_exclusion_list is None:
+            regex_exclusion_list = []
         self.excludes = regex_exclusion_list
+        self.ignore_order = ignore_order
+
+    def __perform_find(self, obj: object, item):
+        """Returns a dict of matches of the 'item' in the object 'obj'.  The returned dict is empty if there are no
+                matches. Excludes path determined by the constructor."""
+        return DeepSearch(obj, item, verbose_level=2, exclude_regex_paths=self.excludes)
+
+    def is_not_found(self, obj: object, item):
+        """Returns None if there are no occurrences of 'item' in object 'obj' else returns a ValueError.  The argument
+                'item' may be a scalar or a list.  Excludes path and failure on ordering of elements are determined by
+                the constructor."""
+
+        all_matches = []
+
+        if isinstance(item, list):
+            for value in item:
+                matches = self.__perform_find(obj, value)
+                if len(matches) > 0:
+                    all_matches.append(matches)
+        else:
+            matches = self.__perform_find(obj, item)
+            if len(matches) > 0:
+                all_matches.append(matches)
+
+        if len(all_matches) > 0:
+            raise ValueError(f"{all_matches}")
+
+        assert len(all_matches) == 0
+
+    def is_found(self, obj: object, item):
+        """Returns None if there are no occurrences of 'item' in object 'obj' else returns a ValueError.  The argument
+                'item' may be a scalar or a list.  Excludes path and failure on ordering of elements are determined by
+                the constructor."""
+
+        all_matches = []
+
+        if isinstance(item, list):
+            for value in item:
+                matches = self.__perform_find(obj, value)
+                if len(matches) > 0:
+                    all_matches.append(matches)
+        else:
+            matches = self.__perform_find(obj, item)
+            if len(matches) > 0:
+                all_matches.append(matches)
+
+        if len(all_matches) == 0:
+            raise ValueError("No matches found for '" + str(item) + "'")
+
+        assert len(all_matches) > 0
+
+    def __perform_diff(self, expected, actual):
+        """Returns a dict with differences between 'expected' and 'actual'.  The returned dict is empty if 'expected'
+                and 'actual' are equivalent.  Both 'expected' and 'actual' must be dicts. Excludes path and failure on
+                ordering of elements are determined by the constructor.  Elements must match number of repetitions."""
+        return DeepDiff(expected, actual, ignore_order=self.ignore_order, report_repetition=True,
+                        exclude_regex_paths=self.excludes)
+
+    def __perform_diff_with_eval(self, expected, actual):
+        """Returns None if 'expected' and 'actual' are equivalent else returns a ValueError. Both 'expected' and
+                'actual' must be dicts.  Excludes path and failure on ordering of elements are determined by the
+                constructor.  Elements must match number of repetitions."""
+
+        diffs = self.__perform_diff(expected, actual)
 
-    def compare(self, expected: str, actual: str, label: str):
-        exp = json.loads(expected)
-        act = json.loads(actual)
-        diffs = DeepDiff(exp, act, exclude_regex_paths=self.excludes)
         if len(diffs) > 0:
             raise ValueError(f"{diffs}")
+
         assert len(diffs) == 0
+
+    def compare(self, expected, actual, label: str):
+        """Returns None if 'expected' and 'actual' are equivalent else returns a ValueError. Both 'expected' and
+                'actual' must be either dicts or strings that parse as JSON to dicts. Excludes path and failure on
+                ordering of elements are determined by the constructor.  Elements must match number of repetitions."""
+
+        if isinstance(expected, str):
+            exp = json.loads(expected)
+        else:
+            exp = expected
+
+        if isinstance(actual, str):
+            act = json.loads(actual)
+        else:
+            act = actual
+
+        return self.__perform_diff_with_eval(exp, act)
+
+    def compare_lists(self, expected, actual: list, label: str):
+        """Returns None if 'actual' is equivalent to 'expected' else returns a ValueError.
+
+                The 'actual' argument must be a list.  The 'expected' argument may be a list or a dict.  If a list, then
+                'expected' and 'actual' are compared against each other.  If a dict, then 'actual' is equivalent if it
+                contains elements with the same repetitions as defined in the 'expected' dict with the key equal to the
+                 element in 'actual' and the value equal to the number of repetitions.
+
+                Order of elements is ignored.  Elements must match number of repetitions."""
+
+        expected_list = []
+
+        if isinstance(expected, dict):
+            for key, value in expected.items():
+                expected_list += list(repeat(key, value))
+        else:
+            expected_list = expected
+
+        return self.__perform_diff_with_eval({"json-compare-helper-internal-list": expected_list},
+                                             {"json-compare-helper-internal-list": actual})
+
+    @staticmethod
+    def compare_lists_subset(expected_subset, actual: list):
+        """Returns None if the 'actual' list contains at least 'expected_subset' else returns a ValueError.  The
+                'actual' list may contain 0 or more additional elements than defined in 'expected_subset'.
+
+                The 'actual' argument must be a list.  The argument 'expected_subset' may be a list or a dict.  In the
+                latter case, the key defines the item that must appear in 'actual' and the value defines the number of
+                 repetitions.
+
+                Order of elements is ignored.  Elements must match number of repetitions."""
+
+        expected_subset_map = {}
+
+        if isinstance(expected_subset, list):
+            for item in expected_subset:
+                value = expected_subset_map.get(item)
+                if value is None:
+                    expected_subset_map[item] = 1
+                else:
+                    expected_subset_map[item] = value + 1
+        else:
+            expected_subset_map = expected_subset
+
+        actual_map = {}
+
+        for item in actual:
+            value = actual_map.get(item)
+            if value is None:
+                actual_map[item] = 1
+            else:
+                actual_map[item] = value + 1
+
+        for key, value in expected_subset_map.items():
+            actual_value = actual_map.get(key)
+            if actual_value is None:
+                raise ValueError("Actual list did not contain element '" + str(key) + "'")
+            else:
+                if actual_value != value:
+                    raise ValueError("Actual list had item '" + str(key) + "' with repetition " + str(actual_value)
+                                     + " but required repetition " + str(value))
+
+        return None
+
+    @staticmethod
+    def compare_lists_superset(expected_superset, actual: list):
+        """Returns None if the 'actual' list contains only elements that appear in 'expected_superset' else returns a
+                ValueError.  The 'actual' list cannot contain more elements than are defined in 'expected_superset'; the
+                'expected_superset' may define 0 or more values not contained in 'actual'.
+
+                The 'actual' argument must be a list.  The argument 'expected_superset' may be a list or a dict.  In the
+                latter case, the key defines the item that must appear in 'actual' and the value defines the number of
+                 repetitions.
+
+                Order of elements is ignored.  Elements must match number of repetitions."""
+
+        expected_superset_map = {}
+
+        if isinstance(expected_superset, list):
+            for item in expected_superset:
+                value = expected_superset_map.get(item)
+                if value is None:
+                    expected_superset_map[item] = 1
+                else:
+                    expected_superset_map[item] = value + 1
+        else:
+            expected_superset_map = expected_superset
+
+        actual_map = {}
+
+        for item in actual:
+            value = actual_map.get(item)
+            if value is None:
+                actual_map[item] = 1
+            else:
+                actual_map[item] = value + 1
+
+        for key, value in actual_map.items():
+            expected_value = expected_superset_map.get(key)
+            if expected_value is None:
+                raise ValueError("Actual list contained element '" + str(key)
+                                 + "' that did not appear in the expected superset")
+            else:
+                if expected_value != value:
+                    raise ValueError("Actual list had item '" + str(key) + "' with repetition " + str(value)
+                                     + " but required repetition " + str(expected_value))
+
+        return None
+
+    @staticmethod
+    def create_list_from_list_using_filter_regex(regex, source_list: list):
+        """Creates and returns a list of those items in the 'source_list' matching the regex in the 'regex'.  The
+                argument 'regex' may be a string or a compiled regex object.
+
+                For the 'regex', consider using anchors to explicitly match from the start (or end) of a string.  For
+                example, a string such as "^malware--" will explicitly match from the start of a string."""
+
+        def search_funct(element):
+
+            if isinstance(regex, str):
+                # 'regex' is a string
+                match = re.search(regex, element)
+            else:
+                # assume 'regex' is a compiled regex pattern object
+                match = regex.match(element)
+
+            if match is None:
+                return False
+            else:
+                return True
+
+        return list(filter(search_funct, source_list))
+

{deltafi-2.0rc1713530263087.dist-info → deltafi-2.0rc1714076410617.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deltafi
-Version: 2.0rc1713530263087
+Version: 2.0rc1714076410617
 Summary: SDK for DeltaFi plugins and actions
 License: Apache License, Version 2.0
 Keywords: deltafi

{deltafi-2.0rc1713530263087.dist-info → deltafi-2.0rc1714076410617.dist-info}/RECORD

@@ -13,7 +13,7 @@ deltafi/result.py,sha256=rugAkh9NZdl0QDHzyxDoZbkE8dnJNAFLbqBNdIjjn_k,8177
 deltafi/storage.py,sha256=toq58EPZgzj2TfDF-YpFUmRnsWSjACA0KQAZzkM04xU,2740
 deltafi/test_kit/__init__.py,sha256=qv6y7PpBG0ekTN9EuD9Lj8JYOLVqZA6tvHwgjplncAM,709
 deltafi/test_kit/assertions.py,sha256=2eahqmbedhnHXMguiJHdaV-6sx4_jvCbxH4HSzx6PV8,1378
-deltafi/test_kit/compare_helpers.py,sha256=Oi07zsq7jlpAHxqjwHsea84acC3lAL3ooG0VC42lLAc,1581
+deltafi/test_kit/compare_helpers.py,sha256=eRA6x1LcFAmKVT7kV00pHXz6crl_FPcEEez9BUJGJqA,12178
 deltafi/test_kit/constants.py,sha256=epz0OS-qILcc8t7iIs5B3m2-wvZx8FpYpyb19ZsImbI,833
 deltafi/test_kit/domain.py,sha256=uqpDravlb6E3Ddm4QpRaJTdiVuQ2MMdZnzc4Oi9EZJA,2090
 deltafi/test_kit/egress.py,sha256=nF7YYak-_X35m7h2rSIcju86IJBf8cVaFHs7xw7-_b8,1899
@@ -21,6 +21,6 @@ deltafi/test_kit/enrich.py,sha256=M682cqInVS4aipI0jOrR25x7m0ErrpjGpebXGZDPwxo,25
 deltafi/test_kit/framework.py,sha256=m11V6JMZHn4oXnmB_pEgI5p7fZWCWAO7HjHLunSh5AA,14602
 deltafi/test_kit/transform.py,sha256=q9zQdZswTKwU5Om8E9Lwg0G5JI8LEXuRZjT9oam-Zoo,4085
 deltafi/test_kit/validate.py,sha256=NnXD5amOE_9a4Zr-v9DKYIv5f_HvwtmlI-IdFtVp7ko,1933
-deltafi-2.0rc1713530263087.dist-info/METADATA,sha256=M8bj2tsQIgAkHIKkYzYQ3eAT6A51colJHptMVKPJnMo,1446
-deltafi-2.0rc1713530263087.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-deltafi-2.0rc1713530263087.dist-info/RECORD,,
+deltafi-2.0rc1714076410617.dist-info/METADATA,sha256=LXznZYJQVwFe6BQS9465IqiDxCG46eVusE89NJTX5fE,1446
+deltafi-2.0rc1714076410617.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+deltafi-2.0rc1714076410617.dist-info/RECORD,,