RepoAuditor 0.2.37__tar.gz → 0.2.39__tar.gz

{repoauditor-0.2.37 → repoauditor-0.2.39}/DEVELOPMENT.md

@@ -1,3 +1,22 @@
+# Fork setup
+
+| Step | Command Line | Additional Information |
+| --- | --- | --- |
+| 1. Fork the repository | -- | https://github.com/gt-sse-center/RepoAuditor/fork |
+| 2. Create a PAT for your forked repository | -- | See [PAT setup instructions](README.md#personal-access-token-pat) |
+| 3. Sync the `test-GitHubCustomization` branch | see instructions below | In the web interface, select "New Branch", then choose `gt-sse-center/RepoAuditor` and `test-GitHubCustomization` as source, and enter `test-GitHubCustomization` as branch name. |
+| 4. Update your forked repository settings to match RepoAuditor's defaults | -- | 
+
+
+To sync the `test-GitHubCustomization` branch using the command line:
+```bash
+git clone <REPOAUDITOR_FORK_URL>
+git remote add upstream https://github.com/gt-sse-center/RepoAuditor
+git fetch upstream
+git checkout -b test-GitHubCustomization upstream/test-GitHubCustomization
+git push origin test-GitHubCustomization
+```
+
 # Local Development
 
 ## Enlistment

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RepoAuditor
-Version: 0.2.37
+Version: 0.2.39
 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.37 → repoauditor-0.2.39}/src/RepoAuditor/ExecuteModules.py

