spaceforge 0.1.0.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

spaceforge/{generator_test.py → test_generator.py}

@@ -1,6 +1,6 @@
 import os
 import tempfile
-from typing import Optional
+from typing import Any, Dict, List
 from unittest.mock import Mock, mock_open, patch
 
 import pytest
@@ -55,7 +55,7 @@ class PluginExample(SpaceforgePlugin):
         Context(
             name_prefix="test_context",
             description="Test context",
-            labels={"env": "test"},
+            labels=["env:test"],
             env=[Variable(key="TEST_VAR", value="test_value")],
         )
     ]
@@ -64,16 +64,17 @@ class PluginExample(SpaceforgePlugin):
         Webhook(
             name_prefix="test_webhook",
             endpoint="https://webhook.example.com",
-            secrets=[Variable(key="SECRET_KEY", value_from_parameter="api_key")],
+            secretFromParameter="api_key",
+            labels=["type:notification"],
         )
     ]
 
     __policies__ = [
         Policy(
             name_prefix="test_policy",
-            type="notification",
+            type="NOTIFICATION",
             body="package test",
-            labels={"type": "security"},
+            labels=["type:security"],
         )
     ]
 
@@ -318,14 +319,32 @@ class NotAPlugin:
         """Test binary installation command generation."""
         generator = PluginGenerator()
         generator.plugin_class = PluginExample
+        generator.plugin_working_directory = "/mnt/workspace/plugins/test_plugin"
+        generator.config = {
+            "setup_virtual_env": "cd /mnt/workspace/plugins/test_plugin && python -m venv ./venv && source venv/bin/activate && pip install spaceforge",
+            "plugin_mounted_path": "/mnt/workspace/plugins/test_plugin/plugin.py",
+        }
+
+        hooks: Dict[str, List[str]] = {"before_init": []}
+        mounted_files: List = []
+        generator._generate_binary_install_command(hooks, mounted_files)
+
+        # Should have added a script execution to hooks
+        assert len(hooks["before_init"]) == 1
+        command = hooks["before_init"][0]
 
-        command = generator.generate_binary_install_command()
+        # Should have added a mounted file with script content
+        assert len(mounted_files) == 1
+        script_content = mounted_files[0].content
 
-        assert "mkdir -p /mnt/workspace/plugins/plugin_binaries" in command
-        assert "curl https://example.com/test-cli-amd64" in command
-        assert "curl https://example.com/test-cli-arm64" in command
-        assert "arch" in command
-        assert "x86_64" in command
+        # Check that hook command runs the script
+        assert "chmod +x" in command
+        assert "binary_install_test-cli.sh" in command
+
+        # Check script content contains binary installation logic
+        assert "test-cli" in script_content
+        assert "https://example.com/test-cli-amd64" in script_content
+        assert "https://example.com/test-cli-arm64" in script_content
 
     def test_generate_binary_install_command_no_binaries(self) -> None:
         """Test binary command generation when no binaries."""
@@ -335,9 +354,18 @@ class NotAPlugin:
 
         generator = PluginGenerator()
         generator.plugin_class = NoBinariesPlugin
-
-        command = generator.generate_binary_install_command()
-        assert command == ""
+        generator.plugin_working_directory = "/mnt/workspace/plugins/nobinaries"
+        generator.config = {
+            "setup_virtual_env": "cd /mnt/workspace/plugins/nobinaries && python -m venv ./venv && source venv/bin/activate && pip install spaceforge",
+            "plugin_mounted_path": "/mnt/workspace/plugins/nobinaries/plugin.py",
+        }
+
+        hooks: Dict[str, List[str]] = {"before_init": []}
+        mounted_files: List = []
+        generator._generate_binary_install_command(hooks, mounted_files)
+        # No binaries should mean no new commands or files added
+        assert len(hooks["before_init"]) == 0
+        assert len(mounted_files) == 0
 
     def test_generate_binary_install_command_missing_urls(self) -> None:
         """Test binary command generation with missing URLs."""
@@ -347,9 +375,16 @@ class NotAPlugin:
 
         generator = PluginGenerator()
         generator.plugin_class = InvalidBinaryPlugin
