openmetadata-ingestion 1.4.8.0__py3-none-any.whl → 1.5.0.0rc2__py3-none-any.whl

metadata/data_quality/interface/sqlalchemy/sqa_test_suite_interface.py

@@ -14,26 +14,23 @@ Interfaces with database for all database engine
 supporting sqlalchemy abstraction layer
 """
 
-from datetime import datetime, timezone
-from typing import Optional, Union
+from typing import Union
 
 from sqlalchemy.orm import DeclarativeMeta
 from sqlalchemy.orm.util import AliasedClass
 
+from metadata.data_quality.builders.i_validator_builder import IValidatorBuilder
+from metadata.data_quality.builders.sqa_validator_builder import SQAValidatorBuilder
 from metadata.data_quality.interface.test_suite_interface import TestSuiteInterface
-from metadata.data_quality.validations.validator import Validator
 from metadata.generated.schema.entity.data.table import Table
 from metadata.generated.schema.entity.services.databaseService import DatabaseConnection
-from metadata.generated.schema.tests.basic import TestCaseResult
 from metadata.generated.schema.tests.testCase import TestCase
-from metadata.generated.schema.tests.testDefinition import TestDefinition
 from metadata.ingestion.connections.session import create_and_bind_session
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.mixins.sqalchemy.sqa_mixin import SQAInterfaceMixin
 from metadata.profiler.processor.runner import QueryRunner
 from metadata.profiler.processor.sampler.sqlalchemy.sampler import SQASampler
 from metadata.utils.constants import TEN_MIN
-from metadata.utils.importer import import_test_case_class
 from metadata.utils.logger import test_suite_logger
 from metadata.utils.ssl_manager import get_ssl_connection
 from metadata.utils.timeout import cls_timeout
@@ -144,37 +141,7 @@ class SQATestSuiteInterface(SQAInterfaceMixin, TestSuiteInterface):
             )
         )
 
-    def run_test_case(
-        self,
-        test_case: TestCase,
-    ) -> Optional[TestCaseResult]:
-        """Run table tests where platformsTest=OpenMetadata
-
-        Args:
-            test_case: test case object to execute
-
-        Returns:
-            TestCaseResult object
-        """
-
-        try:
-            TestHandler = import_test_case_class(  # pylint: disable=invalid-name
-                self.ometa_client.get_by_id(
-                    TestDefinition, test_case.testDefinition.id
-                ).entityType.value,
-                "sqlalchemy",
-                test_case.testDefinition.fullyQualifiedName,
-            )
-
-            test_handler = TestHandler(
-                self.runner,
-                test_case=test_case,
-                execution_date=int(datetime.now(tz=timezone.utc).timestamp() * 1000),
-            )
-
-            return Validator(validator_obj=test_handler).validate()
-        except Exception as err:
-            logger.error(
-                f"Error executing {test_case.testDefinition.fullyQualifiedName} - {err}"
-            )
-            raise RuntimeError(err)
+    def _get_validator_builder(
+        self, test_case: TestCase, entity_type: str
+    ) -> IValidatorBuilder:
+        return SQAValidatorBuilder(self.runner, test_case, entity_type)

metadata/data_quality/interface/test_suite_interface.py

@@ -15,20 +15,34 @@ supporting sqlalchemy abstraction layer
 """
 
 from abc import ABC, abstractmethod
-from typing import Optional
+from typing import Optional, Type
 
+from metadata.data_quality.builders.i_validator_builder import IValidatorBuilder
+from metadata.data_quality.validations.base_test_handler import BaseTestValidator
+from metadata.data_quality.validations.runtime_param_setter.param_setter import (
+    RuntimeParameterSetter,
+)
+from metadata.data_quality.validations.runtime_param_setter.param_setter_factory import (
+    RuntimeParameterSetterFactory,
+)
 from metadata.generated.schema.entity.data.table import Table
 from metadata.generated.schema.entity.services.databaseService import DatabaseConnection
 from metadata.generated.schema.tests.basic import TestCaseResult
 from metadata.generated.schema.tests.testCase import TestCase