@@ -267,7 +267,7 @@ def Execute(
 
     for results in all_results:
         if results is None:
-            continue
+            continue  # pragma: no cover
 
         final_results.append(list(itertools.chain(*results)))
 

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

@@ -112,7 +112,7 @@ def _Impl(
 
         for transform_result in transform_results:
             if transform_result is not None and isinstance(transform_result, Exception):
-                raise transform_result
+                raise transform_result  # pragma: no cover
 
     for sequential_index, (results_index, item) in enumerate(sequential):
         with dm.Nested(

{repoauditor-0.2.37 → repoauditor-0.2.39}/src/RepoAuditor/Plugins/GitHubCustomization/Impl/ExistsRequirementImpl.py

@@ -79,7 +79,7 @@ class ExistsRequirementImpl(Requirement):
                     if full_file_path.is_dir() and any(full_file_path.iterdir()):
                         return Requirement.EvaluateImplResult(
                             EvaluateResult.Success,
-                            f"File found in {self.github_file} directory of the repository",
+                            f"File found in {location} directory of the repository",
                         )
 
                     return Requirement.EvaluateImplResult(

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

{repoauditor-0.2.37 → repoauditor-0.2.39}/tests/CommandLineProcessor_UnitTest.py

@@ -8,12 +8,10 @@
 
 import re
 import textwrap
-
-from typing import cast, Optional
+from typing import Optional, cast
 from unittest.mock import patch
 
 import pytest
-
 from dbrownell_Common.TestHelpers.StreamTestHelpers import GenerateDoneManagerAndContent
 from dbrownell_Common.Types import override
 

{repoauditor-0.2.37 → repoauditor-0.2.39}/tests/Module_UnitTest.py

@@ -7,11 +7,12 @@
 """Unit test for Module.py"""
 
 import copy
-
+from typing import Optional, cast
 from unittest.mock import Mock
 
 import pytest
-
+from dbrownell_Common.Streams.DoneManager import DoneManager
+from dbrownell_Common.TestHelpers.StreamTestHelpers import GenerateDoneManagerAndContent
 from dbrownell_Common.Types import override
 
 from RepoAuditor.Module import *
@@ -389,6 +390,53 @@ def test_ModuleNoData():
     assert initial_data is None
 
 
+# ----------------------------------------------------------------------
+def test_Module_SingleParallel():
+    """Test parallel execution of the module when only 1 query is present."""
+    # Since we have only one query with parallel execution style,
+    # it should default to sequential processing.
+    module = MyModule(
+        "MyModule",
+        "The only module",
+        ExecutionStyle.Sequential,
+        [queryA],
+        produce_data=True,
+    )
+
+    status_func = Mock()
+
+    initial_data = module.GenerateInitialData({})
+    results = module.Evaluate(
+        initial_data,
+        {},
+        status_func,
+        max_num_threads=1,
+    )
+    assert results[0][0].result == EvaluateResult.Success
+    assert results[0][0].context is None
+    assert results[0][0].resolution is None
+    assert results[0][0].rationale is None
+    assert results[0][0].requirement is requirementA1
+    assert results[0][0].query is queryA
+    assert results[0][0].module is module
+
+
+# ----------------------------------------------------------------------
+def test_ProvidedDoneManager():
+    """Test for when a DoneManager is provided to the ParallelSequentialProcessor."""
+    module = MyModule(
+        "MyModule",
+        "The only module",
+        ExecutionStyle.Sequential,
+        [queryA],
+        produce_data=True,
+    )
+    dm_and_sink = GenerateDoneManagerAndContent()
+    dm = cast(DoneManager, next(dm_and_sink))
+    result = ParallelSequentialProcessor(module.queries, lambda query: (0, []), dm)
+    assert isinstance(result, list)
+
+
 # ----------------------------------------------------------------------
 class TestProcessRequriements:
     # ----------------------------------------------------------------------

repoauditor-0.2.39/tests/Plugins/GitHubCustomization/CutomizationQuery_UnitTest.py

@@ -0,0 +1,60 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for CustomizationQuery.py"""
+
+import pytest
+from git import Repo
+
+from RepoAuditor.Plugins.GitHubCustomization.CustomizationQuery import CustomizationQuery, TemporaryDirectory
+
+
+def mock_clone_from(github_url, repo_dirname, branch="main"):
+    """A mocked clone_from method for the git.Repo class."""
+    pass
+
+
+class MockTemporaryDirectory:
+    """A mock class to replace tempfile.TemporaryDirectory."""
+
+    def __init__(self):
+        self.name = "test_temp_directory"
+
+    def cleanup(self):
+        """Mocked cleanup method"""
+
+
+@pytest.fixture(autouse=True)
+def patch_temp_directory(monkeypatch):
+    monkeypatch.delattr("tempfile.TemporaryDirectory")
+
+
+class TestCustomizationQuery:
+    def test_GetData(self, module_data, monkeypatch):
+        """Test the GetData method."""
+        monkeypatch.setattr(
+            TemporaryDirectory,
+            "__init__",
+            MockTemporaryDirectory.__init__,
+        )
+        monkeypatch.setattr(
+            Repo,
+            "clone_from",
+            mock_clone_from,
+        )
+
+        query = CustomizationQuery()
+        query_data = query.GetData(module_data)
+
+        assert query_data["repo_dir"].name == "test_temp_directory"
+
+    def test_Cleanup(self, module_data):
+        """Test the Cleanup method."""
+        query = CustomizationQuery()
+        module_data["repo_dir"] = MockTemporaryDirectory()
+        result = query.Cleanup(module_data)
+
+        assert result is None

repoauditor-0.2.39/tests/Plugins/GitHubCustomization/ExistsRequirementImpl_UnitTest.py

@@ -0,0 +1,121 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for GitHub/Impl/ClassicValueRequirementImpl.py"""
+
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from RepoAuditor.Plugins.GitHubCustomization.Impl.ExistsRequirementImpl import ExistsRequirementImpl
+from RepoAuditor.Requirement import EvaluateResult
+
+
+class MockDirectory:
+    def __init__(self):
+        self.name = "repository"
+
+
+class TestExistsRequirementImpl:
+    def test_Constructor(self):
+        """Test the requirement implementation constructor."""
+        requirement = ExistsRequirementImpl(
+            name="Exists Some Value",
+            dynamic_arg_name="exists",
+            github_file="README.md",
+            possible_locations=[
+                "README.md",
+            ],
+            resolution="Get test to pass",
+            rationale="For testing",
+        )
+        assert requirement.github_file == "README.md"
+
+    def test_Disabled(self):
+        """Test disabled requirement."""
+        requirement = ExistsRequirementImpl(
+            name="Exists Some Value",
+            dynamic_arg_name="exists",
+            github_file="README.md",
+            possible_locations=[
+                "README.md",
+            ],
+            resolution="Get test to pass",
+            rationale="For testing",
+        )
+
+        query_data = {}
+        requirement_args = {"exists": False}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.DoesNotApply
+
+    def test_NotFound(self):
+        """Test for when file is not found."""
+        requirement = ExistsRequirementImpl(
+            name="Exists Some Value",
+            dynamic_arg_name="exists",
+            github_file="README.md",
+            possible_locations=[
+                "MEREAD.md",
+            ],
+            resolution="Get test to pass",
+            rationale="For testing",
+        )
+
+        query_data = {"repo_dir": MockDirectory()}
+        requirement_args = {"exists": True}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.Error
+        assert "No README.md file found" in result.context
+
+    def test_Found(self):
+        """Test for when file is found as is."""
+        requirement = ExistsRequirementImpl(
+            name="Exists Some Value",
+            dynamic_arg_name="exists",
+            github_file="README.md",
+            possible_locations=[
+                "README.md",
+            ],
+            resolution="Get test to pass",
+            rationale="For testing",
+        )
+
+        tempdir = TemporaryDirectory()
+        with open(Path(tempdir.name, "README.md"), "w") as f:
+            f.write("temp file in temp directory")
+
+        query_data = {"repo_dir": tempdir}
+        requirement_args = {"exists": True}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.Success
+        assert "README.md found in repository" in result.context
+
+    def test_FoundInDirectory(self):
+        """Test if provided path is directory."""
+        requirement = ExistsRequirementImpl(
+            name="Exists Some Value",
+            dynamic_arg_name="exists",
+            github_file="README.md",
+            possible_locations=[
+                "docs",
+            ],
+            resolution="Get test to pass",
+            rationale="For testing",
+        )
+
+        tempdir = TemporaryDirectory()
+        # Create "docs" directory
+        docs_dir = Path(tempdir.name) / "docs"
+        docs_dir.mkdir(parents=True)
+
+        with open(docs_dir / "README.md", "w") as f:
+            f.write("temp file in temp directory")
+
+        query_data = {"repo_dir": tempdir}
+        requirement_args = {"exists": True}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.Success
+        assert "File found in docs directory of the repository" in result.context

{repoauditor-0.2.37/tests/Plugins → repoauditor-0.2.39/tests/Plugins/GitHubCustomization}/GitHubCustomization_UnitTest.py

@@ -7,9 +7,10 @@
 """Unit tests for the GitHub Customization Plugin"""
 
 import sys
-import pluggy
 from pathlib import Path
 
+import pluggy
+
 from RepoAuditor import APP_NAME
 from RepoAuditor.Plugins.GitHubCustomizationPlugin import GetModule
 

{repoauditor-0.2.37 → repoauditor-0.2.39}/tests/Plugins/GitHubCustomization_EndToEndTest.py

@@ -6,18 +6,17 @@
 # -------------------------------------------------------------------------------
 """End-to-end tests for the GitHubCustomization plugin."""
 
-import pytest
 from pathlib import Path
 
+import pytest
 from dbrownell_Common.TestHelpers.StreamTestHelpers import (
     InitializeStreamCapabilities,
 )
 from typer.testing import CliRunner
+from utilities import CheckPATFileExists, GetGithubUrl, ScrubDurationGithuburlAndSpaces
 
 from RepoAuditor.EntryPoint import app
 
-from utilities import ScrubDurationGithuburlAndSpaces, GetGithubUrl, CheckPATFileExists
-
 # ----------------------------------------------------------------------
 pytest.fixture(InitializeStreamCapabilities(), scope="session", autouse=True)
 

{repoauditor-0.2.37 → repoauditor-0.2.39}/tests/Plugins/GitHubModule/ClassicBranchProtectionQuery_UnitTest.py

@@ -6,17 +6,7 @@
 # -------------------------------------------------------------------------------
 """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(

{repoauditor-0.2.37 → repoauditor-0.2.39}/tests/Plugins/GitHubModule/DefaultBranchQuery_UnitTest.py

@@ -6,17 +6,7 @@
 # -------------------------------------------------------------------------------
 """Unit tests for DefaultBranchQuery.py"""
 
-import pytest
-
 from RepoAuditor.Plugins.GitHub.DefaultBranchQuery import DefaultBranchQuery
-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(

{repoauditor-0.2.37 → repoauditor-0.2.39}/tests/Plugins/GitHubModule/GitHubModule_UnitTest.py

@@ -8,8 +8,6 @@
 
 from pathlib import Path
 
-import pytest
-
 from RepoAuditor.Plugins.GitHub.Module import GitHubModule
 from RepoAuditor.Plugins.GitHubBase.Module import _GitHubSession
 

repoauditor-0.2.39/tests/Plugins/GitHubModule/GitHubSession_UnitTest.py

@@ -0,0 +1,89 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for GitHubSession"""
+
+from pathlib import Path
+
+import pytest
+import requests
+
+from RepoAuditor.Plugins.GitHubBase.Module import _GitHubSession
+
+
+@pytest.fixture
+def github_pat(fs):
+    """Fixture for GitHub PAT file, which creates a fake PAT file and returns the path."""
+    pat_path = Path(__file__).parent / "dummy_github_pat.txt"
+    fs.create_file(pat_path, contents="github_path_abcdefghijklmnop")
+    return pat_path
+
+
+def mock_request(
+    self,
+    method,
+    url,
+    *args,
+    **kwargs,
+):
+    """Mocked request function."""
+    r = requests.Response()
+    r.status_code = 200
+    r.method = method
+    r.url = url
+    return r
+
+
+class TestGitHubSession:
+    """Unit tests for the _GitHubSession class."""
+
+    @classmethod
+    def setup_class(cls):
+        """Setup values for each test."""
+        cls.github_url = "https://github.com/gt-sse-center/RepoAuditor"
+
+    def test_Construct(self, github_pat):
+        """Test constructor."""
+        session = _GitHubSession(github_url=self.github_url, github_pat=github_pat)
+
+        assert session.github_url == self.github_url
+
+    def test_ConstructTrailingSlash(self, github_pat):
+        """Test with trailing slash for URL."""
+        session = _GitHubSession(github_url=self.github_url + "/", github_pat=github_pat)
+
+        assert session.github_url == self.github_url
+
+    def test_InvalidRepository(self, github_pat):
+        """Test with invalid repository URL."""
+        with pytest.raises(ValueError):
+            _GitHubSession(
+                github_url="https://github.com/gt-sse-center/RepoAuditor/123", github_pat=github_pat
+            )
+
+    def test_EnterpriseUrl(self, github_pat):
+        """Test with enterprise URL."""
+        github_enterprise_url = "https://github.gatech.edu/gt-sse-center/RepoAuditor"
+        session = _GitHubSession(github_url=github_enterprise_url, github_pat=github_pat)
+        assert session.github_url == github_enterprise_url
+
+    def test_Request(self, github_pat, monkeypatch):
+        """Test the _GitHubSession.request method."""
+        session = _GitHubSession(github_url=self.github_url, github_pat=github_pat)
+
+        monkeypatch.setattr(requests.Session, "request", mock_request)
+        r = session.request("GET", "test")
+
+        assert r.url == "https://api.github.com/repos/gt-sse-center/RepoAuditor/test"
+
+    def test_RequestLeadingSlash(self, github_pat, monkeypatch):
+        """Test the _GitHubSession.request method."""
+        session = _GitHubSession(github_url=self.github_url, github_pat=github_pat)
+
+        monkeypatch.setattr(requests.Session, "request", mock_request)
+        r = session.request("GET", "/test")
+
+        assert r.url == "https://api.github.com/repos/gt-sse-center/RepoAuditor/test"

{repoauditor-0.2.37 → repoauditor-0.2.39}/tests/Plugins/GitHubModule/StandardQuery_UnitTest.py

@@ -6,17 +6,7 @@
 # -------------------------------------------------------------------------------
 """Unit tests for StandardQuery.py"""
 
-import pytest
-
 from RepoAuditor.Plugins.GitHub.StandardQuery import StandardQuery
-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(

{repoauditor-0.2.37 → repoauditor-0.2.39}/tests/Plugins/GitHubRuleset_EndToEndTest.py

@@ -7,17 +7,16 @@
 """End-to-end tests for the GitHubRulesets plugin."""
 
 from pathlib import Path
-import pytest
 
+import pytest
 from dbrownell_Common.TestHelpers.StreamTestHelpers import (
     InitializeStreamCapabilities,
 )
 from typer.testing import CliRunner
+from utilities import CheckPATFileExists, GetGithubUrl, ScrubDurationGithuburlAndSpaces
 
 from RepoAuditor.EntryPoint import app
 
-from utilities import ScrubDurationGithuburlAndSpaces, GetGithubUrl, CheckPATFileExists
-
 # ----------------------------------------------------------------------
 pytest.fixture(InitializeStreamCapabilities(), scope="session", autouse=True)
 

repoauditor-0.2.39/tests/Plugins/GitHubRulesets/EnableRulesetRequirementImpl_UnitTest.py

@@ -0,0 +1,105 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Unit tests for the EnableRulesetRequirementImpl requirement implementation."""
+
+from RepoAuditor.Plugins.GitHubRulesets.Impl.EnableRulesetRequirementImpl import EnableRulesetRequirementImpl
+from RepoAuditor.Requirement import EvaluateResult
+
+
+class TestEnableRulesetRequirementImpl:
+    """Unit tests for the EnableRulesetRequirementImpl class."""
+
+    def test_Constructor(self):
+        """Test the EnableRulesetRequirementImpl constructor."""
+        requirement = EnableRulesetRequirementImpl(
+            name="Test Name",
+            default_value=False,
+            dynamic_arg_name="true",
+            github_ruleset_type="Test Ruleset",
+            github_ruleset_value="test_ruleset",
+            get_configuration_value_func=lambda _: True,
+            resolution="Test Resolution",
+            rationale="Test rationale",
+        )
+
+        assert requirement.name == "Test Name"
+        assert requirement.default_value is False
+        assert requirement.dynamic_arg_name == "true"
+        assert requirement.github_ruleset_type == "Test Ruleset"
+
+    def test_Evaluate_DoesNotApply(self):
+        """Test the _EvaluateImpl method when dynamic_arg_name is False."""
+        requirement = EnableRulesetRequirementImpl(
+            name="Test Name",
+            default_value=False,
+            dynamic_arg_name="true",
+            github_ruleset_type="Test Ruleset",
+            github_ruleset_value="test_ruleset",
+            get_configuration_value_func=lambda _: True,
+            resolution="Test Resolution",
+            rationale="Test rationale",
+        )
+        query_data = {}
+        requirement_args = {"true": False}
+        result = requirement.Evaluate(query_data, requirement_args)
+        print(result)
+        assert result.result == EvaluateResult.DoesNotApply
+
+    def test_Evaluate_InvalidRule(self):
+        """Test the _EvaluateImpl method when dynamic_arg_name is False."""
+        requirement = EnableRulesetRequirementImpl(
+            name="Test Name",
+            default_value=False,
+            dynamic_arg_name="true",
+            github_ruleset_type="Test Ruleset",
+            github_ruleset_value="test_ruleset",
+            get_configuration_value_func=lambda rule: rule.get("type", "") == "valid rule",
+            resolution="Test Resolution",
+            rationale="Test rationale",
+        )
+        query_data = {
+            "rules": [
+                {
+                    "type": "invalid_rule",
+                    "ruleset": {
+                        "name": "Invalid",
+                        "id": "00",
+                    },
+                },
+            ]
+        }
+        requirement_args = {"true": True}
+        result = requirement.Evaluate(query_data, requirement_args)
+        assert result.result == EvaluateResult.Error
+
+    def test_Evaluate_ValidRule(self):
+        """Test the _EvaluateImpl method when dynamic_arg_name is False."""
+        requirement = EnableRulesetRequirementImpl(
+            name="Test Name",
+            default_value=False,
+            dynamic_arg_name="true",
+            github_ruleset_type="Test Ruleset",
+            github_ruleset_value="test_ruleset",
+            get_configuration_value_func=lambda rule: rule.get("type", "") == "valid_rule",
+            resolution="Test Resolution",
+            rationale="Test rationale",
+        )
+        query_data = {
+            "rules": [
+                {
+                    "type": "valid_rule",
+                    "ruleset": {
+                        "name": "Valid",
+                        "id": "00",
+                    },
+                }
+            ]
+        }
+        requirement_args = {"true": True}
+        result = requirement.Evaluate(query_data, requirement_args)
+
+        assert result.result == EvaluateResult.Success