altimate-datapilot-cli 0.0.8__py3-none-any.whl

datapilot/core/platforms/dbt/insights/checks/check_model_has_labels_keys.py

@@ -0,0 +1,112 @@
+from typing import List
+from typing import Sequence
+from typing import Set
+from typing import Tuple
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+from datapilot.utils.formatting.utils import numbered_list
+
+
+class CheckModelHasLabelsKeys(ChecksInsight):
+    NAME = "Model Has labels"
+    ALIAS = "check_model_has_labels_keys"
+    DESCRIPTION = "Models should have all the labels keys as per the configuration."
+    REASON_TO_FLAG = (
+        "Missing labels keys in the model can lead to inconsistency in metadata management and understanding of the model. "
+        "It's important to ensure that the model includes all the required labels keys as per the configuration."
+    )
+    LABEL_KEYS_STR = "labels_keys"
+    ALLOW_EXTRA_KEYS_STR = "allow_extra_keys"
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        self.labels_keys = self.get_check_config(self.LABEL_KEYS_STR)
+        self.allow_extra_keys = self.get_check_config(self.ALLOW_EXTRA_KEYS_STR)
+
+        insights = []
+        for node_id, node in self.nodes.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping model {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.model:
+                status_code, missibg_labels, extra_labels = self._check_labels_keys(node_id)
+                if status_code == 1:
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            path=node.original_file_path,
+                            original_file_path=node.original_file_path,
+                            insight=self._build_failure_result(node_id, missibg_labels, extra_labels),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _build_failure_result(self, model_unique_id: str, missing_keys: Sequence[str], extra_labels: Sequence[str]) -> DBTInsightResult:
+        failure_message = (
+            f"The following labels keys are missing in the model `{model_unique_id}`:\n{missing_keys}. "
+            "Ensure that the model includes all the required labels keys."
+        )
+        if not self.allow_extra_keys:
+            failure_message += (
+                f"The following extra labels keys are present in the model `{model_unique_id}`:\n{extra_labels}. "
+                "Ensure that the model does not include any extra labels keys."
+            )
+        recommendation = (
+            f"Add the missing labels keys listed above in the model `{model_unique_id}`. "
+            "Ensuring that the model has all the required labels keys helps in maintaining metadata consistency and understanding."
+        )
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message.format(
+                missing_keys=numbered_list(missing_keys),
+                model_unique_id=model_unique_id,
+            ),
+            recommendation=recommendation.format(model_unique_id=model_unique_id),
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"missing_keys": missing_keys, "model_unique_id": model_unique_id, "extra_keys": extra_labels},
+        )
+
+    def _check_labels_keys(self, node_id) -> Tuple[int, Set[str]]:
+        status_code = 0
+        missing_keys = set(self.labels_keys) - set(self.get_node(node_id).label)
+        config = self.get_node(node_id).config.dict() if self.get_node(node_id).config else {}
+        labels = config.get("labels", {})
+        label_keys = set(labels.keys())
+        extra_keys = set()
+        if missing_keys:
+            status_code = 1
+        if not self.allow_extra_keys:
+            extra_keys = label_keys - set(self.labels_keys)
+            if extra_keys:
+                status_code = 1
+        return status_code, missing_keys, extra_keys
+
+    @classmethod
+    def get_config_schema(cls):
+        config_schema = super().get_config_schema()
+        config_schema["config"] = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                cls.LABEL_KEYS_STR: {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                    },
+                    "description": "A list of meta keys that should be present in the model.",
+                },
+                cls.ALLOW_EXTRA_KEYS_STR: {
+                    "type": "boolean",
+                    "default": False,
+                },
+            },
+            "required": [cls.LABEL_KEYS_STR],
+        }
+        return config_schema

datapilot/core/platforms/dbt/insights/checks/check_model_has_meta_keys.py