+from metadata.generated.schema.tests.testDefinition import TestDefinition
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.profiler.api.models import ProfileSampleConfig
+from metadata.utils.logger import test_suite_logger
 from metadata.utils.partition import get_partition_details
 
+logger = test_suite_logger()
+
 
 class TestSuiteInterface(ABC):
     """Abstract interface for the processor"""
 
+    runtime_params_setter_fact = RuntimeParameterSetterFactory
+
     @abstractmethod
     def __init__(
         self,
@@ -41,10 +55,78 @@ class TestSuiteInterface(ABC):
         self.service_connection_config = service_connection_config
         self.table_entity = table_entity
 
+    @property
+    def sampler(self):
+        """Get the sampler object
+
+        Note: Overriden in the implementation class. This should be removed from the interface. It has been
+        implemented as the RuntimeParameterSetter takes the sampler as an argument, though we may want to
+        remove that dependency.
+        """
+        return None
+
     @abstractmethod
+    def _get_validator_builder(
+        self, test_case: TestCase, entity_type: str
+    ) -> IValidatorBuilder:
+        """get the builder class for the validator. Define this in the implementation class
+
+        Args:
+            test_case (TestCase): test case object
+            entity_type (str): type of the entity
+
+        Returns:
+            IValidatorBuilder: a validator builder
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def _get_runtime_params_setter_fact(cls) -> RuntimeParameterSetterFactory:
+        """Get the runtime parameter setter factory."""
+        return cls.runtime_params_setter_fact()
+
+    @classmethod
+    def _set_runtime_params_setter_fact(
+        cls, class_fact: Type[RuntimeParameterSetterFactory]
+    ):
+        """Set the runtime parameter setter factory.
+        Use this method to set the runtime parameter setter factory and override the default.
+
+        Args:
+            class_fact (Type[RuntimeParameterSetterFactory]): the runtime parameter setter factory class
+        """
+        cls.runtime_params_setter_fact = class_fact
+
     def run_test_case(self, test_case: TestCase) -> Optional[TestCaseResult]:
         """run column data quality tests"""
-        raise NotImplementedError
+        runtime_params_setter_fact: RuntimeParameterSetterFactory = (
+            self._get_runtime_params_setter_fact()
+        )  # type: ignore
+        runtime_params_setter: Optional[
+            RuntimeParameterSetter
+        ] = runtime_params_setter_fact.get_runtime_param_setter(
+            test_case.testDefinition.fullyQualifiedName,  # type: ignore
+            self.ometa_client,
+            self.service_connection_config,
+            self.table_entity,
+            self.sampler,
+        )
+
+        # get `column` or `table` type for validator import
+        entity_type: str = self.ometa_client.get_by_id(
+            TestDefinition, test_case.testDefinition.id
+        ).entityType.value
+
+        validator_builder = self._get_validator_builder(test_case, entity_type)
+        validator_builder.set_runtime_params(runtime_params_setter)
+        validator: BaseTestValidator = validator_builder.validator
+        try:
+            return validator.run_validation()
+        except Exception as err:
+            logger.error(
+                f"Error executing {test_case.testDefinition.fullyQualifiedName} - {err}"
+            )
+            raise RuntimeError(err)
 
     def _get_sample_query(self) -> Optional[str]:
         """Get the sampling query for the data quality tests

metadata/data_quality/processor/test_case_runner.py

@@ -14,7 +14,7 @@ This Processor is in charge of executing the test cases
 """
 import traceback
 from copy import deepcopy
-from typing import List, Optional, cast
+from typing import List, Optional
 
 from metadata.data_quality.api.models import (
     TableAndTests,
@@ -36,7 +36,11 @@ from metadata.generated.schema.metadataIngestion.workflow import (
     OpenMetadataWorkflowConfig,
 )
 from metadata.generated.schema.tests.testCase import TestCase
-from metadata.generated.schema.tests.testDefinition import TestDefinition, TestPlatform
+from metadata.generated.schema.tests.testDefinition import (
+    EntityType,
+    TestDefinition,
+    TestPlatform,
+)
 from metadata.generated.schema.tests.testSuite import TestSuite
 from metadata.generated.schema.type.basic import EntityLink, FullyQualifiedEntityName
 from metadata.ingestion.api.models import Either
@@ -60,8 +64,8 @@ class TestCaseRunner(Processor):
         self.metadata = metadata
 
         self.processor_config: TestSuiteProcessorConfig = (
-            TestSuiteProcessorConfig.parse_obj(
-                self.config.processor.dict().get("config")
+            TestSuiteProcessorConfig.model_validate(
+                self.config.processor.model_dump().get("config")
             )
         )
 
@@ -82,20 +86,14 @@ class TestCaseRunner(Processor):
             test_suite_fqn=fqn.build(
                 None,
                 TestSuite,
-                table_fqn=record.table.fullyQualifiedName.__root__,
+                table_fqn=record.table.fullyQualifiedName.root,
             ),
-            table_fqn=record.table.fullyQualifiedName.__root__,
+            table_fqn=record.table.fullyQualifiedName.root,
         )
-
-        if not test_cases:
-            return Either(
-                left=StackTraceError(
-                    name="No test Cases",
-                    error=f"No tests cases found for table {record.table.fullyQualifiedName.__root__}",
-                )
-            )
-
         openmetadata_test_cases = self.filter_for_om_test_cases(test_cases)
+        openmetadata_test_cases = self.filter_incompatible_test_cases(
+            record.table, openmetadata_test_cases
+        )
 
         test_suite_runner = test_suite_source_factory.create(
             record.service_type.lower(),
@@ -104,6 +102,12 @@ class TestCaseRunner(Processor):
             record.table,
         ).get_data_quality_runner()
 
+        logger.debug(
+            f"Found {len(openmetadata_test_cases)} test cases for table {record.table.fullyQualifiedName.root}"
+        )
+        if len(openmetadata_test_cases) == 0:
+            logger.warning("No test cases found for the table")
+
         test_results = [
             test_case_result
             for test_case in openmetadata_test_cases
@@ -113,17 +117,14 @@ class TestCaseRunner(Processor):
         return Either(right=TestCaseResults(test_results=test_results))
 
     def get_test_cases(
-        self, test_cases: Optional[List[TestCase]], test_suite_fqn: str, table_fqn: str
+        self, test_cases: List[TestCase], test_suite_fqn: str, table_fqn: str
     ) -> List[TestCase]:
         """
         Based on the test suite test cases that we already know, pick up
         the rest from the YAML config, compare and create the new ones
         """
         if self.processor_config.testCases is not None:
-            cli_test_cases = self.get_test_case_from_cli_config()  # type: ignore
-            cli_test_cases = cast(
-                List[TestCaseDefinition], cli_test_cases
-            )  # satisfy type checker
+            cli_test_cases = self.get_test_case_from_cli_config()
             return self.compare_and_create_test_cases(
                 cli_test_cases_definitions=cli_test_cases,
                 test_cases=test_cases,
@@ -135,15 +136,13 @@ class TestCaseRunner(Processor):
 
     def get_test_case_from_cli_config(
         self,
-    ) -> Optional[List[TestCaseDefinition]]:
+    ) -> List[TestCaseDefinition]:
         """Get all the test cases names defined in the CLI config file"""
-        if self.processor_config.testCases is not None:
-            return list(self.processor_config.testCases)
-        return None
+        return list(self.processor_config.testCases or [])
 
     def compare_and_create_test_cases(
         self,
-        cli_test_cases_definitions: Optional[List[TestCaseDefinition]],
+        cli_test_cases_definitions: List[TestCaseDefinition],
         test_cases: List[TestCase],
         table_fqn: str,
         test_suite_fqn: str,
@@ -162,9 +161,7 @@ class TestCaseRunner(Processor):
             return test_cases
         test_cases = deepcopy(test_cases) or []
         test_case_names = (
-            {test_case.name.__root__ for test_case in test_cases}
-            if test_cases
-            else set()
+            {test_case.name.root for test_case in test_cases} if test_cases else set()
         )
 
         # we'll check the test cases defined in the CLI config file and not present in the platform
@@ -196,20 +193,22 @@ class TestCaseRunner(Processor):
                         description=test_case_to_create.description,
                         displayName=test_case_to_create.displayName,
                         testDefinition=FullyQualifiedEntityName(
-                            __root__=test_case_to_create.testDefinitionName
+                            test_case_to_create.testDefinitionName
                         ),
                         entityLink=EntityLink(
-                            __root__=entity_link.get_entity_link(
+                            entity_link.get_entity_link(
                                 Table,
                                 fqn=table_fqn,
                                 column_name=test_case_to_create.columnName,
                             )
                         ),
                         testSuite=test_suite_fqn,
-                        parameterValues=list(test_case_to_create.parameterValues)
-                        if test_case_to_create.parameterValues
-                        else None,
-                        owner=None,
+                        parameterValues=(
+                            list(test_case_to_create.parameterValues)
+                            if test_case_to_create.parameterValues
+                            else None
+                        ),
+                        owners=None,
                         computePassedFailedRowCount=test_case_to_create.computePassedFailedRowCount,
                     )
                 )
@@ -245,11 +244,11 @@ class TestCaseRunner(Processor):
             test_case_to_update.name for test_case_to_update in test_cases_to_update
         }
         for indx, test_case in enumerate(deepcopy(test_cases)):
-            if test_case.name.__root__ in test_cases_to_update_names:
+            if test_case.name.root in test_cases_to_update_names:
                 test_case_definition = next(
                     test_case_to_update
                     for test_case_to_update in test_cases_to_update
-                    if test_case_to_update.name == test_case.name.__root__
+                    if test_case_to_update.name == test_case.name.root
                 )
                 updated_test_case = self.metadata.patch_test_case_definition(
                     test_case=test_case,
@@ -281,7 +280,7 @@ class TestCaseRunner(Processor):
             )
             if TestPlatform.OpenMetadata not in test_definition.testPlatforms:
                 logger.debug(
-                    f"Test case {test_case.name.__root__} is not an OpenMetadata test case."
+                    f"Test case {test_case.name.root} is not an OpenMetadata test case."
                 )
                 continue
             om_test_cases.append(test_case)
@@ -294,15 +293,15 @@ class TestCaseRunner(Processor):
         """Execute the test case and return the result, if any"""
         try:
             test_result = test_suite_runner.run_and_handle(test_case)
-            self.status.scanned(test_case.fullyQualifiedName.__root__)
+            self.status.scanned(test_case.fullyQualifiedName.root)
             return test_result
         except Exception as exc:
-            error = f"Could not run test case {test_case.name.__root__}: {exc}"
+            error = f"Could not run test case {test_case.name.root}: {exc}"
             logger.debug(traceback.format_exc())
             logger.error(error)
             self.status.failed(
                 StackTraceError(
-                    name=test_case.name.__root__,
+                    name=test_case.name.root,
                     error=error,
                     stackTrace=traceback.format_exc(),
                 )
@@ -321,3 +320,40 @@ class TestCaseRunner(Processor):
 
     def close(self) -> None:
         """Nothing to close"""
+
+    def filter_incompatible_test_cases(
+        self, table: Table, test_cases: List[TestCase]
+    ) -> List[TestCase]:
+        """Filter out test cases that are defined for incompatible columns. An example of this is a
+        test case that checks for a column value to be between two values, but the column is of type
+        VARCHAR and not a numeric type. Incompatible test cases will be logged as failures.
+
+        Args:
+            table: Table entity the test cases are run against
+            test_cases: List of test cases
+
+        Returns:
+            List of test cases that are compatible with the table columns
+        """
+        result: List[TestCase] = []
+        for tc in test_cases:
+            test_definition: TestDefinition = self.metadata.get_by_id(
+                TestDefinition, tc.testDefinition.id, nullable=False
+            )
+            if test_definition.entityType != EntityType.COLUMN:
+                result.append(tc)
+                continue
+            column_name = entity_link.get_decoded_column(tc.entityLink.root)
+            column = next(c for c in table.columns if c.name.root == column_name)
+
+            if column.dataType not in test_definition.supportedDataTypes:
+                self.status.failed(
+                    StackTraceError(
+                        name="Incompatible Column for Test Case",
+                        error=f"Test case {tc.name.root} of type {test_definition.name.root}"
+                        f" is not compatible with column {column.name.root} of type {column.dataType.value}",
+                    )
+                )
+            else:
+                result.append(tc)
+        return result

metadata/data_quality/runner/base_test_suite_source.py

@@ -71,7 +71,7 @@ class BaseTestSuiteRunner:
             DatabaseService.__config__
         """
         config_copy = deepcopy(
-            config.source.serviceConnection.__root__.config  # type: ignore
+            config.source.serviceConnection.root.config  # type: ignore
         )
         if hasattr(
             config_copy,  # type: ignore

metadata/data_quality/runner/core.py

@@ -31,8 +31,8 @@ class DataTestsRunner:
     def run_and_handle(self, test_case: TestCase):
         """run and handle test case validation"""
         logger.info(
-            f"Executing test case {test_case.name.__root__} "
-            f"for entity {self.test_runner_interface.table_entity.fullyQualifiedName.__root__}"
+            f"Executing test case {test_case.name.root} "
+            f"for entity {self.test_runner_interface.table_entity.fullyQualifiedName.root}"
         )
         test_result = self.test_runner_interface.run_test_case(
             test_case,

metadata/data_quality/source/test_suite.py

@@ -72,7 +72,7 @@ class TestSuiteSource(Source):
         """
         table: Table = self.metadata.get_by_name(
             entity=Table,
-            fqn=self.source_config.entityFullyQualifiedName.__root__,
+            fqn=self.source_config.entityFullyQualifiedName.root,
             fields=["tableProfilerConfig", "testSuite"],
         )
 
@@ -80,19 +80,21 @@ class TestSuiteSource(Source):
 
     def _get_test_cases_from_test_suite(
         self, test_suite: Optional[TestSuite]
-    ) -> Optional[List[TestCase]]:
+    ) -> List[TestCase]:
         """Return test cases if the test suite exists and has them"""
         if test_suite:
             test_cases = self.metadata.list_all_entities(
                 entity=TestCase,
                 fields=["testSuite", "entityLink", "testDefinition"],
-                params={"testSuiteId": test_suite.id.__root__},
+                params={"testSuiteId": test_suite.id.root},
             )
             test_cases = cast(List[TestCase], test_cases)  # satisfy type checker
-
+            if self.source_config.testCases is not None:
+                test_cases = [
+                    t for t in test_cases if t.name in self.source_config.testCases
+                ]
             return test_cases
-
-        return None
+        return []
 
     def prepare(self):
         """Nothing to prepare"""
@@ -110,7 +112,7 @@ class TestSuiteSource(Source):
             yield Either(
                 left=StackTraceError(
                     name="Missing Table",
-                    error=f"Could not retrieve table entity for {self.source_config.entityFullyQualifiedName.__root__}."
+                    error=f"Could not retrieve table entity for {self.source_config.entityFullyQualifiedName.root}."
                     " Make sure the table exists in OpenMetadata and/or the JWT Token provided is valid.",
                 )
             )
@@ -125,31 +127,31 @@ class TestSuiteSource(Source):
                 name=fqn.build(
                     None,
                     TestSuite,
-                    table_fqn=self.source_config.entityFullyQualifiedName.__root__,
+                    table_fqn=self.source_config.entityFullyQualifiedName.root,
                 ),
-                displayName=f"{self.source_config.entityFullyQualifiedName.__root__} Test Suite",
+                displayName=f"{self.source_config.entityFullyQualifiedName.root} Test Suite",
                 description="Test Suite created from YAML processor config file",
-                owner=None,
-                executableEntityReference=self.source_config.entityFullyQualifiedName.__root__,
+                owners=None,
+                executableEntityReference=self.source_config.entityFullyQualifiedName.root,
             )
             yield Either(
                 right=TableAndTests(
                     executable_test_suite=executable_test_suite,
-                    service_type=self.config.source.serviceConnection.__root__.config.type.value,
+                    service_type=self.config.source.serviceConnection.root.config.type.value,
                 )
             )
 
         test_suite: Optional[TestSuite] = None
         if table.testSuite:
             test_suite = self.metadata.get_by_id(
-                entity=TestSuite, entity_id=table.testSuite.id.__root__
+                entity=TestSuite, entity_id=table.testSuite.id.root
             )
 
         if test_suite and not test_suite.executable:
             yield Either(
                 left=StackTraceError(
                     name="Non-executable Test Suite",
-                    error=f"The table {self.source_config.entityFullyQualifiedName.__root__} "
+                    error=f"The table {self.source_config.entityFullyQualifiedName.root} "
                     "has a test suite that is not executable.",
                 )
             )
@@ -161,7 +163,7 @@ class TestSuiteSource(Source):
                 right=TableAndTests(
                     table=table,
                     test_cases=test_suite_cases,
-                    service_type=self.config.source.serviceConnection.__root__.config.type.value,
+                    service_type=self.config.source.serviceConnection.root.config.type.value,
                 )
             )
 

metadata/data_quality/validations/base_test_handler.py

@@ -18,8 +18,11 @@ from __future__ import annotations
 import reprlib
 from abc import ABC, abstractmethod
 from datetime import datetime
-from typing import Callable, List, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Callable, List, Optional, Type, TypeVar, Union
 
+from metadata.data_quality.validations.runtime_param_setter.param_setter import (
+    RuntimeParameterSetter,
+)
 from metadata.generated.schema.tests.basic import (
     TestCaseResult,
     TestCaseStatus,
@@ -28,16 +31,24 @@ from metadata.generated.schema.tests.basic import (
 from metadata.generated.schema.tests.testCase import TestCase, TestCaseParameterValue
 from metadata.profiler.processor.runner import QueryRunner
 
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
 T = TypeVar("T", bound=Callable)
 R = TypeVar("R")
 
 
 class BaseTestValidator(ABC):
-    """Abstract class for test case handlers"""
+    """Abstract class for test case handlers
+    The runtime_parameter_setter is run after the test case is created to set the runtime parameters.
+    This can be useful to resolve complex test parameters based on the parameters gibven by the user.
+    """
+
+    runtime_parameter_setter: Optional[Type[RuntimeParameterSetter]] = None
 
     def __init__(
         self,
-        runner: QueryRunner,
+        runner: Union[QueryRunner, List["DataFrame"]],
         test_case: TestCase,
         execution_date: Union[datetime, float],
     ) -> None:
@@ -94,6 +105,8 @@ class BaseTestValidator(ABC):
         row_count: Optional[int] = None,
         failed_rows: Optional[int] = None,
         passed_rows: Optional[int] = None,
+        min_bound: Optional[float] = None,
+        max_bound: Optional[float] = None,
     ) -> TestCaseResult:
         """Returns a TestCaseResult object with the given args
 
@@ -111,6 +124,9 @@ class BaseTestValidator(ABC):
             result=result,
             testResultValue=test_result_value,
             sampleData=None,
+            # if users don't set the min/max bound, we'll change the inf/-inf (used for computation) to None
+            minBound=None if min_bound == float("-inf") else min_bound,
+            maxBound=None if max_bound == float("inf") else max_bound,
         )
 
         if (row_count is not None and row_count != 0) and (
@@ -149,7 +165,7 @@ class BaseTestValidator(ABC):
         """
         return TestCaseStatus.Success if condition else TestCaseStatus.Failed
 
-    def get_min_bound(self, param_name: str):
+    def get_min_bound(self, param_name: str) -> Optional[float]:
         """get min value for max value in column test case"""
         return self.get_test_case_param_value(
             self.test_case.parameterValues,  # type: ignore
@@ -158,7 +174,7 @@ class BaseTestValidator(ABC):
             default=float("-inf"),
         )
 
-    def get_max_bound(self, param_name: str):
+    def get_max_bound(self, param_name: str) -> Optional[float]:
         """get max value for max value in column test case"""
         return self.get_test_case_param_value(
             self.test_case.parameterValues,  # type: ignore
@@ -166,3 +182,7 @@ class BaseTestValidator(ABC):
             float,
             default=float("inf"),
         )
+
+    def get_predicted_value(self) -> Optional[str]:
+        """Get predicted value"""
+        return None

metadata/data_quality/validations/column/base/columnValueLengthsToBeBetween.py

@@ -83,6 +83,8 @@ class BaseColumnValueLengthsToBeBetweenValidator(BaseTestValidator):
             ],
             row_count=row_count,
             failed_rows=failed_rows,
+            min_bound=min_bound,
+            max_bound=max_bound,
         )
 
     @abstractmethod

metadata/data_quality/validations/column/base/columnValueMaxToBeBetween.py

@@ -65,6 +65,8 @@ class BaseColumnValueMaxToBeBetweenValidator(BaseTestValidator):
             self.get_test_case_status(min_bound <= res <= max_bound),
             f"Found max={res} vs.  the expected min={min_bound}, max={max_bound}.",
             [TestResultValue(name=MAX, value=str(res))],
+            min_bound=min_bound,
+            max_bound=max_bound,
         )
 
     @abstractmethod

metadata/data_quality/validations/column/base/columnValueMeanToBeBetween.py

@@ -65,6 +65,8 @@ class BaseColumnValueMeanToBeBetweenValidator(BaseTestValidator):
             self.get_test_case_status(min_bound <= res <= max_bound),
             f"Found mean={res} vs.  the expected min={min_bound}, max={max_bound}.",
             [TestResultValue(name=MEAN, value=str(res))],
+            min_bound=min_bound,
+            max_bound=max_bound,
         )
 
     @abstractmethod

metadata/data_quality/validations/column/base/columnValueMedianToBeBetween.py

@@ -65,6 +65,8 @@ class BaseColumnValueMedianToBeBetweenValidator(BaseTestValidator):
             self.get_test_case_status(min_bound <= res <= max_bound),
             f"Found median={res} vs.  the expected min={min_bound}, max={max_bound}.",
             [TestResultValue(name=MEDIAN, value=str(res))],
+            min_bound=min_bound,
+            max_bound=max_bound,
         )
 
     @abstractmethod

metadata/data_quality/validations/column/base/columnValueMinToBeBetween.py

@@ -65,6 +65,8 @@ class BaseColumnValueMinToBeBetweenValidator(BaseTestValidator):
             self.get_test_case_status(min_bound <= res <= max_bound),
             f"Found min={res} vs.  the expected min={min_bound}, max={max_bound}.",
             [TestResultValue(name=MIN, value=str(res))],
+            min_bound=min_bound,
+            max_bound=max_bound,
         )
 
     @abstractmethod