-
+        generator.plugin_working_directory = "/mnt/workspace/plugins/invalidbinary"
+        generator.config = {
+            "setup_virtual_env": "cd /mnt/workspace/plugins/invalidbinary && python -m venv ./venv && source venv/bin/activate && pip install spaceforge",
+            "plugin_mounted_path": "/mnt/workspace/plugins/invalidbinary/plugin.py",
+        }
+
+        hooks: Dict[str, List[str]] = {"before_init": []}
+        mounted_files: List = []
         with pytest.raises(ValueError, match="must have at least one download URL"):
-            generator.generate_binary_install_command()
+            generator._generate_binary_install_command(hooks, mounted_files)
 
     def test_get_plugin_policies(self) -> None:
         """Test policy extraction."""
@@ -361,7 +396,7 @@ class NotAPlugin:
         assert policies is not None
         assert len(policies) == 1
         assert policies[0].name_prefix == "test_policy"
-        assert policies[0].type == "notification"
+        assert policies[0].type == "NOTIFICATION"
         assert policies[0].body == "package test"
 
     def test_get_plugin_webhooks(self) -> None:
@@ -377,33 +412,50 @@ class NotAPlugin:
         assert webhooks[0].endpoint == "https://webhook.example.com"
 
     @patch("os.path.exists")
-    @patch("builtins.open", new_callable=mock_open, read_data="requirements content")
-    def test_get_plugin_contexts_with_requirements(
-        self, mock_file: Mock, mock_exists: Mock
-    ) -> None:
+    def test_get_plugin_contexts_with_requirements(self, mock_exists: Mock) -> None:
         """Test context generation with requirements.txt."""
         mock_exists.side_effect = (
             lambda path: path == "requirements.txt" or "plugin.py" in path
         )
 
-        generator = PluginGenerator(self.test_plugin_path)
-        generator.plugin_class = PluginExample
-        generator.plugin_working_directory = "/mnt/workspace/plugins/test_plugin"
+        # Mock specific file contents with a custom open function
+        original_open = open
+
+        def mock_open_func(filename: str, *args: Any, **kwargs: Any) -> Any:
+            if filename == "requirements.txt":
+                from io import StringIO
 
-        contexts = generator.get_plugin_contexts()
+                return StringIO("requirements content")
+            elif "plugin.py" in filename:
+                from io import StringIO
+
+                return StringIO("plugin content")
+            else:
+                return original_open(filename, *args, **kwargs)
+
+        with patch("builtins.open", side_effect=mock_open_func):
+            generator = PluginGenerator(self.test_plugin_path)
+            generator.plugin_class = PluginExample
+            generator.plugin_working_directory = "/mnt/workspace/plugins/test_plugin"
+            generator.config = {
+                "setup_virtual_env": "cd /mnt/workspace/plugins/test_plugin && python -m venv ./venv && source venv/bin/activate && pip install spaceforge",
+                "plugin_mounted_path": "/mnt/workspace/plugins/test_plugin/plugin.py",
+            }
+
+            contexts = generator.get_plugin_contexts()
 
         assert len(contexts) == 1
         context = contexts[0]
 
-        # Should have before_init hooks for venv setup
+        # Should have before_init hooks with mkdir command
         assert context.hooks is not None
         assert "before_init" in context.hooks
-        venv_command = None
+        mkdir_command = None
         for cmd in context.hooks["before_init"]:
-            if "python -m venv" in cmd:
-                venv_command = cmd
+            if "mkdir -p" in cmd:
+                mkdir_command = cmd
                 break
-        assert venv_command is not None
+        assert mkdir_command is not None
 
         # Should have requirements.txt as mounted file
         assert context.mounted_files is not None
@@ -415,22 +467,44 @@ class NotAPlugin:
         assert req_file is not None
         assert req_file.content == "requirements content"
 
+        # Should have plugin.py as mounted file
+        plugin_file = None
+        for mf in context.mounted_files:
+            if "plugin.py" in mf.path:
+                plugin_file = mf
+                break
+        assert plugin_file is not None
+        assert plugin_file.content == "plugin content"
+
     @patch("os.path.exists")
-    @patch("builtins.open", new_callable=mock_open, read_data="plugin content")
-    def test_get_plugin_contexts_basic(
-        self, mock_file: Mock, mock_exists: Mock
-    ) -> None:
+    def test_get_plugin_contexts_basic(self, mock_exists: Mock) -> None:
         """Test basic context generation."""
         mock_exists.side_effect = lambda path: "plugin.py" in path
 
