deltafi 1.2.20__py3-none-any.whl → 2.0.0__py3-none-any.whl

deltafi/test_kit/framework.py

@@ -1,7 +1,7 @@
 #
 #    DeltaFi - Data transformation and enrichment platform
 #
-#    Copyright 2021-2023 DeltaFi Contributors <deltafi@deltafi.org>
+#    Copyright 2021-2024 DeltaFi Contributors <deltafi@deltafi.org>
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
 #    you may not use this file except in compliance with the License.
@@ -26,7 +26,6 @@ from deltafi.logger import get_logger
 from deltafi.metric import Metric
 from deltafi.result import ErrorResult, FilterResult
 from deltafi.storage import Segment
-
 from .assertions import *
 from .compare_helpers import GenericCompareHelper, CompareHelper
 from .constants import *
@@ -37,15 +36,20 @@ class IOContent:
     The IOContent class holds the details for loading input or output
      content into the test framework.
     Attributes:
-        file_name (str): The name of file in test/data.
-        content_name (str): The name of the content.
-        content_type (str): The media type of the content
-        offset (int): Offset to use in Segment
-        content_bytes (str): Bypass file read, and uses these bytes for content
+        file_name (str)    : The name of file in test/data.
+        content_name (str) : The name of the content.
+        content_type (str) : The media type of the content
+        offset (int)       : Offset to use in Segment
+        content_bytes (str): Optional.  If set to a String of length greater than zero, indicates to consumers of this
+                             IOContent that they should bypass file read and use these bytes for content.
+        no_content (bool)  : Optional.  If 'True', then consumers should not attempt to interpret content but should
+                             apply other aspects of this IOContent.  When 'True', 'content_bytes' should be ignored and
+                             loaded content, if any, should be interpreted as empty String or otherwise as documented by
+                             the consumer.
     """
 
     def __init__(self, file_name: str, content_name: str = None, content_type: str = None, offset: int = 0,
-                 content_bytes: str = ""):
+                 content_bytes: str = "", no_content: bool = False):
         self.file_name = file_name
         if content_name is None:
             self.content_name = file_name
@@ -56,7 +60,11 @@ class IOContent:
         else:
             self.content_type = content_type
         self.offset = offset
-        self.content_bytes = content_bytes
+        self.no_content = no_content
+        if no_content:
+            self.content_bytes = None
+        else:
+            self.content_bytes = content_bytes
         self.segment_uuid = uuid.uuid4()
 
     @classmethod
@@ -79,7 +87,10 @@ class LoadedContent:
         if data is not None:
             self.data = data
         else:
-            self.data = ioc.content_bytes
+            if ioc.no_content:
+                self.data = ""
+            else:
+                self.data = ioc.content_bytes
         self.segment = Segment.from_dict(
             {"uuid": str(ioc.segment_uuid), "offset": self.offset, "size": len(self.data), "did": did})
 
@@ -103,6 +114,10 @@ class InternalContentService:
         seg_id = segments[0].uuid
         return self.loaded_content[seg_id].data
 
+    def get_bytes(self, segments: List[Segment]):
+        seg_id = segments[0].uuid
+        return self.loaded_content[seg_id].data.encode('utf-8')
+
     def get_output(self, seg_id: str):
         if seg_id in self.outputs:
             return self.outputs[seg_id]
@@ -123,8 +138,8 @@ class TestCaseBase(ABC):
         - inputs: (optional) List[IOContent]: input content to action
         - parameters: (optional) Dict: map of action input parameters
         - in_meta: (optional) Dict: map of metadata as input to action
-        - in_domains: (optional) List[Domain]: list of domains as input to action
-        - in_enrichments: (optional) List[Domain]: list of enrichments as input to action
+        - join_meta: (optional): List[Dict]: When a List is provided, this enables the JOIN portion of an action.
+        When using JOIN, join_meta must match the size of inputs, though the Dict can be empty
         - did: (optional): str: overrides random DID
         """
         if "action" in data:
@@ -144,16 +159,14 @@ class TestCaseBase(ABC):
 
         self.inputs = data["inputs"] if "inputs" in data else []
         self.file_name = data["file_name"] if "file_name" in data else "filename"
