RepoAuditor 0.2.61__tar.gz → 0.2.67__tar.gz

{repoauditor-0.2.61 → repoauditor-0.2.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RepoAuditor
-Version: 0.2.61
+Version: 0.2.67
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/gt-sse-center/RepoAuditor
 Project-URL: Documentation, https://github.com/gt-sse-center/RepoAuditor

repoauditor-0.2.67/default_config.yaml

@@ -0,0 +1,4 @@
+includes: ["GitHub", "CommunityStandards"]
+GitHub-url: "https://github.com/gt-sse-center/RepoAuditor"
+CommunityStandards-url: "https://github.com/gt-sse-center/RepoAuditor"
+# GitHub-pat: "PAT"

{repoauditor-0.2.61 → repoauditor-0.2.67}/src/RepoAuditor/Display.py

@@ -37,16 +37,16 @@ def GetInternalPanelContent(
     if module.description:
         internal_content.append(f"{module.description.strip()}\n")
 
-    internal_content.append(
-        textwrap.dedent(
-            f"""\
-                Successful:     {num_success} ({(num_success / num_requirements):.02%})
-                Warnings:       {num_warning} ({(num_warning / num_requirements):.02%})
-                Errors:         {num_error} ({(num_error / num_requirements):.02%})
-                Skipped:        {num_does_not_apply} ({(num_does_not_apply / num_requirements):.02%})
-                """,
-        ),
+    metrics_display = textwrap.dedent(
+        f"""\
+            [grey66]
+            Successful:     {num_success} ({(num_success / num_requirements):.02%})
+            Warnings:       {num_warning} ({(num_warning / num_requirements):.02%})
+            Errors:         {num_error} ({(num_error / num_requirements):.02%})
+            Skipped:        {num_does_not_apply} ({(num_does_not_apply / num_requirements):.02%})
+        """,
     )
+    internal_content.append(metrics_display)
 
     for result in results:
         if not dm.is_verbose and result.result in [
@@ -106,6 +106,17 @@ def GetInternalPanelContent(
             ),
         )
 
+    # Finally print statistics at the end in a panel if verbose
+    internal_content.append(
+        Panel(
+            metrics_display,
+            title="Metrics",
+            title_align="left",
+            border_style="grey66",
+            padding=(1, 1, 0, 1),
+        ),
+    )
+
     return internal_content
 
 

{repoauditor-0.2.61 → repoauditor-0.2.67}/src/RepoAuditor/Plugins/GitHub/Impl/EnableRulesetRequirementImpl.py

@@ -59,25 +59,62 @@ class EnableRulesetRequirementImpl(EnableRequirementImpl):
         query_data: dict[str, Any],
         requirement_args: dict[str, Any],
     ) -> Requirement.EvaluateImplResult:
+        expected_rule_enabled = self.enabled_by_default
+
         if requirement_args[self.dynamic_arg_name]:
-            # Get the rules for the specified branch
-            rules = query_data.get("rules", [])
-
-            for rule in rules:
-                if self.get_configuration_value_func(rule):
-                    # Get the ruleset associated with the rule
-                    ruleset = rule["ruleset"]
-                    return self.EvaluateImplResult(
-                        EvaluateResult.Success,
-                        f"Ruleset '{ruleset['name']}' enforces {self.github_settings_value}",
-                    )
+            expected_rule_enabled = not expected_rule_enabled
+            provide_rationale = False
+        else:
+            provide_rationale = True
+
+        query_data["__expected_value"] = "Enable" if expected_rule_enabled else "Disable"
+
+        # Get the rules for the specified branch
+        rules = query_data.get("rules", [])
+
+        # Check if the rule is checked in the ruleset
+        rule_enabled = False
+        ruleset = None
+        for rule in rules:
+            # If the rule is present, it is checked
+            if self.get_configuration_value_func(rule):
+                rule_enabled = True
+                # Get the ruleset associated with the rule
+                ruleset = rule["ruleset"]
+                break
+
+        # If rule is active and we want it enabled,
+        # or rule is inactive and we want it disabled,
+        # return success.
+        if rule_enabled == expected_rule_enabled:
+            context = (
+                f"{self.github_settings_value} is enabled in Ruleset '{ruleset['name']}'"
+                if expected_rule_enabled
+                else f"{self.github_settings_value} is disabled"
+            )
+            return self.EvaluateImplResult(
+                EvaluateResult.Success,
+                context,
+            )
+
+        # When rule is active but we want it disabled
+        if rule_enabled:
+            assert expected_rule_enabled is False
 
             return self.EvaluateImplResult(
                 EvaluateResult.Error,
-                f"No active branch ruleset requiring {self.github_settings_value} found",
+                f"{self.github_settings_value} rule active in ruleset '{ruleset['name']}'. It should be set to {expected_rule_enabled}",
                 provide_resolution=True,
-                provide_rationale=True,
+                provide_rationale=provide_rationale,
             )
 
-        # Requirement flag not set so DoesNotApply
-        return Requirement.EvaluateImplResult(EvaluateResult.DoesNotApply, None)
+        # Rule is inactive but we want it on
+        assert rule_enabled is False
+        assert expected_rule_enabled is True
+
+        return self.EvaluateImplResult(
+            EvaluateResult.Error,
+            f"No active branch ruleset with {self.github_settings_value} found",
+            provide_resolution=True,
+            provide_rationale=provide_rationale,
+        )

{repoauditor-0.2.61 → repoauditor-0.2.67}/src/RepoAuditor/Plugins/GitHub/Impl/ValueRequirementImpl.py

@@ -28,14 +28,14 @@ class DoesNotApplyResult:
 
 # ----------------------------------------------------------------------
 class ValueRequirementImpl(Requirement):
-    """Object that implements settings specified by a value."""
+    """Object that implements checking of metadata/settings are set to the specified value."""
 
     # ----------------------------------------------------------------------
     def __init__(
         self,
         name: str,
         default_value: str,
-        github_settings_value: Optional[str],
+        github_value: Optional[str],
         get_configuration_value_func: Callable[[dict[str, Any]], str | DoesNotApplyResult | None],
         resolution: str,
         rationale: str,
@@ -44,13 +44,10 @@ class ValueRequirementImpl(Requirement):
         requires_explicit_include: bool = False,
         missing_value_is_warning: bool = True,
     ) -> None:
-        if github_settings_value is None:
-            github_settings_value = "the entity"
-        else:
-            github_settings_value = f"'{github_settings_value}'"
+        github_value = f"'{github_value}'" if github_value else "the entity"
 
         if subject is None:
-            subject = github_settings_value
+            subject = github_value
 
         super().__init__(
             name,
@@ -61,7 +58,7 @@ class ValueRequirementImpl(Requirement):
             requires_explicit_include=requires_explicit_include,
         )
 
-        self.github_settings_value = github_settings_value
+        self.github_value = github_value
         self.default_value = default_value
         self.get_configuration_value_func = get_configuration_value_func
         self.missing_value_is_warning = missing_value_is_warning
@@ -75,7 +72,7 @@ class ValueRequirementImpl(Requirement):
                 str,
                 typer.Option(
                     self.default_value,
-                    help=f"Ensures that {self.github_settings_value} is set to the provided value.",
+                    help=f"Ensures that {self.github_value} is set to the provided value.",
                 ),
             ),
         }
