RepoAuditor 0.2.84__tar.gz → 0.3.0__tar.gz

{repoauditor-0.2.84 → repoauditor-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RepoAuditor
-Version: 0.2.84
+Version: 0.3.0
 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.84 → repoauditor-0.3.0}/src/RepoAuditor/Plugins/CommunityStandards/Requirements/LicenseFile.py

@@ -14,7 +14,7 @@ from RepoAuditor.Plugins.CommunityStandards.Impl.ExistsRequirementImpl import (
 
 
 class LicenseFile(ExistsRequirementImpl):
-    """Validates that a CODE_OF_CONDUCT file is configured."""
+    """Validates that a file with licensing information is present."""
 
     def __init__(self) -> None:
         super().__init__(

{repoauditor-0.2.84 → repoauditor-0.3.0}/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.84"
+__version__ = "0.3.0"

repoauditor-0.2.84/tests/Plugins/CommunityStandards/GitHubCommunityStandards_UnitTest.py → repoauditor-0.3.0/tests/Plugins/CommunityStandards/CommunityStandards_UnitTest.py

@@ -4,7 +4,7 @@
 # |  Distributed under the MIT License.
 # |
 # -------------------------------------------------------------------------------
-"""Unit tests for the GitHub Community Standards Plugin"""
+"""Unit tests for the Community Standards Plugin"""
 
 import sys
 from pathlib import Path

{repoauditor-0.2.84 → repoauditor-0.3.0}/tests/Plugins/CommunityStandards_EndToEndTest.py

@@ -165,7 +165,7 @@ class TestCommunityStandards:
     @patch.object(
         CommunityStandardsQuery,
         "GetData",
-        GetDataFunctional("CONTRIBUTING.md"),
+        GetDataFunctional("docs/CONTRIBUTING.md"),
     )
     def test_NoContributing(self, pat_args, snapshot):
         """Test if a CONTRIBUTING file does not exist in the repository."""

repoauditor-0.3.0/tests/Plugins/GitHubModule/RulesetRequirements/AllowMainlineForcePushesRule_UnitTest.py

@@ -0,0 +1,53 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for AllowMainlineForcePushesRule.py"""
+
+from RepoAuditor.Plugins.GitHub.RulesetRequirements.AllowMainlineForcePushes import (
+    AllowMainlineForcePushesRule,
+)
+from RepoAuditor.Requirement import EvaluateResult
+
+from . import create_rule
+
+
+class TestAllowMainlineForcePushesRule:
+    """Unit tests for the AllowMainlineForcePushesRule requirement."""
+
+    def test_Enabled(self, query_data):
+        """Test if the rule is enabled on the main branch."""
+        requirement = AllowMainlineForcePushesRule()
+
+        query_data["rules"].append(
+            create_rule(
+                name="main",
+                rule_type="non_fast_forward",
+                ruleset_name="main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"yes": True})
+        assert result.result == EvaluateResult.Success
+        assert f"{requirement.github_settings_value} is enabled" in result.context
+
+    def test_Disabled(self, query_data):
+        """Test if the rule is disabled by not providing the appropriate rule within the ruleset."""
+        requirement = AllowMainlineForcePushesRule()
+
+        query_data["rules"].append(
+            create_rule(
+                name="Random Rule",
+                # Wrong rule type
+                rule_type="push_request",
+                ruleset_name="main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"yes": True})
+        assert result.result == EvaluateResult.Error
+        assert f"No active branch ruleset with {requirement.github_settings_value} found" in result.context

repoauditor-0.3.0/tests/Plugins/GitHubModule/RulesetRequirements/DismissStalePullRequestApprovalsRule_UnitTest.py

@@ -0,0 +1,73 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for DismissStalePullRequestApprovalsRule.py"""
+
+from RepoAuditor.Plugins.GitHub.RulesetRequirements.DismissStalePullRequestApprovals import (
+    DismissStalePullRequestApprovalsRule,
+)
+from RepoAuditor.Requirement import EvaluateResult
+
+from . import create_rule
+
+
+class TestDismissStalePullRequestApprovalsRule:
+    """Unit tests for the DismissStalePullRequestApprovalsRule requirement."""
+
+    def test_Enabled(self, query_data):
+        """Test if the rule is enabled on the main branch."""
+        requirement = DismissStalePullRequestApprovalsRule()
+
+        query_data["rules"].append(
+            create_rule(
+                name="PR Rules",
+                rule_type="pull_request",
+                ruleset_name="main",
+                parameters={"dismiss_stale_reviews_on_push": True},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Success
+        assert f"{requirement.github_settings_value} is enabled" in result.context
+
+    def test_Disabled(self, 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(
+                name="PR Rules",
+                # Wrong rule type
+                rule_type="pull_request",
+                ruleset_name="main",
+                parameters={"dismiss_stale_reviews_on_push": False},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error
+
+    def test_WrongRuleType(self, 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(
+                name="Inactive PR Rules",
+                # Wrong rule type
+                rule_type="push_request",
+                ruleset_name="Ruleset Main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error

repoauditor-0.3.0/tests/Plugins/GitHubModule/RulesetRequirements/EnsureStatusChecksRule_UnitTest.py

@@ -0,0 +1,73 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for EnsureStatusChecksRule.py"""
+
+from RepoAuditor.Plugins.GitHub.RulesetRequirements.EnsureStatusChecks import EnsureStatusChecksRule
+from RepoAuditor.Requirement import EvaluateResult
+
+from . import create_rule
+
+
+class TestEnsureStatusChecksRule:
+    """Unit tests for the EnsureStatusChecksRule requirement."""
+
+    def test_Enabled(self, query_data):
+        """Test if the rule is enabled on the main branch."""
+        requirement = EnsureStatusChecksRule()
+
+        query_data["rules"].append(
+            create_rule(
+                name="main",
+                rule_type="required_status_checks",
+                ruleset_name="main",
+                parameters={
+                    "required_status_checks": [
+                        "CI+CD",
+                        "Additional Check",
+                    ]
+                },
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Success
+        assert f"{requirement.github_settings_value} is enabled" in result.context
+
+    def test_NoStatusChecks(self, query_data):
+        """Test if the rule is enabled but no status checks are provided."""
+        requirement = EnsureStatusChecksRule()
+
+        query_data["rules"].append(
+            create_rule(
+                name="main",
+                rule_type="required_status_checks",
+                ruleset_name="main",
+                parameters={"required_status_checks": []},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error
+        assert f"No active branch ruleset with {requirement.github_settings_value} found" in result.context
+
+    def test_Disabled(self, query_data):
+        """Test if the rule is disabled by not providing the appropriate rule within the ruleset."""
+        requirement = EnsureStatusChecksRule()
+
+        query_data["rules"].append(
+            create_rule(
+                name="Random Rule",
+                # Wrong rule type
+                rule_type="pull_request",
+                ruleset_name="main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error
+        assert f"No active branch ruleset with {requirement.github_settings_value} found" in result.context

repoauditor-0.3.0/tests/Plugins/GitHubModule/RulesetRequirements/RequireApprovalMostRecentPushRule_UnitTest.py

@@ -0,0 +1,73 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for RequireApprovalMostRecentPushRule.py"""
+
+from RepoAuditor.Plugins.GitHub.RulesetRequirements.RequireApprovalMostRecentPush import (
+    RequireApprovalMostRecentPushRule,
+)
+from RepoAuditor.Requirement import EvaluateResult
+
+from . import create_rule
+
+
+class TestRequireApprovalMostRecentPushRule:
+    """Unit tests for the RequireApprovalMostRecentPushRule requirement."""
+
+    def test_Enabled(self, query_data):
+        """Test if the rule is enabled on the main branch."""
+        requirement = RequireApprovalMostRecentPushRule()
+
+        query_data["rules"].append(
+            create_rule(
+                name="PR Rules",
+                rule_type="pull_request",
+                ruleset_name="main",
+                parameters={"require_last_push_approval": True},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Success
+        assert f"{requirement.github_settings_value} is enabled" in result.context
+
+    def test_Disabled(self, 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(
+                name="PR Rules",
+                # Wrong rule type
+                rule_type="pull_request",
+                ruleset_name="main",
+                parameters={"require_last_push_approval": False},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error
+
+    def test_WrongRuleType(self, 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(
+                name="Inactive PR Rules",
+                # Wrong rule type
+                rule_type="push_request",
+                ruleset_name="Ruleset Main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error

repoauditor-0.3.0/tests/Plugins/GitHubModule/RulesetRequirements/RequireApprovalsRule_UnitTest.py

@@ -0,0 +1,71 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for RequireApprovalsRule.py"""
+
+from RepoAuditor.Plugins.GitHub.RulesetRequirements.RequireApprovals import RequireApprovalsRule
+from RepoAuditor.Requirement import EvaluateResult
+
+from . import create_rule
+
+
+class TestRequireApprovalsRule:
+    """Unit tests for the RequireApprovalsRule requirement."""
+
+    def test_Enabled(self, query_data):
+        """Test if the rule is enabled on the main branch."""
+        requirement = RequireApprovalsRule()
+
+        query_data["rules"].append(
+            create_rule(
+                name="PR Rules",
+                rule_type="pull_request",
+                ruleset_name="main",
+                parameters={"required_approving_review_count": 1},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Success
+        assert f"{requirement.github_settings_value} is enabled" in result.context
+
+    def test_Disabled(self, 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(
+                name="PR Rules",
+                # Wrong rule type
+                rule_type="pull_request",
+                ruleset_name="main",
+                parameters={"required_approving_review_count": 0},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error
+
+    def test_WrongRuleType(self, 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(
+                name="Inactive PR Rules",
+                # Wrong rule type
+                rule_type="push_request",
+                ruleset_name="main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error

repoauditor-0.3.0/tests/Plugins/GitHubModule/RulesetRequirements/RequireCodeOwnerReviewRule_UnitTest.py

@@ -0,0 +1,73 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for RequireCodeOwnerReviewRule.py"""
+
+from RepoAuditor.Plugins.GitHub.RulesetRequirements.RequireCodeOwnerReview import (
+    RequireCodeOwnerReviewRule,
+)
+from RepoAuditor.Requirement import EvaluateResult
+
+from . import create_rule
+
+
+class TestRequireCodeOwnerReviewRule:
+    """Unit tests for the RequireCodeOwnerReviewRule requirement."""
+
+    def test_Enabled(self, query_data):
+        """Test if the rule is enabled on the main branch."""
+        requirement = RequireCodeOwnerReviewRule()
+
+        query_data["rules"].append(
+            create_rule(
+                name="PR Rules",
+                rule_type="pull_request",
+                ruleset_name="main",
+                parameters={"require_code_owner_review": True},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"yes": True})
+        assert result.result == EvaluateResult.Success
+        assert f"{requirement.github_settings_value} is enabled" in result.context
+
+    def test_Disabled(self, 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(
+                name="PR Rules",
+                # Wrong rule type
+                rule_type="pull_request",
+                ruleset_name="main",
+                parameters={"require_code_owner_review": False},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"yes": True})
+        assert result.result == EvaluateResult.Error
+
+    def test_WrongRuleType(self, 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(
+                name="Inactive PR Rules",
+                # Wrong rule type
+                rule_type="push_request",
+                ruleset_name="Ruleset Main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"yes": True})
+        assert result.result == EvaluateResult.Error

repoauditor-0.3.0/tests/Plugins/GitHubModule/RulesetRequirements/RequireConversationResolutionRule_UnitTest.py

@@ -0,0 +1,73 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for RequireConversationResolutionRule.py"""
+
+from RepoAuditor.Plugins.GitHub.RulesetRequirements.RequireConversationResolution import (
+    RequireConversationResolutionRule,
+)
+from RepoAuditor.Requirement import EvaluateResult
+
+from . import create_rule
+
+
+class TestRequireConversationResolutionRule:
+    """Unit tests for the RequireConversationResolutionRule requirement."""
+
+    def test_Enabled(self, query_data):
+        """Test if the rule is enabled on the main branch."""
+        requirement = RequireConversationResolutionRule()
+
+        query_data["rules"].append(
+            create_rule(
+                name="PR Rules",
+                rule_type="pull_request",
+                ruleset_name="main",
+                parameters={"required_review_thread_resolution": True},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Success
+        assert f"{requirement.github_settings_value} is enabled" in result.context
+
+    def test_Disabled(self, 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(
+                name="PR Rules",
+                # Wrong rule type
+                rule_type="pull_request",
+                ruleset_name="main",
+                parameters={"required_review_thread_resolution": False},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error
+
+    def test_WrongRuleType(self, 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(
+                name="Inactive PR Rules",
+                # Wrong rule type
+                rule_type="push_request",
+                ruleset_name="Ruleset Main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error

repoauditor-0.3.0/tests/Plugins/GitHubModule/RulesetRequirements/RequirePullRequests_UnitTest.py

@@ -0,0 +1,71 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for the RequirePullRequests.py"""
+
+from RepoAuditor.Plugins.GitHub.RulesetRequirements.RequirePullRequests import RequirePullRequests
+from RepoAuditor.Requirement import EvaluateResult
+
+from . import create_rule
+
+
+class TestRequirePullRequests:
+    """Unit tests for the RequirePullRequests requirement."""
+
+    def test_Enabled(self, query_data):
+        """Test if the rule is enabled on the main branch."""
+        requirement = RequirePullRequests()
+
+        query_data["rules"].append(
+            create_rule(
+                name="PR Rules",
+                rule_type="pull_request",
+                ruleset_name="Ruleset Main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Success
+        assert f"{requirement.github_settings_value} is enabled" in result.context
+
+    def test_Disabled(self, query_data):
+        """Test if the required rule is disabled on the main branch
+        by providing the wrong rule type.
+        """
+        requirement = RequirePullRequests()
+
+        query_data["rules"].append(
+            create_rule(
+                name="Inactive PR Rules",
+                # Wrong rule type
+                rule_type="push_request",
+                ruleset_name="Ruleset Main",
+                parameters={},
+            )
+        )
+
+        result = requirement.Evaluate(query_data, {"no": True})
+        assert result.result == EvaluateResult.Success
+
+    def test_WrongTarget(self, query_data):
+        """Test if rules are applied on the wrong branch."""
+        requirement = RequirePullRequests()
+        query_data["rules"] = [
+            # GitHub behavior is to always give enforced rules on the specified target target.
+            # Hence the rules here will be empty.
+        ]
+
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error
+
+    def test_NoRulesets(self, query_data):
+        """Test if no rules are applied on the main branch."""
+        requirement = RequirePullRequests()
+        query_data["rules"] = []
+        result = requirement.Evaluate(query_data, {"no": False})
+        assert result.result == EvaluateResult.Error
+        assert f"No active branch ruleset with {requirement.github_settings_value} found" in result.context