-        self.outputs = data["outputs"] if "outputs" in data else []
         self.parameters = data["parameters"] if "parameters" in data else {}
         self.in_meta = data["in_meta"] if "in_meta" in data else {}
-        self.in_domains = data["in_domains"] if "in_domains" in data else []
-        self.in_enrichments = data["in_enrichments"] if "in_enrichments" in data else []
         self.use_did = data["did"] if "did" in data else None
         self.expected_result_type = None
         self.err_or_filt_cause = None
         self.err_or_filt_context = None
         self.err_or_filt_annotations = None
+        self.join_meta = data["join_meta"] if "join_meta" in data else None
         self.expected_metrics = []
 
     def add_metric(self, metric: Metric):
@@ -164,7 +177,7 @@ class TestCaseBase(ABC):
         A Sets the expected output of the action to an Error Result
         :param cause: the expected error cause
         :param context: the expected error context
-        :param annotations (Optional): Dict: the expected annotations
+        :param annotations: Dict: (Optional) the expected annotations
         """
         self.expected_result_type = ErrorResult
         self.err_or_filt_cause = cause
@@ -175,8 +188,8 @@ class TestCaseBase(ABC):
         """
         A Sets the expected output of the action to a Filter Result
         :param cause: the expected filter cause (message)
-        :param context (Optional): the expected filter context
-        :param annotations (Optional): Dict: the expected annotations
+        :param context: (Optional) the expected filter context
+        :param annotations: Dict: (Optional) the expected annotations
         """
         self.expected_result_type = FilterResult
         self.err_or_filt_cause = cause
@@ -193,10 +206,10 @@ class ActionTest(ABC):
         """
         self.content_service = InternalContentService()
         self.did = ""
-        self.expected_outputs = []
         self.loaded_inputs = []
         self.package_name = package_name
         self.res_path = ""
+        self.context = None
 
     def __reset__(self, did: str):
         self.content_service = InternalContentService()
@@ -204,9 +217,9 @@ class ActionTest(ABC):
             self.did = str(uuid.uuid4())
         else:
             self.did = did
-        self.expected_outputs = []
         self.loaded_inputs = []
         self.res_path = ""
+        self.context = None
 
     def load_file(self, ioc: IOContent):
         file_res = self.res_path.joinpath(ioc.file_name)
@@ -220,19 +233,12 @@ class ActionTest(ABC):
 
         # Load inputs
         for input_ioc in test_case.inputs:
-            if len(input_ioc.content_bytes) == 0:
+            if not input_ioc.no_content and len(input_ioc.content_bytes) == 0:
                 self.loaded_inputs.append(LoadedContent(self.did, input_ioc, self.load_file(input_ioc)))
             else:
                 self.loaded_inputs.append(LoadedContent(self.did, input_ioc, None))
 