@@ -103,7 +100,7 @@ class ValueRequirementImpl(Requirement):
 
             return Requirement.EvaluateImplResult(
                 EvaluateResult.Error,
-                f"{self.github_settings_value} cannot be set to '{expected_value}' because {result.reason}",
+                f"{self.github_value} cannot be set to '{expected_value}' because {result.reason}",
             )
 
         result = str(result)
@@ -113,7 +110,7 @@ class ValueRequirementImpl(Requirement):
 
             return Requirement.EvaluateImplResult(
                 EvaluateResult.Error,
-                f"{self.github_settings_value} must be set to '{expected_value}' (it is currently set to '{result}').",
+                f"{self.github_value} must be set to '{expected_value}' (it is currently set to '{result}').",
                 provide_resolution=True,
                 provide_rationale=is_default_expected_value,
             )

{repoauditor-0.2.61 → repoauditor-0.2.67}/src/RepoAuditor/Plugins/GitHub/RulesetQuery.py

@@ -56,6 +56,9 @@ class RulesetQuery(Query):
 
             branch = response["default_branch"]
 
+        # Record the branch name
+        module_data["branch"] = branch
+
         # Fetch ruleset data for a specific branch.
         # This only returns active rules on the branch
         rules_response = module_data["session"].get(f"rules/branches/{branch}")