@@ -0,0 +1,108 @@
+from typing import List
+from typing import Sequence
+from typing import Set
+from typing import Tuple
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+from datapilot.utils.formatting.utils import numbered_list
+
+
+class CheckModelHasMetaKeys(ChecksInsight):
+    NAME = "Model has all valid keys in metadata"
+    ALIAS = "check_model_has_valid_meta_keys"
+    DESCRIPTION = "Model always has a list of valid metadata keys."
+    REASON_TO_FLAG = (
+        "Missing meta keys in the model can lead to inconsistency in metadata management and understanding of the model. "
+        "It's important to ensure that the model includes all the required meta keys as per the configuration."
+    )
+    META_KEYS_STR = "meta_keys"
+    ALLOW_EXTRA_KEYS_STR = "allow_extra_keys"
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        self.meta_keys = self.get_check_config(self.META_KEYS_STR)
+        self.allow_extra_keys = self.get_check_config(self.ALLOW_EXTRA_KEYS_STR)
+        insights = []
+        for node_id, node in self.nodes.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping model {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.model:
+                status_code, missing_keys, extra_keys = self._check_meta_keys(node_id)
+                if status_code == 1:
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            path=node.original_file_path,
+                            original_file_path=node.original_file_path,
+                            insight=self._build_failure_result(node_id, missing_keys, extra_keys),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _build_failure_result(self, model_unique_id: str, missing_keys: Sequence[str], extra_keys: Set[str]) -> DBTInsightResult:
+        failure_message = (
+            f"The following meta keys are missing in the model `{model_unique_id}`:\n{numbered_list(missing_keys)}. "
+            "Ensure that the model includes all the required meta keys."
+        )
+        if not self.allow_extra_keys:
+            failure_message += (
+                f"The following extra meta keys are present in the model `{model_unique_id}`:\n{numbered_list(extra_keys)}. "
+                "Ensure that the model does not include any extra meta keys."
+            )
+        recommendation = (
+            f"Add the missing meta keys listed above in the model `{model_unique_id}`. "
+            "Ensuring that the model has all the required meta keys helps in maintaining metadata consistency and understanding."
+        )
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation.format(model_unique_id=model_unique_id),
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"missing_keys": missing_keys, "model_unique_id": model_unique_id, "extra_keys": extra_keys},
+        )
+
+    def _check_meta_keys(self, node_id) -> Tuple[int, Set[str], Set[str]]:
+        status_code = 0
+        model = self.get_node(node_id)
+        meta = model.meta.dict() if model.meta else {}
+        model_meta_keys = set(meta.keys())
+        missing_keys = None
+        extra_keys = None
+        if model.meta:
+            missing_keys = model_meta_keys - set(model.meta.keys())
+        if missing_keys:
+            status_code = 1
+        if not self.allow_extra_keys:
+            extra_keys = set(model.meta.keys()) - model_meta_keys
+        return status_code, missing_keys, extra_keys
+
+    @classmethod
+    def get_config_schema(cls):
+        config_schema = super().get_config_schema()
+        config_schema["config"] = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                cls.META_KEYS_STR: {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                    },
+                    "description": "A list of metadata keys that should be present in the model properties files.",
+                },
+                cls.ALLOW_EXTRA_KEYS_STR: {
+                    "type": "boolean",
+                    "default": False,
+                },
+            },
+            "required": [cls.META_KEYS_STR],
+        }
+        return config_schema

datapilot/core/platforms/dbt/insights/checks/check_model_has_properties_file.py