-        generator = PluginGenerator(self.test_plugin_path)
-        generator.plugin_class = PluginExample
-        generator.plugin_working_directory = "/mnt/workspace/plugins/test_plugin"
+        # Mock specific file contents with a custom open function
+        original_open = open
 
-        with patch.object(
-            generator, "get_available_hooks", return_value=["after_plan"]
-        ):
-            contexts = generator.get_plugin_contexts()
+        def mock_open_func(filename: str, *args: Any, **kwargs: Any) -> Any:
+            if "plugin.py" in filename:
+                from io import StringIO
+
+                return StringIO("plugin content")
+            else:
+                return original_open(filename, *args, **kwargs)
+
+        with patch("builtins.open", side_effect=mock_open_func):
+            generator = PluginGenerator(self.test_plugin_path)
+            generator.plugin_class = PluginExample
+            generator.plugin_working_directory = "/mnt/workspace/plugins/test_plugin"
+            generator.config = {
+                "setup_virtual_env": "cd /mnt/workspace/plugins/test_plugin && python -m venv ./venv && source venv/bin/activate && pip install spaceforge",
+                "plugin_mounted_path": "/mnt/workspace/plugins/test_plugin/plugin.py",
+            }
+
+            with patch.object(
+                generator, "get_available_hooks", return_value=["after_plan"]
+            ):
+                contexts = generator.get_plugin_contexts()
 
         assert len(contexts) == 1
         context = contexts[0]
@@ -444,19 +518,36 @@ class NotAPlugin:
                 break
         assert plugin_file is not None
 
-        # Should have spacepy runner hooks
+        # Should have hooks for after_plan (the hook we mocked as available)
         assert context.hooks is not None
         assert "after_plan" in context.hooks
-        runner_command = context.hooks["after_plan"][0]
-        assert "python -m spaceforge runner" in runner_command
-        assert "after_plan" in runner_command
+
+        # Should have a script execution command
+        hook_command = context.hooks["after_plan"][0]
+        assert "chmod +x" in hook_command
+        assert "after_plan.sh" in hook_command
+
+        # Should have a mounted script file for after_plan
+        after_plan_script = None
+        for mf in context.mounted_files:
+            if "after_plan.sh" in mf.path:
+                after_plan_script = mf
+                break
+        assert after_plan_script is not None
+        assert "spaceforge runner" in after_plan_script.content
+        assert "after_plan" in after_plan_script.content
 
     def test_generate_manifest(self) -> None:
         """Test complete manifest generation."""
         generator = PluginGenerator(self.test_plugin_path)
+        generator.plugin_class = PluginExample
+        generator.plugin_working_directory = "/mnt/workspace/plugins/test_plugin"
+        generator.config = {
+            "setup_virtual_env": "cd /mnt/workspace/plugins/test_plugin && python -m venv ./venv && source venv/bin/activate && pip install spaceforge",
+            "plugin_mounted_path": "/mnt/workspace/plugins/test_plugin/plugin.py",
+        }
 
         with patch.object(generator, "load_plugin"):
-            generator.plugin_class = PluginExample
             manifest = generator.generate_manifest()
 
         assert isinstance(manifest, PluginManifest)