{repoauditor-0.2.61 → repoauditor-0.2.67}/src/RepoAuditor/Plugins/GitHub/RulesetRequirements/RequirePullRequests.py

@@ -14,12 +14,12 @@ class RequirePullRequests(EnableRulesetRequirementImpl):
 
     def __init__(self) -> None:
         super().__init__(
-            name="RequirePullRequests",
-            enabled_by_default=False,
-            dynamic_arg_name="enabled",
+            name="RequirePullRequestsRule",
+            enabled_by_default=True,
+            dynamic_arg_name="disabled",
             github_ruleset_type="pull_request",
-            github_ruleset_value="Pull Requests",
+            github_ruleset_value="Require a pull request before merging",
             get_configuration_value_func=lambda rule: rule.get("type", "") == "pull_request",
-            resolution="Enable pull request requirements in repository rulesets",
+            resolution="{__expected_value} pull request rule in repository rulesets",
             rationale="Pull request reviews help maintain code quality and collaboration",
         )

{repoauditor-0.2.61 → repoauditor-0.2.67}/src/RepoAuditor/Plugins/GitHub/RulesetRequirements/RequireSignedCommits.py

@@ -10,15 +10,15 @@ from RepoAuditor.Plugins.GitHub.Impl.EnableRulesetRequirementImpl import EnableR
 
 
 class RequireSignedCommits(EnableRulesetRequirementImpl):
