spaceforge 0.0.2__py3-none-any.whl → 0.0.3__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 Dict, List
 from unittest.mock import Mock, mock_open, patch
 
 import pytest
@@ -318,8 +318,15 @@ 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",
+        }
 
-        command = generator.generate_binary_install_command()
+        hooks: Dict[str, List[str]] = {"before_init": []}
+        generator._generate_binary_install_command(hooks)
+        command = hooks["before_init"][-1]
 
         assert "mkdir -p /mnt/workspace/plugins/plugin_binaries" in command
         assert "curl https://example.com/test-cli-amd64" in command
@@ -335,9 +342,16 @@ class NotAPlugin:
 
         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",
+        }
 
-        command = generator.generate_binary_install_command()
-        assert command == ""
+        hooks: Dict[str, List[str]] = {"before_init": []}
+        generator._generate_binary_install_command(hooks)
+        # No binaries should mean no new commands added
+        assert len(hooks["before_init"]) == 0
 
     def test_generate_binary_install_command_missing_urls(self) -> None:
         """Test binary command generation with missing URLs."""
@@ -347,9 +361,15 @@ 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": []}
         with pytest.raises(ValueError, match="must have at least one download URL"):
-            generator.generate_binary_install_command()
+            generator._generate_binary_install_command(hooks)
 
     def test_get_plugin_policies(self) -> None:
         """Test policy extraction."""
@@ -389,6 +409,10 @@ class NotAPlugin:
         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()
 
@@ -426,6 +450,10 @@ class NotAPlugin:
         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"]
@@ -447,16 +475,21 @@ class NotAPlugin:
         # Should have spacepy runner hooks
         assert context.hooks is not None
         assert "after_plan" in context.hooks
-        runner_command = context.hooks["after_plan"][0]
+        runner_command = context.hooks["after_plan"][1]
         assert "python -m spaceforge runner" in runner_command
         assert "after_plan" in runner_command
 
     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 +507,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 +533,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,8 +639,15 @@ 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",
+        }
 
-        command = generator.generate_binary_install_command()
+        hooks: Dict[str, List[str]] = {"before_init": []}
+        generator._generate_binary_install_command(hooks)
+        command = hooks["before_init"][-1]
 
         assert "https://example.com/binary-amd64" in command
         assert "arm64 binary not available" in command
@@ -638,6 +678,10 @@ 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",
+        }
 
         with patch("os.path.exists") as mock_exists:
             # Only plugin file exists, not requirements.txt
@@ -669,3 +713,70 @@ class TestPluginGeneratorEdgeCases:
         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",
