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

spaceforge/test_plugin_file_operations.py

@@ -0,0 +1,118 @@
+"""Tests for SpaceforgePlugin file operation methods."""
+
+import json
+import os
+from typing import Any, Dict
+from unittest.mock import patch
+
+import pytest
+
+from spaceforge.plugin import SpaceforgePlugin
+
+
+class TestSpaceforgePluginFileOperations:
+    """Test file reading and parsing functionality."""
+
+    def test_should_return_plan_data_when_plan_file_exists(self, temp_dir: str) -> None:
+        """Should parse and return plan JSON when file exists and is valid."""
+        # Arrange
+        plugin = SpaceforgePlugin()
+        plugin._workspace_root = temp_dir
+        plan_data = {"resource_changes": [{"type": "create"}]}
+        plan_path = os.path.join(temp_dir, "spacelift.plan.json")
+
+        with open(plan_path, "w") as f:
+            json.dump(plan_data, f)
+
+        # Act
+        result = plugin.get_plan_json()
+
+        # Assert
+        assert result == plan_data
+
+    def test_should_return_none_and_log_error_when_plan_file_missing(
+        self, temp_dir: str
+    ) -> None:
+        """Should return None and log error when plan file doesn't exist."""
+        # Arrange
+        plugin = SpaceforgePlugin()
+        plugin._workspace_root = temp_dir
+
+        # Act
+        with patch.object(plugin.logger, "error") as mock_error:
+            result = plugin.get_plan_json()
+
+        # Assert
+        assert result is None
+        mock_error.assert_called_with("spacelift.plan.json does not exist.")
+
+    def test_should_raise_json_decode_error_when_plan_file_invalid(
+        self, temp_dir: str
+    ) -> None:
+        """Should raise JSONDecodeError when plan file contains invalid JSON."""
+        # Arrange
+        plugin = SpaceforgePlugin()
+        plugin._workspace_root = temp_dir
+        plan_path = os.path.join(temp_dir, "spacelift.plan.json")
+
+        with open(plan_path, "w") as f:
+            f.write("invalid json {")
+
+        # Act & Assert
+        with pytest.raises(json.JSONDecodeError):
+            plugin.get_plan_json()
+
+    def test_should_return_state_data_when_state_file_exists(
+        self, temp_dir: str
+    ) -> None:
+        """Should parse and return state JSON when file exists and is valid."""
+        # Arrange
+        plugin = SpaceforgePlugin()
+        plugin._workspace_root = temp_dir
+        state_data: Dict[str, Any] = {"values": {"root_module": {}}}
+        state_path = os.path.join(temp_dir, "spacelift.state.before.json")
+
+        with open(state_path, "w") as f:
+            json.dump(state_data, f)
+
+        # Act
+        result = plugin.get_state_before_json()
+
+        # Assert
+        assert result == state_data
+
+    def test_should_return_none_and_log_error_when_state_file_missing(
+        self, temp_dir: str
+    ) -> None:
+        """Should return None and log error when state file doesn't exist."""
+        # Arrange
+        plugin = SpaceforgePlugin()
+        plugin._workspace_root = temp_dir
+
+        # Act
+        with patch.object(plugin.logger, "error") as mock_error:
+            result = plugin.get_state_before_json()
+
+        # Assert
+        assert result is None
+        mock_error.assert_called_with("spacelift.state.before.json does not exist.")
+
+    def test_custom_policy_input(
+        self, temp_dir: str, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Should return custom policy input when file exists."""
+        # Arrange
+        monkeypatch.chdir(temp_dir)
+        plugin = SpaceforgePlugin()
+        plugin._is_local = False
+        plugin._workspace_root = temp_dir
+        custom_policy_data = {"test": "input"}
+
+        # Act
+        plugin.add_to_policy_input("test", custom_policy_data)
+
+        with open(temp_dir + "/test.custom.spacelift.json", "r") as f:
+            policy_data = json.load(f)
+
+        # Assert
+        assert policy_data == custom_policy_data

spaceforge/test_plugin_hooks.py

@@ -0,0 +1,100 @@
+"""Tests for SpaceforgePlugin hook system."""
+
+from spaceforge.plugin import SpaceforgePlugin
+
+
+class TestSpaceforgePluginHooks:
+    """Test hook method detection and execution."""
+
+    def test_should_provide_all_expected_hook_methods(self) -> None:
+        """Should define all standard Spacelift hook methods as callable."""
+        # Arrange
+        plugin = SpaceforgePlugin()
+        expected_hooks = [
+            "before_init",
+            "after_init",
+            "before_plan",
+            "after_plan",
+            "before_apply",
+            "after_apply",
+            "before_perform",
+            "after_perform",
+            "before_destroy",
+            "after_destroy",
+            "after_run",
+        ]
+
+        # Act & Assert
+        for hook_name in expected_hooks:
+            assert hasattr(plugin, hook_name)
+            hook_method = getattr(plugin, hook_name)
+            assert callable(hook_method)
+            # Should be able to call without error (default implementation is pass)
+            hook_method()
+
+    def test_should_return_all_available_hooks_for_base_class(self) -> None:
+        """Should detect and return all hook methods defined in base class."""
+        # Arrange
+        plugin = SpaceforgePlugin()
+        expected_hooks = [
+            "before_init",
+            "after_init",
+            "before_plan",
+            "after_plan",
+            "before_apply",
+            "after_apply",
+            "before_perform",
+            "after_perform",
+            "before_destroy",
+            "after_destroy",
+            "after_run",
+        ]
+
+        # Act
+        hooks = plugin.get_available_hooks()
+
+        # Assert
+        for expected_hook in expected_hooks:
+            assert expected_hook in hooks
+
+    def test_should_detect_overridden_hooks_in_custom_plugin(self) -> None:
+        """Should include all hooks including overridden ones in custom plugins."""
+
+        # Arrange
+        class TestPluginWithHooks(SpaceforgePlugin):
+            def after_plan(self) -> None:
+                pass
+
+            def before_apply(self) -> None:
+                pass
+
+            def custom_method(self) -> None:  # Not a hook
+                pass
+
+        plugin = TestPluginWithHooks()
+
+        # Act
+        hooks = plugin.get_available_hooks()
+
+        # Assert
+        assert "after_plan" in hooks
+        assert "before_apply" in hooks
+        assert "custom_method" not in hooks  # Not a recognized hook
+
+        # Should still have all the expected hooks from the base class
+        expected_hooks = [
+            "before_init",
+            "after_init",
+            "before_plan",
+            "after_plan",
+            "before_apply",
+            "after_apply",
+            "before_perform",
+            "after_perform",
+            "before_destroy",
+            "after_destroy",
+            "after_run",
+        ]
+
+        for expected_hook in expected_hooks:
+            assert expected_hook in hooks

spaceforge/test_plugin_inheritance.py

@@ -0,0 +1,102 @@
+"""Tests for SpaceforgePlugin inheritance and customization."""
+
+import os
+from typing import Dict
+from unittest.mock import patch
+
+from spaceforge.plugin import SpaceforgePlugin
+
+
+class TestSpaceforgePluginInheritance:
+    """Test custom plugin creation and inheritance patterns."""
+
+    def test_should_support_custom_plugin_with_metadata(self) -> None:
+        """Should allow creation of custom plugins with metadata attributes."""
+
+        # Arrange & Act
+        class CustomPlugin(SpaceforgePlugin):
+            __plugin_name__ = "custom"
+            __version__ = "2.0.0"
+            __author__ = "Custom Author"
+
+            def __init__(self) -> None:
+                super().__init__()
+                self.custom_state = "initialized"
+
+            def after_plan(self) -> None:
+                self.custom_state = "plan_executed"
+
+            def custom_method(self) -> str:
+                return "custom_result"
+
+        plugin = CustomPlugin()
+
+        # Assert
+        assert plugin.__plugin_name__ == "custom"
+        assert plugin.__version__ == "2.0.0"
+        assert plugin.__author__ == "Custom Author"
+        assert plugin.custom_state == "initialized"
+        assert plugin.custom_method() == "custom_result"
+
+        # Test hook override
+        plugin.after_plan()
+        assert plugin.custom_state == "plan_executed"
+
+        # Test inherited functionality
+        assert hasattr(plugin, "logger")
+        assert hasattr(plugin, "run_cli")
+
+    def test_should_support_complex_initialization_logic(self) -> None:
+        """Should allow complex initialization patterns in custom plugins."""
+
+        # Arrange & Act
+        class ComplexPlugin(SpaceforgePlugin):
+            def __init__(self) -> None:
+                super().__init__()
+                self.config = self._load_config()
+                self.initialized = True
+
+            def _load_config(self) -> Dict[str, str]:
+                return {"setting1": "value1", "setting2": "value2"}
+
+            def after_plan(self) -> None:
+                self.config_info = f"Config loaded: {self.config}"
+
+        plugin = ComplexPlugin()
+
+        # Assert
+        assert plugin.initialized is True
+        assert plugin.config == {"setting1": "value1", "setting2": "value2"}
+
+        plugin.after_plan()
+        assert hasattr(plugin, "config_info")
+        assert "Config loaded:" in plugin.config_info
+
+    def test_should_support_environment_variable_access_in_custom_plugins(self) -> None:
+        """Should allow custom plugins to access environment variables."""
+
+        # Arrange
+        class EnvPlugin(SpaceforgePlugin):
+            def get_custom_env(self) -> str:
+                return os.environ.get("CUSTOM_ENV", "default_value")
+
+        plugin = EnvPlugin()
+
+        # Act & Assert - no environment variable
+        assert plugin.get_custom_env() == "default_value"
+
+        # Act & Assert - with environment variable set
+        with patch.dict(os.environ, {"CUSTOM_ENV": "custom_value"}):
+            assert plugin.get_custom_env() == "custom_value"
+
+    def test_should_share_logger_instances_across_plugin_instances(self) -> None:
+        """Should use the same logger instance for multiple plugin instances of same class."""
+        # Arrange & Act
+        plugin1 = SpaceforgePlugin()
+        plugin2 = SpaceforgePlugin()
+
+        # Assert
+        # Python loggers are singletons by name, so they should be the same instance
+        assert plugin1.logger is plugin2.logger
+        assert plugin1.logger.name == "spaceforge.SpaceforgePlugin"
+        assert plugin2.logger.name == "spaceforge.SpaceforgePlugin"

spaceforge/{runner_test.py → test_runner.py}

@@ -1,13 +1,12 @@
 import os
-import sys
 import tempfile
-from typing import Any, Optional
+from typing import Optional
 from unittest.mock import Mock, patch
 
 import pytest
 
 from spaceforge.plugin import SpaceforgePlugin
-from spaceforge.runner import PluginRunner, main, runner_command
+from spaceforge.runner import PluginRunner, runner_command
 
 
 class PluginForTesting(SpaceforgePlugin):
@@ -171,8 +170,8 @@ class NotAPlugin:
         assert "after_plan" in getattr(runner.plugin_instance, "executed_hooks")
 
         # Verify print statements
-        mock_print.assert_any_call("[SPACEPY] Running hook: after_plan")
-        mock_print.assert_any_call("[SPACEPY] Hook completed: after_plan")
+        mock_print.assert_any_call("[SpaceForge] Running hook: after_plan")
+        mock_print.assert_any_call("[SpaceForge] Hook completed: after_plan")
 
     def test_run_hook_not_found(self) -> None:
         """Test running a hook that doesn't exist."""
@@ -211,7 +210,7 @@ class NotAPlugin:
 
         # Should print error message
         mock_print.assert_any_call(
-            "[SPACEPY] Error running hook 'error_hook': Test error from hook"
+            "[SpaceForge] Error running hook 'error_hook': Test error from hook"
         )
 
     def test_run_hook_multiple_hooks(self) -> None:
@@ -363,68 +362,6 @@ class MainTestPlugin(SpaceforgePlugin):
 
         shutil.rmtree(self.temp_dir, ignore_errors=True)
 
-    @patch("spaceforge.runner.PluginRunner")
-    @patch("builtins.print")
-    def test_main_insufficient_args(
-        self, mock_print: Mock, mock_runner_class: Mock
-    ) -> None:
-        """Test main function with insufficient arguments."""
-        original_argv = sys.argv
-        try:
-            sys.argv = ["runner.py"]  # Missing hook_name
-
-            with pytest.raises(SystemExit) as exc_info:
-                main()
-
-            assert exc_info.value.code == 1
-            mock_print.assert_called_with(
-                "Usage: python -m spaceforge.runner <hook_name>"
-            )
-            mock_runner_class.assert_not_called()
-
-        finally:
-            sys.argv = original_argv
-
-    @patch("spaceforge.runner.PluginRunner")
-    @patch("builtins.print")
-    def test_main_too_many_args(
-        self, mock_print: Mock, mock_runner_class: Mock
-    ) -> None:
-        """Test main function with too many arguments."""
-        original_argv = sys.argv
-        try:
-            sys.argv = ["runner.py", "after_plan", "extra_arg"]
-
-            with pytest.raises(SystemExit) as exc_info:
-                main()
-
-            assert exc_info.value.code == 1
-            mock_print.assert_called_with(
-                "Usage: python -m spaceforge.runner <hook_name>"
-            )
-            mock_runner_class.assert_not_called()
-
-        finally:
-            sys.argv = original_argv
-
-    @patch("spaceforge.runner.PluginRunner")
-    def test_main_success(self, mock_runner_class: Mock) -> None:
-        """Test successful main function execution."""
-        mock_runner = Mock()
-        mock_runner_class.return_value = mock_runner
-
-        original_argv = sys.argv
-        try:
-            sys.argv = ["runner.py", "after_plan"]
-
-            main()
-
-            mock_runner_class.assert_called_once_with()
-            mock_runner.run_hook.assert_called_once_with("after_plan")
-
-        finally:
-            sys.argv = original_argv
-
 
 class TestRunnerEdgeCases:
     """Test edge cases and error conditions."""

spaceforge/test_runner_cli.py

@@ -0,0 +1,69 @@
+"""Tests for PluginRunner CLI interface."""
+
+import os
+from unittest.mock import Mock, patch
+
+from spaceforge.runner import runner_command
+
+
+class TestRunnerClickCommand:
+    """Test Click command interface."""
+
+    def test_should_execute_hook_via_click_command(self, temp_dir: str) -> None:
+        """Should execute hook through Click command interface."""
+        # Arrange
+        click_plugin_path = os.path.join(temp_dir, "click_plugin.py")
+        with open(click_plugin_path, "w") as f:
+            f.write(
+                """
+from spaceforge import SpaceforgePlugin
+
+class ClickTestPlugin(SpaceforgePlugin):
+    def after_plan(self):
+        print("Hook executed via click")
+"""
+            )
+
+        # Act
+        from click.testing import CliRunner
+
+        cli_runner = CliRunner()
+
+        with patch("spaceforge.runner.PluginRunner") as mock_runner_class:
+            mock_runner = Mock()
+            mock_runner_class.return_value = mock_runner
+
+            result = cli_runner.invoke(
+                runner_command, ["after_plan", "--plugin-file", click_plugin_path]
+            )
+
+        # Assert
+        assert result.exit_code == 0
+        mock_runner_class.assert_called_once_with(click_plugin_path)
+        mock_runner.run_hook.assert_called_once_with("after_plan")
+
+    def test_should_use_custom_plugin_file_when_specified(self, temp_dir: str) -> None:
+        """Should use specified plugin file path instead of default."""
+        # Arrange
+        custom_plugin_path = os.path.join(temp_dir, "custom_plugin.py")
+        # Create the file since Click validates existence
+        with open(custom_plugin_path, "w") as f:
+            f.write("# dummy plugin file for testing")
+
+        # Act
+        from click.testing import CliRunner
+
+        cli_runner = CliRunner()
+
+        with patch("spaceforge.runner.PluginRunner") as mock_runner_class:
+            mock_runner = Mock()
+            mock_runner_class.return_value = mock_runner
+
+            result = cli_runner.invoke(
+                runner_command, ["before_apply", "--plugin-file", custom_plugin_path]
+            )
+
+        # Assert
+        assert result.exit_code == 0
+        mock_runner_class.assert_called_once_with(custom_plugin_path)
+        mock_runner.run_hook.assert_called_once_with("before_apply")

spaceforge/test_runner_core.py

@@ -0,0 +1,124 @@
+"""Tests for PluginRunner core functionality."""
+
+import os
+from typing import List
+from unittest.mock import Mock, patch
+
+import pytest
+
+from spaceforge.plugin import SpaceforgePlugin
+from spaceforge.runner import PluginRunner
+
+
+class RunnerTestPlugin(SpaceforgePlugin):
+    """Reusable test plugin for runner tests."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.executed_hooks: List[str] = []
+
+    def after_plan(self) -> None:
+        self.executed_hooks.append("after_plan")
+
+    def before_apply(self) -> None:
+        self.executed_hooks.append("before_apply")
+
+    def error_hook(self) -> None:
+        raise ValueError("Test error from hook")
+
+
+class TestPluginRunnerInitialization:
+    """Test PluginRunner initialization and configuration."""
+
+    def test_should_initialize_with_custom_plugin_path(self) -> None:
+        """Should accept and store custom plugin file path."""
+        # Arrange & Act
+        runner = PluginRunner("custom_plugin.py")
+
+        # Assert
+        assert runner.plugin_path == "custom_plugin.py"
+        assert runner.plugin_instance is None
+
+    def test_should_use_default_plugin_path_when_none_provided(self) -> None:
+        """Should use 'plugin.py' as default when no path specified."""
+        # Arrange & Act
+        runner = PluginRunner()
+
+        # Assert
+        assert runner.plugin_path == "plugin.py"
+        assert runner.plugin_instance is None
+
+
+class TestPluginRunnerLoading:
+    """Test plugin 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
+        runner = PluginRunner("nonexistent.py")
+
+        # Act & Assert
+        with pytest.raises(FileNotFoundError, match="Plugin file not found"):
+            runner.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 }")
+
+        runner = PluginRunner(invalid_path)
+
+        # Act & Assert
+        with pytest.raises(Exception):  # Could be syntax error
+            runner.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
+"""
+            )
+
+        runner = PluginRunner(no_plugin_path)
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="No SpaceforgePlugin subclass found"):
+            runner.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
+        runner = PluginRunner(test_plugin_file)
+
+        # Act
+        runner.load_plugin()
+
+        # Assert
+        assert runner.plugin_instance is not None
+        assert runner.plugin_instance.__class__.__name__ == "TestPlugin"
+
+    @patch("spaceforge.runner.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
+        runner = PluginRunner(test_plugin_file)
+
+        # Act & Assert
+        with pytest.raises(ImportError, match="Could not load plugin"):
+            runner.load_plugin()