RepoAuditor 0.2.27__tar.gz → 0.2.28__tar.gz

{repoauditor-0.2.27 → repoauditor-0.2.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RepoAuditor
-Version: 0.2.27
+Version: 0.2.28
 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.27 → repoauditor-0.2.28}/pyproject.toml

@@ -39,7 +39,7 @@ repo_auditor = "RepoAuditor:EntryPoint.app"
 [project.entry-points.RepoAuditor]
 GitHubPlugin = "RepoAuditor.Plugins.GitHubPlugin"
 GitHubCustomizationPlugin = "RepoAuditor.Plugins.GitHubCustomizationPlugin"
-GitHubRulesetPlugin="RepoAuditor.Plugins.GitHubRuleset"
+GitHubRulesetPlugin="RepoAuditor.Plugins.GitHubRulesetsPlugin"
 
 [build-system]
 requires = ["hatchling"]

repoauditor-0.2.28/src/RepoAuditor/Plugins/GitHubRulesets/Impl/EnableRulesetRequirementImpl.py

@@ -0,0 +1,83 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Contains the EnableRequirementImpl object."""
+
+from typing import Any, Optional
+from collections.abc import Callable
+
+from dbrownell_Common.Types import override  # type: ignore[import-untyped]
+
+from RepoAuditor.Requirement import EvaluateResult, Requirement
+from RepoAuditor.Plugins.GitHub.Impl.EnableRequirementImpl import EnableRequirementImpl
+
+
+# ----------------------------------------------------------------------
+class EnableRulesetRequirementImpl(EnableRequirementImpl):
+    """Object that implements ruleset settings that can be enabled/disabled."""
+
+    # ----------------------------------------------------------------------
+    def __init__(
+        self,
+        name: str,
+        default_value: bool,  # noqa: FBT001
+        dynamic_arg_name: str,
+        github_ruleset_type: str,
+        github_ruleset_value: str,
+        get_configuration_value_func: Callable[[dict[str, Any]], Optional[bool]],
+        resolution: str,
+        rationale: str,
+        subject: Optional[str] = None,
+        *,
+        requires_explicit_include: bool = False,
+        unset_set_terminology: tuple[str, str] = ("unchecked", "checked"),
+        missing_value_is_warning: bool = True,
+    ) -> None:
+        super().__init__(
+            name=name,
+            default_value=default_value,
+            dynamic_arg_name=dynamic_arg_name,
+            github_settings_value=github_ruleset_value,
+            get_configuration_value_func=get_configuration_value_func,
+            resolution=resolution,
+            rationale=rationale,
+            subject=subject,
+            requires_explicit_include=requires_explicit_include,
+            unset_set_terminology=unset_set_terminology,
+            missing_value_is_warning=missing_value_is_warning,
+        )
+
+        self.github_ruleset_type = github_ruleset_type
+
+    # ----------------------------------------------------------------------
+    @override
+    def _EvaluateImpl(
+        self,
+        query_data: dict[str, Any],
+        requirement_args: dict[str, Any],
+    ) -> Requirement.EvaluateImplResult:
+        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_ruleset_type}",
+                    )
+
+            return self.EvaluateImplResult(
+                EvaluateResult.Error,
+                f"No active branch ruleset requiring {self.github_ruleset_type} found",
+                provide_resolution=True,
+                provide_rationale=True,
+            )
+
+        # Requirement flag not set so DoesNotApply
+        return Requirement.EvaluateImplResult(EvaluateResult.DoesNotApply, None)

repoauditor-0.2.28/src/RepoAuditor/Plugins/GitHubRulesets/Module.py

@@ -0,0 +1,26 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Contains the GitHubRulesetModule object."""
+
+from RepoAuditor.Module import ExecutionStyle
+from RepoAuditor.Plugins.GitHubBase.Module import GitHubBaseModule
+from RepoAuditor.Plugins.GitHubRulesets.RulesetQuery import RulesetQuery
+
+
+class GitHubRulesetsModule(GitHubBaseModule):
+    """Module that validates GitHub repository rulesets."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            "GitHubRulesets",
+            "Validates GitHub repository rulesets.",
+            ExecutionStyle.Parallel,
+            [
+                RulesetQuery(),
+            ],
+            requires_explicit_include=True,
+        )

repoauditor-0.2.28/src/RepoAuditor/Plugins/GitHubRulesets/Requirements/RequirePullRequests.py

@@ -0,0 +1,25 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Contains the RequirePullRequests object."""
+
+from RepoAuditor.Plugins.GitHubRulesets.Impl.EnableRulesetRequirementImpl import EnableRulesetRequirementImpl
+
+
+class RequirePullRequests(EnableRulesetRequirementImpl):
+    """Require pull requests before merging to default branch."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            name="RequirePullRequests",
+            default_value=False,
+            dynamic_arg_name="true",
+            github_ruleset_type="Pull Requests",
+            github_ruleset_value="pull_request",
+            get_configuration_value_func=lambda rule: rule.get("type", "") == "pull_request",
+            resolution="Enable pull request requirements in repository rulesets",
+            rationale="Pull request reviews help maintain code quality and collaboration",
+        )

repoauditor-0.2.28/src/RepoAuditor/Plugins/GitHubRulesets/Requirements/RequireSignedCommits.py

@@ -0,0 +1,25 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Contains the RequireSignedCommits object."""
+
+from RepoAuditor.Plugins.GitHubRulesets.Impl.EnableRulesetRequirementImpl import EnableRulesetRequirementImpl
+
+
+class RequireSignedCommits(EnableRulesetRequirementImpl):
+    """Require signed commits."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            name="RequireSignedCommits",
+            default_value=False,
+            dynamic_arg_name="true",
+            github_ruleset_type="Signed Commits",
+            github_ruleset_value="required_signatures",
+            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.28/src/RepoAuditor/Plugins/GitHubRulesets/Requirements/RequireStatusChecks.py

@@ -0,0 +1,25 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Contains the RequireStatusChecks object."""
+
+from RepoAuditor.Plugins.GitHubRulesets.Impl.EnableRulesetRequirementImpl import EnableRulesetRequirementImpl
+
+
+class RequireStatusChecks(EnableRulesetRequirementImpl):
+    """Require status checks to pass before merging."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            name="RequireStatusChecks",
+            default_value=False,
+            dynamic_arg_name="true",
+            github_ruleset_type="Status Checks",
+            github_ruleset_value="required_status_checks",
+            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.27 → repoauditor-0.2.28}/src/RepoAuditor/Plugins/GitHubRulesets/RulesetQuery.py

@@ -45,9 +45,30 @@ class RulesetQuery(Query):
             data, or None if an error occurs.
 
         """
