bitwarden_workflow_linter 0.12.8__tar.gz → 0.13.1__tar.gz

{bitwarden_workflow_linter-0.12.8 → bitwarden_workflow_linter-0.13.1}/.github/CODEOWNERS

@@ -9,5 +9,5 @@
 
 # AppSec owns default_actions and actionlint_version files
 src/bitwarden_workflow_linter/default_actions.json @bitwarden/team-appsec
-actionlint_version.json @bitwarden/team-appsec
+src/bitwarden_workflow_linter/actionlint_version.yaml @bitwarden/team-appsec
 

{bitwarden_workflow_linter-0.12.8 → bitwarden_workflow_linter-0.13.1}/.github/renovate.json

@@ -23,7 +23,7 @@
   "customManagers": [
     {
       "customType": "regex",
-      "fileMatch": ["^actionlint_version\\.json$"],
+      "fileMatch": ["^actionlint_version\\.yaml$"],
       "matchStrings": [
         "\"actionlint_version\":\\s*\"(?<currentValue>[^\"]+)\""
       ],

{bitwarden_workflow_linter-0.12.8 → bitwarden_workflow_linter-0.13.1}/.github/workflows/ci.yml

@@ -29,6 +29,8 @@ jobs:
           pipenv install --dev
 
       - name: Run pytest
+        env:
+          PYTHONPATH: "${{ github.workspace }}/src"
         run: pipenv run pytest tests --cov=src
 
       - name: Check type hinting

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitwarden_workflow_linter
-Version: 0.12.8
+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.12.8 → bitwarden_workflow_linter-0.13.1}/src/bitwarden_workflow_linter/__about__.py

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

bitwarden_workflow_linter-0.13.1/src/bitwarden_workflow_linter/actionlint_version.yaml

@@ -0,0 +1 @@
+actionlint_version: "1.7.7"

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

@@ -5,49 +5,31 @@ import subprocess
 import platform
 import urllib.request
 import os
-import json
 
 from ..rule import Rule
 from ..models.workflow import Workflow
 from ..utils import LintLevels, Settings
 
 
-def install_actionlint(platform_system: str) -> Tuple[bool, str]:
+def install_actionlint(platform_system: str, version: str) -> Tuple[bool, str]:
     """If actionlint is not installed, detects OS platform
     and installs actionlint"""
 
     error = f"An error occurred when installing Actionlint on {platform_system}"
 
-    if platform_system.startswith("Linux"):
-        return install_actionlint_source(error)
-    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"
+    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.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"
     return False, error
 
-# temporarily commenting out this logic to allow time to troubleshoot it running in CI
-# def load_config() -> dict:
-#     """Load configuration from a JSON file."""
-#     config_path = os.path.join(os.path.dirname(__file__), "../../../actionlint_version.json")
-#     if not os.path.exists(config_path):
-#         raise FileNotFoundError(f"Configuration file not found: {config_path}")
-#     with open(config_path, "r") as config_file:
-#         return json.load(config_file)
-
-def install_actionlint_source(error) -> Tuple[bool, str]:
-    #config = load_config()
-    #if "actionlint_version" not in config:
-    #    raise KeyError("The 'actionlint_version' is missing in the configuration file.")
-    version = "1.7.7"
+def install_actionlint_source(error, version) -> Tuple[bool, str]:
+    version = version
     """Install Actionlint Binary from provided script"""
     url = "https://raw.githubusercontent.com/rhysd/actionlint/main/scripts/download-actionlint.bash"
     request = urllib.request.urlopen(url)
@@ -55,21 +37,24 @@ def install_actionlint_source(error) -> 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) -> 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,
@@ -77,7 +62,23 @@ def check_actionlint(platform_system: str) -> Tuple[bool, str]:
 please check your package installer or manually install it",
         )
     except FileNotFoundError:
-        return install_actionlint(platform_system)
+        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):
@@ -95,11 +96,15 @@ class RunActionlint(Rule):
                 "Running actionlint without a filename is not currently supported"
             )
 
-        installed, location = check_actionlint(platform.system())
+        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_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.12.8 → bitwarden_workflow_linter-0.13.1}/src/bitwarden_workflow_linter/utils.py

@@ -107,17 +107,18 @@ class SettingsError(Exception):
 
 SettingsFromFactory = TypeVar("SettingsFromFactory", bound="Settings")
 
-
 class Settings:
     """Class that contains configuration-as-code for any portion of the app."""
 
     enabled_rules: list[dict[str, str]]
     approved_actions: dict[str, Action]
+    actionlint_version: str
 
     def __init__(
         self,
         enabled_rules: Optional[list[dict[str, str]]] = None,
         approved_actions: Optional[dict[str, dict[str, str]]] = None,
+        actionlint_version: Optional[str] = None,
     ) -> None:
         """Settings object that can be overridden in settings.py.
 
@@ -134,7 +135,11 @@ class Settings:
 
         if approved_actions is None:
             approved_actions = {}
+        
+        if actionlint_version is None:
+            actionlint_version = ""
 
+        self.actionlint_version = actionlint_version
         self.enabled_rules = enabled_rules
         self.approved_actions = {
             name: Action(**action) for name, action in approved_actions.items()
@@ -142,6 +147,7 @@ class Settings:
 
     @staticmethod
     def factory() -> SettingsFromFactory:
+        # load default settings
         with (
             importlib.resources.files("bitwarden_workflow_linter")
             .joinpath("default_settings.yaml")
@@ -149,6 +155,16 @@ class Settings:
         ):
             settings = yaml.load(file)
 
+        # load actionlint version
+        with (
+            importlib.resources.files("bitwarden_workflow_linter")
+            .joinpath("actionlint_version.yaml")
+            .open("r", encoding="utf-8") as version_file
+        ):
+            version_data = yaml.load(version_file)
+            actionlint_version = version_data["actionlint_version"]
+
+        # load override settings
         settings_filename = "settings.yaml"
         local_settings = None
 
@@ -159,6 +175,7 @@ class Settings:
         if local_settings:
             settings.update(local_settings)
 
+        # load approved actions
         if settings["approved_actions_path"] == "default_actions.json":
             with (
                 importlib.resources.files("bitwarden_workflow_linter")
@@ -172,7 +189,9 @@ class Settings:
             ) as action_file:
                 settings["approved_actions"] = json.load(action_file)
 
+        
         return Settings(
             enabled_rules=settings["enabled_rules"],
             approved_actions=settings["approved_actions"],
+            actionlint_version=actionlint_version,
         )

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.12.8/tests/rules/test_run_actionlint.py

@@ -1,181 +0,0 @@
-"""Test src/bitwarden_workflow_linter/rules/run_actionlint."""
-
-import pytest
-import subprocess
-
-from ruamel.yaml import YAML
-
-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()
-
-
-@pytest.fixture(name="rule")
-def fixture_rule():
-    return RunActionlint()
-
-
-def test_rule_on_correct_workflow(rule):
-    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):
-    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")
-    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")
-    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")
-    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")
-    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")
-    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")
-    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")
-    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")
-    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")
-    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")
-    assert result is False
-
-
-def test_run_actionlint_installed(monkeypatch, rule):
-    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):
-    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):
-    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