RepoAuditor 0.2.72__tar.gz → 0.2.73__tar.gz

{repoauditor-0.2.72 → repoauditor-0.2.73}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RepoAuditor
-Version: 0.2.72
+Version: 0.2.73
 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.72 → repoauditor-0.2.73}/src/RepoAuditor/Plugins/GitHub/ClassicBranchProtectionRequirements/EnsureStatusChecks.py

@@ -24,7 +24,7 @@ class EnsureStatusChecks(Requirement):
     def __init__(self) -> None:
         super().__init__(
             "EnsureStatusChecks",
-            "Ensure that status checks have been enabled for the '{branch}' branch.",
+            "Ensure that status checks have been enabled for the branch.",
             ExecutionStyle.Parallel,
             textwrap.dedent(
                 """\

{repoauditor-0.2.72 → repoauditor-0.2.73}/src/RepoAuditor/Plugins/GitHub/Impl/EnableRequirementImpl.py

@@ -44,7 +44,7 @@ class EnableRequirementImpl(Requirement):
 
         super().__init__(
             name,
-            f"Validates that {subject} is set to {{__expected_value}}.",
+            f"Validates that {subject} is set to the expected value.",
             ExecutionStyle.Parallel,
             resolution,
             rationale,
@@ -79,16 +79,6 @@ class EnableRequirementImpl(Requirement):
         query_data: dict[str, Any],
         requirement_args: dict[str, Any],
     ) -> Requirement.EvaluateImplResult:
-        expected_value = self.enabled_by_default
-
-        if requirement_args[self.dynamic_arg_name]:
-            expected_value = not expected_value
-            provide_rationale = False
-        else:
-            provide_rationale = True
-
-        query_data["__expected_value"] = expected_value
-
         result = self.get_configuration_value_func(query_data)
         if result is None:
             if query_data["session"].is_enterprise:
@@ -105,6 +95,14 @@ class EnableRequirementImpl(Requirement):
 
             return Requirement.EvaluateImplResult(EvaluateResult.DoesNotApply, None)
 
+        expected_value = self.enabled_by_default
+
+        if requirement_args[self.dynamic_arg_name]:
+            expected_value = not expected_value
+            provide_rationale = False
+        else:
+            provide_rationale = True
+
         if result != expected_value:
             query_data["__checked_desc"] = self.unset_set_terminology[int(expected_value)]
 

{repoauditor-0.2.72 → repoauditor-0.2.73}/src/RepoAuditor/Plugins/GitHub/Impl/EnableRulesetRequirementImpl.py

@@ -67,8 +67,7 @@ class EnableRulesetRequirementImpl(EnableRequirementImpl):
         else:
             provide_rationale = True
 
-        query_data["__expected_value"] = expected_rule_enabled
-        query_data["__enabled_str"] = "Enable" if expected_rule_enabled else "Disable"
+        query_data["__expected_value"] = "Enable" if expected_rule_enabled else "Disable"
 
         # Get the rules for the specified branch
         rules = query_data.get("rules", [])

{repoauditor-0.2.72 → repoauditor-0.2.73}/src/RepoAuditor/Plugins/GitHub/Impl/ValueRequirementImpl.py

@@ -51,7 +51,7 @@ class ValueRequirementImpl(Requirement):
 
         super().__init__(
             name,
-            f"Validates that {subject} is set to '{{__expected_value}}'.",
+            f"Validates that {subject} is set to the expected value.",
             ExecutionStyle.Parallel,
             resolution,
             rationale,
@@ -84,9 +84,6 @@ class ValueRequirementImpl(Requirement):
         query_data: dict[str, Any],
         requirement_args: dict[str, Any],
     ) -> Requirement.EvaluateImplResult:
-        expected_value = requirement_args["value"]
-        query_data["__expected_value"] = f"{expected_value}"
-
         result = self.get_configuration_value_func(query_data)
         if result is None:
             if self.missing_value_is_warning:
@@ -94,6 +91,7 @@ class ValueRequirementImpl(Requirement):
 
             return Requirement.EvaluateImplResult(EvaluateResult.DoesNotApply, None)
 
+        expected_value = requirement_args["value"]
         is_default_expected_value = expected_value == self.default_value
 
         if isinstance(result, DoesNotApplyResult):
@@ -108,6 +106,8 @@ class ValueRequirementImpl(Requirement):
         result = str(result)
 
         if result != expected_value:
+            query_data["__expected_value"] = f"'{expected_value}'"
+
             return Requirement.EvaluateImplResult(
                 EvaluateResult.Error,
                 f"{self.github_value} must be set to '{expected_value}' (it is currently set to '{result}').",

{repoauditor-0.2.72 → repoauditor-0.2.73}/src/RepoAuditor/Plugins/GitHub/RulesetRequirements/RequirePullRequests.py

@@ -20,6 +20,6 @@ class RequirePullRequests(EnableRulesetRequirementImpl):
             github_ruleset_type="pull_request",
             github_ruleset_value="Require a pull request before merging",
             get_configuration_value_func=lambda rule: rule.get("type", "") == "pull_request",
-            resolution="{__enabled_str} pull request rule in repository rulesets",
+            resolution="{__expected_value} pull request rule in repository rulesets",
             rationale="Pull request reviews help maintain code quality and collaboration",
         )

{repoauditor-0.2.72 → repoauditor-0.2.73}/src/RepoAuditor/Plugins/GitHub/RulesetRequirements/RequireSignedCommits.py

@@ -20,6 +20,6 @@ class RequireSignedCommits(EnableRulesetRequirementImpl):
             github_ruleset_type="required_signatures",
             github_ruleset_value="Require signed commits",
             get_configuration_value_func=lambda rule: rule.get("type", "") == "required_signatures",
-            resolution="{__enabled_str} commit signing requirement in repository rulesets",
+            resolution="Enable commit signing requirement in repository rulesets",
             rationale="Signed commits ensure commit authenticity",
         )

{repoauditor-0.2.72 → repoauditor-0.2.73}/src/RepoAuditor/Plugins/GitHub/RulesetRequirements/RequireStatusChecks.py

@@ -20,6 +20,6 @@ class RequireStatusChecks(EnableRulesetRequirementImpl):
             github_ruleset_type="required_status_checks",
             github_ruleset_value="Require status checks to pass",
             get_configuration_value_func=lambda rule: rule.get("type", "") == "required_status_checks",
-            resolution="{__enabled_str} required status checks in repository rulesets",
+            resolution="Configure required status checks in repository rulesets",
             rationale="Status checks ensure code quality and compatibility",
         )

{repoauditor-0.2.72 → repoauditor-0.2.73}/src/RepoAuditor/Plugins/GitHub/StandardRequirements/DefaultBranch.py

@@ -24,7 +24,7 @@ class DefaultBranch(StandardValueRequirementImpl):
             "main",
             "settings",
             "Default Branch",
-            "Default Branch",
+            None,
             lambda data: data["standard"].get("default_branch", None),
             textwrap.dedent(
                 """\

{repoauditor-0.2.72 → repoauditor-0.2.73}/src/RepoAuditor/Plugins/GitHub/StandardRequirements/Description.py

@@ -24,7 +24,7 @@ class Description(Requirement):
     def __init__(self) -> None:
         super().__init__(
             "Description",
-            "Validates if the repository has a description.",
+            "Validates a repository's description.",
             ExecutionStyle.Parallel,
             textwrap.dedent(
                 """\

{repoauditor-0.2.72 → repoauditor-0.2.73}/src/RepoAuditor/Plugins/GitHub/StandardRequirements/Private.py

@@ -25,7 +25,7 @@ class Private(Requirement):
     def __init__(self) -> None:
         super().__init__(
             "Private",
-            "Validates that the repository's visibility is set to '{__expected_visibility}'.",
+            "Validates that the repository is set to the expected visibility.",
             ExecutionStyle.Parallel,
             textwrap.dedent(
                 """\
@@ -71,15 +71,16 @@ class Private(Requirement):
         query_data: dict[str, Any],
         requirement_args: dict[str, Any],
     ) -> Requirement.EvaluateImplResult:
-        expect_private = requirement_args["enabled"]
-        query_data["__expected_visibility"] = "private" if expect_private else "public"
-
         result = query_data["standard"].get("private", None)
 
         if result is None:
             return CreateIncompleteDataResult()
 
+        expect_private = requirement_args["enabled"]
+
         if result != expect_private:
+            query_data["__expected_visibility"] = "private" if expect_private else "public"
+
             return Requirement.EvaluateImplResult(
                 EvaluateResult.Error,
                 f"The repository's visibility must be {query_data['__expected_visibility']}.",

{repoauditor-0.2.72 → repoauditor-0.2.73}/src/RepoAuditor/Requirement.py

@@ -112,9 +112,6 @@ class Requirement(ABC):
         """Evaluate the requirements given the query data and specific arguments."""
         result_info = self._EvaluateImpl(query_data, requirement_args)
 
-        # Fill in templates in description string
-        self.description = self.description.format(**query_data)
-
         if result_info.result == EvaluateResult.Error:
             return Requirement.EvaluateInfo(
                 result_info.result,

{repoauditor-0.2.72 → repoauditor-0.2.73}/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.72"
+__version__ = "0.2.73"

{repoauditor-0.2.72 → repoauditor-0.2.73}/tests/Plugins/GitHubModule/ClassicBranchProtectionRequirements/DismissStalePullRequestApprovals_UnitTest.py

@@ -32,44 +32,44 @@ def requirement():
     return DismissStalePullRequestApprovals()
 
 
-@pytest.fixture(name="requirement_args")
-def requirement_args_fixture():
-    return {"disabled": False}
-
-
 class TestDismissStalePullRequestApprovals:
-    def test_required_pull_request_reviews_missing(self, requirement, query_data, requirement_args):
+    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, requirement_args):
+    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, requirement_args):
+    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, requirement_args):
+    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, requirement_args):
+    def test_successful(self, requirement, query_data):
         """Test successful"""
         query_data["branch_protection_data"]["required_pull_request_reviews"]["dismiss_stale_reviews"] = True
+        requirement_args = {"disabled": False}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.Success

{repoauditor-0.2.72 → repoauditor-0.2.73}/tests/Plugins/GitHubModule/ClassicBranchProtectionRequirements/RequireApprovalMostRecentPush_UnitTest.py

@@ -32,35 +32,34 @@ def requirement():
     return RequireApprovalMostRecentPush()
 
 
-@pytest.fixture(name="requirement_args")
-def requirement_args_fixture():
-    return {"disabled": False}
-
-
 class TestRequireApprovalMostRecentPush:
-    def test_required_pull_request_reviews_missing(self, requirement, query_data, requirement_args):
+    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, requirement_args):
+    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, requirement_args):
+    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, requirement_args):
+    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