-        # Fetch ruleset data from the GitHub API
-        ruleset_data = module_data["session"].get("rulesets")
+        branch = module_data.get("branch")
+        if branch is None:
+            # Get the default branch name
+            response = module_data["session"].get("")
+
+            response.raise_for_status()
+            response = response.json()
+
+            branch = response["default_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}")
+
+        rules_response.raise_for_status()
 
         # Add ruleset data to module_data
-        module_data["ruleset_data"] = ruleset_data
+        module_data["rules"] = rules_response.json()
+
+        # Also get the associated ruleset for each rule
+        for rule in module_data["rules"]:
+            ruleset_respone = module_data["session"].get(f"rulesets/{rule['ruleset_id']}")
+            ruleset_respone.raise_for_status()
+            ruleset = ruleset_respone.json()
+            rule["ruleset"] = ruleset
+
         return module_data

repoauditor-0.2.27/src/RepoAuditor/Plugins/GitHubRuleset.py → repoauditor-0.2.28/src/RepoAuditor/Plugins/GitHubRulesetsPlugin.py

@@ -11,10 +11,10 @@ import pluggy
 from RepoAuditor import APP_NAME
 from RepoAuditor.Module import Module
 
-from RepoAuditor.Plugins.GitHubRulesets.Module import GitHubRulesetModule
+from RepoAuditor.Plugins.GitHubRulesets.Module import GitHubRulesetsModule
 
 
 @pluggy.HookimplMarker(APP_NAME)
 def GetModule() -> Module:
     """Return GitHubRulesetModule Module."""
-    return GitHubRulesetModule()
+    return GitHubRulesetsModule()

{repoauditor-0.2.27 → repoauditor-0.2.28}/src/RepoAuditor/__init__.py