+        }
+
+        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")):
+                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,167 @@
+"""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": []}
+
+        # Act
+        generator._generate_binary_install_command(hooks)
+        command = hooks["before_init"][-1]
+
+        # Assert
+        assert "mkdir -p /mnt/workspace/plugins/plugin_binaries" in command
+        assert "curl https://example.com/multi-cli-amd64" in command
+        assert "curl https://example.com/multi-cli-arm64" in command
+        assert "arch" in command
+        assert "x86_64" in command
+
+    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": []}
+
+        # Act
+        generator._generate_binary_install_command(hooks)
+
+        # Assert
+        assert len(hooks["before_init"]) == 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": []}
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="must have at least one download URL"):
+            generator._generate_binary_install_command(hooks)
+
+    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": []}
+
+        # Act
+        generator._generate_binary_install_command(hooks)
+        command = hooks["before_init"][-1]
+
+        # Assert
+        assert "https://example.com/binary-amd64" in command
+        assert "arm64 binary not available" in command

spaceforge/test_generator_core.py

@@ -0,0 +1,180 @@
+"""Tests for PluginGenerator core functionality."""
+
+import os
+from unittest.mock import Mock, patch
+
+import pytest
+
+from spaceforge.generator import PluginGenerator
+from spaceforge.plugin import SpaceforgePlugin
+
+
+class TestPluginGeneratorInitialization:
+    """Test PluginGenerator initialization and configuration."""
+
+    def test_should_initialize_with_custom_paths(self) -> None:
+        """Should accept and store custom plugin and output paths."""
+        # Arrange & Act
+        generator = PluginGenerator("custom_plugin.py", "custom_output.yaml")
+
+        # Assert
+        assert generator.plugin_path == "custom_plugin.py"
+        assert generator.output_path == "custom_output.yaml"
+        assert generator.plugin_class is None
+        assert generator.plugin_instance is None
+        assert generator.plugin_working_directory is None
+
+    def test_should_use_defaults_when_no_paths_provided(self) -> None:
+        """Should use default paths when none specified."""
+        # Arrange & Act
+        generator = PluginGenerator()
+
+        # Assert
+        assert generator.plugin_path == "plugin.py"
+        assert generator.output_path == "plugin.yaml"
+
+
+class TestPluginGeneratorLoading:
+    """Test plugin file loading functionality."""
+
+    def test_should_raise_file_not_found_when_plugin_file_missing(self) -> None:
+        """Should raise FileNotFoundError when plugin file doesn't exist."""
+        # Arrange
+        generator = PluginGenerator("nonexistent.py")
+
+        # Act & Assert
+        with pytest.raises(FileNotFoundError, match="Plugin file not found"):
+            generator.load_plugin()
+
+    def test_should_raise_exception_when_plugin_file_has_syntax_errors(
+        self, temp_dir: str
+    ) -> None:
+        """Should raise exception when plugin file has invalid Python syntax."""
+        # Arrange
+        invalid_path = os.path.join(temp_dir, "invalid.py")
+        with open(invalid_path, "w") as f:
+            f.write("invalid python syntax }")
+
+        generator = PluginGenerator(invalid_path)
+
+        # Act & Assert
+        with pytest.raises(Exception):  # Could be syntax error or import error
+            generator.load_plugin()
+
+    def test_should_raise_value_error_when_no_spaceforge_plugin_found(
+        self, temp_dir: str
+    ) -> None:
+        """Should raise ValueError when file has no SpaceforgePlugin subclass."""
+        # Arrange
+        no_plugin_path = os.path.join(temp_dir, "no_plugin.py")
+        with open(no_plugin_path, "w") as f:
+            f.write(
+                """
+class NotAPlugin:
+    pass
+"""
+            )
+
+        generator = PluginGenerator(no_plugin_path)
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="No SpaceforgePlugin subclass found"):
+            generator.load_plugin()
+
+    def test_should_load_plugin_successfully_when_valid_file_provided(
+        self, test_plugin_file: str
+    ) -> None:
+        """Should successfully load plugin from valid file."""
+        # Arrange
+        generator = PluginGenerator(test_plugin_file)
+
+        # Act
+        generator.load_plugin()
+
+        # Assert
+        assert generator.plugin_class is not None
+        assert generator.plugin_instance is not None
+        assert generator.plugin_class.__name__ == "TestPlugin"
+        assert generator.plugin_working_directory == "/mnt/workspace/plugins/test"
+
+    @patch("spaceforge.generator.importlib.util.spec_from_file_location")
+    def test_should_raise_import_error_when_spec_is_none(
+        self, mock_spec: Mock, test_plugin_file: str
+    ) -> None:
+        """Should raise ImportError when importlib spec creation fails."""
+        # Arrange
+        mock_spec.return_value = None
+        generator = PluginGenerator(test_plugin_file)
+
+        # Act & Assert
+        with pytest.raises(ImportError, match="Could not load plugin"):
+            generator.load_plugin()
+
+
+class TestPluginGeneratorMetadata:
+    """Test metadata extraction functionality."""
+
+    def test_should_extract_complete_metadata_when_all_attributes_present(self) -> None:
+        """Should extract all metadata when plugin has complete attributes."""
+
+        # Arrange
+        class CompletePlugin(SpaceforgePlugin):
+            """Complete test plugin."""
+
+            __plugin_name__ = "complete_test"
+            __version__ = "2.0.0"
+            __author__ = "Test Author"
+
+        generator = PluginGenerator()
+        generator.plugin_class = CompletePlugin
+
+        # Act
+        metadata = generator.get_plugin_metadata()
+
+        # Assert
+        assert metadata["name_prefix"] == "complete_test"
+        assert metadata["version"] == "2.0.0"
+        assert metadata["author"] == "Test Author"
+        assert metadata["description"] == "Complete test plugin."
+
+    def test_should_use_defaults_when_metadata_attributes_missing(self) -> None:
+        """Should use default values when plugin metadata attributes are missing."""
+
+        # Arrange
+        class MinimalPlugin(SpaceforgePlugin):
+            pass
+
+        generator = PluginGenerator()
+        generator.plugin_class = MinimalPlugin
+
+        # Act
+        metadata = generator.get_plugin_metadata()
+
+        # Assert
+        assert metadata["name_prefix"] == "SpaceforgePlugin"  # inherited
+        assert metadata["version"] == "1.0.0"  # inherited from base
+        assert metadata["author"] == "Spacelift Team"  # inherited from base
+        assert "MinimalPlugin" in metadata["description"]
+
+    def test_should_generate_name_from_class_name_when_plugin_name_missing(
+        self,
+    ) -> None:
+        """Should derive name from class name when __plugin_name__ not set."""
+
+        # Arrange
+        class MinimalPlugin:  # Don't inherit from SpaceforgePlugin
+            __name__ = "MinimalPlugin"
+
+        generator = PluginGenerator()
+        generator.plugin_class = MinimalPlugin  # type: ignore[assignment]
+
+        # Act
+        metadata = generator.get_plugin_metadata()
+
+        # Assert
+        assert (
+            metadata["name_prefix"] == "minimal"
+        )  # class name lowercased with 'plugin' removed
+        assert metadata["version"] == "1.0.0"  # default
+        assert metadata["author"] == "Unknown"  # default
+        assert "MinimalPlugin" in metadata["description"]

