RepoAuditor 0.4.3__tar.gz → 0.4.5__tar.gz

{repoauditor-0.4.3 → repoauditor-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RepoAuditor
-Version: 0.4.3
+Version: 0.4.5
 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.4.3 → repoauditor-0.4.5}/src/RepoAuditor/EntryPoint.py

@@ -14,6 +14,7 @@ import traceback
 from pathlib import Path
 from typing import Annotated, Optional
 
+import click
 import pluggy
 import typer
 from click.exceptions import UsageError
@@ -39,7 +40,10 @@ class NaturalOrderGrouper(TyperGroup):
     """Group commands in natural order."""
 
     # ----------------------------------------------------------------------
-    def list_commands(self, *args, **kwargs) -> list[str]:  # noqa: ARG002  # pragma: no cover
+    def list_commands(
+        self,
+        ctx: click.Context,  # noqa: ARG002
+    ) -> list[str]:  # pragma: no cover
         """Return a list of all the commands, to be sorted in a natural ordering."""
         return list(self.commands.keys())
 
@@ -233,14 +237,18 @@ def EntryPoint(  # noqa: PLR0913  # pragma: no cover
         ),
     ] = None,
     all_warnings_as_error: Annotated[  # noqa: FBT002
-        bool, typer.Option("--all-warnings-as-error", help="Treat all warnings as errors.")
+        bool,
+        typer.Option("--all-warnings-as-error", help="Treat all warnings as errors."),
     ] = False,
     ignore_all_warnings: Annotated[  # noqa: FBT002
         bool, typer.Option("--ignore-all-warnings", help="Ignore all warnings.")
     ] = False,
     single_threaded: Annotated[  # noqa: FBT002
         bool,
-        typer.Option("--single-threaded", help="Do not use multiple threads when evaluating requirements."),
+        typer.Option(
+            "--single-threaded",
+            help="Do not use multiple threads when evaluating requirements.",
+        ),
     ] = False,
     no_resolution: Annotated[  # noqa: FBT002
         bool,
@@ -327,8 +335,8 @@ def EntryPoint(  # noqa: PLR0913  # pragma: no cover
 
             # Since `output` can be None, we use the nullcontext manager to represent None
             with (
-                Path(output).open(mode="w+", encoding="UTF-8") if output else contextlib.nullcontext() as file
-            ):
+                Path(output).open(mode="w+", encoding="UTF-8") if output else contextlib.nullcontext()
+            ) as file:
                 DisplayResults(
                     dm,
                     all_results,

{repoauditor-0.4.3 → repoauditor-0.4.5}/src/RepoAuditor/Plugins/GitHub/ClassicBranchProtectionQuery.py

@@ -162,6 +162,12 @@ class ClassicBranchProtectionQuery(Query):
         if not module_data["branch_data"].get("protected", False):
             return None
 
+        # Classic branch protection information is only accessible when a pat is provided.
+        # Exit gracefully if there isn't a PAT, as the ClassicBranchProtectionQuery
+        # will print a warning if the PAT wasn't provided.
+        if module_data["session"].github_pat is None:
+            return None
+
         # Note that once here, we know that the branch is protected, but we don't know the
         # protection scheme used (rule sets or classic). Attempt to get the classic information
         # and then see if rule sets are in use if the classic information is not found.
@@ -178,12 +184,6 @@ class ClassicBranchProtectionQuery(Query):
             if ruleset_response:
                 return None
 
-            # Classic branch protection information is only accessible when a pat is provided. Exit
-            # gracefully if there isn't a PAT, as the DefaultBranchQuery will print a warning if
-            # the PAT wasn't provided.
-            if module_data["session"].github_pat is None:
-                return None
-
             # If here, let the error result in an exception in the code that follows.
 
         response.raise_for_status()

{repoauditor-0.4.3 → repoauditor-0.4.5}/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.4.3"
+__version__ = "0.4.5"

{repoauditor-0.4.3 → repoauditor-0.4.5}/tests/Plugins/GitHubModule/EnableRulesetRequirementImpl_UnitTest.py

@@ -134,3 +134,25 @@ class TestEnableRulesetRequirementImpl:
         result = requirement.Evaluate(query_data, requirement_args)
 
         assert result.result == EvaluateResult.Success
+
+    def test_NoneRuleType(self, query_data):
+        """Test behavior when the rule type provided is None."""
+        requirement = EnableRulesetRequirementImpl(
+            name="Test Name",
+            enabled_by_default=False,
+            dynamic_arg_name="yes",
+            github_ruleset_type="Test Ruleset",
+            github_ruleset_value="test_ruleset",
+            get_configuration_value_func=lambda x: x,
+            resolution="Test Resolution",
+            rationale="Test rationale",
+        )
+
+        # Set correct get_configuration_value_func
+        requirement.get_configuration_value_func = requirement._GetValue
+
+        query_data = {"rules": [{"type": None}]}
+        requirement_args = {"yes": True}
+        result = requirement.Evaluate(query_data, requirement_args)
+
+        assert result.result == EvaluateResult.Error

{repoauditor-0.4.3 → repoauditor-0.4.5}/tests/Plugins/GitHubModule/RulesetRequirements/BlockMainlineForcePushesRule_UnitTest.py

@@ -10,8 +10,7 @@ from RepoAuditor.Plugins.GitHub.RulesetRequirements.BlockMainlineForcePushes imp
     BlockMainlineForcePushesRule,
 )
 from RepoAuditor.Requirement import EvaluateResult
-
-from . import create_rule
+from tests.Plugins.GitHubModule.RulesetRequirements import create_rule
 
 
 class TestBlockMainlineForcePushesRule:

{repoauditor-0.4.3 → repoauditor-0.4.5}/tests/Plugins/GitHubModule/RulesetRequirements/DismissStalePullRequestApprovalsRule_UnitTest.py

@@ -6,20 +6,25 @@
 # -------------------------------------------------------------------------------
 """Unit tests for DismissStalePullRequestApprovalsRule.py"""
 
+import pytest
+
 from RepoAuditor.Plugins.GitHub.RulesetRequirements.DismissStalePullRequestApprovals import (
     DismissStalePullRequestApprovalsRule,
 )
 from RepoAuditor.Requirement import EvaluateResult
+from tests.Plugins.GitHubModule.RulesetRequirements import create_rule
+
 
-from . import create_rule
+@pytest.fixture(name="requirement")
+def requirement_fixture():
+    return DismissStalePullRequestApprovalsRule()
 
 
 class TestDismissStalePullRequestApprovalsRule:
     """Unit tests for the DismissStalePullRequestApprovalsRule requirement."""
 
-    def test_Enabled(self, query_data):
+    def test_Enabled(self, requirement, query_data):
         """Test if the rule is enabled on the main branch."""
-        requirement = DismissStalePullRequestApprovalsRule()
 
         query_data["rules"].append(
             create_rule(
@@ -34,11 +39,10 @@ class TestDismissStalePullRequestApprovalsRule:
         assert result.result == EvaluateResult.Success
         assert f"{requirement.github_settings_value} is enabled" in result.context
 
-    def test_Disabled(self, query_data):
+    def test_Disabled(self, requirement, query_data):
         """Test if the required rule is disabled on the main branch
         by providing the value as false.
         """
-        requirement = DismissStalePullRequestApprovalsRule()
 
         query_data["rules"].append(
             create_rule(
@@ -53,11 +57,10 @@ class TestDismissStalePullRequestApprovalsRule:
         result = requirement.Evaluate(query_data, {"no": False})
         assert result.result == EvaluateResult.Error
 
-    def test_WrongRuleType(self, query_data):
+    def test_WrongRuleType(self, requirement, query_data):
         """Test if the required rule is disabled on the main branch
         by providing the wrong rule type.
         """
-        requirement = DismissStalePullRequestApprovalsRule()
 
         query_data["rules"].append(
             create_rule(
@@ -71,3 +74,18 @@ class TestDismissStalePullRequestApprovalsRule:
 
         result = requirement.Evaluate(query_data, {"no": False})
         assert result.result == EvaluateResult.Error
+
+    def test_NoneRuleType(self, requirement, query_data):
+        """Test behavior when the rule type provided is None."""
+        query_data["rules"].append(
+            create_rule(
+                name="Inactive PR Rules",
+                # None rule type
+                rule_type=None,
+                ruleset_name="main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error

{repoauditor-0.4.3 → repoauditor-0.4.5}/tests/Plugins/GitHubModule/RulesetRequirements/EnsureStatusChecksRule_UnitTest.py

@@ -8,8 +8,7 @@
 
 from RepoAuditor.Plugins.GitHub.RulesetRequirements.EnsureStatusChecks import EnsureStatusChecksRule
 from RepoAuditor.Requirement import EvaluateResult
-
-from . import create_rule
+from tests.Plugins.GitHubModule.RulesetRequirements import create_rule
 
 
 class TestEnsureStatusChecksRule:

{repoauditor-0.4.3 → repoauditor-0.4.5}/tests/Plugins/GitHubModule/RulesetRequirements/RequireApprovalMostRecentPushRule_UnitTest.py

@@ -6,20 +6,25 @@
 # -------------------------------------------------------------------------------
 """Unit tests for RequireApprovalMostRecentPushRule.py"""
 
+import pytest
+
 from RepoAuditor.Plugins.GitHub.RulesetRequirements.RequireApprovalMostRecentPush import (
     RequireApprovalMostRecentPushRule,
 )
 from RepoAuditor.Requirement import EvaluateResult
+from tests.Plugins.GitHubModule.RulesetRequirements import create_rule
+
 
-from . import create_rule
+@pytest.fixture(name="requirement")
+def requirement_fixture():
+    return RequireApprovalMostRecentPushRule()
 
 
 class TestRequireApprovalMostRecentPushRule:
     """Unit tests for the RequireApprovalMostRecentPushRule requirement."""
 
-    def test_Enabled(self, query_data):
+    def test_Enabled(self, requirement, query_data):
         """Test if the rule is enabled on the main branch."""
-        requirement = RequireApprovalMostRecentPushRule()
 
         query_data["rules"].append(
             create_rule(
@@ -34,11 +39,10 @@ class TestRequireApprovalMostRecentPushRule:
         assert result.result == EvaluateResult.Success
         assert f"{requirement.github_settings_value} is enabled" in result.context
 
-    def test_Disabled(self, query_data):
+    def test_Disabled(self, requirement, query_data):
         """Test if the required rule is disabled on the main branch
         by providing the value as false.
         """
-        requirement = RequireApprovalMostRecentPushRule()
 
         query_data["rules"].append(
             create_rule(
@@ -53,11 +57,10 @@ class TestRequireApprovalMostRecentPushRule:
         result = requirement.Evaluate(query_data, {"no": False})
         assert result.result == EvaluateResult.Error
 
-    def test_WrongRuleType(self, query_data):
+    def test_WrongRuleType(self, requirement, query_data):
         """Test if the required rule is disabled on the main branch
         by providing the wrong rule type.
         """
-        requirement = RequireApprovalMostRecentPushRule()
 
         query_data["rules"].append(
             create_rule(
@@ -71,3 +74,19 @@ class TestRequireApprovalMostRecentPushRule:
 
         result = requirement.Evaluate(query_data, {"no": False})
         assert result.result == EvaluateResult.Error
+
+    def test_NoneRuleType(self, requirement, query_data):
+        """Test behavior when the rule type provided is None."""
+
+        query_data["rules"].append(
+            create_rule(
+                name="Inactive PR Rules",
+                # None rule type
+                rule_type=None,
+                ruleset_name="main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error

{repoauditor-0.4.3 → repoauditor-0.4.5}/tests/Plugins/GitHubModule/RulesetRequirements/RequireApprovalsRule_UnitTest.py

@@ -6,18 +6,23 @@
 # -------------------------------------------------------------------------------
 """Unit tests for RequireApprovalsRule.py"""
 
+import pytest
+
 from RepoAuditor.Plugins.GitHub.RulesetRequirements.RequireApprovals import RequireApprovalsRule
 from RepoAuditor.Requirement import EvaluateResult
+from tests.Plugins.GitHubModule.RulesetRequirements import create_rule
+
 
-from . import create_rule
+@pytest.fixture(name="requirement")
+def requirement_fixture():
+    return RequireApprovalsRule()
 
 
 class TestRequireApprovalsRule:
     """Unit tests for the RequireApprovalsRule requirement."""
 
-    def test_Enabled(self, query_data):
+    def test_Enabled(self, requirement, query_data):
         """Test if the rule is enabled on the main branch."""
-        requirement = RequireApprovalsRule()
 
         query_data["rules"].append(
             create_rule(
@@ -32,11 +37,10 @@ class TestRequireApprovalsRule:
         assert result.result == EvaluateResult.Success
         assert f"{requirement.github_settings_value} is enabled" in result.context
 
-    def test_Disabled(self, query_data):
+    def test_Disabled(self, requirement, query_data):
         """Test if the required rule is disabled on the main branch
         by providing the value as false.
         """
-        requirement = RequireApprovalsRule()
 
         query_data["rules"].append(
             create_rule(
@@ -51,11 +55,10 @@ class TestRequireApprovalsRule:
         result = requirement.Evaluate(query_data, {"no": False})
         assert result.result == EvaluateResult.Error
 
-    def test_WrongRuleType(self, query_data):
+    def test_WrongRuleType(self, requirement, query_data):
         """Test if the required rule is disabled on the main branch
         by providing the wrong rule type.
         """
-        requirement = RequireApprovalsRule()
 
         query_data["rules"].append(
             create_rule(
@@ -69,3 +72,19 @@ class TestRequireApprovalsRule:
 
         result = requirement.Evaluate(query_data, {"no": False})
         assert result.result == EvaluateResult.Error
+
+    def test_NoneRuleType(self, requirement, query_data):
+        """Test behavior when the rule type provided is None."""
+
+        query_data["rules"].append(
+            create_rule(
+                name="Inactive PR Rules",
+                # None rule type
+                rule_type=None,
+                ruleset_name="main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error

{repoauditor-0.4.3 → repoauditor-0.4.5}/tests/Plugins/GitHubModule/RulesetRequirements/RequireCodeOwnerReviewRule_UnitTest.py

@@ -6,20 +6,25 @@
 # -------------------------------------------------------------------------------
 """Unit tests for RequireCodeOwnerReviewRule.py"""
 
+import pytest
+
 from RepoAuditor.Plugins.GitHub.RulesetRequirements.RequireCodeOwnerReview import (
     RequireCodeOwnerReviewRule,
 )
 from RepoAuditor.Requirement import EvaluateResult
+from tests.Plugins.GitHubModule.RulesetRequirements import create_rule
+
 
-from . import create_rule
+@pytest.fixture(name="requirement")
+def requirement_fixture():
+    return RequireCodeOwnerReviewRule()
 
 
 class TestRequireCodeOwnerReviewRule:
     """Unit tests for the RequireCodeOwnerReviewRule requirement."""
 
-    def test_Enabled(self, query_data):
+    def test_Enabled(self, requirement, query_data):
         """Test if the rule is enabled on the main branch."""
-        requirement = RequireCodeOwnerReviewRule()
 
         query_data["rules"].append(
             create_rule(
@@ -34,11 +39,10 @@ class TestRequireCodeOwnerReviewRule:
         assert result.result == EvaluateResult.Success
         assert f"{requirement.github_settings_value} is enabled" in result.context
 
-    def test_Disabled(self, query_data):
+    def test_Disabled(self, requirement, query_data):
         """Test if the required rule is disabled on the main branch
         by providing the value as false.
         """
-        requirement = RequireCodeOwnerReviewRule()
 
         query_data["rules"].append(
             create_rule(
@@ -53,11 +57,10 @@ class TestRequireCodeOwnerReviewRule:
         result = requirement.Evaluate(query_data, {"yes": True})
         assert result.result == EvaluateResult.Error
 
-    def test_WrongRuleType(self, query_data):
+    def test_WrongRuleType(self, requirement, query_data):
         """Test if the required rule is disabled on the main branch
         by providing the wrong rule type.
         """
-        requirement = RequireCodeOwnerReviewRule()
 
         query_data["rules"].append(
             create_rule(
@@ -71,3 +74,19 @@ class TestRequireCodeOwnerReviewRule:
 
         result = requirement.Evaluate(query_data, {"yes": True})
         assert result.result == EvaluateResult.Error
+
+    def test_NoneRuleType(self, requirement, query_data):
+        """Test behavior when the rule type provided is None."""
+
+        query_data["rules"].append(
+            create_rule(
+                name="Inactive PR Rules",
+                # None rule type
+                rule_type=None,
+                ruleset_name="main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"yes": True})
+        assert result.result == EvaluateResult.Error

{repoauditor-0.4.3 → repoauditor-0.4.5}/tests/Plugins/GitHubModule/RulesetRequirements/RequireConversationResolutionRule_UnitTest.py

@@ -6,20 +6,25 @@
 # -------------------------------------------------------------------------------
 """Unit tests for RequireConversationResolutionRule.py"""
 
+import pytest
+
 from RepoAuditor.Plugins.GitHub.RulesetRequirements.RequireConversationResolution import (
     RequireConversationResolutionRule,
 )
 from RepoAuditor.Requirement import EvaluateResult
+from tests.Plugins.GitHubModule.RulesetRequirements import create_rule
+
 
-from . import create_rule
+@pytest.fixture(name="requirement")
+def requirement_fixture():
+    return RequireConversationResolutionRule()
 
 
 class TestRequireConversationResolutionRule:
     """Unit tests for the RequireConversationResolutionRule requirement."""
 
-    def test_Enabled(self, query_data):
+    def test_Enabled(self, requirement, query_data):
         """Test if the rule is enabled on the main branch."""
-        requirement = RequireConversationResolutionRule()
 
         query_data["rules"].append(
             create_rule(
@@ -34,11 +39,10 @@ class TestRequireConversationResolutionRule:
         assert result.result == EvaluateResult.Success
         assert f"{requirement.github_settings_value} is enabled" in result.context
 
-    def test_Disabled(self, query_data):
+    def test_Disabled(self, requirement, query_data):
         """Test if the required rule is disabled on the main branch
         by providing the value as false.
         """
-        requirement = RequireConversationResolutionRule()
 
         query_data["rules"].append(
             create_rule(
@@ -53,11 +57,10 @@ class TestRequireConversationResolutionRule:
         result = requirement.Evaluate(query_data, {"no": False})
         assert result.result == EvaluateResult.Error
 
-    def test_WrongRuleType(self, query_data):
+    def test_WrongRuleType(self, requirement, query_data):
         """Test if the required rule is disabled on the main branch
         by providing the wrong rule type.
         """
-        requirement = RequireConversationResolutionRule()
 
         query_data["rules"].append(
             create_rule(
@@ -71,3 +74,19 @@ class TestRequireConversationResolutionRule:
 
         result = requirement.Evaluate(query_data, {"no": False})
         assert result.result == EvaluateResult.Error
+
+    def test_NoneRuleType(self, requirement, query_data):
+        """Test behavior when the rule type provided is None."""
+
+        query_data["rules"].append(
+            create_rule(
+                name="Inactive PR Rules",
+                # None rule type
+                rule_type=None,
+                ruleset_name="main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error

{repoauditor-0.4.3 → repoauditor-0.4.5}/tests/Plugins/GitHubModule/RulesetRequirements/RequirePullRequests_UnitTest.py

@@ -8,8 +8,7 @@
 
 from RepoAuditor.Plugins.GitHub.RulesetRequirements.RequirePullRequests import RequirePullRequests
 from RepoAuditor.Requirement import EvaluateResult
-
-from . import create_rule
+from tests.Plugins.GitHubModule.RulesetRequirements import create_rule
 
 
 class TestRequirePullRequests:

{repoauditor-0.4.3 → repoauditor-0.4.5}/tests/Plugins/GitHubModule/RulesetRequirements/RequireSignedCommits_UnitTest.py

@@ -10,8 +10,7 @@ from RepoAuditor.Plugins.GitHub.RulesetRequirements.RequireSignedCommits import
     RequireSignedCommits,
 )
 from RepoAuditor.Requirement import EvaluateResult
-
-from . import create_rule
+from tests.Plugins.GitHubModule.RulesetRequirements import create_rule
 
 
 class TestRequireSignedCommits:

{repoauditor-0.4.3 → repoauditor-0.4.5}/tests/Plugins/GitHubModule/RulesetRequirements/RequireStatusChecksToPassRule_UnitTest.py

@@ -10,8 +10,7 @@ from RepoAuditor.Plugins.GitHub.RulesetRequirements.RequireStatusChecksToPass im
     RequireStatusChecksToPassRule,
 )
 from RepoAuditor.Requirement import EvaluateResult
-
-from . import create_rule
+from tests.Plugins.GitHubModule.RulesetRequirements import create_rule
 
 
 class TestRequireStatusChecksToPassRule:

{repoauditor-0.4.3 → repoauditor-0.4.5}/tests/Plugins/GitHubModule/RulesetRequirements/RequireUpToDateBranchesRule_UnitTest.py

@@ -6,20 +6,25 @@
 # -------------------------------------------------------------------------------
 """Unit tests for RequireUpToDateBranchesRule.py"""
 
+import pytest
+
 from RepoAuditor.Plugins.GitHub.RulesetRequirements.RequireUpToDateBranches import (
     RequireUpToDateBranchesRule,
 )
 from RepoAuditor.Requirement import EvaluateResult
+from tests.Plugins.GitHubModule.RulesetRequirements import create_rule
+
 
-from . import create_rule
+@pytest.fixture(name="requirement")
+def requirement_fixture():
+    return RequireUpToDateBranchesRule()
 
 
 class TestRequireUpToDateBranchesRule:
     """Unit tests for the RequireUpToDateBranchesRule requirement."""
 
-    def test_Enabled(self, query_data):
+    def test_Enabled(self, requirement, query_data):
         """Test if the rule is enabled on the main branch."""
-        requirement = RequireUpToDateBranchesRule()
 
         query_data["rules"].append(
             create_rule(
@@ -34,11 +39,10 @@ class TestRequireUpToDateBranchesRule:
         assert result.result == EvaluateResult.Success
         assert f"{requirement.github_settings_value} is enabled" in result.context
 
-    def test_Disabled(self, query_data):
+    def test_Disabled(self, requirement, query_data):
         """Test if the required rule is disabled on the main branch
         by providing the value as false.
         """
-        requirement = RequireUpToDateBranchesRule()
 
         query_data["rules"].append(
             create_rule(
@@ -53,11 +57,10 @@ class TestRequireUpToDateBranchesRule:
         result = requirement.Evaluate(query_data, {"no": False})
         assert result.result == EvaluateResult.Error
 
-    def test_WrongRuleType(self, query_data):
+    def test_WrongRuleType(self, requirement, query_data):
         """Test if the required rule is disabled on the main branch
         by providing the wrong rule type.
         """
-        requirement = RequireUpToDateBranchesRule()
 
         query_data["rules"].append(
             create_rule(
@@ -71,3 +74,19 @@ class TestRequireUpToDateBranchesRule:
 
         result = requirement.Evaluate(query_data, {"no": False})
         assert result.result == EvaluateResult.Error
+
+    def test_NoneRuleType(self, requirement, query_data):
+        """Test behavior when the rule type provided is None."""
+
+        query_data["rules"].append(
+            create_rule(
+                name="Inactive PR Rules",
+                # None rule type
+                rule_type=None,
+                ruleset_name="main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error