@@ -3,4 +3,4 @@ APP_NAME = "RepoAuditor"
 # Note that this value will be overwritten by calls to `python ../../Build.py update_version` based
 # on changes observed in the git repository. The default value below will be used until the value
 # here is explicitly updated by the Continuous Integration system.
-__version__ = "0.2.27"
+__version__ = "0.2.28"

repoauditor-0.2.28/tests/Plugins/GitHubRuleset_EndToEndTest.py

@@ -0,0 +1,73 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""End-to-end tests for the GitHubRulesets plugin."""
+
+from pathlib import Path
+import pytest
+
+from dbrownell_Common.TestHelpers.StreamTestHelpers import (
+    InitializeStreamCapabilities,
+)
+from typer.testing import CliRunner
+
+from RepoAuditor.EntryPoint import app
+
+from utilities import ScrubDurationGithuburlAndSpaces, GetGithubUrl, CheckPATFileExists
+
+# ----------------------------------------------------------------------
+pytest.fixture(InitializeStreamCapabilities(), scope="session", autouse=True)
+
+
+# ----------------------------------------------------------------------
+class TestGitHubRuleset:
+    """End-to-end tests for rulesets in a GitHub repository."""
+
+    def test_RequireStatusChecks(self, pat_args, snapshot):
+        """Test for Status Checks not required ruleset"""
+        result = CliRunner().invoke(app, pat_args + ["--GitHubRulesets-RequireStatusChecks-true"])
+
+        assert result.exit_code == -1, result.output
+        assert ScrubDurationGithuburlAndSpaces(result.stdout) == snapshot
+
+    def test_RequirePullRequests(self, pat_args, snapshot):
+        """Test for Pull Requests required ruleset"""
+        result = CliRunner().invoke(app, pat_args + ["--GitHubRulesets-RequirePullRequests-true"])
+
+        assert result.exit_code == -1, result.output
+        assert ScrubDurationGithuburlAndSpaces(result.stdout) == snapshot
+
+    def test_RequireSignedCommits(self, pat_args, snapshot):
+        """Test for Signed Commits required ruleset"""
+        result = CliRunner().invoke(app, pat_args + ["--GitHubRulesets-RequireSignedCommits-true"])
+
+        assert result.exit_code == -1, result.output
+        assert ScrubDurationGithuburlAndSpaces(result.stdout) == snapshot
+
+
+# ----------------------------------------------------------------------
+# ----------------------------------------------------------------------
+# ----------------------------------------------------------------------
+@pytest.fixture
+def args() -> list[str]:
+    return [
+        "--include",
+        "GitHubRulesets",
+        "--GitHubRulesets-url",
+        GetGithubUrl(),
+    ]
+
+
+# ----------------------------------------------------------------------
+@pytest.fixture
+def pat_args(args) -> list[str]:
+    _github_pat_filename = (Path(__file__).parent / "github_pat.txt").resolve()
+    CheckPATFileExists(_github_pat_filename)
+
+    with _github_pat_filename.open() as f:
+        pat_value = f.read().strip()
+
+    return args + ["--GitHubRulesets-pat", pat_value]

repoauditor-0.2.28/tests/Plugins/GitHubRuleset_UnitTest.py

@@ -0,0 +1,190 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for the GitHub Rulesets Plugin"""
+
+from typing import Any
+
+from RepoAuditor.Requirement import EvaluateResult
+from RepoAuditor.Plugins.GitHubRulesets.Requirements.RequirePullRequests import RequirePullRequests
+from RepoAuditor.Plugins.GitHubRulesets.Requirements.RequireStatusChecks import RequireStatusChecks
+from RepoAuditor.Plugins.GitHubRulesets.Requirements.RequireSignedCommits import (
+    RequireSignedCommits,
+)
+
+
+def create_rule(name: str, rule_type: str, ruleset_name: str, parameters: dict[str, Any]):
+    """Helper function to create rule structure"""
+    return {
+        "name": name,
+        "type": rule_type,
+        "ruleset": {"name": ruleset_name},
+        "parameters": parameters,
+    }
+
+
+# ----------------------------------------------------------------------
+class TestRequirePullRequests:
+    """Unit tests for the RequirePullRequests requirement."""
+
+    def test_Enabled(self):
+        """Test if the rule is enabled on the main branch."""
+        requirement = RequirePullRequests()
+        context = {
+            "rules": [
+                create_rule(
+                    name="PR Rules",
+                    rule_type="pull_request",
+                    ruleset_name="Ruleset Main",
+                    parameters={},
+                )
+            ]
+        }
+        result = requirement.Evaluate(context, {"true": True})
+        assert result.result == EvaluateResult.Success
+        assert "enforces Pull Requests" in result.context
+
+    def test_Disabled(self):
+        """Test if the required rule is disabled on the main branch
+        by providing the wrong rule type.
+        """
+        requirement = RequirePullRequests()
+        context = {
+            "rules": [
+                create_rule(
+                    name="Inactive PR Rules",
+                    # Wrong rule type
+                    rule_type="",
+                    ruleset_name="Ruleset Main",
+                    parameters={},
+                )
+            ]
+        }
+        result = requirement.Evaluate(context, {"true": True})
+        assert result.result == EvaluateResult.Error
+
+    def test_WrongTarget(self):
+        """Test if rules are applied on the wrong branch."""
+        requirement = RequirePullRequests()
+        context = {
+            "rules": [
+                # GitHub behavior is to always give enforced rules on the specified target target.
+                # Hence the rules here will be empty.
+            ]
+        }
+        result = requirement.Evaluate(context, {"true": True})
+        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, {"true": True})
+        assert result.result == EvaluateResult.Error
+        assert "No active branch ruleset requiring Pull Requests found" in result.context
+
+
+# ----------------------------------------------------------------------
+class TestRequireSignedCommits:
+    """Unit tests for the RequireSignedCommits requirement."""
+
+    def test_Enabled(self):
+        """Test if the rule is enabled on the main branch."""
+        requirement = RequireSignedCommits()
+        context = {
+            "rules": [
+                create_rule(
+                    name="Signing Rules",
+                    rule_type="required_signatures",
+                    ruleset_name="Ruleset Main",
+                    parameters={},
+                )
+            ]
+        }
+        result = requirement.Evaluate(context, {"true": True})
+        assert result.result == EvaluateResult.Success
+        assert "enforces Signed Commits" in result.context
+
+    def test_Disabled(self):
+        """Test if the required rule is disabled on the main branch
+        by providing the wrong rule type.
+        """
+        requirement = RequireSignedCommits()
+        context = {
+            "rules": [
+                create_rule(
+                    name="Signing Rules",
+                    # Wrong rule type
+                    rule_type="pull_request",
+                    ruleset_name="Ruleset Main",
+                    parameters={},
+                )
+            ]
+        }
+        result = requirement.Evaluate(context, {"true": True})
+        assert result.result == EvaluateResult.Error
+
+    def test_PartialConfig(self):
+        """Test for rules that are not actively enforced."""
+        requirement = RequireSignedCommits()
+        context = {
+            "rules": [
+                # GitHub only returns rules that are actively enforced
+            ]
+        }
+        result = requirement.Evaluate(context, {"true": True})
+        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, {"true": True})
+        assert result.result == EvaluateResult.Error
+        assert "No active branch ruleset requiring Signed Commits found" in result.context
+
+
+# ----------------------------------------------------------------------
+class TestRequireStatusChecks:
+    """Unit tests for the RequireStatusChecks requirement."""
+
+    def test_Enabled(self):
+        """Test if the rule is enabled on the main branch."""
+        requirement = RequireStatusChecks()
+        context = {
+            "rules": [
+                create_rule(
+                    name="CI Checks",
+                    rule_type="required_status_checks",
+                    ruleset_name="Ruleset Main",
+                    parameters={},
+                )
+            ]
+        }
+        result = requirement.Evaluate(context, {"true": True})
+        assert result.result == EvaluateResult.Success
+        assert "enforces Status Checks" in result.context
+
+    def test_EmptyChecks(self):
+        """Test for Status Check rules which don't have an associated CI check."""
+        requirement = RequireStatusChecks()
+        context = {
+            "rules": [
+                # GitHub won't allow active status check rules
+                # which don't have associated CI checks.
+                # Hence empty.
+            ]
+        }
+        result = requirement.Evaluate(context, {"true": True})
+        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, {"true": True})
+        assert result.result == EvaluateResult.Error
+        assert "No active branch ruleset requiring Status Checks found" in result.context