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

dbt_bouncer/checks/manifest/check_macros.py

@@ -1,6 +1,5 @@
-# mypy: disable-error-code="union-attr"
-
 import re
+from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar, Literal
 
 from pydantic import Field
@@ -15,6 +14,7 @@ from jinja2 import Environment, nodes
 from jinja2_simple_tags import StandaloneTag
 
 from dbt_bouncer.check_base import BaseCheck
+from dbt_bouncer.checks.common import DbtBouncerFailedCheckError
 
 
 class TagExtension(StandaloneTag):
@@ -24,14 +24,17 @@ class TagExtension(StandaloneTag):
 class CheckMacroArgumentsDescriptionPopulated(BaseCheck):
     """Macro arguments must have a populated description.
 
+    Parameters:
+        min_description_length (int | None): Minimum length required for the description to be considered populated.
+
     Receives:
         macro (Macros): The Macros 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 macro path. Macro paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the macro path. Only macro 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 macro path. Macro paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the macro path. Only macro paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -44,20 +47,33 @@ class CheckMacroArgumentsDescriptionPopulated(BaseCheck):
             - name: check_macro_arguments_description_populated
               include: ^macros/common
         ```
+        ```yaml
+        manifest_checks:
+            - name: check_macro_arguments_description_populated
+              min_description_length: 25 # Setting a stricter requirement for description length
+        ```
 
     """
 
-    macro: "Macros" = Field(default=None)
+    min_description_length: int | None = Field(default=None)
+    macro: "Macros | None" = Field(default=None)
     name: Literal["check_macro_arguments_description_populated"]
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If macro arguments are not populated.
+
+        """
+        if self.macro is None:
+            raise DbtBouncerFailedCheckError("self.macro is None")
         environment = Environment(autoescape=True, extensions=[TagExtension])
         ast = environment.parse(self.macro.macro_sql)
 
         if hasattr(ast.body[0], "args"):
             # Assume macro is a "true" macro
-            macro_arguments = [a.name for a in ast.body[0].args]
+            macro_arguments = [a.name for a in getattr(ast.body[0], "args", [])]
         else:
             if "materialization" in [
                 x.value.value
@@ -83,17 +99,22 @@ class CheckMacroArgumentsDescriptionPopulated(BaseCheck):
         # macro.arguments: List of args manually added to the properties file
 
         non_complying_args = []
-        for arg in macro_arguments:
-            macro_doc_raw = [x for x in self.macro.arguments if x.name == arg]
-            if macro_doc_raw == [] or (
-                arg not in [x.name for x in self.macro.arguments]
-                or len(macro_doc_raw[0].description.strip()) <= 4
-            ):
-                non_complying_args.append(arg)
-
-        assert non_complying_args == [], (
-            f"Macro `{self.macro.name}` does not have a populated description for the following argument(s): {non_complying_args}."
-        )
+        if self.macro.arguments:
+            for arg in macro_arguments:
+                macro_doc_raw = [x for x in self.macro.arguments if x.name == arg]
+                if macro_doc_raw == [] or (
+                    arg not in [x.name for x in self.macro.arguments]
+                    or not self._is_description_populated(
+                        str(macro_doc_raw[0].description or ""),
+                        self.min_description_length,
+                    )
+                ):
+                    non_complying_args.append(arg)
+
+        if non_complying_args != []:
+            raise DbtBouncerFailedCheckError(
+                f"Macro `{self.macro.name}` does not have a populated description for the following argument(s): {non_complying_args}."
+            )
 
 
 class CheckMacroCodeDoesNotContainRegexpPattern(BaseCheck):
@@ -106,48 +127,59 @@ class CheckMacroCodeDoesNotContainRegexpPattern(BaseCheck):
         macro (Macros): The Macros 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 macro path. Macro paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the macro path. Only macro 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 macro path. Macro paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the macro path. Only macro 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:
-            # Prefer `coalesce` over `ifnull`: https://docs.sqlfluff.com/en/stable/rules.html#sqlfluff.rules.sphinx.Rule_CV02
+            # Prefer `coalesce` over `ifnull`: [https://docs.sqlfluff.com/en/stable/rules.html#sqlfluff.rules.sphinx.Rule_CV02](https://docs.sqlfluff.com/en/stable/rules.html#sqlfluff.rules.sphinx.Rule_CV02)
             - name: check_macro_code_does_not_contain_regexp_pattern
               regexp_pattern: .*[i][f][n][u][l][l].*
         ```
 
     """
 
