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

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

@@ -0,0 +1,117 @@
+from typing import List
+from typing import Set
+
+from datapilot.config.utils import get_insight_configuration
+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 CheckSourceHasMetaKeys(ChecksInsight):
+    NAME = "Source has required metadata keys"
+    ALIAS = "check_source_has_meta_keys"
+    DESCRIPTION = "Check if the source has required metadata keys"
+    REASON_TO_FLAG = "Missing meta keys in the source can lead to inconsistency in metadata management and understanding of the source. It's important to ensure that the source includes all the required meta keys as per the configuration."
+    META_KEYS_STR = "meta_keys"
+    ALLOW_EXTRA_KEYS_STR = "allow_extra_keys"
+
+    def _build_failure_result(
+        self,
+        source_id: int,
+        missing: Set[str],
+        extra: Set[str],
+    ) -> DBTInsightResult:
+        """
+        Build failure result for the insight if a model's parent schema is not whitelist or in blacklist.
+        """
+        failure_message = ""
+        if missing:
+            failure_message += f"The source:{source_id} does not have the following meta keys defined: {numbered_list(missing)}\n"
+        if extra:
+            failure_message += f"The source:{source_id} has the following extra meta keys defined: {numbered_list(extra)}\n"
+
+        recommendation = "Define the meta keys for the source to ensure consistency in analysis."
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"source_id": source_id},
+        )
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generate the insight response for the check. This method is called by the insight runner to generate the insight
+        response for the check.
+        Ensures that the source has a list of valid meta keys.
+        meta_keys are provided in the configuration file.
+        """
+        insights = []
+        self.insight_config = get_insight_configuration(self.config)
+        self.meta_keys = self.get_check_config(self.META_KEYS_STR) or []
+        self.allow_extra_keys = self.get_check_config(self.ALLOW_EXTRA_KEYS_STR)
+        if not self.meta_keys and not self.allow_extra_keys:
+            self.logger.error(f"Meta keys are not provided in the configuration file for the insight: {self.ALIAS}")
+            return insights
+
+        for node_id, node in self.sources.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping source {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.source:
+                status_code, missing, extra = self._check_source_has_meta_keys(node_id)
+                if status_code:
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            original_file_path=node.original_file_path,
+                            path=node.original_file_path,
+                            insight=self._build_failure_result(node_id, missing, extra),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _check_source_has_meta_keys(self, source_unique_id: str):
+        status_code = 0
+        model = self.get_node(source_unique_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 sources properties.",
+                },
+                cls.ALLOW_EXTRA_KEYS_STR: {
+                    "type": "boolean",
+                    "default": False,
+                },
+            },
+            "required": [cls.META_KEYS_STR],
+        }
+        return config_schema

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

@@ -0,0 +1,82 @@
+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 CheckSourceHasTests(ChecksInsight):
+    NAME = "Source has tests"
+    ALIAS = "check_source_has_tests"
+    DESCRIPTION = "Check if the source has tests"
+    REASON_TO_FLAG = "The source table is missing tests. Ensure that the source table has tests."
+    TESTS_STR = "tests"
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        insights = []
+        source_threshold = self.get_check_config(self.TESTS_STR) or 1
+        for node_id, node in self.sources.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.source:
+                source_test_count = self.get_source_test_count(node_id)
+                if source_test_count < source_threshold:
+                    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, source_test_count, source_threshold),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _build_failure_result(self, source_unique_id: str, source_test_count: int, source_test_count_threshold: int) -> DBTInsightResult:
+        failure_message = (
+            "The following sources do not have enough tests. Ensure that each source has at least {source_test_count_threshold} tests."
+        )
+        recommendation = "Add tests for each source listed above. Having tests ensures proper validation and data integrity."
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message.format(
+                source_test_count_threshold=source_test_count_threshold,
+            ),
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"source_test_count": source_test_count, "source_unique_id": source_unique_id},
+        )
+
+    def get_source_test_count(self, node_id: str) -> int:
+        """
+        Getting test count of sources by checking child nodes of sources that have type test.
+        """
+        count = 0
+        for child_id in self.children_map.get(node_id, []):
+            child = self.get_node(child_id)
+            if child.resource_type == AltimateResourceType.test:
+                count += 1
+        return count
+
+    @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_STR: {
+                    "type": "integer",
+                    "description": "Minimum number of tests required for each source",
+                    "default": 0,
+                },
+            },
+            "required": [cls.TESTS_STR],
+        }
+        return config_schema

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

@@ -0,0 +1,117 @@
+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 CheckSourceHasTestsByGroup(ChecksInsight):
+    NAME = "Source has tests by group"
+    ALIAS = "check_source_has_tests_by_group"
+    DESCRIPTION = "Check if sources have a number of tests for specific test groups."
+    REASON_TO_FLAG = "Sources 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]:
+        insights = []
+        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)
+        }
+        for node_id, node in self.sources.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping source {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.source:
+                missing_test_groups = self._source_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, source_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 source `{source_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 source 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={"source_unique_id": source_unique_id, "missing_test_groups": missing_test_groups},
+        )
+
+    def _source_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.TESTS_LIST_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],
+        }

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

@@ -0,0 +1,113 @@
+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 CheckSourceHasTestsByName(ChecksInsight):
+    NAME = "Source has tests by name"
+    ALIAS = "check_source_has_tests_by_name"
+    DESCRIPTION = "Checks that the source has tests with specific names."
+    REASON_TO_FLAG = "Sources 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.sources.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping source {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.source:
+                missing_tests = self._source_has_tests_by_name(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),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _build_failure_result(self, source_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 source `{source_unique_id}` does not have enough tests:\n{tests_str}. "
+        recommendation = (
+            "Add tests with the specified names for each source 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={"source_unique_id": source_unique_id},
+        )
+
+    def _source_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.TESTS_LIST_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],
+        }

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

@@ -0,0 +1,119 @@
+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 CheckSourceHasTestsByType(ChecksInsight):
+    NAME = "Source has tests by type"
+    ALIAS = "check_source_has_tests_by_type"
+    DESCRIPTION = "Checks that the source has tests with specific types."
+    REASON_TO_FLAG = "Sources 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_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.sources.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping source {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.source:
+                missing_tests = self._source_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, source_unique_id: str, missing_tests) -> 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 source `{source_unique_id}` does not have enough tests for the following types:\n{missing_test_type_str}. "
+        recommendation = (
+            "Add tests with the specified types for each source listed above. "
+            "Having tests with specific types 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={"source_unique_id": source_unique_id},
+        )
+
+    def _source_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:
+                child_tags = child.tags or []
+                test_type = "data" if "data" in child_tags else "schema"
+                test_count[test_type] = test_count.get(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": ["schema", "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

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

@@ -0,0 +1,62 @@
+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 CheckSourceTableHasDescription(ChecksInsight):
+    NAME = "Source table has description"
+    ALIAS = "check_source_table_has_desc"
+    DESCRIPTION = "Ensures that the source table has a description"
+    REASON_TO_FLAG = "Missing description for the source table can lead to confusion and inconsistency in analysis. "
+
+    def _build_failure_result(self, source_id: int) -> DBTInsightResult:
+        """
+        Build failure result for the insight if a model's parent schema is not whitelist or in blacklist.
+        """
+        failure_message = f"The source:{source_id} does not have a description defined.\n"
+
+        recommendation = "Define the description for the source table to ensure consistency in analysis."
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"source_id": source_id},
+        )
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generate the insight response for the check. This method is called by the insight runner to generate the insight
+        response for the check.
+        Ensures that the source table has a description
+        """
+        insights = []
+        for node_id, node in self.sources.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping source {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.source:
+                if not self._check_source_table_desc(node_id):
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            original_file_path=node.original_file_path,
+                            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 _check_source_table_desc(self, source_unique_id: str) -> bool:
+        source = self.get_node(source_unique_id)
+        if source.description is None:
+            return False
+        return True