spaceforge/test_generator_hooks.py

@@ -0,0 +1,90 @@
+"""Tests for PluginGenerator hook detection."""
+
+import os
+
+from pytest import MonkeyPatch
+
+from spaceforge.generator import PluginGenerator
+from spaceforge.plugin import SpaceforgePlugin
+
+
+class TestPluginGeneratorHooks:
+    """Test hook method detection functionality."""
+
+    def test_should_detect_overridden_hook_methods(self) -> None:
+        """Should identify hook methods that have been overridden in plugin."""
+
+        # Arrange
+        class HookedPlugin(SpaceforgePlugin):
+            def after_plan(self) -> None:
+                pass
+
+            def before_apply(self) -> None:
+                pass
+
+        generator = PluginGenerator()
+        generator.plugin_class = HookedPlugin
+
+        # Act
+        hooks = generator.get_available_hooks()
+
+        # Assert
+        assert "after_plan" in hooks
+        assert "before_apply" in hooks
+        assert len(hooks) == 2
+
+    def test_should_return_empty_list_when_no_hooks_overridden(self) -> None:
+        """Should return empty list when plugin has no overridden hook methods."""
+
+        # Arrange
+        class NoHooksPlugin(SpaceforgePlugin):
+            pass
+
+        generator = PluginGenerator()
+        generator.plugin_class = NoHooksPlugin
+
+        # Act
+        hooks = generator.get_available_hooks()
+
+        # Assert
+        assert hooks == []
+
+    def test_contexts_should_not_have_duplicates_pip_install_in_hooks(
+        self, temp_dir: str, monkeypatch: MonkeyPatch
+    ) -> None:
+        """Should not have duplicate hook methods in the list."""
+
+        # Arrange
+        plugin_content = """
+from spaceforge import SpaceforgePlugin
+class DuplicateHooksPlugin(SpaceforgePlugin):
+    def before_init(self) -> None:
+        pass
+        """
+
+        requirements_content = """
+requests
+        """
+
+        plugin_path = os.path.join(temp_dir, "plugin.py")
+        with open(plugin_path, "w") as f:
+            f.write(plugin_content)
+        with open(os.path.join(temp_dir, "requirements.txt"), "w") as f:
+            f.write(requirements_content)
+
+        # Change to temporary directory (automatically restored after test)
+        monkeypatch.chdir(temp_dir)
+
+        generator = PluginGenerator(plugin_path)
+        generator.load_plugin()
+
+        # Act
+        contexts = generator.get_plugin_contexts()
+        hooks = contexts[0].hooks
+        assert hooks is not None
+
+        # Assert
+        processed_hooks = []
+        for hook in hooks["before_init"]:
+            assert hook not in processed_hooks
+            processed_hooks.append(hook)