@@ -0,0 +1,64 @@
+from typing import List
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+
+
+class CheckModelHasPropertiesFile(ChecksInsight):
+    NAME = "Model has properties file"
+    ALIAS = "check_model_has_properties_file"
+    DESCRIPTION = "Models should have a properties/schema file (.yml) defined."
+    REASON_TO_FLAG = (
+        "Missing properties file for a model can lead to inadequate configuration and documentation, "
+        "resulting in potential issues in data processing and understanding."
+    )
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        insights = []
+        for node_id, node in self.nodes.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping model {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.model:
+                status_code = self._check_properties_file(node_id)
+                if status_code == 1:
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            path=node.original_file_path,
+                            original_file_path=node.original_file_path,
+                            insight=self._build_failure_result(node_id),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _build_failure_result(self, model_unique_id: str) -> DBTInsightResult:
+        failure_message = (
+            f"The model {model_unique_id} do not have a properties file (.yml) defined."
+            "Ensure that each model has a corresponding .yml file for additional configuration and documentation."
+        )
+        recommendation = (
+            "Add a properties file (.yml) for each model listed above. "
+            "Having a properties file helps in providing additional configuration and documentation for the model."
+        )
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"model_unique_id": model_unique_id},
+        )
+
+    def _check_properties_file(self, node_id) -> int:
+        status_code = 0
+        node = self.get_node(node_id)
+        if node.resource_type == AltimateResourceType.model and not node.patch_path:
+            status_code = 1
+        return status_code

datapilot/core/platforms/dbt/insights/checks/check_model_has_tests_by_group.py

@@ -0,0 +1,118 @@
+from typing import Dict
+from typing import List
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+
+
+class CheckModelHasTestsByGroup(ChecksInsight):
+    NAME = "Model has tests by group"
+    ALIAS = "check_model_has_tests_by_group"
+    DESCRIPTION = "Check if models have a number of tests for specific test groups."
+    REASON_TO_FLAG = "Models should have tests with specific groups for proper validation."
+    TESTS_LIST_STR = "tests"
+    TEST_GROUP_STR = "test_group"
+    TEST_COUNT_STR = "min_count"
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        self.test_list = self.get_check_config(self.TESTS_LIST_STR) or []
+        self.test_groups = {
+            tuple(test.get(self.TEST_GROUP_STR, [])): test.get(self.TEST_COUNT_STR, 0)
+            for test in self.test_list
+            if test.get(self.TEST_GROUP_STR)
+        }
+        if not self.test_groups:
+            self.logger.warning(f"No test groups found in the configuration for {self.ALIAS}. Skipping the insight.")
+            return []
+        insights = []
+        for node_id, node in self.nodes.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping model {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.model:
+                missing_test_groups = self._model_has_tests_by_group(node_id)
+                if missing_test_groups:
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            path=node.original_file_path,
+                            original_file_path=node.original_file_path,
+                            insight=self._build_failure_result(node_id, missing_test_groups),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _build_failure_result(self, model_unique_id: str, missing_test_groups: List[Dict]) -> DBTInsightResult:
+        missing_test_group_str = ""
+        for test in missing_test_groups:
+            missing_test_group_str += f"Test Group: {test.get(self.TEST_GROUP_STR)}, Min Count: {test.get(self.TEST_COUNT_STR)}, Actual Count: {test.get('actual_count')}\n"
+
+        failure_message = f"The model `{model_unique_id}` does not have enough tests for the following groups:\n{missing_test_group_str}. "
+        recommendation = (
+            "Add tests with the specified groups for each model listed above. "
+            "Having tests with specific groups ensures proper validation and data integrity."
+        )
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"model_unique_id": model_unique_id, "missing_test_groups": missing_test_groups},
+        )
+
+    def _model_has_tests_by_group(self, node_id) -> List[Dict]:
+        """
+        For model, check all dependencies and if node type is test, check if it has the required groups.
+        Only return true if all child.group in test_groups
+        """
+        test_group_count = {}
+        for child_id in self.children_map.get(node_id, []):
+            child = self.get_node(child_id)
+            if child.resource_type == AltimateResourceType.test:
+                for group in self.test_groups:
+                    if child.name in group:
+                        test_group_count[group] = test_group_count.get(group, 0) + 1
+        missing_test_groups = []
+        for group, count in self.test_groups.items():
+            if test_group_count.get(group, 0) < count:
+                missing_test_groups.append(
+                    {self.TEST_GROUP_STR: group, self.TEST_COUNT_STR: count, "actual_count": test_group_count.get(group, 0)}
+                )
+
+        return missing_test_groups
+
+    @classmethod
+    def get_config_schema(cls):
+        config_schema = super().get_config_schema()
+        config_schema["config"] = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                cls.TESTS_LIST_STR: {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            cls.TEST_GROUP_STR: {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "List of tests part of a group. If a test is part of any of the groups, it will be counted.",
+                            },
+                            cls.TEST_COUNT_STR: {"type": "integer", "description": "The minimum number of tests required", "default": 1},
+                        },
+                        "required": [cls.TEST_GROUP_STR, cls.TEST_COUNT_STR],
+                    },
+                    "description": "A list of tests with names and minimum counts required.",
+                    "default": [],
+                },
+            },
+            "required": [cls.TESTS_LIST_STR],
+        }
+        return config_schema

