bitwarden_workflow_linter 0.13.0__tar.gz → 0.13.1__tar.gz

{bitwarden_workflow_linter-0.13.0 → bitwarden_workflow_linter-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitwarden_workflow_linter
-Version: 0.13.0
+Version: 0.13.1
 Summary: Custom GitHub Action Workflow Linter
 Project-URL: Homepage, https://github.com/bitwarden/workflow-linter
 Project-URL: Issues, https://github.com/bitwarden/workflow-linter/issues

{bitwarden_workflow_linter-0.13.0 → bitwarden_workflow_linter-0.13.1}/src/bitwarden_workflow_linter/__about__.py

@@ -1,3 +1,3 @@
 """Metadata for Workflow Linter."""
 
-__version__ = "0.13.0"
+__version__ = "0.13.1"

{bitwarden_workflow_linter-0.13.0 → bitwarden_workflow_linter-0.13.1}/src/bitwarden_workflow_linter/rules/run_actionlint.py

@@ -17,17 +17,12 @@ def install_actionlint(platform_system: str, version: str) -> Tuple[bool, str]:
 
     error = f"An error occurred when installing Actionlint on {platform_system}"
 
-    if platform_system.startswith("Linux"):
+    if platform_system.startswith(("Linux", "Darwin")):
+        """Homebrew does not maintain non-latest versions of actionlint so Mac will install from source"""
         return install_actionlint_source(error,version)
-    elif platform_system == "Darwin":
-        try:
-            subprocess.run(["brew", "install", "actionlint"], check=True)
-            return True, ""
-        except (FileNotFoundError, subprocess.CalledProcessError):
-            return False, f"{error} : check Brew installation"
     elif platform_system.startswith("Win"):
         try:
-            subprocess.run(["choco", "install", "actionlint", "-y"], check=True)
+            subprocess.run(["choco", "install", "actionlint", "-y", f"--version='{version}'"], check=True)
             return True, ""
         except (FileNotFoundError, subprocess.CalledProcessError):
             return False, f"{error} : check Choco installation"
@@ -42,21 +37,24 @@ def install_actionlint_source(error, version) -> Tuple[bool, str]:
         fp.write(request.read())
     try:
         subprocess.run(["bash", "download-actionlint.bash", version], check=True)
-        return True, os.getcwd()
+        return True, "./actionlint"
     except (FileNotFoundError, subprocess.CalledProcessError):
         return False, error
 
 
-def check_actionlint(platform_system: str, version: str) -> Tuple[bool, str]:
+def check_actionlint_path(platform_system: str, version: str) -> Tuple[bool, str]:
     """Check if the actionlint is in the system's PATH."""
     try:
-        subprocess.run(
+        installed = subprocess.run(
             ["actionlint", "--version"],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             check=True,
         )
-        return True, ""
+        if version in f"{installed}":
+            return True, ""
+        else:
+            return install_actionlint(platform_system, version)
     except subprocess.CalledProcessError:
         return (
             False,
@@ -64,7 +62,23 @@ def check_actionlint(platform_system: str, version: str) -> Tuple[bool, str]:
 please check your package installer or manually install it",
         )
     except FileNotFoundError:
-        return install_actionlint(platform_system, version)
+        return check_actionlint_local(platform_system, version)
+
+def check_actionlint_local(platform_system: str, version: str) -> Tuple[bool, str]:
+
+        try:
+            installed = subprocess.run(
+            ["./actionlint", "--version"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=True,
+            )
+            if version in f"{installed}":
+                return True, "./actionlint"
+            else:
+                return install_actionlint(platform_system, version)
+        except FileNotFoundError:
+                return install_actionlint(platform_system, version)
 
 
 class RunActionlint(Rule):
@@ -82,12 +96,15 @@ class RunActionlint(Rule):
                 "Running actionlint without a filename is not currently supported"
             )
 
+        if not self.settings.actionlint_version:
+            raise KeyError("The 'actionlint_version' is missing in the configuration file.")
+
         """Check if Actionlint is alerady installed and if it is installed somewhere not on the PATH (location)"""
-        installed, location = check_actionlint(platform.system(), self.settings.actionlint_version)
+        installed, location = check_actionlint_path(platform.system(), self.settings.actionlint_version)
         if installed:
             if location:
                 result = subprocess.run(
-                    [location + "/actionlint", obj.filename],
+                     [location, obj.filename],
                     capture_output=True,
                     text=True,
                     check=False,

bitwarden_workflow_linter-0.13.1/tests/rules/test_run_actionlint.py

@@ -0,0 +1,377 @@
+"""Test src/bitwarden_workflow_linter/rules/run_actionlint."""
+
+import pytest
+import subprocess
+import os
+
+from ruamel.yaml import YAML
+
+from src.bitwarden_workflow_linter.utils import Settings
+from src.bitwarden_workflow_linter.load import WorkflowBuilder
+from src.bitwarden_workflow_linter.rules.run_actionlint import (
+    RunActionlint,
+    install_actionlint_source,
+    check_actionlint_path,
+    install_actionlint,
+    check_actionlint_local,
+)
+
+yaml = YAML()
+settings = Settings.factory()
+
+@pytest.fixture(name="rule")
+def fixture_rule():
+    return RunActionlint(settings)
+
+
+def test_rule_on_correct_workflow(rule):
+    rule.settings = settings
+    correct_workflow = WorkflowBuilder.build("tests/fixtures/test_workflow.yaml")
+    result, _ = rule.fn(correct_workflow)
+    assert result is True
+
+
+def test_rule_on_incorrect_workflow(rule):
+    rule.settings = settings
+    incorrect_workflow = WorkflowBuilder.build(
+        "tests/fixtures/test_workflow_incorrect.yaml"
+    )
+    result, _ = rule.fn(incorrect_workflow)
+    assert result is False
+
+
+def test_pass_install_actionlint_linux():
+    result, _ = install_actionlint("Linux", settings.actionlint_version)
+    assert result is True
+
+
+def test_install_actionlint_darwin(monkeypatch):
+    def mock_run(*args, **kwargs):
+        return subprocess.CompletedProcess(args, 0)
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+    result, _ = install_actionlint("Darwin", settings.actionlint_version)
+    assert result is True
+
+
+def test_failed_install_actionlint_darwin(monkeypatch):
+    def mock_run(*args, **kwargs):
+        raise subprocess.CalledProcessError(1, "cmd")
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+    result, error = install_actionlint("Darwin", settings.actionlint_version)
+    assert result is False
+    assert "An error occurred" in error
+
+
+def test_install_actionlint_windows(monkeypatch):
+    def mock_run(*args, **kwargs):
+        return subprocess.CompletedProcess(args, 0)
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+    result, _ = install_actionlint("Windows", settings.actionlint_version)
+    assert result is True
+
+
+def test_failed_install_actionlint_windows(monkeypatch):
+    def mock_run(*args, **kwargs):
+        raise subprocess.CalledProcessError(1, "cmd")
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+    result, error = install_actionlint("Windows", settings.actionlint_version)
+    assert result is False
+    assert "An error occurred" in error
+
+
+def test_install_actionlint_source(monkeypatch):
+    def mock_run(*args, **kwargs):
+        return subprocess.CompletedProcess(args, 0)
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    result, _ = install_actionlint_source("An error occurred", settings.actionlint_version)
+    assert result is True
+
+
+def test_failed_install_actionlint_source(monkeypatch):
+    def mock_run(*args, **kwargs):
+        raise subprocess.CalledProcessError(1, "cmd")
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    result, error = install_actionlint_source("An error occurred", settings.actionlint_version)
+    assert result is False
+    assert "An error occurred" in error
+
+# test_check_actionlint in path
+def test_check_actionlint_in_path(monkeypatch):
+    def mock_installed(*args, **kwargs):
+        return settings.actionlint_version
+
+    monkeypatch.setattr(subprocess, "run", mock_installed)
+
+    result, message = check_actionlint_path("Linux", settings.actionlint_version)
+    assert result is True
+    assert message == ""
+
+def test_check_actionlint_not_in_path(monkeypatch):
+    def mock_run(*args, **kwargs):
+        raise subprocess.CalledProcessError(1, args[0])
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    result, message = check_actionlint_path("Linux", settings.actionlint_version)
+    assert result is False
+    assert message == "Failed to install Actionlint, please check your package installer or manually install it"
+
+def test_run_actionlint_not_installed(monkeypatch, rule):
+    def mock_check_actionlint_path(*args, **kwargs):
+        return False, ""
+
+    monkeypatch.setattr(
+        "src.bitwarden_workflow_linter.rules.run_actionlint.check_actionlint_path",
+        mock_check_actionlint_path,
+    )
+
+    workflow = WorkflowBuilder.build("tests/fixtures/test_workflow.yaml")
+    result, error = rule.fn(workflow)
+    assert result is False
+    assert "Actionlint must pass" in error
+
+def test_run_actionlint_installed_error(monkeypatch, rule):
+    def mock_check_actionlint_path(*args, **kwargs):
+        return True, "/mock/location"
+
+    def mock_run(*args, **kwargs):
+        return subprocess.CompletedProcess(args, 110, stdout="An error occurred")
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+    monkeypatch.setattr(
+        "src.bitwarden_workflow_linter.rules.run_actionlint.check_actionlint_path",
+        mock_check_actionlint_path,
+    )
+
+    workflow = WorkflowBuilder.build("tests/fixtures/test_workflow.yaml")
+    result, error = rule.fn(workflow)
+    assert result is False
+    assert "An error occurred" in error
+
+# test_check_actionlint_installed
+def test_check_actionlint_installed_linux(monkeypatch):
+    def mock_run(*args, **kwargs):
+        return subprocess.CompletedProcess(args, 0)
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    result, _ = check_actionlint_path("Linux", settings.actionlint_version)
+    assert result is True
+
+def test_check_actionlint_installed_darwin(monkeypatch):
+    def mock_run(*args, **kwargs):
+        return subprocess.CompletedProcess(args, 0)
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    result, _ = check_actionlint_path("Darwin", settings.actionlint_version)
+    assert result is True
+
+def test_check_actionlint_installed_windows(monkeypatch):
+    def mock_run(*args, **kwargs):
+        return subprocess.CompletedProcess(args, 0)
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    result, _ = check_actionlint_path("Windows", settings.actionlint_version)
+    assert result is True
+
+
+#test_failed_check_actionlint_installed
+def test_failed_check_actionlint_installed_linux(monkeypatch):
+    def mock_run(*args, **kwargs):
+        raise subprocess.CalledProcessError(1, "cmd")
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    result, _ = check_actionlint_path("Linux", settings.actionlint_version)
+    assert result is False
+
+def test_failed_check_actionlint_installed_darwin(monkeypatch):
+    def mock_run(*args, **kwargs):
+        raise subprocess.CalledProcessError(1, "cmd")
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    result, _ = check_actionlint_path("Darwin", settings.actionlint_version)
+    assert result is False
+
+def test_failed_check_actionlint_installed_windows(monkeypatch):
+    def mock_run(*args, **kwargs):
+        raise subprocess.CalledProcessError(1, "cmd")
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    result, _ = check_actionlint_path("Windows", settings.actionlint_version)
+    assert result is False
+
+# test_check_actionlint_installed_locally
+def test_check_actionlint_installed_locally_linux(monkeypatch):
+    monkeypatch.setattr(os.path, "exists", True)
+
+    result, message = check_actionlint_local("Linux", settings.actionlint_version)
+
+    assert result is True
+    assert message == "./actionlint"
+
+def test_check_actionlint_installed_locally_darwin(monkeypatch):
+    monkeypatch.setattr(os.path, "exists", True)
+
+    result, message = check_actionlint_local("Darwin", settings.actionlint_version)
+
+    assert result is True
+    assert message == "./actionlint"
+
+def test_check_actionlint_installed_locally_windows(monkeypatch):
+    def mock_exists(*args, **kwargs):
+        return True
+
+    def mock_run(*args, **kwargs):
+        return subprocess.CompletedProcess(args, 0)
+
+    monkeypatch.setattr(os.path, "exists", mock_exists)
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    result, _ = check_actionlint_local("Windows", settings.actionlint_version)
+
+    assert result is True
+
+# test_install_actionlint
+def test_install_actionlint_linux():
+    result, _ = install_actionlint("Linux", settings.actionlint_version)
+    assert result is True
+
+def test_install_actionlint_darwin(monkeypatch):
+    def mock_run(*args, **kwargs):
+        return subprocess.CompletedProcess(args, 0)
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+    result, _ = install_actionlint("Darwin", settings.actionlint_version)
+    assert result is True
+
+def test_install_actionlint_windows(monkeypatch):
+    def mock_run(*args, **kwargs):
+        return subprocess.CompletedProcess(args, 0)
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+    result, _ = install_actionlint("Windows", settings.actionlint_version)
+    assert result is True
+
+def test_install_actionlint_source(monkeypatch):
+    def mock_run(*args, **kwargs):
+        return subprocess.CompletedProcess(args, 0)
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    result, _ = install_actionlint_source("An error occurred", settings.actionlint_version)
+    assert result is True
+
+# test non available OS
+def test_install_actionlint_non_available_os():
+    result, error = install_actionlint("MockOS", settings.actionlint_version)
+    assert result is False
+    assert "An error occurred when installing Actionlint on MockOS" in error
+
+# test_failed_install_actionlint
+def test_failed_install_actionlint_darwin(monkeypatch):
+    def mock_run(*args, **kwargs):
+        raise subprocess.CalledProcessError(1, "cmd")
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+    result, error = install_actionlint("Darwin", settings.actionlint_version)
+    assert result is False
+    assert "An error occurred" in error
+
+def test_failed_install_actionlint_windows(monkeypatch):
+    def mock_run(*args, **kwargs):
+        raise subprocess.CalledProcessError(1, "cmd")
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+    result, error = install_actionlint("Windows", settings.actionlint_version)
+    assert result is False
+    assert "An error occurred" in error
+
+def test_failed_install_actionlint_linux(monkeypatch):
+    def mock_run(*args, **kwargs):
+        raise subprocess.CalledProcessError(1, "cmd")
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    result, error = install_actionlint_source("An error occurred", settings.actionlint_version)
+    assert result is False
+    assert "An error occurred" in error
+
+def test_check_actionlint_not_installed(monkeypatch):
+    def mock_run(*args, **kwargs):
+        raise FileNotFoundError
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+
+    result, _ = check_actionlint_path("Linux", settings.actionlint_version)
+    assert result is False
+
+
+def test_run_actionlint_installed(monkeypatch, rule):
+    rule.settings = settings
+    
+    def mock_check_actionlint(*args, **kwargs):
+        return True, "/mock/location"
+
+    def mock_run(*args, **kwargs):
+        return subprocess.CompletedProcess(args, 0, stdout="")
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+    monkeypatch.setattr(
+        "src.bitwarden_workflow_linter.rules.run_actionlint.check_actionlint_path",
+        mock_check_actionlint,
+    )
+
+    workflow = WorkflowBuilder.build("tests/fixtures/test_workflow.yaml")
+    result, _ = rule.fn(workflow)
+    assert result is True
+
+
+def test_run_actionlint_not_installed(monkeypatch, rule):
+    rule.settings = settings
+
+    def mock_check_actionlint(*args, **kwargs):
+        return False, ""
+
+    monkeypatch.setattr(
+        "src.bitwarden_workflow_linter.rules.run_actionlint.check_actionlint_path",
+        mock_check_actionlint,
+    )
+
+    workflow = WorkflowBuilder.build("tests/fixtures/test_workflow.yaml")
+    result, error = rule.fn(workflow)
+    assert result is False
+    assert "Actionlint must pass" in error
+
+
+def test_run_actionlint_installed_error(monkeypatch, rule):
+    rule.settings = settings
+
+    def mock_check_actionlint(*args, **kwargs):
+        return True, "/mock/location"
+
+    def mock_run(*args, **kwargs):
+        return subprocess.CompletedProcess(args, 110, stdout="An error occurred")
+
+    monkeypatch.setattr(subprocess, "run", mock_run)
+    monkeypatch.setattr(
+        "src.bitwarden_workflow_linter.rules.run_actionlint.check_actionlint_path",
+        mock_check_actionlint,
+    )
+
+    workflow = WorkflowBuilder.build("tests/fixtures/test_workflow.yaml")
+    result, error = rule.fn(workflow)
+    assert result is False
+    assert "An error occurred" in error

bitwarden_workflow_linter-0.13.0/tests/rules/test_run_actionlint.py

@@ -1,190 +0,0 @@
-"""Test src/bitwarden_workflow_linter/rules/run_actionlint."""
-
-import pytest
-import subprocess
-
-from ruamel.yaml import YAML
-
-from src.bitwarden_workflow_linter.utils import Settings
-from src.bitwarden_workflow_linter.load import WorkflowBuilder
-from src.bitwarden_workflow_linter.rules.run_actionlint import (
-    RunActionlint,
-    install_actionlint_source,
-    check_actionlint,
-    install_actionlint,
-)
-
-yaml = YAML()
-settings = Settings.factory()
-
-@pytest.fixture(name="rule")
-def fixture_rule():
-    return RunActionlint()
-
-
-def test_rule_on_correct_workflow(rule):
-    rule.settings = settings
-    correct_workflow = WorkflowBuilder.build("tests/fixtures/test_workflow.yaml")
-    result, _ = rule.fn(correct_workflow)
-    assert result is True
-
-
-def test_rule_on_incorrect_workflow(rule):
-    rule.settings = settings
-    incorrect_workflow = WorkflowBuilder.build(
-        "tests/fixtures/test_workflow_incorrect.yaml"
-    )
-    result, _ = rule.fn(incorrect_workflow)
-    assert result is False
-
-
-def test_pass_install_actionlint_linux():
-    result, _ = install_actionlint("Linux", settings.actionlint_version)
-    assert result is True
-
-
-def test_install_actionlint_darwin(monkeypatch):
-    def mock_run(*args, **kwargs):
-        return subprocess.CompletedProcess(args, 0)
-
-    monkeypatch.setattr(subprocess, "run", mock_run)
-    result, _ = install_actionlint("Darwin", settings.actionlint_version)
-    assert result is True
-
-
-def test_failed_install_actionlint_darwin(monkeypatch):
-    def mock_run(*args, **kwargs):
-        raise subprocess.CalledProcessError(1, "cmd")
-
-    monkeypatch.setattr(subprocess, "run", mock_run)
-    result, error = install_actionlint("Darwin", settings.actionlint_version)
-    assert result is False
-    assert "An error occurred" in error
-
-
-def test_install_actionlint_windows(monkeypatch):
-    def mock_run(*args, **kwargs):
-        return subprocess.CompletedProcess(args, 0)
-
-    monkeypatch.setattr(subprocess, "run", mock_run)
-    result, _ = install_actionlint("Windows", settings.actionlint_version)
-    assert result is True
-
-
-def test_failed_install_actionlint_windows(monkeypatch):
-    def mock_run(*args, **kwargs):
-        raise subprocess.CalledProcessError(1, "cmd")
-
-    monkeypatch.setattr(subprocess, "run", mock_run)
-    result, error = install_actionlint("Windows", settings.actionlint_version)
-    assert result is False
-    assert "An error occurred" in error
-
-
-def test_install_actionlint_source(monkeypatch):
-    def mock_run(*args, **kwargs):
-        return subprocess.CompletedProcess(args, 0)
-
-    monkeypatch.setattr(subprocess, "run", mock_run)
-
-    result, _ = install_actionlint_source("An error occurred", settings.actionlint_version)
-    assert result is True
-
-
-def test_failed_install_actionlint_source(monkeypatch):
-    def mock_run(*args, **kwargs):
-        raise subprocess.CalledProcessError(1, "cmd")
-
-    monkeypatch.setattr(subprocess, "run", mock_run)
-
-    result, error = install_actionlint_source("An error occurred", settings.actionlint_version)
-    assert result is False
-    assert "An error occurred" in error
-
-
-def test_check_actionlint_installed(monkeypatch):
-    def mock_run(*args, **kwargs):
-        return subprocess.CompletedProcess(args, 0)
-
-    monkeypatch.setattr(subprocess, "run", mock_run)
-
-    result, _ = check_actionlint("Linux", settings.actionlint_version)
-    assert result is True
-
-
-def test_failed_check_actionlint_installed(monkeypatch):
-    def mock_run(*args, **kwargs):
-        raise subprocess.CalledProcessError(1, "cmd")
-
-    monkeypatch.setattr(subprocess, "run", mock_run)
-
-    result, _ = check_actionlint("Linux", settings.actionlint_version)
-    assert result is False
-
-
-def test_check_actionlint_not_installed(monkeypatch):
-    def mock_run(*args, **kwargs):
-        raise FileNotFoundError
-
-    monkeypatch.setattr(subprocess, "run", mock_run)
-
-    result, _ = check_actionlint("Linux", settings.actionlint_version)
-    assert result is False
-
-
-def test_run_actionlint_installed(monkeypatch, rule):
-    rule.settings = settings
-    
-    def mock_check_actionlint(*args, **kwargs):
-        return True, "/mock/location"
-
-    def mock_run(*args, **kwargs):
-        return subprocess.CompletedProcess(args, 0, stdout="")
-
-    monkeypatch.setattr(subprocess, "run", mock_run)
-    monkeypatch.setattr(
-        "src.bitwarden_workflow_linter.rules.run_actionlint.check_actionlint",
-        mock_check_actionlint,
-    )
-
-    workflow = WorkflowBuilder.build("tests/fixtures/test_workflow.yaml")
-    result, _ = rule.fn(workflow)
-    assert result is True
-
-
-def test_run_actionlint_not_installed(monkeypatch, rule):
-    rule.settings = settings
-
-    def mock_check_actionlint(*args, **kwargs):
-        return False, ""
-
-    monkeypatch.setattr(
-        "src.bitwarden_workflow_linter.rules.run_actionlint.check_actionlint",
-        mock_check_actionlint,
-    )
-
-    workflow = WorkflowBuilder.build("tests/fixtures/test_workflow.yaml")
-    result, error = rule.fn(workflow)
-    assert result is False
-    assert "Actionlint must pass" in error
-
-
-def test_run_actionlint_installed_error(monkeypatch, rule):
-    rule.settings = settings
-
-    def mock_check_actionlint(*args, **kwargs):
-        return True, "/mock/location"
-
-    def mock_run(*args, **kwargs):
-        return subprocess.CompletedProcess(args, 110, stdout="An error occurred")
-
-    monkeypatch.setattr(subprocess, "run", mock_run)
-    monkeypatch.setattr(
-        "src.bitwarden_workflow_linter.rules.run_actionlint.check_actionlint",
-        mock_check_actionlint,
-    )
-
-    workflow = WorkflowBuilder.build("tests/fixtures/test_workflow.yaml")
-    result, error = rule.fn(workflow)
-    assert result is False
-    assert "An error occurred" in error