crackerjack 0.20.2__tar.gz → 0.20.3__tar.gz

{crackerjack-0.20.2 → crackerjack-0.20.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: crackerjack
-Version: 0.20.2
+Version: 0.20.3
 Summary: Crackerjack: code quality toolkit
 Keywords: bandit,black,creosote,mypy,pyright,pytest,refurb,ruff
 Author-Email: lesleslie <les@wedgwoodwebworks.com>

{crackerjack-0.20.2 → crackerjack-0.20.3}/crackerjack/crackerjack.py

@@ -1022,23 +1022,34 @@ class Crackerjack:
 
         if options.publish:
             if platform.system() == "Darwin":
-                authorize = self.execute_command(
-                    ["pdm", "self", "add", "keyring"], capture_output=True, text=True
+                # First check if keyring is already installed in PDM
+                check_keyring = self.execute_command(
+                    ["pdm", "self", "list"], capture_output=True, text=True
                 )
-                if authorize.returncode > 0:
-                    error = PublishError(
-                        message="Authentication setup failed",
-                        error_code=ErrorCode.AUTHENTICATION_ERROR,
-                        details=f"Failed to add keyring support to PDM.\nCommand output:\n{authorize.stderr}",
-                        recovery="Please manually add your keyring credentials to PDM. Run `pdm self add keyring` and try again.",
-                        exit_code=1,
-                    )
-                    handle_error(
-                        error=error,
-                        console=self.console,
-                        verbose=options.verbose,
-                        ai_agent=options.ai_agent,
+                keyring_installed = "keyring" in check_keyring.stdout
+
+                if not keyring_installed:
+                    # Only attempt to install keyring if it's not already installed
+                    self.console.print("Installing keyring for PDM...")
+                    authorize = self.execute_command(
+                        ["pdm", "self", "add", "keyring"],
+                        capture_output=True,
+                        text=True,
                     )
+                    if authorize.returncode > 0:
+                        error = PublishError(
+                            message="Authentication setup failed",
+                            error_code=ErrorCode.AUTHENTICATION_ERROR,
+                            details=f"Failed to add keyring support to PDM.\nCommand output:\n{authorize.stderr}",
+                            recovery="Please manually add your keyring credentials to PDM. Run `pdm self add keyring` and try again.",
+                            exit_code=1,
+                        )
+                        handle_error(
+                            error=error,
+                            console=self.console,
+                            verbose=options.verbose,
+                            ai_agent=options.ai_agent,
+                        )
 
             build = self.execute_command(
                 ["pdm", "build"], capture_output=True, text=True

{crackerjack-0.20.2 → crackerjack-0.20.3}/crackerjack/pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "pdm-backend" ]
 
 [project]
 name = "crackerjack"
-version = "0.20.1"
+version = "0.20.2"
 description = "Crackerjack: code quality toolkit"
 readme = "README.md"
 keywords = [

{crackerjack-0.20.2 → crackerjack-0.20.3}/pyproject.toml

@@ -6,7 +6,7 @@ requires = [
 
 [project]
 name = "crackerjack"
-version = "0.20.2"
+version = "0.20.3"
 description = "Crackerjack: code quality toolkit"
 readme = "README.md"
 keywords = [

{crackerjack-0.20.2 → crackerjack-0.20.3}/tests/test_crackerjack.py

@@ -1,4 +1,5 @@
 import os
+import subprocess
 import typing as t
 from contextlib import suppress
 from dataclasses import dataclass
@@ -12,6 +13,7 @@ from crackerjack.crackerjack import (
     CodeCleaner,
     ConfigManager,
     Crackerjack,
+    OptionsProtocol,
     ProjectManager,
 )
 
@@ -180,7 +182,7 @@ class TestCrackerjackProcess:
         options = options_factory(commit=True, no_config_updates=True)
         with patch.object(Crackerjack, "_update_project") as mock_update_project:
 
-            def side_effect(opts: t.Any) -> None:
+            def side_effect(opts: OptionsProtocol) -> None:
                 if opts.no_config_updates:
                     mock_console_print("Skipping config updates.")
 
@@ -580,7 +582,9 @@ class TestCrackerjackProcess:
             with patch("platform.system", return_value="Linux"):
                 with patch.object(Crackerjack, "execute_command") as mock_cj_execute:
 
-                    def mock_execute_side_effect(*args: t.Any, **kwargs: t.Any):
+                    def mock_execute_side_effect(
+                        *args: t.Any, **kwargs: t.Any
+                    ) -> subprocess.CompletedProcess[str]:
                         cmd = args[0][0]
                         if cmd == "pdm" and "build" in args[0]:
                             return MagicMock(
@@ -596,55 +600,154 @@ class TestCrackerjackProcess:
 
             mock_handle_error.assert_called()
 
-    def test_process_with_darwin_platform(
-        self,
-        mock_execute: MagicMock,
-        mock_console_print: MagicMock,
-        tmp_path: Path,
-        tmp_path_package: Path,
-        create_package_dir: None,
-        options_factory: t.Callable[..., OptionsForTesting],
-    ) -> None:
-        options = options_factory(publish="micro", no_config_updates=True)
-        with patch("platform.system", return_value="Darwin"):
-            with patch.object(Crackerjack, "execute_command") as mock_cj_execute:
-                mock_cj_execute.side_effect = [
-                    MagicMock(returncode=0, stdout="Success"),
-                    MagicMock(returncode=0, stdout="Success"),
-                    MagicMock(returncode=0, stdout="Success"),
-                    MagicMock(returncode=0, stdout="Success"),
-                ]
-                with patch.object(Crackerjack, "_update_project"):
-                    cj = Crackerjack(dry_run=True)
-                    cj.process(options)
-                    mock_cj_execute.assert_any_call(
-                        ["pdm", "self", "add", "keyring"],
-                        capture_output=True,
-                        text=True,
-                    )
+    def test_keyring_check_install_darwin(self) -> None:
+        """Test checking for keyring on Darwin (macOS) and installing it."""
+        # Create a minimal options object
+        options = OptionsForTesting(publish=BumpOption.micro)
 
-    def test_process_with_darwin_platform_keyring_failure(
-        self,
-        mock_execute: MagicMock,
-        mock_console_print: MagicMock,
-        tmp_path: Path,
-        tmp_path_package: Path,
-        create_package_dir: None,
-        options_factory: t.Callable[..., OptionsForTesting],
-    ) -> None:
-        with patch("crackerjack.errors.handle_error") as mock_handle_error:
-            options = options_factory(publish="micro", no_config_updates=True)
-            with patch("platform.system", return_value="Darwin"):
-                with patch.object(Crackerjack, "execute_command") as mock_cj_execute:
-                    mock_cj_execute.return_value = MagicMock(
-                        returncode=1, stdout="", stderr="Authorization failed"
-                    )
-                    with patch.object(Crackerjack, "_update_project"):
-                        with suppress(SystemExit):
-                            cj = Crackerjack(dry_run=True)
-                            cj.process(options)
+        # Use a list to track actual calls
+        actual_calls = []
 
-            mock_handle_error.assert_called()
+        # Create a Crackerjack instance for testing
+        crackerjack = Crackerjack(dry_run=False)
+
+        # Mock platform.system to return 'Darwin'
+        with patch("platform.system", return_value="Darwin"):
+            # Create a custom execute_command function that tracks calls
+            def mock_execute_side_effect(
+                *args: t.Any, **kwargs: t.Any
+            ) -> subprocess.CompletedProcess[str]:
+                cmd = args[0]
+                actual_calls.append(cmd)  # Track each command
+
+                if cmd == ["pdm", "self", "list"]:
+                    # Important: This MUST NOT contain the string "keyring" to trigger installation
+                    return MagicMock(
+                        returncode=0, stdout="packages installed: pytest, black"
+                    )
+                elif cmd == ["pdm", "self", "add", "keyring"]:
+                    return MagicMock(returncode=0, stdout="installed keyring")
+                elif cmd == ["pdm", "build"]:
+                    return MagicMock(returncode=0, stdout="build output")
+                elif cmd == ["pdm", "publish", "--no-build"]:
+                    return MagicMock(returncode=0, stdout="publish output")
+                return MagicMock(returncode=0, stdout="")
+
+            # Mock execute_command with our custom side_effect
+            with patch.object(
+                crackerjack, "execute_command", side_effect=mock_execute_side_effect
+            ):
+                # Mock console.print
+                with patch.object(crackerjack.console, "print"):
+                    # Call the method we're testing
+                    crackerjack._publish_project(options)
+
+            # Check that all the expected commands were called
+            assert ["pdm", "self", "list"] in actual_calls
+            assert ["pdm", "self", "add", "keyring"] in actual_calls
+            assert ["pdm", "build"] in actual_calls
+            assert ["pdm", "publish", "--no-build"] in actual_calls
+
+    def test_keyring_already_installed_darwin(self) -> None:
+        """Test behavior when keyring is already installed on Darwin (macOS)."""
+        # Create a minimal options object
+        options = OptionsForTesting(publish=BumpOption.micro)
+
+        # Use a list to track actual calls
+        actual_calls = []
+
+        # Create a Crackerjack instance for testing
+        crackerjack = Crackerjack(dry_run=False)
+
+        # Mock platform.system to return 'Darwin'
+        with patch("platform.system", return_value="Darwin"):
+            # Create a custom execute_command function that tracks calls
+            def mock_execute_side_effect(
+                *args: t.Any, **kwargs: t.Any
+            ) -> subprocess.CompletedProcess[str]:
+                cmd = args[0]
+                actual_calls.append(cmd)  # Track each command
+
+                if cmd == ["pdm", "self", "list"]:
+                    return MagicMock(returncode=0, stdout="keyring         25.6.0")
+                elif cmd == ["pdm", "build"]:
+                    return MagicMock(returncode=0, stdout="build output")
+                elif cmd == ["pdm", "publish", "--no-build"]:
+                    return MagicMock(returncode=0, stdout="publish output")
+                return MagicMock(returncode=0, stdout="")
+
+            # Mock execute_command with our custom side_effect
+            with patch.object(
+                crackerjack, "execute_command", side_effect=mock_execute_side_effect
+            ):
+                # Mock console.print
+                with patch.object(crackerjack.console, "print"):
+                    # Call the method we're testing
+                    crackerjack._publish_project(options)
+
+            # Check that keyring installation was skipped
+            assert ["pdm", "self", "list"] in actual_calls
+            assert ["pdm", "self", "add", "keyring"] not in actual_calls
+            assert ["pdm", "build"] in actual_calls
+            assert ["pdm", "publish", "--no-build"] in actual_calls
+
+    def test_keyring_install_failure_darwin(self) -> None:
+        """Test handling of keyring installation failure on Darwin (macOS)."""
+        # Create a minimal options object with ai_agent False to avoid extra mocking
+        options = OptionsForTesting(publish=BumpOption.micro, ai_agent=False)
+
+        # Create a Crackerjack instance for testing
+        crackerjack = Crackerjack(dry_run=False)
+
+        # Mock the PublishError class to capture its creation
+        with patch("crackerjack.errors.PublishError") as mock_publish_error:
+            # Set up the mock to return a MagicMock that we can track
+            error_instance = MagicMock()
+            mock_publish_error.return_value = error_instance
+
+            # Mock handle_error to avoid actual exit
+            with patch("crackerjack.errors.handle_error") as mock_handle_error:
+                # Mock platform.system to return 'Darwin'
+                with patch("platform.system", return_value="Darwin"):
+                    # Create a custom execute_command function with failure scenario
+                    def mock_execute_side_effect(
+                        *args: t.Any, **kwargs: t.Any
+                    ) -> subprocess.CompletedProcess[str]:
+                        cmd = args[0]
+
+                        if cmd == ["pdm", "self", "list"]:
+                            # This must NOT contain the string "keyring" to trigger installation
+                            return MagicMock(
+                                returncode=0, stdout="packages installed: pytest, black"
+                            )
+                        elif cmd == ["pdm", "self", "add", "keyring"]:
+                            # Return a failure for keyring installation
+                            mock_result = MagicMock()
+                            mock_result.returncode = 1
+                            mock_result.stdout = ""
+                            mock_result.stderr = "Installation failed"
+                            return mock_result
+                        return MagicMock(returncode=0, stdout="")
+
+                    # Mock execute_command with our custom side_effect
+                    with patch.object(
+                        crackerjack,
+                        "execute_command",
+                        side_effect=mock_execute_side_effect,
+                    ):
+                        # Mock console.print to avoid terminal output
+                        with patch.object(crackerjack.console, "print"):
+                            # Call the method we're testing with error suppression
+                            with suppress(SystemExit):
+                                crackerjack._publish_project(options)
+
+                # Check that the error handler was called with the right error
+                mock_handle_error.assert_called_once_with(
+                    error=error_instance,
+                    console=crackerjack.console,
+                    verbose=options.verbose,
+                    ai_agent=options.ai_agent,
+                )
 
     def test_process_with_commit_input(
         self,