{repoauditor-0.2.72 → repoauditor-0.2.73}/tests/Plugins/GitHubModule/ClassicBranchProtectionRequirements/RequireApprovals_UnitTest.py

@@ -30,47 +30,47 @@ def requirement():
     return RequireApprovals()
 
 
-@pytest.fixture(name="requirement_args")
-def requirement_args_fixture():
-    return {"value": "1"}
-
-
 class TestRequireApprovals:
-    def test_required_pull_request_reviews_missing(self, requirement, query_data, requirement_args):
+    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, requirement_args):
+    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_required_approving_review_count_missing(self, requirement, query_data, requirement_args):
+    def test_required_approving_review_count_missing(self, requirement, query_data):
         """Test when `required_approving_review_count` 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_required_approving_review_count_none(self, requirement, query_data, requirement_args):
+    def test_required_approving_review_count_none(self, requirement, query_data):
         """Test when `required_approving_review_count` is None"""
         query_data["branch_protection_data"]["required_pull_request_reviews"][
             "required_approving_review_count"
         ] = None
+        requirement_args = {}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.DoesNotApply
         assert result.context is None
 
-    def test_IncorrectValue(self, requirement, query_data, requirement_args):
+    def test_IncorrectValue(self, requirement, query_data):
         """Test incorrect"""
         query_data["branch_protection_data"]["required_pull_request_reviews"][
             "required_approving_review_count"
         ] = "2"
+        requirement_args = {"value": "1"}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.Error
         assert (
@@ -78,10 +78,11 @@ class TestRequireApprovals:
             in result.context
         )
 
-    def test_Successful(self, requirement, query_data, requirement_args):
+    def test_Successful(self, requirement, query_data):
         """Test successful"""
         query_data["branch_protection_data"]["required_pull_request_reviews"][
             "required_approving_review_count"
         ] = "1"
+        requirement_args = {"value": "1"}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.Success

{repoauditor-0.2.72 → repoauditor-0.2.73}/tests/Plugins/GitHubModule/ClassicBranchProtectionRequirements/RequireCodeOwnerReview_UnitTest.py

@@ -32,47 +32,47 @@ def requirement():
     return RequireCodeOwnerReview()
 
 
-@pytest.fixture(name="requirement_args")
-def requirement_args_fixture():
-    return {"enabled": True}
-
-
 class TestRequireCodeOwnerReview:
-    def test_required_pull_request_reviews_missing(self, requirement, query_data, requirement_args):
+    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, requirement_args):
+    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_code_owner_reviews_missing(self, requirement, query_data, requirement_args):
+    def test_require_code_owner_reviews_missing(self, requirement, query_data):
         """Test when `require_code_owner_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_require_code_owner_reviews_none(self, requirement, query_data, requirement_args):
+    def test_require_code_owner_reviews_none(self, requirement, query_data):
         """Test when `require_code_owner_reviews` is None"""
         query_data["branch_protection_data"]["required_pull_request_reviews"][
             "require_code_owner_reviews"
         ] = None
+        requirement_args = {}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.DoesNotApply
         assert result.context is None
 
-    def test_IncorrectValue(self, requirement, query_data, requirement_args):
+    def test_IncorrectValue(self, requirement, query_data):
         """Test incorrect"""
         query_data["branch_protection_data"]["required_pull_request_reviews"][
             "require_code_owner_reviews"
         ] = False
+        requirement_args = {"enabled": True}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.Error
         assert (
@@ -80,10 +80,11 @@ class TestRequireCodeOwnerReview:
             in result.context
         )
 
-    def test_Successful(self, requirement, query_data, requirement_args):
+    def test_Successful(self, requirement, query_data):
         """Test successful"""
         query_data["branch_protection_data"]["required_pull_request_reviews"][
             "require_code_owner_reviews"
         ] = True
+        requirement_args = {"enabled": True}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.Success

{repoauditor-0.2.72 → repoauditor-0.2.73}/tests/Plugins/GitHubModule/ClassicBranchProtectionRequirements/RequireUpToDateBranches_UnitTest.py

@@ -24,36 +24,35 @@ def requirement():
     return RequireUpToDateBranches()
 
 
-@pytest.fixture(name="requirement_args")
-def requirement_args_fixture():
-    return {"disabled": True}
-
-
 class TestRequireUpToDateBranches:
-    def test_required_status_checks_missing(self, requirement, query_data, requirement_args):
+    def test_required_status_checks_missing(self, requirement, query_data):
         """Test when `required_status_checks` 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_status_checks_none(self, requirement, query_data, requirement_args):
+    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 = {}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.DoesNotApply
         assert result.context is None
 
-    def test_strict_missing(self, requirement, query_data, requirement_args):
+    def test_strict_missing(self, requirement, query_data):
         """Test when `strict` is missing"""
         query_data["branch_protection_data"]["required_status_checks"] = {}
+        requirement_args = {}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.DoesNotApply
         assert result.context is None
 
-    def test_strict_none(self, requirement, query_data, requirement_args):
+    def test_strict_none(self, requirement, query_data):
         """Test when `strict` is None"""
         query_data["branch_protection_data"]["required_status_checks"] = {"strict": None}
+        requirement_args = {}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.DoesNotApply
         assert result.context is None
@@ -69,8 +68,9 @@ class TestRequireUpToDateBranches:
             in result.context
         )
 
-    def test_Successful(self, requirement, query_data, requirement_args):
+    def test_Successful(self, requirement, query_data):
         """Test successful"""
         query_data["branch_protection_data"]["required_status_checks"]["strict"] = False
+        requirement_args = {"disabled": True}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.Success

{repoauditor-0.2.72 → repoauditor-0.2.73}/tests/Plugins/GitHubModule/StandardQueryRequirements/DependabotSecurityUpdates_UnitTest.py

@@ -33,43 +33,39 @@ def requirement():
     return DependabotSecurityUpdates()
 
 
-@pytest.fixture(name="requirement_args")
-def requirement_args_fixture():
-    return {"disabled": False}
-
-
 class TestDependabotSecurityUpdates:
-    def test_security_and_analysis_missing(self, requirement, query_data, requirement_args):
+    def test_security_and_analysis_missing(self, requirement, query_data):
         """Test if `security_and_analysis` is missing"""
         query_data["standard"] = {}
-        result = requirement.Evaluate(query_data, requirement_args)
+        result = requirement.Evaluate(query_data, requirement_args={})
         assert result.result == EvaluateResult.Warning
         assert "Incomplete data was encountered" in result.context
 
-    def test_dependabot_security_updates_missing(self, requirement, query_data, requirement_args):
+    def test_dependabot_security_updates_missing(self, requirement, query_data):
         """Test if `dependabot_security_updates` is missing"""
         query_data["standard"]["security_and_analysis"] = {}
-        result = requirement.Evaluate(query_data, requirement_args)
+        result = requirement.Evaluate(query_data, requirement_args={})
         assert result.result == EvaluateResult.Warning
         assert "Incomplete data was encountered" in result.context
 
-    def test_status_missing(self, requirement, query_data, requirement_args):
+    def test_status_missing(self, requirement, query_data):
         """Test if `status` is missing"""
         query_data["standard"]["security_and_analysis"]["dependabot_security_updates"] = {}
-        result = requirement.Evaluate(query_data, requirement_args)
+        result = requirement.Evaluate(query_data, requirement_args={})
         assert result.result == EvaluateResult.Warning
         assert "Incomplete data was encountered" in result.context
 
-    def test_status_none(self, requirement, query_data, requirement_args):
+    def test_status_none(self, requirement, query_data):
         """Test if `status` is None"""
         query_data["standard"]["security_and_analysis"]["dependabot_security_updates"]["status"] = None
-        result = requirement.Evaluate(query_data, requirement_args)
+        result = requirement.Evaluate(query_data, requirement_args={})
         assert result.result == EvaluateResult.Warning
         assert "Incomplete data was encountered" in result.context
 
-    def test_Incorrect(self, requirement, query_data, requirement_args):
+    def test_Incorrect(self, requirement, query_data):
         """Result doesn't match expected value"""
         query_data["standard"]["security_and_analysis"]["dependabot_security_updates"]["status"] = True
+        requirement_args = {"disabled": False}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.Error
         assert (

{repoauditor-0.2.72 → repoauditor-0.2.73}/tests/Plugins/GitHubModule/StandardQueryRequirements/License_UnitTest.py

@@ -37,7 +37,7 @@ class TestLicense:
         query_data["standard"] = {}
         result = requirement.Evaluate(
             query_data,
-            requirement_args={"value": requirement.default_value},
+            requirement_args={},
         )
         assert result.result == EvaluateResult.Warning
         assert "Incomplete data was encountered" in result.context

{repoauditor-0.2.72 → repoauditor-0.2.73}/tests/Plugins/GitHubModule/StandardQueryRequirements/MergeCommitMessage_UnitTest.py

@@ -28,48 +28,47 @@ def requirement():
     return MergeCommitMessage()
 
 
-@pytest.fixture(name="requirement_args")
-def requirement_args_fixture():
-    return {"value": "BLANK"}
-
-
 class TestMergeCommitMessage:
-    def test_allow_merge_commit_missing(self, requirement, query_data, requirement_args):
+    def test_allow_merge_commit_missing(self, requirement, query_data):
         """Test if `allow_merge_commit` is missing"""
         query_data["standard"] = {}
-        result = requirement.Evaluate(query_data, requirement_args)
+        result = requirement.Evaluate(query_data, requirement_args={})
         assert result.result == EvaluateResult.Warning
         assert "Incomplete data was encountered" in result.context
 
-    def test_allow_merge_commit_none(self, requirement, query_data, requirement_args):
+    def test_allow_merge_commit_none(self, requirement, query_data):
         """Test if `allow_merge_commit` is None"""
         query_data["standard"]["allow_merge_commit"] = None
-        result = requirement.Evaluate(query_data, requirement_args)
+        result = requirement.Evaluate(query_data, requirement_args={})
         assert result.result == EvaluateResult.Warning
         assert "Incomplete data was encountered" in result.context
 
-    def test_Disabled(self, requirement, query_data, requirement_args):
+    def test_Disabled(self, requirement, query_data):
         """Test when merge commits are disabled"""
         query_data["standard"]["allow_merge_commit"] = False
+        requirement_args = {"value": "BLANK"}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.DoesNotApply
         assert "Merge commits are not enabled" in result.context
 
-    def test_MissingMergeCommitMessage(self, requirement, query_data, requirement_args):
+    def test_MissingMergeCommitMessage(self, requirement, query_data):
         """Missing merge_commit_message value"""
         query_data["standard"].pop("merge_commit_message", None)
+        requirement_args = {"value": "BLANK"}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.Warning
         assert "Incomplete data was encountered" in result.context
 
-    def test_Successful(self, requirement, query_data, requirement_args):
+    def test_Successful(self, requirement, query_data):
         """Test successful with BLANK commit message value"""
+        requirement_args = {"value": "BLANK"}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.Success
 
-    def test_IncorrectCommitMessage(self, requirement, query_data, requirement_args):
+    def test_IncorrectCommitMessage(self, requirement, query_data):
         """With incorrect commit message value"""
         query_data["standard"]["merge_commit_message"] = "BLUR"
+        requirement_args = {"value": "BLANK"}
         result = requirement.Evaluate(query_data, requirement_args)
         assert result.result == EvaluateResult.Error
         assert "it is currently set to 'BLUR'" in result.context