-        # Load expected outputs
-        for output_ioc in test_case.outputs:
-            if len(output_ioc.content_bytes) == 0:
-                self.expected_outputs.append(LoadedContent(self.did, output_ioc, self.load_file(output_ioc)))
-            else:
-                self.expected_outputs.append(LoadedContent(self.did, output_ioc, None))
-
-    def make_content_list(self, test_case: TestCaseBase):
+    def make_content_list(self):
         content_list = []
         for loaded_input in self.loaded_inputs:
             c = Content(name=loaded_input.name, segments=[loaded_input.segment], media_type=loaded_input.content_type,
@@ -242,34 +248,43 @@ class ActionTest(ABC):
 
         return content_list
 
-    def make_df_msg(self, test_case: TestCaseBase):
-        content_list = self.make_content_list(test_case)
+    def make_df_msgs(self, test_case: TestCaseBase):
+        content_list = self.make_content_list()
         self.content_service.load(self.loaded_inputs)
 
-        return DeltaFileMessage(
-            metadata=test_case.in_meta,
-            content_list=content_list,
-            domains=test_case.in_domains,
-            enrichments=test_case.in_enrichments)
+        delta_file_messages = []
+
+        if test_case.join_meta is None:
+            delta_file_messages.append(DeltaFileMessage(metadata=test_case.in_meta, content_list=content_list))
+        else:
+            for index, content in enumerate(content_list):
+                delta_file_messages.append(DeltaFileMessage(
+                    metadata=test_case.join_meta[index],
+                    content_list=[content]))
+
+        return delta_file_messages
 
     def make_context(self, test_case: TestCaseBase):
         action_name = INGRESS_FLOW + "." + test_case.action.__class__.__name__
-        return Context(
+        join = {} if test_case.join_meta else None
+        self.context = Context(
             did=self.did,
-            action_flow=INGRESS_FLOW,
+            delta_file_name=test_case.file_name,
+            data_source="DATASRC",
+            flow_name=INGRESS_FLOW,
+            flow_id="FLOWID",
             action_name=action_name,
-            source_filename=test_case.file_name,
-            ingress_flow=INGRESS_FLOW,
-            egress_flow=EGRESS_FLOW,
-            system=SYSTEM,
+            action_version="1.0",
             hostname=HOSTNAME,
+            system_name=SYSTEM,
             content_service=self.content_service,
-            collect=None,
-            collected_dids=None,
+            saved_content=[],
+            join=join,
             logger=get_logger())
+        return self.context
 
     def make_event(self, test_case: TestCaseBase):
-        return Event(delta_file_messages=[self.make_df_msg(test_case)], context=self.make_context(test_case),
+        return Event(delta_file_messages=self.make_df_msgs(test_case), context=self.make_context(test_case),
                      params=test_case.parameters, queue_name="", return_address="")
 
     def call_action(self, test_case: TestCaseBase):
@@ -311,37 +326,27 @@ class ActionTest(ABC):
         else:
             raise ValueError(f"unknown type: {test_case.expected_result_type}")
 
-    def compare_content_details(self, expected: LoadedContent, actual: Content):
+    @staticmethod
+    def compare_content_details(expected: LoadedContent, actual: Content):
         assert_equal(expected.content_type, actual.media_type)
         assert_equal(expected.name, actual.name)
 
-    def compare_one_content(self, comparitor: CompareHelper, expected: LoadedContent, actual, index):
+    def compare_one_content(self, comparator: CompareHelper, expected: LoadedContent, actual, index):
         self.compare_content_details(expected, actual)
         seg_id = actual.segments[0].uuid
-        comparitor.compare(expected.data, self.content_service.get_output(seg_id), f"Content[{index}]")
-
-    def compare_all_output(self, comparitor: CompareHelper, content: List):
-        assert_equal_len(self.expected_outputs, content)
-        for index, expected in enumerate(self.expected_outputs):
-            self.compare_one_content(comparitor, expected, content[index], index)
-
-    def compare_domains(self, comparitor: CompareHelper, expected_items: List[Dict], results: List[Dict]):
-        assert_equal_len(expected_items, results)
-        for index, expected in enumerate(expected_items):
-            actual = results[index]
-            assert_equal(expected['name'], actual['name'])
-            assert_equal(expected['mediaType'], actual['mediaType'])
-
-            expected_value = expected['value']
-            if type(expected_value) == str:
-                comparitor.compare(expected_value, actual['value'], f"Domain[{index}]")
-            elif type(expected_value) == IOContent:
-                expected_data = self.load_file(expected_value)
-                comparitor.compare(expected_data, actual['value'], f"Domain[{index}]")
+        comparator.compare(expected.data, self.content_service.get_output(seg_id), f"Content[{index}]")
+
+    def compare_content_list(self, comparator: CompareHelper, expected_outputs: List[IOContent], content: List):
+        assert_equal_len(expected_outputs, content)
+        for index, expected_ioc in enumerate(expected_outputs):
+            if not expected_ioc.no_content and len(expected_ioc.content_bytes) == 0:
+                expected = LoadedContent(self.did, expected_ioc, self.load_file(expected_ioc))
             else:
-                raise ValueError(f"unknown expected_value type: {type(expected_value)}")
+                expected = LoadedContent(self.did, expected_ioc, None)
+            self.compare_one_content(comparator, expected, content[index], index)
 
-    def compare_one_metric(self, expected: Metric, result: Metric):
+    @staticmethod
+    def compare_one_metric(expected: Metric, result: Metric):
         assert expected.name == result.name
         assert_equal_with_label(expected.value, result.value, expected.name)
         assert_keys_and_values(expected.tags, result.tags)
@@ -351,3 +356,7 @@ class ActionTest(ABC):
             assert_equal_len(expected_metrics, results)
             for index, expected in enumerate(expected_metrics):
                 self.compare_one_metric(expected, results[index])
+
+    def has_saved_content__size(self, count: int):
+        assert_equal_with_label(
+            count, len(self.context.saved_content), "savedContent")

deltafi/test_kit/transform.py

@@ -1,7 +1,7 @@
 #
 #    DeltaFi - Data transformation and enrichment platform
 #
-#    Copyright 2021-2023 DeltaFi Contributors <deltafi@deltafi.org>
+#    Copyright 2021-2024 DeltaFi Contributors <deltafi@deltafi.org>
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
 #    you may not use this file except in compliance with the License.
@@ -18,24 +18,34 @@
 
 from typing import List
 
-from deltafi.result import TransformResult
+from deltafi.result import TransformResult, TransformResults
 
 from .assertions import *
-from .framework import TestCaseBase, ActionTest
+from .framework import TestCaseBase, ActionTest, IOContent
 
 
 class TransformTestCase(TestCaseBase):
     def __init__(self, fields: Dict):
         super().__init__(fields)
-        self.metadata = {}
-        self.delete_metadata_keys = []
-        self.annotations = {}
+        self.results = []
 
-    def expect_transform_result(self, metadata: Dict, delete_metadata_keys: List[str], annotations: Dict):
+    def expect_transform_result(self):
         self.expected_result_type = TransformResult
-        self.metadata = metadata
-        self.delete_metadata_keys = delete_metadata_keys
-        self.annotations = annotations
+
+    def expect_transform_results(self):
+        self.expected_result_type = TransformResults
+
+    def add_transform_result(self, content: List[IOContent], metadata: Dict, delete_metadata_keys: List[str],
+                             annotations: Dict, name: str = None):
+        self.results.append(
+            {
+                'content': content,
+                'metadata': metadata,
+                'delete_metadata_keys': delete_metadata_keys,
+                'annotations': annotations,
+                'name': name
+            }
+        )
 
 
 class TransformActionTest(ActionTest):
@@ -50,6 +60,8 @@ class TransformActionTest(ActionTest):
     def transform(self, test_case: TransformTestCase):
         if test_case.expected_result_type == TransformResult:
             self.expect_transform_result(test_case)
+        elif test_case.expected_result_type == TransformResults:
+            self.expect_transform_results(test_case)
         else:
             super().execute(test_case)
 
@@ -57,19 +69,35 @@ class TransformActionTest(ActionTest):
         result = super().run_and_check_result_type(test_case, TransformResult)
         self.assert_transform_result(test_case, result)
 
+    def expect_transform_results(self, test_case: TransformTestCase):
+        result = super().run_and_check_result_type(test_case, TransformResults)
+        self.assert_transform_results(test_case, result)
+
+    def assert_transform_results(self, test_case: TransformTestCase, result: TransformResults):
+        assert_equal_len(test_case.results, result.child_results)
+        for index, child_result in enumerate(result.child_results):
+            self.compare_one_transform_result(test_case, child_result, index)
+            expected = test_case.results[index]
+            if 'name' in expected:
+                assert_equal_with_label(expected["name"], child_result.delta_file_name, f"name[{index}]")
+
     def assert_transform_result(self, test_case: TransformTestCase, result: TransformResult):
         # Check metrics
         self.compare_metrics(test_case.expected_metrics, result.metrics)
+        self.compare_one_transform_result(test_case, result, 0)
+
+    def compare_one_transform_result(self, test_case: TransformTestCase, result: TransformResult, index: int):
+        expected = test_case.results[index]
 
         # Check output
-        self.compare_all_output(test_case.compare_tool, result.content)
+        self.compare_content_list(test_case.compare_tool, expected['content'], result.content)
 
         # Check metadata
-        assert_keys_and_values(test_case.metadata, result.metadata)
+        assert_keys_and_values(expected['metadata'], result.metadata)
 
         # Check deleted metadata
-        for key in test_case.delete_metadata_keys:
+        for key in expected['delete_metadata_keys']:
             assert_key_in(key, result.delete_metadata_keys)
 
         # Check annotations
-        assert_keys_and_values(test_case.annotations, result.annotations)
+        assert_keys_and_values(expected['annotations'], result.annotations)

{deltafi-1.2.20.dist-info → deltafi-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deltafi
-Version: 1.2.20
+Version: 2.0.0
 Summary: SDK for DeltaFi plugins and actions
 License: Apache License, Version 2.0
 Keywords: deltafi
@@ -17,14 +17,16 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development
+Requires-Dist: PyYAML (==6.0.2)
 Requires-Dist: deepdiff (==6.7.1)
 Requires-Dist: json-logging (==1.3.0)
-Requires-Dist: minio (==7.2.5)
-Requires-Dist: pydantic (==2.7.1)
-Requires-Dist: redis (==5.0.4)
-Requires-Dist: requests (==2.31.0)
-Requires-Dist: urllib3 (==2.2.1)
+Requires-Dist: minio (==7.2.10)
+Requires-Dist: pydantic (==2.9.2)
+Requires-Dist: redis (==5.2.0)
+Requires-Dist: requests (==2.32.3)
+Requires-Dist: urllib3 (==2.2.3)
 Project-URL: Bug Reports, https://chat.deltafi.org/deltafi/channels/bug-reports
 Project-URL: Documentation, https://docs.deltafi.org/#/
 Project-URL: Source Code, https://gitlab.com/deltafi/deltafi

deltafi-2.0.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+deltafi/__init__.py,sha256=sSGWjpvzcCzgLywoEg55z_0satt0g_LPTwNIWtylgF4,709
+deltafi/action.py,sha256=kuDY7-qcJsiRTB3ZigiYg-XOcNeahnDU3NGSZBy10vM,5753
+deltafi/actioneventqueue.py,sha256=_05aDeqVpUbGWG3jFf0AalOsVfAvOTn0oBxjpQIQxIs,2847
+deltafi/actiontype.py,sha256=CpVI0wk9C-eu44e0jYvqBzE6yIX_zfRrW5RCf4ohu4Y,913
+deltafi/domain.py,sha256=wCWqCjWbQ02thAMHYXTuUMHY58QZyyTRkYNZFd3kPPo,12182
+deltafi/exception.py,sha256=LNNFqc_lA89I-RvnVsbTQ2vnWQ9WZXdQqLwiXwNgc_w,943
+deltafi/genericmodel.py,sha256=WU8zfqEO_n84CZ0KpH9FhgTsL9jyU0EXSuhL0IdLWFw,1152
+deltafi/input.py,sha256=ydAhuw68N9qMeacc9YE4U79zRqxWiinZNkm1AxoFBEk,1656
+deltafi/logger.py,sha256=mKfJTnuupf3sto6hV-SIXajtcP-xTSSdJ2Ufd-lJPTo,2140
+deltafi/metric.py,sha256=79Gb2C1qYXeQYshgFPu2BcMT5oEb0LhmNfwyulSqsIc,972
+deltafi/plugin.py,sha256=7e4wblHAG41UCOZ1RcWjkw-0RJF4_dAksx5b4XCNIU4,15521
+deltafi/result.py,sha256=2mefttQAdvYhsw6IjvouY4L5W1n3s6tP7oJUhLtyyVk,9047
+deltafi/storage.py,sha256=vCE29Yzk5s7ub4O1PdaxXBKPBQy4OHs7j46z3O5MezE,2979
+deltafi/test_kit/__init__.py,sha256=sSGWjpvzcCzgLywoEg55z_0satt0g_LPTwNIWtylgF4,709
+deltafi/test_kit/assertions.py,sha256=MdUXENLn0aDvknMtsnSAb-DwvpzXlMkaYQ6-RRkWG8s,1378
+deltafi/test_kit/compare_helpers.py,sha256=qRINvCQqBUaalT1DG2oz2egSkUjiSOfqKF5U7WyeT_g,12957
+deltafi/test_kit/constants.py,sha256=Suygx9CEob2Skw4UyzzMCibQ8hRhGHC_d_Xab8AJMFE,833
+deltafi/test_kit/egress.py,sha256=53SBeJJmphDl-jZdqkC1dKYWZ4ATWlzY02TUt0Sj1zs,1899
+deltafi/test_kit/framework.py,sha256=g7NRl_KxUFio8aZ1xo1gEBKqL9qquYx9qAyFpPLHsmM,15150
+deltafi/test_kit/transform.py,sha256=Qj9LIyZ8RYj0tCeq7agrDlEkkgtBR86TNinV9oncTnM,4089
+deltafi-2.0.0.dist-info/METADATA,sha256=S8ORZcGFlq_9FZ3C38gUYNA7A7qr-ufZTDVbaAbW1UI,1517
+deltafi-2.0.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+deltafi-2.0.0.dist-info/RECORD,,

{deltafi-1.2.20.dist-info → deltafi-2.0.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: true
 Tag: py3-none-any

deltafi/test_kit/domain.py

@@ -1,59 +0,0 @@
-#
-#    DeltaFi - Data transformation and enrichment platform
-#
-#    Copyright 2021-2023 DeltaFi Contributors <deltafi@deltafi.org>
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-#
-
-from deltafi.result import DomainResult
-
-from .assertions import *
-from .framework import TestCaseBase, ActionTest
-
-
-class DomainTestCase(TestCaseBase):
-    def __init__(self, fields: Dict):
-        super().__init__(fields)
-        self.annotations = {}
-
-    def expect_domain_result(self, annotations: Dict):
-        self.expected_result_type = DomainResult
-        self.annotations = annotations
-
-
-class DomainActionTest(ActionTest):
-    def __init__(self, package_name: str):
-        """
-        Provides structure for testing DeltaFi Domain action
-        Args:
-            package_name: name of the actions package for finding resources
-        """
-        super().__init__(package_name)
-
-    def domain(self, test_case: DomainTestCase):
-        if test_case.expected_result_type == DomainResult:
-            self.expect_domain_result(test_case)
-        else:
-            super().execute(test_case)
-
-    def expect_domain_result(self, test_case: DomainTestCase):
-        result = super().run_and_check_result_type(test_case, DomainResult)
-        self.assert_domain_result(test_case, result)
-
-    def assert_domain_result(self, test_case: DomainTestCase, result: DomainResult):
-        # Check metrics
-        self.compare_metrics(test_case.expected_metrics, result.metrics)
-
-        # Check annotations
-        assert_keys_and_values(test_case.annotations, result.annotations)

deltafi/test_kit/enrich.py

@@ -1,70 +0,0 @@
-#
-#    DeltaFi - Data transformation and enrichment platform
-#
-#    Copyright 2021-2023 DeltaFi Contributors <deltafi@deltafi.org>
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-#
-
-from deltafi.result import EnrichResult
-
-from .assertions import *
-from .framework import TestCaseBase, ActionTest
-
-
-class EnrichTestCase(TestCaseBase):
-    def __init__(self, fields: Dict):
-        super().__init__(fields)
-        self.enrichments = []
-        self.annotations = {}
-
-    def expect_enrich_result(self, annotations: Dict):
-        self.expected_result_type = EnrichResult
-        self.annotations = annotations
-
-    def add_enrichment(self, name: str, value: str, media_type: str):
-        self.enrichments.append({'name': name, 'value': value, 'mediaType': media_type})
-
-
-class EnrichActionTest(ActionTest):
-    def __init__(self, package_name: str):
-        """
-        Provides structure for testing DeltaFi Enrich action
-        Args:
-            package_name: name of the actions package for finding resources
-        """
-        super().__init__(package_name)
-
-    def enrich(self, test_case: EnrichTestCase):
-        if test_case.expected_result_type == EnrichResult:
-            self.expect_enrich_result(test_case)
-        else:
-            super().execute(test_case)
-
-    def expect_enrich_result(self, test_case: EnrichTestCase):
-        result = super().run_and_check_result_type(test_case, EnrichResult)
-        self.assert_enrich_result(test_case, result)
-
-    def assert_enrich_result(self, test_case: EnrichTestCase, result: EnrichResult):
-        # Check metrics
-        self.compare_metrics(test_case.expected_metrics, result.metrics)
-
-        # Check annotations
-        assert_keys_and_values(test_case.annotations, result.annotations)
-
-        # Check enrichments
-        assert_equal_len(test_case.enrichments, result.enrichments)
-        if len(test_case.enrichments) > 0:
-            for index, expected in enumerate(test_case.enrichments):
-                actual = result.enrichments[index]
-                assert_equal(expected, actual)