datapilot/core/platforms/dbt/insights/checks/check_model_has_tests_by_name.py

@@ -0,0 +1,114 @@
+from typing import Dict
+from typing import List
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+
+
+class CheckModelHasTestsByName(ChecksInsight):
+    NAME = "Model has tests by name"
+    ALIAS = "check_model_has_tests_by_name"
+    DESCRIPTION = "Checks that the model has tests with specific names."
+    REASON_TO_FLAG = "Models should have tests with specific names for proper validation."
+    TESTS_LIST_STR = "tests"
+    TEST_NAME_STR = "test"
+    TEST_COUNT_STR = "min_count"
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        self.test_list = self.get_check_config(self.TESTS_LIST_STR) or []
+        self.tests = {
+            test.get(self.TEST_NAME_STR): test.get(self.TEST_COUNT_STR, 0) for test in self.test_list if test.get(self.TEST_NAME_STR)
+        }
+        if not self.tests:
+            self.logger.warning(f"No tests found in the configuration for {self.ALIAS}. Skipping the insight.")
+            return []
+        insights = []
+        for node_id, node in self.nodes.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping model {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.model:
+                status, missing_tests = self._model_has_tests_by_name(node_id)
+                if not status:
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            path=node.original_file_path,
+                            original_file_path=node.original_file_path,
+                            insight=self._build_failure_result(node_id, missing_tests),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _build_failure_result(self, model_unique_id: str, missing_tests: List[Dict]) -> DBTInsightResult:
+        tests_str = ""
+        for test in missing_tests:
+            tests_str += f"Test Name: {test.get(self.TEST_NAME_STR)}, Min Count: {test.get(self.TEST_COUNT_STR)}, Actual Count: {test.get('actual_count')}\n"
+
+        failure_message = f"The model `{model_unique_id}` does not have enough tests:\n{tests_str}. "
+        recommendation = (
+            "Add tests with the specified names for each model listed above. "
+            "Having tests with specific names ensures proper validation and data integrity."
+        )
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"model_unique_id": model_unique_id},
+        )
+
+    def _model_has_tests_by_name(self, node_id) -> bool:
+        """
+        For model, check all dependencies and if node type is test, check if it has the required names.
+        Only return true if all child.name in test_names
+        """
+        test_count = {}
+
+        for child_id in self.children_map.get(node_id, []):
+            child = self.get_node(child_id)
+            if child.resource_type == AltimateResourceType.test:
+                test_name = child.name
+                test_count[test_name] = test_count.get(test_name, 0) + 1
+
+        missing_tests = []
+        for test_name, min_count in self.tests.items():
+            if test_count.get(test_name, 0) < min_count:
+                missing_tests.append({"test_name": test_name, "min_count": min_count, "actual_count": test_count.get(test_name, 0)})
+
+        if missing_tests:
+            return False, missing_tests
+
+        return True, None
+
+    @classmethod
+    def get_config_schema(cls):
+        config_schema = super().get_config_schema()
+        config_schema["config"] = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                cls.TESTS_LIST_STR: {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            cls.TEST_NAME_STR: {"type": "string", "description": "The name of the test"},
+                            cls.TEST_COUNT_STR: {"type": "integer", "description": "The minimum number of tests required", "default": 1},
+                        },
+                        "required": [cls.TEST_NAME_STR, cls.TEST_COUNT_STR],
+                    },
+                    "description": "A list of tests with names and minimum counts required.",
+                    "default": [],
+                },
+            },
+            "required": [cls.TESTS_LIST_STR],
+        }
+        return config_schema