-    macro: "Macros" = Field(default=None)
+    macro: "Macros | None" = Field(default=None)
     name: Literal["check_macro_code_does_not_contain_regexp_pattern"]
     regexp_pattern: str
 
     def execute(self) -> None:
-        """Execute the check."""
-        assert (
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If macro code contains banned string.
+
+        """
+        if self.macro is None:
+            raise DbtBouncerFailedCheckError("self.macro is None")
+        if (
             re.compile(self.regexp_pattern.strip(), flags=re.DOTALL).match(
                 self.macro.macro_sql
             )
-            is None
-        ), (
-            f"Macro `{self.macro.name}` contains a banned string: `{self.regexp_pattern.strip()}`."
-        )
+            is not None
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"Macro `{self.macro.name}` contains a banned string: `{self.regexp_pattern.strip()}`."
+            )
 
 
 class CheckMacroDescriptionPopulated(BaseCheck):
     """Macros must have a populated description.
 
+    Parameters:
+        min_description_length (int | None): Minimum length required for the description to be considered populated.
+
     Receives:
         macro (Macros): The Macros 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 macro path. Macro paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the macro path. Only macro 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 macro path. Macro paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the macro path. Only macro paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -163,14 +195,25 @@ class CheckMacroDescriptionPopulated(BaseCheck):
 
     """
 
-    macro: "Macros" = Field(default=None)
+    macro: "Macros | None" = Field(default=None)
+    min_description_length: int | None = Field(default=None)
     name: Literal["check_macro_description_populated"]
 
     def execute(self) -> None:
-        """Execute the check."""
-        assert self.is_description_populated(self.macro.description), (
-            f"Macro `{self.macro.name}` does not have a populated description."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If macro description is not populated.
+
+        """
+        if self.macro is None:
+            raise DbtBouncerFailedCheckError("self.macro is None")
+        if not self._is_description_populated(
+            str(self.macro.description or ""), self.min_description_length
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"Macro `{self.macro.name}` does not have a populated description."
+            )
 
 
 class CheckMacroMaxNumberOfLines(BaseCheck):
@@ -183,10 +226,10 @@ class CheckMacroMaxNumberOfLines(BaseCheck):
         macro (Macros): The Macros 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 macro path. Macro paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the macro path. Only macro 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 macro path. Macro paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the macro path. Only macro paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -201,17 +244,25 @@ class CheckMacroMaxNumberOfLines(BaseCheck):
 
     """
 
-    macro: "Macros" = Field(default=None)
+    macro: "Macros | None" = Field(default=None)
     name: Literal["check_macro_max_number_of_lines"]
     max_number_of_lines: int = Field(default=50)
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If max lines exceeded.
+
+        """
+        if self.macro is None:
+            raise DbtBouncerFailedCheckError("self.macro is None")
         actual_number_of_lines = self.macro.macro_sql.count("\n") + 1
 
-        assert actual_number_of_lines <= self.max_number_of_lines, (
-            f"Macro `{self.macro.name}` has {actual_number_of_lines} lines, this is more than the maximum permitted number of lines ({self.max_number_of_lines})."
-        )
+        if actual_number_of_lines > self.max_number_of_lines:
+            raise DbtBouncerFailedCheckError(
+                f"Macro `{self.macro.name}` has {actual_number_of_lines} lines, this is more than the maximum permitted number of lines ({self.max_number_of_lines})."
+            )
 
 
 class CheckMacroNameMatchesFileName(BaseCheck):
@@ -223,10 +274,10 @@ class CheckMacroNameMatchesFileName(BaseCheck):
         macro (Macros): The Macros 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 macro path. Macro paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the macro path. Only macro 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 macro path. Macro paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the macro path. Only macro paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -236,27 +287,31 @@ class CheckMacroNameMatchesFileName(BaseCheck):
 
     """
 
-    macro: "Macros" = Field(default=None)
+    macro: "Macros | None" = Field(default=None)
     name: Literal["check_macro_name_matches_file_name"]
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If macro name does not match file name.
+
+        """
+        if self.macro is None:
+            raise DbtBouncerFailedCheckError("self.macro is None")
+        file_path = Path(clean_path_str(self.macro.original_file_path))
+        file_stem = file_path.stem
+
         if self.macro.name.startswith("test_"):
-            assert (
-                self.macro.name[5:]
-                == clean_path_str(self.macro.original_file_path)
-                .split("/")[-1]
-                .split(".")[0]
-            ), (
-                f"Macro `{self.macro.unique_id}` is not in a file named `{self.macro.name[5:]}.sql`."
-            )
+            if self.macro.name[5:] != file_stem:
+                raise DbtBouncerFailedCheckError(
+                    f"Macro `{self.macro.unique_id}` is not in a file named `{self.macro.name[5:]}.sql`."
+                )
         else:
-            assert (
-                self.macro.name
-                == clean_path_str(self.macro.original_file_path)
-                .split("/")[-1]
-                .split(".")[0]
-            ), f"Macro `{self.macro.name}` is not in a file of the same name."
+            if self.macro.name != file_stem:
+                raise DbtBouncerFailedCheckError(
+                    f"Macro `{self.macro.name}` is not in a file of the same name."
+                )
 
 
 class CheckMacroPropertyFileLocation(BaseCheck):
@@ -266,10 +321,10 @@ class CheckMacroPropertyFileLocation(BaseCheck):
         macro (Macros): The Macros 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 macro path. Macro paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the macro path. Only macro 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 macro path. Macro paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the macro path. Only macro paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -279,39 +334,57 @@ class CheckMacroPropertyFileLocation(BaseCheck):
 
     """
 
-    macro: "Macros" = Field(default=None)
+    macro: "Macros | None" = Field(default=None)
     name: Literal["check_macro_property_file_location"]
 
     def execute(self) -> None:
-        """Execute the check."""
-        expected_substr = "_".join(
-            clean_path_str(self.macro.original_file_path)[6:].split("/")[:-1]
-        )
-
-        assert clean_path_str(self.macro.patch_path) is not None, (
-            f"Macro `{self.macro.name}` is not defined in a `.yml` properties file."
-        )
-        properties_yml_name = clean_path_str(self.macro.patch_path).split("/")[-1]
-
-        if clean_path_str(self.macro.original_file_path).startswith(
-            "tests/",
-        ):  # Do not check generic tests (which are also macros)
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If property file location is incorrect.
+
+        """
+        if self.macro is None:
+            raise DbtBouncerFailedCheckError("self.macro is None")
+        original_path = Path(clean_path_str(self.macro.original_file_path))
+
+        # Logic matches previous manual splitting:
+        # If path is `macros/utils/file.sql`, we want `_utils`.
+        # We assume the first part of the path is the root (e.g. 'macros' or 'tests').
+        subdir_parts = original_path.parent.parts[1:]
+        expected_substr = "_" + "_".join(subdir_parts) if subdir_parts else ""
+
+        if self.macro.patch_path is None:
+            raise DbtBouncerFailedCheckError(
+                f"Macro `{self.macro.name}` is not defined in a `.yml` properties file."
+            )
+        clean_patch_path = clean_path_str(self.macro.patch_path)
+        if clean_patch_path is None:
+            raise DbtBouncerFailedCheckError(
+                f"Macro `{self.macro.name}` has an invalid patch path."
+            )
+
+        patch_path = Path(clean_patch_path)
+        properties_yml_name = patch_path.name
+
+        if original_path.parts[0] == "tests":
+            # Do not check generic tests (which are also macros)
             pass
         elif expected_substr == "":  # i.e. macro in ./macros
-            assert properties_yml_name == "_macros.yml", (
-                f"The properties file for `{self.macro.name}` (`{properties_yml_name}`) should be `_macros.yml`."
-            )
+            if properties_yml_name != "_macros.yml":
+                raise DbtBouncerFailedCheckError(
+                    f"The properties file for `{self.macro.name}` (`{properties_yml_name}`) should be `_macros.yml`."
+                )
         else:
-            assert properties_yml_name.startswith(
-                "_",
-            ), (
-                f"The properties file for `{self.macro.name}` (`{properties_yml_name}`) does not start with an underscore."
-            )
-            assert expected_substr in properties_yml_name, (
-                f"The properties file for `{self.macro.name}` (`{properties_yml_name}`) does not contain the expected substring (`{expected_substr}`)."
-            )
-            assert properties_yml_name.endswith(
-                "__macros.yml",
-            ), (
-                f"The properties file for `{self.macro.name.name}` (`{properties_yml_name}`) does not end with `__macros.yml`."
-            )
+            if not properties_yml_name.startswith("_"):
+                raise DbtBouncerFailedCheckError(
+                    f"The properties file for `{self.macro.name}` (`{properties_yml_name}`) does not start with an underscore."
+                )
+            if expected_substr not in properties_yml_name:
+                raise DbtBouncerFailedCheckError(
+                    f"The properties file for `{self.macro.name}` (`{properties_yml_name}`) does not contain the expected substring (`{expected_substr}`)."
+                )
+            if not properties_yml_name.endswith("__macros.yml"):
+                raise DbtBouncerFailedCheckError(
+                    f"The properties file for `{self.macro.name}` (`{properties_yml_name}`) does not end with `__macros.yml`."
+                )

dbt_bouncer/checks/manifest/check_metadata.py

@@ -1,12 +1,13 @@
-# mypy: disable-error-code="union-attr"
-
 import re
-from typing import TYPE_CHECKING, Literal, Optional
+from typing import TYPE_CHECKING, Literal
 
 from pydantic import BaseModel, ConfigDict, Field
 
 if TYPE_CHECKING:
-    from dbt_bouncer.artifact_parsers.parsers_common import DbtBouncerManifest
+    from dbt_bouncer.artifact_parsers.parsers_manifest import DbtBouncerManifest
+
+
+from dbt_bouncer.checks.common import DbtBouncerFailedCheckError
 
 
 class CheckProjectName(BaseModel):
@@ -19,8 +20,8 @@ class CheckProjectName(BaseModel):
         manifest_obj (DbtBouncerManifest): The manifest object.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        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.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -33,33 +34,42 @@ class CheckProjectName(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    description: Optional[str] = Field(
+    description: str | None = Field(
         default=None,
         description="Description of what the check does and why it is implemented.",
     )
-    index: Optional[int] = Field(
+    index: int | None = Field(
         default=None,
         description="Index to uniquely identify the check, calculated at runtime.",
     )
-    manifest_obj: "DbtBouncerManifest" = Field(default=None)
+    manifest_obj: "DbtBouncerManifest | None" = Field(default=None)
     name: Literal["check_project_name"]
-    package_name: Optional[str] = Field(default=None)
+    package_name: str | None = Field(default=None)
     project_name_pattern: str
-    severity: Optional[Literal["error", "warn"]] = Field(
+    severity: Literal["error", "warn"] | None = Field(
         default="error",
         description="Severity of the check, one of 'error' or 'warn'.",
     )
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If project name does not match regex.
+
+        """
+        if self.manifest_obj is None:
+            raise DbtBouncerFailedCheckError("self.manifest_obj is None")
+
         package_name = (
             self.package_name or self.manifest_obj.manifest.metadata.project_name
         )
-        assert (
+        if (
             re.compile(self.project_name_pattern.strip()).match(
-                package_name,
+                str(package_name),
+            )
+            is None
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"Project name (`{package_name}`) does not conform to the supplied regex `({self.project_name_pattern.strip()})`."
             )
-            is not None
-        ), (
-            f"Project name (`{package_name}`) does not conform to the supplied regex `({self.project_name_pattern.strip()})`."
-        )