dbt-bouncer 1.31.2rc3__py3-none-any.whl → 2.0.0__py3-none-any.whl

dbt_bouncer/checks/manifest/check_sources.py

@@ -1,10 +1,9 @@
-# mypy: disable-error-code="union-attr"
-
 import re
-from typing import TYPE_CHECKING, List, Literal
+from pathlib import Path
+from typing import TYPE_CHECKING, Literal
 
 if TYPE_CHECKING:
-    from dbt_bouncer.artifact_parsers.parsers_common import (
+    from dbt_bouncer.artifact_parsers.parsers_manifest import (
         DbtBouncerModelBase,
         DbtBouncerSourceBase,
     )
@@ -14,37 +13,57 @@ if TYPE_CHECKING:
 from pydantic import Field
 
 from dbt_bouncer.check_base import BaseCheck
+from dbt_bouncer.checks.common import DbtBouncerFailedCheckError
 from dbt_bouncer.utils import clean_path_str, find_missing_meta_keys
 
 
 class CheckSourceDescriptionPopulated(BaseCheck):
     """Sources must have a populated description.
 
+    Parameters:
+        min_description_length (int | None): Minimum length required for the description to be considered populated.
+
     Receives:
         source (DbtBouncerSourceBase): The DbtBouncerSourceBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
         manifest_checks:
             - name: check_source_description_populated
         ```
+        ```yaml
+        manifest_checks:
+            - name: check_source_description_populated
+              min_description_length: 25 # Setting a stricter requirement for description length
+        ```
 
     """
 
+    min_description_length: int | None = Field(default=None)
     name: Literal["check_source_description_populated"]
-    source: "DbtBouncerSourceBase" = Field(default=None)
+    source: "DbtBouncerSourceBase | None" = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
-        assert self.is_description_populated(self.source.description), (
-            f"`{self.source.source_name}.{self.source.name}` does not have a populated description."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If description is not populated.
+
+        """
+        if self.source is None:
+            raise DbtBouncerFailedCheckError("self.source is None")
+        if not self._is_description_populated(
+            self.source.description or "", self.min_description_length
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"`{self.source.source_name}.{self.source.name}` does not have a populated description."
+            )
 
 
 class CheckSourceFreshnessPopulated(BaseCheck):
@@ -54,10 +73,10 @@ class CheckSourceFreshnessPopulated(BaseCheck):
         source (DbtBouncerSource): The DbtBouncerSourceBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -68,19 +87,33 @@ class CheckSourceFreshnessPopulated(BaseCheck):
     """
 
     name: Literal["check_source_freshness_populated"]
-    source: "DbtBouncerSourceBase" = Field(default=None)
+    source: "DbtBouncerSourceBase | None" = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If freshness is not populated.
+
+        """
+        if self.source is None:
+            raise DbtBouncerFailedCheckError("self.source is None")
         error_msg = f"`{self.source.source_name}.{self.source.name}` does not have a populated freshness."
-        assert self.source.freshness is not None, error_msg
-        assert (
-            self.source.freshness.error_after.count is not None
+        if self.source.freshness is None:
+            raise DbtBouncerFailedCheckError(error_msg)
+        has_error_after = (
+            self.source.freshness.error_after
+            and self.source.freshness.error_after.count is not None
             and self.source.freshness.error_after.period is not None
-        ) or (
-            self.source.freshness.warn_after.count is not None
+        )
+        has_warn_after = (
+            self.source.freshness.warn_after
+            and self.source.freshness.warn_after.count is not None
             and self.source.freshness.warn_after.period is not None
-        ), error_msg
+        )
+
+        if not (has_error_after or has_warn_after):
+            raise DbtBouncerFailedCheckError(error_msg)
 
 
 class CheckSourceHasMetaKeys(BaseCheck):
@@ -93,10 +126,10 @@ class CheckSourceHasMetaKeys(BaseCheck):
         source (DbtBouncerSource): The DbtBouncerSourceBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -113,33 +146,41 @@ class CheckSourceHasMetaKeys(BaseCheck):
 
     keys: "NestedDict"
     name: Literal["check_source_has_meta_keys"]
-    source: "DbtBouncerSourceBase" = Field(default=None)
+    source: "DbtBouncerSourceBase | None" = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If required meta keys are missing.
+
+        """
+        if self.source is None:
+            raise DbtBouncerFailedCheckError("self.source is None")
         missing_keys = find_missing_meta_keys(
             meta_config=self.source.meta,
             required_keys=self.keys.model_dump(),
         )
 
-        assert missing_keys == [], (
-            f"`{self.source.source_name}.{self.source.name}` is missing the following keys from the `meta` config: {[x.replace('>>', '') for x in missing_keys]}"
-        )
+        if missing_keys != []:
+            raise DbtBouncerFailedCheckError(
+                f"`{self.source.source_name}.{self.source.name}` is missing the following keys from the `meta` config: {[x.replace('>>', '') for x in missing_keys]}"
+            )
 
 
 class CheckSourceHasTags(BaseCheck):
     """Sources must have the specified tags.
 
     Parameters:
-        criteria: (Optional[Literal["any", "all", "one"]]): Whether the source must have any, all, or exactly one of the specified tags. Default: `all`.
+        criteria: (Literal["any", "all", "one"] | None): Whether the source must have any, all, or exactly one of the specified tags. Default: `all`.
         source (DbtBouncerSource): The DbtBouncerSourceBase object to check.
-        tags (List[str]): List of tags to check for.
+        tags (list[str]): List of tags to check for.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -154,22 +195,34 @@ class CheckSourceHasTags(BaseCheck):
 
     criteria: Literal["any", "all", "one"] = Field(default="all")
     name: Literal["check_source_has_tags"]
-    source: "DbtBouncerSourceBase" = Field(default=None)
-    tags: List[str]
+    source: "DbtBouncerSourceBase | None" = Field(default=None)
+    tags: list[str]
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If source does not have required tags.
+
+        """
+        if self.source is None:
+            raise DbtBouncerFailedCheckError("self.source is None")
+        source_tags = self.source.tags or []
         if self.criteria == "any":
-            assert any(tag in self.source.tags for tag in self.tags), (
-                f"`{self.source.source_name}.{self.source.name}` does not have any of the required tags: {self.tags}."
-            )
+            if not any(tag in source_tags for tag in self.tags):
+                raise DbtBouncerFailedCheckError(
+                    f"`{self.source.source_name}.{self.source.name}` does not have any of the required tags: {self.tags}."
+                )
         elif self.criteria == "all":
-            missing_tags = [tag for tag in self.tags if tag not in self.source.tags]
-            assert not missing_tags, (
-                f"`{self.source.source_name}.{self.source.name}` is missing required tags: {missing_tags}."
-            )
-        elif self.criteria == "one":
-            assert sum(tag in self.source.tags for tag in self.tags) == 1, (
+            missing_tags = set(self.tags) - set(source_tags)
+            if missing_tags:
+                raise DbtBouncerFailedCheckError(
+                    f"`{self.source.source_name}.{self.source.name}` is missing required tags: {missing_tags}."
+                )
+        elif (
+            self.criteria == "one" and sum(tag in source_tags for tag in self.tags) != 1
+        ):
+            raise DbtBouncerFailedCheckError(
                 f"`{self.source.source_name}.{self.source.name}` must have exactly one of the required tags: {self.tags}."
             )
 
@@ -181,10 +234,10 @@ class CheckSourceLoaderPopulated(BaseCheck):
         source (DbtBouncerSource): The DbtBouncerSourceBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -195,13 +248,21 @@ class CheckSourceLoaderPopulated(BaseCheck):
     """
 
     name: Literal["check_source_loader_populated"]
-    source: "DbtBouncerSourceBase" = Field(default=None)
+    source: "DbtBouncerSourceBase | None" = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
-        assert self.source.loader != "", (
-            f"`{self.source.source_name}.{self.source.name}` does not have a populated loader."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If loader is not populated.
+
+        """
+        if self.source is None:
+            raise DbtBouncerFailedCheckError("self.source is None")
+        if self.source.loader == "":
+            raise DbtBouncerFailedCheckError(
+                f"`{self.source.source_name}.{self.source.name}` does not have a populated loader."
+            )
 
 
 class CheckSourceNames(BaseCheck):
@@ -214,10 +275,10 @@ class CheckSourceNames(BaseCheck):
         source (DbtBouncerSource): The DbtBouncerSourceBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -231,30 +292,38 @@ class CheckSourceNames(BaseCheck):
 
     name: Literal["check_source_names"]
     source_name_pattern: str
-    source: "DbtBouncerSourceBase" = Field(default=None)
+    source: "DbtBouncerSourceBase | None" = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
-        assert (
-            re.compile(self.source_name_pattern.strip()).match(self.source.name)
-            is not None
-        ), (
-            f"`{self.source.source_name}.{self.source.name}` does not match the supplied regex `({self.source_name_pattern.strip()})`."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If source name does not match regex.
+
+        """
+        if self.source is None:
+            raise DbtBouncerFailedCheckError("self.source is None")
+        if (
+            re.compile(self.source_name_pattern.strip()).match(str(self.source.name))
+            is None
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"`{self.source.source_name}.{self.source.name}` does not match the supplied regex `({self.source_name_pattern.strip()})`."
+            )
 
 
 class CheckSourceNotOrphaned(BaseCheck):
     """Sources must be referenced in at least one model.
 
     Receives:
-        models (List[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
+        models (list[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
         source (DbtBouncerSource): The DbtBouncerSourceBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -264,18 +333,28 @@ class CheckSourceNotOrphaned(BaseCheck):
 
     """
 
-    models: List["DbtBouncerModelBase"] = Field(default=[])
+    models: list["DbtBouncerModelBase"] = Field(default=[])
     name: Literal["check_source_not_orphaned"]
-    source: "DbtBouncerSourceBase" = Field(default=None)
+    source: "DbtBouncerSourceBase | None" = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If source is orphaned.
+
+        """
+        if self.source is None:
+            raise DbtBouncerFailedCheckError("self.source is None")
         num_refs = sum(
-            self.source.unique_id in model.depends_on.nodes for model in self.models
-        )
-        assert num_refs >= 1, (
-            f"Source `{self.source.source_name}.{self.source.name}` is orphaned, i.e. not referenced by any model."
+            self.source.unique_id in getattr(model.depends_on, "nodes", [])
+            for model in self.models
+            if model.depends_on
         )
+        if num_refs < 1:
+            raise DbtBouncerFailedCheckError(
+                f"Source `{self.source.source_name}.{self.source.name}` is orphaned, i.e. not referenced by any model."
+            )
 
 
 class CheckSourcePropertyFileLocation(BaseCheck):
@@ -285,10 +364,10 @@ class CheckSourcePropertyFileLocation(BaseCheck):
         source (DbtBouncerSource): The DbtBouncerSourceBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -299,46 +378,57 @@ class CheckSourcePropertyFileLocation(BaseCheck):
     """
 
     name: Literal["check_source_property_file_location"]
-    source: "DbtBouncerSourceBase" = Field(default=None)
+    source: "DbtBouncerSourceBase | None" = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
-        path_cleaned = clean_path_str(self.source.original_file_path).replace(
-            "models/staging", ""
-        )
-        expected_substring = "_".join(path_cleaned.split("/")[:-1])
-
-        assert path_cleaned.split(
-            "/",
-        )[-1].startswith(
-            "_",
-        ), (
-            f"The properties file for `{self.source.source_name}.{self.source.name}` (`{path_cleaned}`) does not start with an underscore."
-        )
-        assert expected_substring in path_cleaned, (
-            f"The properties file for `{self.source.source_name}.{self.source.name}` (`{path_cleaned}`) does not contain the expected substring (`{expected_substring}`)."
-        )
-        assert path_cleaned.split(
-            "/",
-        )[-1].endswith(
-            "__sources.yml",
-        ), (
-            f"The properties file for `{self.source.source_name}.{self.source.name}` (`{path_cleaned}`) does not end with `__sources.yml`."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If property file location is incorrect.
+
+        """
+        if self.source is None:
+            raise DbtBouncerFailedCheckError("self.source is None")
+        original_path = Path(clean_path_str(self.source.original_file_path))
+
+        if (
+            len(original_path.parts) > 2
+            and original_path.parts[0] == "models"
+            and original_path.parts[1] == "staging"
+        ):
+            subdir_parts = original_path.parent.parts[2:]
+        else:
+            subdir_parts = original_path.parent.parts
+
+        expected_substring = "_" + "_".join(subdir_parts) if subdir_parts else ""
+        properties_yml_name = original_path.name
+
+        if not properties_yml_name.startswith("_"):
+            raise DbtBouncerFailedCheckError(
+                f"The properties file for `{self.source.source_name}.{self.source.name}` (`{properties_yml_name}`) does not start with an underscore."
+            )
+        if expected_substring not in properties_yml_name:
+            raise DbtBouncerFailedCheckError(
+                f"The properties file for `{self.source.source_name}.{self.source.name}` (`{properties_yml_name}`) does not contain the expected substring (`{expected_substring}`)."
+            )
+        if not properties_yml_name.endswith("__sources.yml"):
+            raise DbtBouncerFailedCheckError(
+                f"The properties file for `{self.source.source_name}.{self.source.name}` (`{properties_yml_name}`) does not end with `__sources.yml`."
+            )
 
 
 class CheckSourceUsedByModelsInSameDirectory(BaseCheck):
     """Sources can only be referenced by models that are located in the same directory where the source is defined.
 
     Parameters:
-        models (List[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
+        models (list[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
         source (DbtBouncerSource): The DbtBouncerSourceBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -348,38 +438,47 @@ class CheckSourceUsedByModelsInSameDirectory(BaseCheck):
 
     """
 
-    models: List["DbtBouncerModelBase"] = Field(default=[])
+    models: list["DbtBouncerModelBase"] = Field(default=[])
     name: Literal["check_source_used_by_models_in_same_directory"]
-    source: "DbtBouncerSourceBase" = Field(default=None)
+    source: "DbtBouncerSourceBase | None" = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If source is referenced by models in different directory.
+
+        """
+        if self.source is None:
+            raise DbtBouncerFailedCheckError("self.source is None")
         reffed_models_not_in_same_dir = []
         for model in self.models:
             if (
-                self.source.unique_id in model.depends_on.nodes
+                model.depends_on
+                and self.source.unique_id in getattr(model.depends_on, "nodes", [])
                 and model.original_file_path.split("/")[:-1]
                 != self.source.original_file_path.split("/")[:-1]
             ):
                 reffed_models_not_in_same_dir.append(model.name)
 
-        assert len(reffed_models_not_in_same_dir) == 0, (
-            f"Source `{self.source.source_name}.{self.source.name}` is referenced by models defined in a different directory: {reffed_models_not_in_same_dir}"
-        )
+        if len(reffed_models_not_in_same_dir) != 0:
+            raise DbtBouncerFailedCheckError(
+                f"Source `{self.source.source_name}.{self.source.name}` is referenced by models defined in a different directory: {reffed_models_not_in_same_dir}"
+            )
 
 
 class CheckSourceUsedByOnlyOneModel(BaseCheck):
     """Each source can be referenced by a maximum of one model.
 
     Receives:
-        models (List[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
+        models (list[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
         source (DbtBouncerSource): The DbtBouncerSourceBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Source paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the source path (i.e the .yml file where the source is configured). Only source paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -389,15 +488,25 @@ class CheckSourceUsedByOnlyOneModel(BaseCheck):
 
     """
 
-    models: List["DbtBouncerModelBase"] = Field(default=[])
+    models: list["DbtBouncerModelBase"] = Field(default=[])
     name: Literal["check_source_used_by_only_one_model"]
-    source: "DbtBouncerSourceBase" = Field(default=None)
+    source: "DbtBouncerSourceBase | None" = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If source is referenced by more than one model.
+
+        """
+        if self.source is None:
+            raise DbtBouncerFailedCheckError("self.source is None")
         num_refs = sum(
-            self.source.unique_id in model.depends_on.nodes for model in self.models
-        )
-        assert num_refs <= 1, (
-            f"Source `{self.source.source_name}.{self.source.name}` is referenced by more than one model."
+            self.source.unique_id in getattr(model.depends_on, "nodes", [])
+            for model in self.models
+            if model.depends_on
         )
+        if num_refs > 1:
+            raise DbtBouncerFailedCheckError(
+                f"Source `{self.source.source_name}.{self.source.name}` is referenced by more than one model."
+            )