datapilot/core/platforms/dbt/insights/checks/check_model_has_tests_by_type.py

@@ -0,0 +1,119 @@
+from typing import Dict
+from typing import List
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+
+
+class CheckModelHasTestsByType(ChecksInsight):
+    NAME = "Model has tests by type"
+    ALIAS = "check_model_has_tests_by_type"
+    DESCRIPTION = "Checks that the model has tests with specific types."
+    REASON_TO_FLAG = "Models should have tests with specific types for proper validation."
+    TESTS_LIST_STR = "tests"
+    TEST_TYPE_STR = "test"
+    TEST_COUNT_STR = "min_count"
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        self.test_list = self.get_check_config(self.TESTS_LIST_STR) or []
+        self.tests = {
+            test.get(self.TEST_TYPE_STR): test.get(self.TEST_COUNT_STR, 0) for test in self.test_list if test.get(self.TEST_TYPE_STR)
+        }
+        if not self.tests:
+            self.logger.warning(f"No tests found in the configuration for {self.ALIAS}. Skipping the insight.")
+            return []
+
+        insights = []
+        for node_id, node in self.nodes.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping model {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.model:
+                missing_tests = self._model_has_tests_by_type(node_id)
+                if missing_tests:
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            path=node.original_file_path,
+                            original_file_path=node.original_file_path,
+                            insight=self._build_failure_result(node_id, missing_tests),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _build_failure_result(self, model_unique_id: str, missing_tests: List[Dict]) -> DBTInsightResult:
+        missing_test_type_str = ""
+        for test in missing_tests:
+            missing_test_type_str += f"Test type: {test.get(self.TEST_TYPE_STR)}, Min Count: {test.get(self.TEST_COUNT_STR)}, Actual Count: {test.get('actual_count')}\n"
+
+        failure_message = f"The model `{model_unique_id}` does not have enough tests for the following types:\n{missing_test_type_str}. "
+        recommendation = (
+            "Add tests with the specified names for each model listed above. "
+            "Having tests with specific names ensures proper validation and data integrity."
+        )
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"model_unique_id": model_unique_id, "missing_tests": missing_tests},
+        )
+
+    def _model_has_tests_by_type(self, node_id) -> bool:
+        """
+        For model, check all dependencies and if node type is test, check if it has the required types.
+        Only return true if all child.type in test_types
+        """
+        test_count = {}
+        for child_id in self.children_map.get(node_id, []):
+            child = self.get_node(child_id)
+            if child.resource_type == AltimateResourceType.test:
+                self.logger.info(f"child_id: {child_id}, child: {type(child)}")
+                test_count[child.test_type] = test_count.get(child.test_type, 0) + 1
+        missing_tests = []
+        for test_type in self.tests.keys():
+            if test_count.get(test_type, 0) < self.tests.get(test_type, 0):
+                missing_tests.append(
+                    {
+                        self.TEST_TYPE_STR: test_type,
+                        self.TEST_COUNT_STR: self.tests.get(test_type, 0),
+                        "actual_count": test_count.get(test_type, 0),
+                    }
+                )
+        return missing_tests
+
+    @classmethod
+    def get_config_schema(cls):
+        config_schema = super().get_config_schema()
+        config_schema["config"] = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                cls.TESTS_LIST_STR: {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            cls.TEST_TYPE_STR: {
+                                "type": "string",
+                                "enum": ["singul", "data"],
+                                "description": "The type of the test",
+                            },
+                            cls.TEST_COUNT_STR: {"type": "integer", "description": "The minimum number of tests required", "default": 1},
+                        },
+                        "required": [cls.TEST_TYPE_STR, cls.TEST_COUNT_STR],
+                    },
+                    "description": "A list of tests with names and minimum counts required.",
+                    "default": [],
+                },
+            },
+            "required": [cls.TESTS_LIST_STR],
+        }
+        return config_schema