-    """Require signed commits."""
+    """Check that the "Require signed commits" rule is disabled."""
 
     def __init__(self) -> None:
         super().__init__(
-            name="RequireSignedCommits",
-            enabled_by_default=False,
-            dynamic_arg_name="enabled",
+            name="RequireSignedCommitsRule",
+            enabled_by_default=True,
+            dynamic_arg_name="disabled",
             github_ruleset_type="required_signatures",
-            github_ruleset_value="Signed Commits",
+            github_ruleset_value="Require signed commits",
             get_configuration_value_func=lambda rule: rule.get("type", "") == "required_signatures",
             resolution="Enable commit signing requirement in repository rulesets",
             rationale="Signed commits ensure commit authenticity",

{repoauditor-0.2.61 → repoauditor-0.2.67}/src/RepoAuditor/Plugins/GitHub/RulesetRequirements/RequireStatusChecks.py

@@ -14,11 +14,11 @@ class RequireStatusChecks(EnableRulesetRequirementImpl):
 
     def __init__(self) -> None:
         super().__init__(
-            name="RequireStatusChecks",
-            enabled_by_default=False,
-            dynamic_arg_name="enabled",
+            name="RequireStatusChecksRule",
+            enabled_by_default=True,
+            dynamic_arg_name="disabled",
             github_ruleset_type="required_status_checks",
-            github_ruleset_value="Status Checks",
+            github_ruleset_value="Require status checks to pass",
             get_configuration_value_func=lambda rule: rule.get("type", "") == "required_status_checks",
             resolution="Configure required status checks in repository rulesets",
             rationale="Status checks ensure code quality and compatibility",

{repoauditor-0.2.61 → repoauditor-0.2.67}/src/RepoAuditor/Plugins/GitHub/StandardRequirements/Description.py

@@ -13,7 +13,6 @@ import typer
 from dbrownell_Common.TyperEx import TypeDefinitionItemType  # type: ignore[import-untyped]
 from dbrownell_Common.Types import override  # type: ignore[import-untyped]
 
-from RepoAuditor.Plugins.GitHub.Impl.Common import CreateIncompleteDataResult
 from RepoAuditor.Requirement import EvaluateResult, ExecutionStyle, Requirement
 
 
@@ -73,10 +72,9 @@ class Description(Requirement):
     ) -> Requirement.EvaluateImplResult:
         standard_data = query_data["standard"]
 
+        # If result is None, it means the description is empty.
+        # It is not a permissions issue, since "Read Metadata" is a mandatory permission for all PATs
         result = standard_data.get("description", None)
-        if result is None:
-            return CreateIncompleteDataResult()
-
         expect_description = not requirement_args["allow-empty"]
 
         if expect_description and not result:

{repoauditor-0.2.61 → repoauditor-0.2.67}/src/RepoAuditor/Plugins/GitHub/StandardRequirements/License.py

@@ -9,25 +9,29 @@
 import textwrap
 from typing import Any, Optional
 
-from RepoAuditor.Plugins.GitHub.StandardRequirements.Impl.StandardValueRequirementImpl import (
-    StandardValueRequirementImpl,
-)
+from RepoAuditor.Plugins.GitHub.Impl.ValueRequirementImpl import ValueRequirementImpl
 
 
 # ----------------------------------------------------------------------
-class License(StandardValueRequirementImpl):
+class License(ValueRequirementImpl):
     """Default License as MIT Requirement."""
 
     # ----------------------------------------------------------------------
     def __init__(self) -> None:
         super().__init__(
-            "License",
-            "MIT License",
-            "settings",
-            None,
-            None,
-            _GetValue,
-            textwrap.dedent(
+            name="License",
+            default_value="MIT License",
+            github_value="License",
+            get_configuration_value_func=_GetValue,
+            resolution=textwrap.dedent(
+                """\
+                1) Create a LICENSE/LICENSE.md file in your main branch at the root of your repository.
+                2) Add the appropriate licensing information in the above file.
+
+                For detailed information about open source licenses, you can visit: https://choosealicense.com/
+                """
+            ),
+            rationale=textwrap.dedent(
                 """\
                 The default behavior is to use the MIT License.
 

{repoauditor-0.2.61 → repoauditor-0.2.67}/src/RepoAuditor/Plugins/GitHub/StandardRequirements/MergeCommitMessage.py

@@ -30,18 +30,18 @@ class MergeCommitMessage(StandardValueRequirementImpl):
             _GetValue,
             textwrap.dedent(
                 """\
-                Available values:
+                Available values on GitHub:
 
-                PR_TITLE [Default message]
+                Default message [PR_TITLE]
                     Pull Request number and head branch on the first line; pull request title on the third line
 
-                BLANK [Default to pull request title]
+                Default to pull request title [BLANK]
                     Pull Request title and number on the first line.
 
-                PR_BODY [Default to pull request title and description]
+                Default to pull request title and description [PR_BODY]
                     Pull Request title and number on the first line; pull request description starting on the third line.
 
-            The default setting is BLANK.
+            The default setting is "Default to pull request title [BLANK]".
 
             Reasons for this Default
             ------------------------

{repoauditor-0.2.61 → repoauditor-0.2.67}/src/RepoAuditor/Plugins/GitHub/StandardRequirements/SquashMergeCommitMessage.py

@@ -30,20 +30,20 @@ class SquashMergeCommitMessage(StandardValueRequirementImpl):
             _GetValue,
             textwrap.dedent(
                 """\
-                Available values:
+                Available values on GitHub:
 
-                BLANK [Default to pull request title]
+                Default to pull request title [BLANK]
                     Pull Request title and number on the first line.
 
-                COMMIT_MESSAGES [Default to pull request title and commit details]
+                Default to pull request title and commit details [COMMIT_MESSAGES]
                     Commit title and...
                         [Single Commit] ...commit message
                         [Multiple Commits] ...pull request title and number and list of commits
 
-                PR_BODY [Default to pull request title and description]
+                Default to pull request title and description [PR_BODY]
                     Pull Request title and number on the first line; commit description starting on the third line.
 
-            The default setting is COMMIT_MESSAGES.
+            The default setting is "Default to pull request title and commit details [COMMIT_MESSAGES]".
 
             Reasons for this Default
             ------------------------

{repoauditor-0.2.61 → repoauditor-0.2.67}/src/RepoAuditor/__init__.py

@@ -2,4 +2,4 @@ APP_NAME = "RepoAuditor"
 
 # Note that the default value below will be used until the value
 # here is explicitly updated by the Continuous Integration system.
-__version__ = "0.2.61"
+__version__ = "0.2.67"

{repoauditor-0.2.61 → repoauditor-0.2.67}/tests/Plugins/GitHubModule/ClassicValueRequirementImpl_UnitTest.py

@@ -22,7 +22,7 @@ class TestClassicValueRequirementImpl:
             get_configuration_value_func=lambda _: "yes",
             rationale="For testing",
         )
-        assert requirement.github_settings_value == "'No Settings Section'"
+        assert requirement.github_value == "'No Settings Section'"
 
     def test_NoSettingsValue(self):
         """Test for when no github_settings_value is provided."""
@@ -34,4 +34,4 @@ class TestClassicValueRequirementImpl:
             get_configuration_value_func=lambda _: "yes",
             rationale="For testing",
         )
-        assert requirement.github_settings_value == "the entity"
+        assert requirement.github_value == "the entity"

{repoauditor-0.2.61 → repoauditor-0.2.67}/tests/Plugins/GitHubModule/EnableRulesetRequirementImpl_UnitTest.py

@@ -18,7 +18,7 @@ class TestEnableRulesetRequirementImpl:
         requirement = EnableRulesetRequirementImpl(
             name="Test Name",
             enabled_by_default=False,
-            dynamic_arg_name="true",
+            dynamic_arg_name="enabled",
             github_ruleset_type="Test Ruleset",
             github_ruleset_value="test_ruleset",
             get_configuration_value_func=lambda _: True,
@@ -28,15 +28,15 @@ class TestEnableRulesetRequirementImpl:
 
         assert requirement.name == "Test Name"
         assert requirement.enabled_by_default is False
-        assert requirement.dynamic_arg_name == "true"
+        assert requirement.dynamic_arg_name == "enabled"
         assert requirement.github_ruleset_type == "Test Ruleset"
 
-    def test_Evaluate_DoesNotApply(self):
-        """Test the _EvaluateImpl method when dynamic_arg_name is False."""
+    def test_Evaluate_Disabled(self):
+        """Test the _EvaluateImpl method when dynamic arg is set to `enabled: False`."""
         requirement = EnableRulesetRequirementImpl(
             name="Test Name",
             enabled_by_default=False,
-            dynamic_arg_name="true",
+            dynamic_arg_name="enabled",
             github_ruleset_type="Test Ruleset",
             github_ruleset_value="test_ruleset",
             get_configuration_value_func=lambda _: True,
@@ -44,16 +44,48 @@ class TestEnableRulesetRequirementImpl:
             rationale="Test rationale",
         )
         query_data = {}
-        requirement_args = {"true": False}
+        requirement_args = {"enabled": False}
         result = requirement.Evaluate(query_data, requirement_args)
-        assert result.result == EvaluateResult.DoesNotApply
+        # No rule and should be disabled, hence result is success
+        assert result.result == EvaluateResult.Success
+
+    def test_Evaluate_Disabled_Alternative(self):
+        """Test the _EvaluateImpl method when dynamic arg is
+        set to `disabled: True` but rule is active.
+        """
+        requirement = EnableRulesetRequirementImpl(
+            name="True By Default",
+            enabled_by_default=True,
+            dynamic_arg_name="disabled",
+            github_ruleset_type="Test Ruleset",
+            github_ruleset_value="test_ruleset",
+            get_configuration_value_func=lambda rule: rule.get("type", "") == "valid_rule",
+            resolution="Test Resolution",
+            rationale="Test rationale",
+        )
+        query_data = {
+            "rules": [
+                {
+                    "type": "valid_rule",
+                    "ruleset": {
+                        "name": "Valid",
+                        "id": "01",
+                    },
+                },
+            ]
+        }
+        requirement_args = {"disabled": True}
+        result = requirement.Evaluate(query_data, requirement_args)
+        # No rule and should be disabled, hence result is success
+        assert result.result == EvaluateResult.Error
+        assert "It should be set to False" in result.context
 
     def test_Evaluate_InvalidRule(self):
-        """Test the _EvaluateImpl method when dynamic_arg_name is False."""
+        """Test the _EvaluateImpl method when dynamic arg is set to `enabled: True` and the rule found is invalid."""
         requirement = EnableRulesetRequirementImpl(
             name="Test Name",
             enabled_by_default=False,
-            dynamic_arg_name="true",
+            dynamic_arg_name="enabled",
             github_ruleset_type="Test Ruleset",
             github_ruleset_value="test_ruleset",
             get_configuration_value_func=lambda rule: rule.get("type", "") == "valid rule",
@@ -71,16 +103,16 @@ class TestEnableRulesetRequirementImpl:
                 },
             ]
         }
-        requirement_args = {"true": True}
+        requirement_args = {"enabled": True}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.Error
 
     def test_Evaluate_ValidRule(self):
-        """Test the _EvaluateImpl method when dynamic_arg_name is False."""
+        """Test the _EvaluateImpl method when dynamic arg is set to `enabled: True` and a valid rule is found."""
         requirement = EnableRulesetRequirementImpl(
             name="Test Name",
             enabled_by_default=False,
-            dynamic_arg_name="true",
+            dynamic_arg_name="enabled",
             github_ruleset_type="Test Ruleset",
             github_ruleset_value="test_ruleset",
             get_configuration_value_func=lambda rule: rule.get("type", "") == "valid_rule",
@@ -98,7 +130,7 @@ class TestEnableRulesetRequirementImpl:
                 }
             ]
         }
-        requirement_args = {"true": True}
+        requirement_args = {"enabled": True}
         result = requirement.Evaluate(query_data, requirement_args)
 
         assert result.result == EvaluateResult.Success

{repoauditor-0.2.61 → repoauditor-0.2.67}/tests/Plugins/GitHubModule/RulesetRequirements_UnitTest.py

@@ -43,9 +43,9 @@ class TestRequirePullRequests:
                 )
             ]
         }
-        result = requirement.Evaluate(context, {"enabled": True})
+        result = requirement.Evaluate(context, {"disabled": False})
         assert result.result == EvaluateResult.Success
-        assert "enforces 'Pull Requests'" in result.context
+        assert f"{requirement.github_settings_value} is enabled" in result.context
 
     def test_Disabled(self):
         """Test if the required rule is disabled on the main branch
@@ -57,14 +57,14 @@ class TestRequirePullRequests:
                 create_rule(
                     name="Inactive PR Rules",
                     # Wrong rule type
-                    rule_type="",
+                    rule_type="push_request",
                     ruleset_name="Ruleset Main",
                     parameters={},
                 )
             ]
         }
-        result = requirement.Evaluate(context, {"enabled": True})
-        assert result.result == EvaluateResult.Error
+        result = requirement.Evaluate(context, {"disabled": True})
+        assert result.result == EvaluateResult.Success
 
     def test_WrongTarget(self):
         """Test if rules are applied on the wrong branch."""
@@ -75,16 +75,16 @@ class TestRequirePullRequests:
                 # Hence the rules here will be empty.
             ]
         }
-        result = requirement.Evaluate(context, {"enabled": True})
+        result = requirement.Evaluate(context, {"disabled": False})
         assert result.result == EvaluateResult.Error
 
     def test_NoRulesets(self):
         """Test if no rules are applied on the main branch."""
         requirement = RequirePullRequests()
         context = {"rules": []}
-        result = requirement.Evaluate(context, {"enabled": True})
+        result = requirement.Evaluate(context, {"disabled": False})
         assert result.result == EvaluateResult.Error
-        assert "No active branch ruleset requiring 'Pull Requests' found" in result.context
+        assert f"No active branch ruleset with {requirement.github_settings_value} found" in result.context
 
 
 # ----------------------------------------------------------------------
@@ -104,9 +104,9 @@ class TestRequireSignedCommits:
                 )
             ]
         }
