RepoAuditor 0.2.34__tar.gz → 0.2.37__tar.gz

{repoauditor-0.2.34 → repoauditor-0.2.37}/.github/workflows/CICD_impl.yml

@@ -70,7 +70,7 @@ jobs:
         run: uv run pre-commit run --verbose
 
       - name: Validate Tests
-        run: uv run pytest -k 'not EndToEndTest' --cov-fail-under=80.0
+        run: uv run pytest -k 'not EndToEndTest' --cov-fail-under=95.0
         env:
           COVERAGE_FILE: .coverage.${{ matrix.os }}.${{ matrix.python_version }}
 

{repoauditor-0.2.34 → repoauditor-0.2.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RepoAuditor
-Version: 0.2.34
+Version: 0.2.37
 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
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
-Requires-Dist: dbrownell-common>=0.14.6
+Requires-Dist: dbrownell-common>=0.14.10
 Requires-Dist: pluggy>=1.5.0
 Requires-Dist: requests>=2.32.3
 Requires-Dist: typer>=0.15.3

{repoauditor-0.2.34 → repoauditor-0.2.37}/pyproject.toml

@@ -7,7 +7,7 @@ authors = [
 ]
 requires-python = ">= 3.10"
 dependencies = [
-    "dbrownell-common>=0.14.6",
+    "dbrownell-common>=0.14.10",
     "pluggy>=1.5.0",
     "requests>=2.32.3",
     "typer>=0.15.3",

{repoauditor-0.2.34 → repoauditor-0.2.37}/src/RepoAuditor/EntryPoint.py

@@ -35,9 +35,9 @@ class NaturalOrderGrouper(TyperGroup):
     """Group commands in natural order."""
 
     # ----------------------------------------------------------------------
-    def list_commands(self, *args, **kwargs) -> list[str]:  # noqa: ARG002
+    def list_commands(self, *args, **kwargs) -> list[str]:  # noqa: ARG002  # pragma: no cover
         """Return a list of all the commands, to be sorted in a natural ordering."""
-        return self.commands.keys()
+        return list(self.commands.keys())
 
 
 # ----------------------------------------------------------------------
@@ -64,31 +64,42 @@ _all_modules = _GetModules()
 del _GetModules
 
 
+# ----------------------------------------------------------------------
+def TypeInfoToString(
+    arg_name: str,
+    type_info: TyperEx.TypeDefinitionItemType,
+) -> str:
+    """Convert type information from command line arguments to a string representation.
+
+    Args:
+        arg_name (str): The name of the command line argument.
+        type_info (TyperEx.TypeDefinitionItemType): Type information for the accepted value.
+
+    Returns:
+        str: String description of the command line argument.
+
+    """
+    if isinstance(type_info, TyperEx.TypeDefinitionItem):
+        python_type = type_info.python_type
+        parameter_info = type_info.parameter_info
+    elif isinstance(type_info, tuple):
+        python_type = type_info[0]
+        parameter_info = type_info[1]
+    else:
+        python_type = type_info
+        parameter_info = None
+
+    return "    {arg_name:<50} {type_description:<7} {help}".format(
+        arg_name=arg_name,
+        type_description=python_type.__name__,
+        help="" if parameter_info is None else parameter_info.help,
+    )
+
+
 # ----------------------------------------------------------------------
 def _HelpEpilog() -> str:
     content: list[str] = []
 
-    # ----------------------------------------------------------------------
-    def TypeInfoToString(
-        arg_name: str,
-        type_info: TyperEx.TypeDefinitionItemType,
-    ) -> str:
-        if isinstance(type_info, TyperEx.TypeDefinitionItem):
-            python_type = type_info.python_type
-            parameter_info = type_info.parameter_info
-        elif isinstance(type_info, tuple):
-            python_type = type_info[0]
-            parameter_info = type_info[1]
-        else:
-            python_type = type_info
-            parameter_info = None
-
-        return "    {arg_name:<50} {type_description:<7} {help}".format(
-            arg_name=arg_name,
-            type_description=python_type.__name__,
-            help="" if parameter_info is None else parameter_info.help,
-        )
-
     # ----------------------------------------------------------------------
 
     for module in _all_modules:
@@ -181,7 +192,7 @@ def _VersionCallback(value: bool) -> None:  # noqa: FBT001
     epilog=_HelpEpilog(),
     no_args_is_help=False,
 )
-def EntryPoint(  # noqa: PLR0913
+def EntryPoint(  # noqa: PLR0913  # pragma: no cover
     ctx: typer.Context,
     version: Annotated[  # noqa: ARG001, FBT002
         bool,

{repoauditor-0.2.34 → repoauditor-0.2.37}/src/RepoAuditor/ExecuteModules.py

@@ -151,7 +151,7 @@ def Execute(
                 # ----------------------------------------------------------------------
                 def Transform(
                     status: ExecuteTasks.Status,
-                ) -> ExecuteTasks.TransformResultComplete:
+                ) -> ExecuteTasks.CompleteTransformResult:
                     # ----------------------------------------------------------------------
                     def OnStatus(num_completed: int, *args, **kwargs) -> None:
                         status.OnProgress(
@@ -169,7 +169,7 @@ def Execute(
                         ignore_warnings_module_names=ignore_warnings_module_names,
                     )
 
-                    return ExecuteTasks.TransformResultComplete(evaluate_results, result_code, result_status)
+                    return ExecuteTasks.CompleteTransformResult(evaluate_results, result_code, result_status)
 
                 # ----------------------------------------------------------------------
 

{repoauditor-0.2.34 → repoauditor-0.2.37}/src/RepoAuditor/Impl/ParallelSequentialProcessor.py

@@ -8,7 +8,7 @@
 
 from collections.abc import Callable
 from enum import Enum, auto
-from typing import Optional, TypeVar, cast
+from typing import Optional, TypeVar, Union, cast
 
 from dbrownell_Common import ExecuteTasks  # type: ignore[import-untyped]
 from dbrownell_Common.Streams.DoneManager import DoneManager  # type: ignore[import-untyped]
@@ -87,18 +87,18 @@ def _Impl(
     def Execute(
         results_index: int,
         item: ItemType,
-    ) -> ExecuteTasks.TransformResultComplete:
+    ) -> ExecuteTasks.CompleteTransformResult:
         return_code, result = calculate_result_func(item)
 
         assert results[results_index] is None
         results[results_index] = result
 
-        return ExecuteTasks.TransformResultComplete(None, return_code)
+        return ExecuteTasks.CompleteTransformResult(None, return_code)
 
     # ----------------------------------------------------------------------
 
     if parallel:
-        transform_results: list[Optional[Exception]] = ExecuteTasks.TransformTasks(
+        transform_results: list[Union[None, object, Exception]] = ExecuteTasks.TransformTasks(
             dm,
             "Processing",
             [
@@ -111,7 +111,7 @@ def _Impl(
         )
 
         for transform_result in transform_results:
-            if transform_result is not None:
+            if transform_result is not None and isinstance(transform_result, Exception):
                 raise transform_result
 
     for sequential_index, (results_index, item) in enumerate(sequential):

{repoauditor-0.2.34 → repoauditor-0.2.37}/src/RepoAuditor/Plugins/GitHub/ClassicBranchProtectionRequirements/DismissStalePullRequestApprovals.py

@@ -54,4 +54,4 @@ def _GetValue(
     if settings is None:
         return None
 
-    return settings["dismiss_stale_reviews"]
+    return settings.get("dismiss_stale_reviews", None)

{repoauditor-0.2.34 → repoauditor-0.2.37}/src/RepoAuditor/Plugins/GitHub/ClassicBranchProtectionRequirements/RequireApprovalMostRecentPush.py

@@ -53,4 +53,4 @@ def _GetValue(
     if settings is None:
         return None
 
-    return settings["require_last_push_approval"]
+    return settings.get("require_last_push_approval", None)

{repoauditor-0.2.34 → repoauditor-0.2.37}/src/RepoAuditor/Plugins/GitHub/ClassicBranchProtectionRequirements/RequireApprovals.py

@@ -55,4 +55,4 @@ def _GetValue(
     if settings is None:
         return None
 
-    return settings["required_approving_review_count"]
+    return settings.get("required_approving_review_count", None)

{repoauditor-0.2.34 → repoauditor-0.2.37}/src/RepoAuditor/Plugins/GitHub/ClassicBranchProtectionRequirements/RequireCodeOwnerReview.py

@@ -57,4 +57,4 @@ def _GetValue(
     if settings is None:
         return None
 
-    return settings["require_code_owner_reviews"]
+    return settings.get("require_code_owner_reviews", None)

{repoauditor-0.2.34 → repoauditor-0.2.37}/src/RepoAuditor/Plugins/GitHub/ClassicBranchProtectionRequirements/RequireUpToDateBranches.py

@@ -55,4 +55,4 @@ def _GetValue(
     if settings is None:
         return None
 
-    return settings["strict"]
+    return settings.get("strict", None)

{repoauditor-0.2.34 → repoauditor-0.2.37}/src/RepoAuditor/Plugins/GitHub/StandardQueryRequirements/Description.py

@@ -73,11 +73,10 @@ class Description(Requirement):
     ) -> Requirement.EvaluateImplResult:
         standard_data = query_data["standard"]
 
-        if "description" not in standard_data:
+        result = standard_data.get("description", None)
+        if result is None:
             return CreateIncompleteDataResult()
 
-        result = standard_data["description"]
-
         expect_description = not requirement_args["allow-empty"]
 
         if expect_description and not result:

{repoauditor-0.2.34 → repoauditor-0.2.37}/src/RepoAuditor/Plugins/GitHub/StandardQueryRequirements/SquashCommitMerge.py

@@ -33,7 +33,8 @@ class SquashCommitMerge(StandardEnableRequirementImpl):
 
                 Reasons for this Default
                 ------------------------
-                - Rebase merging is not compatible with signed commits, as GitHub creates a new commit when squashing.
+                - When performing a Squash & Merge, GitHub creates a new merge commit with its key.
+                This makes it difficult to verify author signatures when looking at the commit history.
 
                 Reasons to Override this Default
                 --------------------------------

{repoauditor-0.2.34 → repoauditor-0.2.37}/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.34"
+__version__ = "0.2.37"

{repoauditor-0.2.34 → repoauditor-0.2.37}/tests/EntryPoint_UnitTest.py

@@ -7,12 +7,14 @@
 """Unit tests for EntryPoint.py"""
 
 import pytest
+import typer
 
 from dbrownell_Common.TestHelpers.StreamTestHelpers import InitializeStreamCapabilities
+from dbrownell_Common.TyperEx import TypeDefinitionItem  # type: ignore [import-untyped]
 from typer.testing import CliRunner
 
 from RepoAuditor import __version__
-from RepoAuditor.EntryPoint import app
+from RepoAuditor.EntryPoint import app, TypeInfoToString
 
 from Plugins.utilities import GetGithubUrl
 
@@ -58,3 +60,39 @@ def test_Help() -> None:
 
     assert result.exit_code == 0
     assert "Module Information" in result.output
+
+
+def test_TypeInfoToString() -> None:
+    """Test the TypeInfoToString function to ensure valid command line output."""
+    result = TypeInfoToString(
+        "test_arg",
+        (
+            bool,
+            typer.Option(
+                False,
+                help="Help text.",
+            ),
+        ),
+    )
+    expected_string = "    test_arg                                           bool    Help text."
+    assert expected_string == result
+
+    result = TypeInfoToString(
+        "test_arg",
+        TypeDefinitionItem(
+            bool,
+            typer.models.ParameterInfo(
+                default=False,
+                help="TypeDefinitionItem",
+            ),
+        ),
+    )
+    expected_string = "    test_arg                                           bool    TypeDefinitionItem"
+    assert expected_string == result
+
+    result = TypeInfoToString(
+        "test_none",
+        bool,
+    )
+    expected_string = "    test_none                                          bool    "
+    assert expected_string == result

repoauditor-0.2.37/tests/Plugins/GitHubModule/ClassicBranchProtectionQuery_UnitTest.py

@@ -0,0 +1,98 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for ClassicBranchProtectionQuery.py"""
+
+import pytest
+
+from RepoAuditor.Plugins.GitHub.ClassicBranchProtectionQuery import ClassicBranchProtectionQuery
+from RepoAuditor.Plugins.GitHubBase.Module import _GitHubSession
+
+
+@pytest.fixture
+def module_data():
+    return {
+        "session": _GitHubSession("https://github.com/gt-sse-center/RepoAuditor", "pat"),
+    }
+
+
+def get_mock_request(
+    status_code: int = 200,
+    protected_branch: bool = True,
+    rulesets_exist: bool = True,
+):
+    """A function which creates and returns a `mock_request` function."""
+
+    class MockedResponse:
+        def __init__(self, data, status_code):
+            self._data = data
+            self.status_code = status_code
+
+        def json(self):
+            return self._data
+
+        @staticmethod
+        def raise_for_status():
+            pass
+
+    def mock_request(method, url, *args, **kwargs):
+        """The function to use for monkeypatching"""
+        # remove leading /
+        if len(url) > 0 and url[0] == "/":
+            url = url[1:]
+
+        if method.lower() == "get":
+            if url == "":
+                return MockedResponse({"default_branch": "main"}, status_code)
+            elif url == "branches/main":
+                return MockedResponse({"protected": protected_branch}, status_code)
+            elif url == "branches/main/protection":
+                return MockedResponse("valid-test-data", status_code)
+            elif url == "rules/branches/main":
+                if rulesets_exist:
+                    return MockedResponse("valid-rules", status_code=200)
+                else:
+                    return MockedResponse("", status_code=200)
+
+    return mock_request
+
+
+class TestClassicBranchProtectionQuery:
+    def test_GetData(self, module_data, monkeypatch):
+        """Test successful GetData"""
+        monkeypatch.setattr(module_data["session"], "request", get_mock_request())
+        query = ClassicBranchProtectionQuery()
+        query_data = query.GetData(module_data)
+
+        assert query_data["branch_protection_data"] == "valid-test-data"
+
+    def test_NotProtected(self, module_data, monkeypatch):
+        """Test where branch is not protected."""
+        monkeypatch.setattr(module_data["session"], "request", get_mock_request(protected_branch=False))
+        query = ClassicBranchProtectionQuery()
+        query_data = query.GetData(module_data)
+
+        assert query_data is None
+
+    def test_RulesetProtected(self, module_data, monkeypatch):
+        """Test when the branch is protected by rulesets."""
+        monkeypatch.setattr(module_data["session"], "request", get_mock_request(status_code=404))
+        query = ClassicBranchProtectionQuery()
+        query_data = query.GetData(module_data)
+
+        assert query_data is None
+
+    def test_RulesetProtectedNoRules(self, module_data, monkeypatch):
+        """Test when the branch is protected by rulesets, but no rules exist."""
+        monkeypatch.setattr(
+            module_data["session"], "request", get_mock_request(status_code=404, rulesets_exist=False)
+        )
+        # Set github_pat to None to test a pathway
+        module_data["session"].github_pat = None
+        query = ClassicBranchProtectionQuery()
+        query_data = query.GetData(module_data)
+
+        assert query_data is None

repoauditor-0.2.37/tests/Plugins/GitHubModule/ClassicBranchProtectionRequirements/DismissStalePullRequestApprovals_UnitTest.py

@@ -0,0 +1,75 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for DismissStalePullRequestApprovals.py"""
+
+import pytest
+
+from RepoAuditor.Plugins.GitHub.ClassicBranchProtectionRequirements.DismissStalePullRequestApprovals import (
+    DismissStalePullRequestApprovals,
+)
+from RepoAuditor.Requirement import EvaluateResult
+
+
+@pytest.fixture
+def query_data(session):
+    return {
+        "session": session,
+        "branch": "main",
+        "branch_protection_data": {
+            "required_pull_request_reviews": {
+                "dismiss_stale_reviews": True,
+            },
+        },
+    }
+
+
+@pytest.fixture
+def requirement():
+    return DismissStalePullRequestApprovals()
+
+
+class TestDismissStalePullRequestApprovals:
+    def test_required_pull_request_reviews_missing(self, requirement, query_data):
+        """Test when `required_pull_request_reviews` is missing."""
+        query_data["branch_protection_data"] = {}
+        requirement_args = {}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.DoesNotApply
+        assert result.context is None
+
+    def test_required_pull_request_reviews_none(self, requirement, query_data):
+        """Test when `required_pull_request_reviews` is None"""
+        query_data["branch_protection_data"]["required_pull_request_reviews"] = None
+        requirement_args = {}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.DoesNotApply
+        assert result.context is None
+
+    def test_dismiss_stale_reviews_missing(self, requirement, query_data):
+        """Test when `dismiss_stale_reviews` is missing"""
+        query_data["branch_protection_data"]["required_pull_request_reviews"] = {}
+        requirement_args = {}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.DoesNotApply
+        assert result.context is None
+
+    def test_dismiss_stale_reviews_none(self, requirement, query_data):
+        """Test when `dismiss_stale_reviews` is None"""
+        query_data["branch_protection_data"]["required_pull_request_reviews"] = {
+            "dismiss_stale_reviews": None
+        }
+        requirement_args = {}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.DoesNotApply
+        assert result.context is None
+
+    def test_successful(self, requirement, query_data):
+        """Test successful"""
+        query_data["branch_protection_data"]["required_pull_request_reviews"]["dismiss_stale_reviews"] = True
+        requirement_args = {"false": False}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.Success

repoauditor-0.2.37/tests/Plugins/GitHubModule/ClassicBranchProtectionRequirements/EnsureStatusChecks_UnitTest.py

@@ -0,0 +1,89 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for EnsureStatusChecks.py"""
+
+import pytest
+
+from RepoAuditor.Plugins.GitHub.ClassicBranchProtectionRequirements.EnsureStatusChecks import (
+    EnsureStatusChecks,
+)
+from RepoAuditor.Requirement import EvaluateResult
+
+
+@pytest.fixture
+def query_data(session):
+    return {
+        "session": session,
+        "branch": "main",
+        "branch_protection_data": {
+            "required_status_checks": {
+                "checks": ["check1", "check2"],
+            },
+        },
+    }
+
+
+@pytest.fixture
+def requirement():
+    return EnsureStatusChecks()
+
+
+class TestEnsureStatusChecks:
+    def test_disabled(self, requirement, query_data):
+        """Test disabled requirement"""
+        requirement_args = {"disable": True}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.DoesNotApply
+        assert "The status check requirement has been explicitly disabled." in result.context
+
+    def test_required_status_checks_missing(self, requirement, query_data):
+        """Test when `required_status_checks` is missing"""
+        query_data["branch_protection_data"] = {}
+        requirement_args = {"disable": False}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.DoesNotApply
+        assert result.context is None
+
+    def test_required_status_checks_none(self, requirement, query_data):
+        """Test when `required_status_checks` is None"""
+        query_data["branch_protection_data"] = {"required_status_checks": None}
+        requirement_args = {"disable": False}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.DoesNotApply
+        assert result.context is None
+
+    def test_checks_missing(self, requirement, query_data):
+        """Test when `checks` is missing"""
+        query_data["branch_protection_data"]["required_status_checks"] = {}
+        requirement_args = {"disable": False}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.Error
+        assert "No status checks are configured." in result.context
+
+    def test_checks_none(self, requirement, query_data):
+        """Test when `checks` is None"""
+        query_data["branch_protection_data"]["required_status_checks"] = {"checks": None}
+        requirement_args = {"disable": False}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.Error
+        assert "No status checks are configured." in result.context
+
+    def test_Successful(self, requirement, query_data):
+        """Test successful"""
+        query_data["branch_protection_data"]["required_status_checks"]["checks"] = ["check1", "check2"]
+        requirement_args = {"disable": False}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.Success
+
+    def test_SuccessfulGetDynamicArgDefinitions(self, requirement, query_data):
+        """Test with GetDynamicArgDefinitions"""
+        query_data["branch_protection_data"]["required_status_checks"]["checks"] = ["check1", "check2"]
+        requirement_args = {}
+        for key, value in requirement.GetDynamicArgDefinitions().items():
+            requirement_args[key] = value[1].default
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.Success

repoauditor-0.2.37/tests/Plugins/GitHubModule/ClassicBranchProtectionRequirements/RequireApprovalMostRecentPush_UnitTest.py

@@ -0,0 +1,77 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for RequireApprovalMostRecentPush.py"""
+
+import pytest
+
+from RepoAuditor.Plugins.GitHub.ClassicBranchProtectionRequirements.RequireApprovalMostRecentPush import (
+    RequireApprovalMostRecentPush,
+)
+from RepoAuditor.Requirement import EvaluateResult
+
+
+@pytest.fixture
+def query_data(session):
+    return {
+        "session": session,
+        "branch": "main",
+        "branch_protection_data": {
+            "required_pull_request_reviews": {
+                "require_last_push_approval": True,
+            },
+        },
+    }
+
+
+@pytest.fixture
+def requirement():
+    return RequireApprovalMostRecentPush()
+
+
+class TestRequireApprovalMostRecentPush:
+    def test_required_pull_request_reviews_missing(self, requirement, query_data):
+        """Test when `required_pull_request_reviews` is missing"""
+        query_data["branch_protection_data"] = {}
+        requirement_args = {}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.DoesNotApply
+        assert result.context is None
+
+    def test_required_pull_request_reviews_none(self, requirement, query_data):
+        """Test when `required_pull_request_reviews` is None"""
+        query_data["branch_protection_data"]["required_pull_request_reviews"] = None
+        requirement_args = {}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.DoesNotApply
+        assert result.context is None
+
+    def test_require_last_push_approval_missing(self, requirement, query_data):
+        """Test when `require_last_push_approval` is missing"""
+        query_data["branch_protection_data"]["required_pull_request_reviews"] = {}
+        requirement_args = {}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.DoesNotApply
+        assert result.context is None
+
+    def test_require_last_push_approval_none(self, requirement, query_data):
+        """Test when `require_last_push_approval` is None"""
+        requirement_args = {}
+        query_data["branch_protection_data"]["required_pull_request_reviews"][
+            "require_last_push_approval"
+        ] = None
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.DoesNotApply
+        assert result.context is None
+
+    def test_Successful(self, requirement, query_data):
+        """Test successful"""
+        query_data["branch_protection_data"]["required_pull_request_reviews"][
+            "require_last_push_approval"
+        ] = True
+        requirement_args = {"false": False}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.Success