RepoAuditor 0.2.39__tar.gz → 0.2.40__tar.gz

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

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

@@ -19,6 +19,7 @@ from dbrownell_Common.Streams.DoneManager import DoneManager  # type: ignore[imp
 from rich.progress import Progress, TimeElapsedColumn
 
 from RepoAuditor.Module import EvaluateResult, ExecutionStyle, Module, OnStatusFunc
+from RepoAuditor.Requirement import ReturnCode
 
 
 # ----------------------------------------------------------------------
@@ -75,11 +76,14 @@ def CalcResultInfo(
 
     Returns a code value indicating success, warning, or error,
     as well as a string description of the result.
+    If the result is a warning or error, return immediately.
+    "Does Not Apply" is considered as a success.
     """
-    return_code = 0
+    return_code = ReturnCode.SUCCESS
+    return_msg = ""
 
     if not all_eval_infos:
-        return 0, "module does not apply"
+        return ReturnCode.DOESNOTAPPLY, "module does not apply"
 
     for eval_infos in all_eval_infos:
         for eval_info in eval_infos:
@@ -87,17 +91,18 @@ def CalcResultInfo(
 
             if result == EvaluateResult.Warning:
                 if eval_info.module.name in warnings_as_errors_module_names:
+                    # Treat warnings as errors enabled so recast the result type
                     result = EvaluateResult.Error
                 elif eval_info.module.name in ignore_warnings_module_names:
                     continue
 
             if result == EvaluateResult.Error:
-                return -1, "errors were encountered"
+                return ReturnCode.ERROR, "errors were encountered"
 
             if result == EvaluateResult.Warning:
-                return_code = 1
+                return_code, return_msg = ReturnCode.WARNING, "warnings were encountered"
 
-    return return_code, "" if return_code == 0 else "warnings were encountered"
+    return return_code, return_msg
 
 
 def Execute(

{repoauditor-0.2.39 → repoauditor-0.2.40}/src/RepoAuditor/Module.py

@@ -15,6 +15,7 @@ from dbrownell_Common.TyperEx import TypeDefinitionItemType  # type: ignore[impo
 
 from RepoAuditor.Impl.ParallelSequentialProcessor import ParallelSequentialProcessor
 from RepoAuditor.Query import EvaluateResult, ExecutionStyle, OnStatusFunc, Query, StatusInfo
+from RepoAuditor.Requirement import ReturnCode
 
 
 # ----------------------------------------------------------------------
@@ -133,7 +134,19 @@ class Module(ABC):
                     status_info.num_does_not_apply += len(query.requirements)
 
                     status_func(*status_info.__dict__.values())
-                    return 0, []
+                    # Since query returned None, it means it was not valid.
+                    return 2, [
+                        Module.EvaluateInfo(
+                            result=EvaluateResult.DoesNotApply,
+                            context=f"{query.name} did not return valid data.",
+                            resolution="",
+                            rationale="",
+                            requirement=requirement,
+                            query=query,
+                            module=self,
+                        )
+                        for requirement in query.requirements
+                    ]
 
             prev_query_status_info = StatusInfo()
 
@@ -171,15 +184,18 @@ class Module(ABC):
                 max_num_threads=max_num_threads,
             )
 
-            return_code = 0
+            return_code = ReturnCode.SUCCESS
 
             for evaluate_info in evaluate_infos:
                 if evaluate_info.result == EvaluateResult.Error:
-                    return_code = -1
+                    return_code = ReturnCode.ERROR
                     break
 
                 if evaluate_info.result == EvaluateResult.Warning:
-                    return_code = 1
+                    return_code = ReturnCode.WARNING
+
+                if evaluate_info.result == EvaluateResult.DoesNotApply:
+                    return_code = ReturnCode.DOESNOTAPPLY
 
             # Cleanup any resources created during the query
             query.Cleanup(query_data)

{repoauditor-0.2.39 → repoauditor-0.2.40}/src/RepoAuditor/Query.py

@@ -12,7 +12,7 @@ from dataclasses import dataclass
 from typing import Any, Optional, Protocol
 
 from RepoAuditor.Impl.ParallelSequentialProcessor import ParallelSequentialProcessor
-from RepoAuditor.Requirement import EvaluateResult, ExecutionStyle, Requirement
+from RepoAuditor.Requirement import EvaluateResult, ExecutionStyle, Requirement, ReturnCode
 
 
 # ----------------------------------------------------------------------
@@ -90,21 +90,22 @@ class Query(ABC):
                 query_data,
                 requirement_args.get(requirement.name, {}),
             )
-            return_code = 0
+            return_code = ReturnCode.SUCCESS
 
             with status_info_lock:
                 status_info.num_completed += 1
 
                 if result_info.result == EvaluateResult.DoesNotApply:
                     status_info.num_does_not_apply += 1
+                    return_code = ReturnCode.DOESNOTAPPLY
                 elif result_info.result == EvaluateResult.Success:
                     status_info.num_success += 1
                 elif result_info.result == EvaluateResult.Error:
                     status_info.num_error += 1
-                    return_code = -1
+                    return_code = ReturnCode.ERROR
                 elif result_info.result == EvaluateResult.Warning:
                     status_info.num_warning += 1
-                    return_code = 1
+                    return_code = ReturnCode.WARNING
                 else:
                     raise RuntimeError(result_info.result)  # pragma: no cover
 

{repoauditor-0.2.39 → repoauditor-0.2.40}/src/RepoAuditor/Requirement.py

@@ -8,7 +8,7 @@
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from enum import Enum, auto
+from enum import Enum, IntEnum, auto
 from typing import Any, Optional
 
 from dbrownell_Common.TyperEx import TypeDefinitionItemType  # type: ignore[import-untyped]
@@ -27,6 +27,15 @@ class EvaluateResult(Enum):
     Error = auto()
 
 
+class ReturnCode(IntEnum):
+    """Various return codes for operations, indicating success, failure, warning, etc."""
+
+    SUCCESS = 0
+    ERROR = -1
+    WARNING = 1
+    DOESNOTAPPLY = 2
+
+
 # ----------------------------------------------------------------------
 class Requirement(ABC):
     """A single requirement that can be evaluated against a set of data."""

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

{repoauditor-0.2.39 → repoauditor-0.2.40}/tests/ExecuteModules_UnitTest.py

@@ -178,6 +178,7 @@ class TestExecute:
             (EvaluateResult.Warning, 1, False, False),
             (EvaluateResult.Warning, -1, True, False),
             (EvaluateResult.Warning, 0, False, True),
+            (EvaluateResult.DoesNotApply, 0, False, False),
         ],
     )
     def test_NotSuccess(self, data):
@@ -328,9 +329,9 @@ class TestExecute:
                 Processing 'MyModule' (1 of 1)...
 
 
-                DONE! (0, <scrubbed duration>)
-              DONE! (0, <scrubbed duration>)
-            DONE! (0, <scrubbed duration>)
+                DONE! (2, <scrubbed duration>)
+              DONE! (2, <scrubbed duration>)
+            DONE! (2, <scrubbed duration>)
             """,
         )
 

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

@@ -357,7 +357,20 @@ def test_Module(single_threaded):
     assert results[1][3].module is module
 
     # QueryC
-    assert results[2] == []
+    query_c_expected_results = [
+        Module.EvaluateInfo(
+            result=EvaluateResult.DoesNotApply,
+            context="QueryC did not return valid data.",
+            rationale="",
+            resolution="",
+            requirement=requirement,
+            query=queryC,
+            module=module,
+        )
+        for requirement in queryC.requirements
+    ]
+    for idx, result in enumerate(results[2]):
+        assert result == query_c_expected_results[idx]
 
     # Validate the notifications
     if single_threaded:

{repoauditor-0.2.39 → repoauditor-0.2.40}/tests/Plugins/GitHubRulesets/EnableRulesetRequirementImpl_UnitTest.py

@@ -46,7 +46,6 @@ class TestEnableRulesetRequirementImpl:
         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):