-        result = requirement.Evaluate(context, {"enabled": True})
+        result = requirement.Evaluate(context, {"disabled": False})
         assert result.result == EvaluateResult.Success
-        assert "enforces 'Signed Commits'" in result.context
+        assert f"{requirement.github_settings_value} is enabled" in result.context
 
     def test_Disabled(self):
         """Test if the required rule is disabled on the main branch
@@ -124,7 +124,7 @@ class TestRequireSignedCommits:
                 )
             ]
         }
-        result = requirement.Evaluate(context, {"enabled": True})
+        result = requirement.Evaluate(context, {"disabled": False})
         assert result.result == EvaluateResult.Error
 
     def test_PartialConfig(self):
@@ -135,16 +135,16 @@ class TestRequireSignedCommits:
                 # GitHub only returns rules that are actively enforced
             ]
         }
-        result = requirement.Evaluate(context, {"enabled": True})
+        result = requirement.Evaluate(context, {"disabled": False})
         assert result.result == EvaluateResult.Error
 
     def test_NoRulesets(self):
         """Test if no rules are applied on the main branch."""
         requirement = RequireSignedCommits()
         context = {"rules": []}
-        result = requirement.Evaluate(context, {"enabled": True})
+        result = requirement.Evaluate(context, {"disabled": False})
         assert result.result == EvaluateResult.Error
-        assert "No active branch ruleset requiring 'Signed Commits' found" in result.context
+        assert f"No active branch ruleset with {requirement.github_settings_value} found" in result.context
 
 
 # ----------------------------------------------------------------------
@@ -164,9 +164,9 @@ class TestRequireStatusChecks:
                 )
             ]
         }
-        result = requirement.Evaluate(context, {"enabled": True})
+        result = requirement.Evaluate(context, {"disabled": False})
         assert result.result == EvaluateResult.Success
-        assert "enforces 'Status Checks'" in result.context
+        assert f"{requirement.github_settings_value} is enabled" in result.context
 
     def test_EmptyChecks(self):
         """Test for Status Check rules which don't have an associated CI check."""
@@ -178,13 +178,13 @@ class TestRequireStatusChecks:
                 # Hence empty.
             ]
         }
-        result = requirement.Evaluate(context, {"enabled": True})
+        result = requirement.Evaluate(context, {"disabled": False})
         assert result.result == EvaluateResult.Error
 
     def test_NoRulesets(self):
         """Test if no rules are applied on the main branch."""
         requirement = RequireStatusChecks()
         context = {"rules": []}
-        result = requirement.Evaluate(context, {"enabled": True})
+        result = requirement.Evaluate(context, {"disabled": False})
         assert result.result == EvaluateResult.Error
-        assert "No active branch ruleset requiring 'Status Checks' found" in result.context
+        assert f"No active branch ruleset with {requirement.github_settings_value} found" in result.context