@@ -474,7 +565,7 @@ class NotAPlugin:
         """Test YAML writing functionality."""
         generator = PluginGenerator(output_path=self.test_output_path)
         manifest = PluginManifest(
-            name_prefix="test",
+            name="test",
             version="1.0.0",
             description="Test",
             author="Test Author",
@@ -500,7 +591,7 @@ class NotAPlugin:
         """Test complete generate method."""
         generator = PluginGenerator()
         mock_manifest = PluginManifest(
-            name_prefix="test", version="1.0.0", description="Test", author="Test"
+            name="test", version="1.0.0", description="Test", author="Test"
         )
         mock_generate_manifest.return_value = mock_manifest
 
@@ -606,11 +697,30 @@ class TestPluginGeneratorEdgeCases:
 
         generator = PluginGenerator()
         generator.plugin_class = SingleArchPlugin
+        generator.plugin_working_directory = "/mnt/workspace/plugins/singlearch"
+        generator.config = {
+            "setup_virtual_env": "cd /mnt/workspace/plugins/singlearch && python -m venv ./venv && source venv/bin/activate && pip install spaceforge",
+            "plugin_mounted_path": "/mnt/workspace/plugins/singlearch/plugin.py",
+        }
+
+        hooks: Dict[str, List[str]] = {"before_init": []}
+        mounted_files: List = []
+        generator._generate_binary_install_command(hooks, mounted_files)
+
+        # Should have added a script execution to hooks
+        assert len(hooks["before_init"]) == 1
+        command = hooks["before_init"][0]
 
-        command = generator.generate_binary_install_command()
+        # Should have added a mounted file with script content
+        assert len(mounted_files) == 1
+        script_content = mounted_files[0].content
 
-        assert "https://example.com/binary-amd64" in command
-        assert "arm64 binary not available" in command
+        # Check that hook command runs the script
+        assert "chmod +x" in command
+        assert "binary_install_single-arch.sh" in command
+
+        # Check script content contains the binary URL
+        assert "https://example.com/binary-amd64" in script_content
 
     def test_context_merging_with_existing(self) -> None:
         """Test that generated hooks are merged with existing context hooks."""
@@ -638,11 +748,26 @@ class TestPluginGeneratorEdgeCases:
         generator = PluginGenerator("/fake/path")
         generator.plugin_class = ExistingHooksPlugin
         generator.plugin_working_directory = "/mnt/workspace/plugins/existing_hooks"
+        generator.config = {
+            "setup_virtual_env": "cd /mnt/workspace/plugins/existing_hooks && python -m venv ./venv && source venv/bin/activate && pip install spaceforge",
+            "plugin_mounted_path": "/mnt/workspace/plugins/existing_hooks/plugin.py",
+        }
+
+        # Mock specific file contents with a custom open function
+        original_open = open
+
+        def mock_open_func(filename: str, *args: Any, **kwargs: Any) -> Any:
+            if filename == "/fake/path":
+                from io import StringIO
+
+                return StringIO("fake content")
+            else:
+                return original_open(filename, *args, **kwargs)
 
         with patch("os.path.exists") as mock_exists:
             # Only plugin file exists, not requirements.txt
             mock_exists.side_effect = lambda path: path == "/fake/path"
-            with patch("builtins.open", mock_open(read_data="fake content")):
+            with patch("builtins.open", side_effect=mock_open_func):
                 contexts = generator.get_plugin_contexts()
 
         context = contexts[0]
@@ -658,14 +783,101 @@ class TestPluginGeneratorEdgeCases:
         assert len(existing_files) == 1
 
         # Plugin file should be mounted (path contains the working directory)
-        plugin_files = [
+        # The new implementation creates both plugin.py and hook scripts
+        working_dir_files = [
             mf
             for mf in context.mounted_files
             if "/mnt/workspace/plugins/existing_hooks" in mf.path
         ]
+        assert (
+            len(working_dir_files) >= 1
+        )  # At least plugin.py, possibly hook scripts too
+
+        # Specifically check for plugin.py
+        plugin_files = [
+            mf for mf in context.mounted_files if mf.path.endswith("plugin.py")
+        ]
         assert len(plugin_files) == 1
 
         # Should have existing env vars
         assert context.env is not None
         existing_vars = [var for var in context.env if var.key == "EXISTING"]
         assert len(existing_vars) == 1
+
+    def test_parameters_and_variables_id_generation(self) -> None:
+        class ParametersAndVariablesPlugin(SpaceforgePlugin):
+            __plugin_name__ = "parameters_and_variables"
+
+            __parameters__ = [
+                Parameter(
+                    name="api key",
+                    description="API key for authentication",
+                    required=True,
+                    sensitive=True,
+                ),
+                Parameter(
+                    name="endpoint",
+                    description="API endpoint URL",
+                    required=False,
+                    default="https://api.example.com",
+                ),
+            ]
+
+            __contexts__ = [
+                Context(
+                    name_prefix="existing",
+                    description="Existing context",
+                    hooks={"before_init": ["echo 'existing hook'"]},
+                    mounted_files=[
+                        MountedFile(
+                            path="/existing", content="existing", sensitive=False
+                        )
+                    ],
+                    env=[
+                        Variable(
+                            key="API_KEY",
+                            value_from_parameter="api key",
+                            sensitive=True,
+                        ),
+                        Variable(key="ENDPOINT", value_from_parameter="endpoint"),
+                    ],
+                )
+            ]
+
+            def after_plan(self) -> None:
+                pass
+
+        generator = PluginGenerator("/fake/path")
+        generator.plugin_class = ParametersAndVariablesPlugin
+        generator.plugin_working_directory = (
+            "/mnt/workspace/plugins/parametersandvariables"
+        )
+        generator.config = {
+            "setup_virtual_env": "cd /mnt/workspace/plugins/parametersandvariables && python -m venv ./venv && source venv/bin/activate && pip install spaceforge",
+            "plugin_mounted_path": "/mnt/workspace/plugins/parametersandvariables/plugin.py",
+        }
+
+        # Mock specific file contents with a custom open function
+        original_open = open
+
+        def mock_open_func(filename: str, *args: Any, **kwargs: Any) -> Any:
+            if filename == "/fake/path":
+                from io import StringIO
+
+                return StringIO("fake content")
+            else:
+                return original_open(filename, *args, **kwargs)
+
+        with patch("os.path.exists") as mock_exists:
+            # Only plugin file exists, not requirements.txt
+            mock_exists.side_effect = lambda path: path == "/fake/path"
+            with patch("builtins.open", side_effect=mock_open_func):
+                contexts = generator.get_plugin_contexts()
+                parameters = generator.get_plugin_parameters()
+
+        assert contexts[0].env is not None
+        assert parameters is not None
+        assert parameters[0].id is not None
+        assert parameters[1].id is not None
+        assert parameters[0].id == contexts[0].env[0].value_from_parameter
+        assert parameters[1].id == contexts[0].env[1].value_from_parameter

spaceforge/test_generator_binaries.py

@@ -0,0 +1,194 @@
+"""Tests for PluginGenerator binary handling."""
+
+from typing import Dict, List
+
+import pytest
+
+from spaceforge.cls import Binary
+from spaceforge.generator import PluginGenerator
+from spaceforge.plugin import SpaceforgePlugin
+
+
+class TestPluginGeneratorBinaries:
+    """Test binary extraction and installation command generation."""
+
+    def test_should_extract_binaries_when_defined(self) -> None:
+        """Should extract and return binary list when plugin defines them."""
+
+        # Arrange
+        class BinaryPlugin(SpaceforgePlugin):
+            __binaries__ = [
+                Binary(
+                    name="test-cli",
+                    download_urls={
+                        "amd64": "https://example.com/test-cli-amd64",
+                        "arm64": "https://example.com/test-cli-arm64",
+                    },
+                )
+            ]
+
+        generator = PluginGenerator()
+        generator.plugin_class = BinaryPlugin
+
+        # Act
+        binaries = generator.get_plugin_binaries()
+
+        # Assert
+        assert binaries is not None
+        assert len(binaries) == 1
+        assert binaries[0].name == "test-cli"
+        assert "amd64" in binaries[0].download_urls
+        assert "arm64" in binaries[0].download_urls
+
+    def test_should_return_none_when_no_binaries_defined(self) -> None:
+        """Should return None when plugin has no binaries."""
+
+        # Arrange
+        class NoBinariesPlugin(SpaceforgePlugin):
+            pass
+
+        generator = PluginGenerator()
+        generator.plugin_class = NoBinariesPlugin
+
+        # Act
+        binaries = generator.get_plugin_binaries()
+
+        # Assert
+        assert binaries is None
+
+    def test_should_generate_binary_install_command_for_multi_arch(self) -> None:
+        """Should generate installation commands for multiple architectures."""
+
+        # Arrange
+        class MultiArchPlugin(SpaceforgePlugin):
+            __binaries__ = [
+                Binary(
+                    name="multi-cli",
+                    download_urls={
+                        "amd64": "https://example.com/multi-cli-amd64",
+                        "arm64": "https://example.com/multi-cli-arm64",
+                    },
+                )
+            ]
+
+        generator = PluginGenerator()
+        generator.plugin_class = MultiArchPlugin
+        generator.plugin_working_directory = "/mnt/workspace/plugins/multiarch"
+        generator.config = {
+            "setup_virtual_env": "cd /mnt/workspace/plugins/multiarch && python -m venv ./venv && source venv/bin/activate && pip install spaceforge",
+            "plugin_mounted_path": "/mnt/workspace/plugins/multiarch/plugin.py",
+        }
+
+        hooks: Dict[str, List[str]] = {"before_init": []}
+        mounted_files: List = []
+
+        # Act
+        generator._generate_binary_install_command(hooks, mounted_files)
+
+        # Assert
+        # Should have added a script execution to hooks
+        assert len(hooks["before_init"]) == 1
+        command = hooks["before_init"][0]
+
+        # Should have added a mounted file with script content
+        assert len(mounted_files) == 1
+        script_content = mounted_files[0].content
+
+        # Check that hook command runs the script
+        assert "chmod +x" in command
+        assert "binary_install_multi-cli.sh" in command
+
+        # Check script content contains binary installation logic
+        assert "multi-cli" in script_content
+        assert "https://example.com/multi-cli-amd64" in script_content
+        assert "https://example.com/multi-cli-arm64" in script_content
+
+    def test_should_not_add_commands_when_no_binaries(self) -> None:
+        """Should not add installation commands when plugin has no binaries."""
+
+        # Arrange
+        class NoBinariesPlugin(SpaceforgePlugin):
+            pass
+
+        generator = PluginGenerator()
+        generator.plugin_class = NoBinariesPlugin
+        generator.plugin_working_directory = "/mnt/workspace/plugins/nobinaries"
+        generator.config = {
+            "setup_virtual_env": "cd /mnt/workspace/plugins/nobinaries && python -m venv ./venv && source venv/bin/activate && pip install spaceforge",
+            "plugin_mounted_path": "/mnt/workspace/plugins/nobinaries/plugin.py",
+        }
+
+        hooks: Dict[str, List[str]] = {"before_init": []}
+        mounted_files: List = []
+
+        # Act
+        generator._generate_binary_install_command(hooks, mounted_files)
+
+        # Assert
+        # No binaries should mean no new commands or files added
+        assert len(hooks["before_init"]) == 0
+        assert len(mounted_files) == 0
+
+    def test_should_raise_error_when_binary_has_no_download_urls(self) -> None:
+        """Should raise ValueError when binary has empty download URLs."""
+
+        # Arrange
+        class InvalidBinaryPlugin(SpaceforgePlugin):
+            __binaries__ = [Binary(name="invalid", download_urls={})]
+
+        generator = PluginGenerator()
+        generator.plugin_class = InvalidBinaryPlugin
+        generator.plugin_working_directory = "/mnt/workspace/plugins/invalidbinary"
+        generator.config = {
+            "setup_virtual_env": "cd /mnt/workspace/plugins/invalidbinary && python -m venv ./venv && source venv/bin/activate && pip install spaceforge",
+            "plugin_mounted_path": "/mnt/workspace/plugins/invalidbinary/plugin.py",
+        }
+
+        hooks: Dict[str, List[str]] = {"before_init": []}
+        mounted_files: List = []
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="must have at least one download URL"):
+            generator._generate_binary_install_command(hooks, mounted_files)
+
+    def test_should_handle_single_architecture_binary(self) -> None:
+        """Should generate appropriate commands for single architecture binary."""
+
+        # Arrange
+        class SingleArchPlugin(SpaceforgePlugin):
+            __binaries__ = [
+                Binary(
+                    name="single-arch",
+                    download_urls={"amd64": "https://example.com/binary-amd64"},
+                )
+            ]
+
+        generator = PluginGenerator()
+        generator.plugin_class = SingleArchPlugin
+        generator.plugin_working_directory = "/mnt/workspace/plugins/singlearch"
+        generator.config = {
+            "setup_virtual_env": "cd /mnt/workspace/plugins/singlearch && python -m venv ./venv && source venv/bin/activate && pip install spaceforge",
+            "plugin_mounted_path": "/mnt/workspace/plugins/singlearch/plugin.py",
+        }
+
+        hooks: Dict[str, List[str]] = {"before_init": []}
+        mounted_files: List = []
+
+        # Act
+        generator._generate_binary_install_command(hooks, mounted_files)
+
+        # Assert
+        # Should have added a script execution to hooks
+        assert len(hooks["before_init"]) == 1
+        command = hooks["before_init"][0]
+
+        # Should have added a mounted file with script content
+        assert len(mounted_files) == 1
+        script_content = mounted_files[0].content
+
+        # Check that hook command runs the script
+        assert "chmod +x" in command
+        assert "binary_install_single-arch.sh" in command
+
+        # Check script content contains the binary URL
+        assert "https://example.com/binary-amd64" in script_content