spaceforge 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

spaceforge/test_generator_parameters.py

@@ -0,0 +1,59 @@
+"""Tests for PluginGenerator parameter handling."""
+
+from spaceforge.cls import Parameter
+from spaceforge.generator import PluginGenerator
+from spaceforge.plugin import SpaceforgePlugin
+
+
+class TestPluginGeneratorParameters:
+    """Test parameter extraction and processing."""
+
+    def test_should_extract_parameters_when_defined(self) -> None:
+        """Should extract and return parameter list when plugin defines them."""
+
+        # Arrange
+        class ParameterizedPlugin(SpaceforgePlugin):
+            __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",
+                ),
+            ]
+
+        generator = PluginGenerator()
+        generator.plugin_class = ParameterizedPlugin
+
+        # Act
+        parameters = generator.get_plugin_parameters()
+
+        # Assert
+        assert parameters is not None
+        assert len(parameters) == 2
+        assert parameters[0].name == "api_key"
+        assert parameters[0].sensitive is True
+        assert parameters[1].name == "endpoint"
+        assert parameters[1].default == "https://api.example.com"
+
+    def test_should_return_none_when_no_parameters_defined(self) -> None:
+        """Should return None when plugin has no parameters."""
+
+        # Arrange
+        class NoParamsPlugin(SpaceforgePlugin):
+            pass
+
+        generator = PluginGenerator()
+        generator.plugin_class = NoParamsPlugin
+
+        # Act
+        parameters = generator.get_plugin_parameters()
+
+        # Assert
+        assert parameters is None

spaceforge/test_plugin.py

@@ -0,0 +1,357 @@
+import json
+import logging
+import os
+import subprocess
+from typing import Dict
+from unittest.mock import Mock, patch
+
+import pytest
+
+from spaceforge.plugin import SpaceforgePlugin
+
+
+class TestSpaceforgePluginInitialization:
+    """Test SpaceforgePlugin initialization and configuration."""
+
+    def test_should_initialize_with_defaults_when_no_environment_set(self) -> None:
+        """Should set default values when no environment variables are provided."""
+        # Arrange & Act
+        with patch.dict(os.environ, {}, clear=True):
+            plugin = SpaceforgePlugin()
+
+        # Assert
+        assert plugin._api_token is False
+        assert plugin._spacelift_domain is False
+        assert plugin._api_enabled is False
+        assert plugin._workspace_root == os.getcwd()
+        assert isinstance(plugin.logger, logging.Logger)
+
+    def test_should_enable_api_when_valid_credentials_provided(
+        self, mock_env: Dict[str, str]
+    ) -> None:
+        """Should enable API access when both token and endpoint are provided."""
+        # Arrange & Act
+        with patch.dict(os.environ, mock_env, clear=True):
+            plugin = SpaceforgePlugin()
+
+        # Assert
+        assert plugin._api_token == "test_token"
+        assert plugin._spacelift_domain == "https://test.spacelift.io"
+        assert plugin._api_enabled is True
+        assert plugin._workspace_root == os.getcwd()
+
+    def test_should_normalize_domain_with_trailing_slash(self) -> None:
+        """Should remove trailing slash from domain URL."""
+        # Arrange
+        test_env = {
+            "SPACELIFT_API_TOKEN": "test_token",
+            "TF_VAR_spacelift_graphql_endpoint": "https://test.spacelift.io/",
+        }
+
+        # Act
+        with patch.dict(os.environ, test_env, clear=True):
+            plugin = SpaceforgePlugin()
+
+        # Assert
+        assert plugin._spacelift_domain == "https://test.spacelift.io"
+        assert plugin._api_enabled is True
+
+    def test_should_disable_api_when_domain_has_no_https_prefix(self) -> None:
+        """Should disable API when domain doesn't use HTTPS."""
+        # Arrange
+        test_env = {
+            "SPACELIFT_API_TOKEN": "test_token",
+            "TF_VAR_spacelift_graphql_endpoint": "test.spacelift.io",
+        }
+
+        # Act
+        with patch.dict(os.environ, test_env, clear=True):
+            plugin = SpaceforgePlugin()
+
+        # Assert
+        assert plugin._spacelift_domain == "test.spacelift.io"
+        assert plugin._api_enabled is False
+
+    def test_should_disable_api_when_only_token_provided(self) -> None:
+        """Should disable API when only token is provided without domain."""
+        # Arrange & Act
+        with patch.dict(os.environ, {"SPACELIFT_API_TOKEN": "test_token"}, clear=True):
+            plugin = SpaceforgePlugin()
+
+        # Assert
+        assert plugin._api_enabled is False
+
+    def test_should_disable_api_when_only_domain_provided(self) -> None:
+        """Should disable API when only domain is provided without token."""
+        # Arrange & Act
+        with patch.dict(
+            os.environ,
+            {"TF_VAR_spacelift_graphql_endpoint": "https://test.spacelift.io"},
+            clear=True,
+        ):
+            plugin = SpaceforgePlugin()
+
+        # Assert
+        assert plugin._api_enabled is False
+
+
+class TestSpaceforgePluginLogging:
+    """Test logging configuration and functionality."""
+
+    def test_should_configure_logger_with_correct_name_and_level(self) -> None:
+        """Should set up logger with proper name and level."""
+        # Arrange & Act
+        with patch.dict(os.environ, {}, clear=True):
+            plugin = SpaceforgePlugin()
+
+        # Assert
+        assert plugin.logger.name == "spaceforge.SpaceforgePlugin"
+        assert len(plugin.logger.handlers) >= 1
+        assert plugin.logger.getEffectiveLevel() <= logging.INFO
+
+    def test_should_enable_debug_logging_when_debug_env_set(self) -> None:
+        """Should set DEBUG level when SPACELIFT_DEBUG environment variable is true."""
+        # Arrange
+        test_env = {"SPACELIFT_DEBUG": "true"}
+
+        # Act
+        with patch.dict(os.environ, test_env, clear=True):
+            plugin = SpaceforgePlugin()
+
+        # Assert
+        assert plugin.logger.level == logging.DEBUG
+
+    def test_should_include_run_id_in_log_format(self) -> None:
+        """Should include run ID in log message format when available."""
+        # Arrange
+        test_env = {"TF_VAR_spacelift_run_id": "run-123"}
+
+        # Act
+        with patch.dict(os.environ, test_env, clear=True):
+            plugin = SpaceforgePlugin()
+            formatter = plugin.logger.handlers[0].formatter
+
+            record = logging.LogRecord(
+                name="test",
+                level=logging.INFO,
+                pathname="",
+                lineno=0,
+                msg="test message",
+                args=(),
+                exc_info=None,
+            )
+            record.levelname = "INFO"
+
+        # Assert
+        assert formatter is not None
+        formatted = formatter.format(record)
+        assert "[run-123]" in formatted or "[local]" in formatted
+
+    def test_logger_color_formatting(self) -> None:
+        """Test color formatting for different log levels."""
+        plugin = SpaceforgePlugin()
+        formatter = plugin.logger.handlers[0].formatter
+        assert formatter is not None
+
+        # Test different log levels
+        levels_to_test = [
+            (logging.INFO, "INFO"),
+            (logging.DEBUG, "DEBUG"),
+            (logging.WARNING, "WARNING"),
+            (logging.ERROR, "ERROR"),
+        ]
+
+        for level, level_name in levels_to_test:
+            record = logging.LogRecord(
+                name="test",
+                level=level,
+                pathname="",
+                lineno=0,
+                msg="test message",
+                args=(),
+                exc_info=None,
+            )
+            record.levelname = level_name
+            formatted = formatter.format(record)
+
+            # Should contain color codes and plugin name
+            assert "\033[" in formatted  # ANSI color codes
+            assert "(SpaceforgePlugin)" in formatted
+            assert "test message" in formatted
+
+
+# Hook tests moved to test_plugin_hooks.py
+
+
+class TestSpaceforgePluginCLI:
+    """Test command-line interface execution functionality."""
+
+    def test_should_execute_cli_command_and_log_output_on_success(self) -> None:
+        """Should run CLI command and log output when execution succeeds."""
+        # Arrange
+        plugin = SpaceforgePlugin()
+        mock_process = Mock()
+        mock_process.communicate.return_value = (b"success output\n", None)
+        mock_process.returncode = 0
+
+        # Act
+        with patch("subprocess.Popen") as mock_popen:
+            with patch.object(plugin.logger, "info") as mock_info:
+                mock_popen.return_value = mock_process
+                plugin.run_cli("echo", "test")
+
+        # Assert
+        mock_popen.assert_called_once_with(
+            ("echo", "test"), stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+        )
+        mock_info.assert_called_with("success output")
+
+    def test_should_log_error_when_cli_command_fails(self) -> None:
+        """Should log error details when CLI command returns non-zero exit code."""
+        # Arrange
+        plugin = SpaceforgePlugin()
+        mock_process = Mock()
+        mock_process.communicate.return_value = (None, b"error output\n")
+        mock_process.returncode = 1
+
+        # Act
+        with patch("subprocess.Popen") as mock_popen:
+            with patch.object(plugin.logger, "error") as mock_error:
+                mock_popen.return_value = mock_process
+                plugin.run_cli("false")
+
+        # Assert
+        mock_error.assert_any_call("Command failed with return code 1")
+        mock_error.assert_any_call("error output")
+
+    def test_run_cli_with_multiple_args(self) -> None:
+        """Test CLI command with multiple arguments."""
+        plugin = SpaceforgePlugin()
+
+        with patch("subprocess.Popen") as mock_popen:
+            mock_process = Mock()
+            mock_process.communicate.return_value = (b"", None)
+            mock_process.returncode = 0
+            mock_popen.return_value = mock_process
+
+            with patch.object(plugin.logger, "debug") as mock_debug:
+                plugin.run_cli("git", "status", "--porcelain")
+
+            mock_popen.assert_called_once_with(
+                ("git", "status", "--porcelain"),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+            )
+            mock_debug.assert_called_with("Running CLI command: git status --porcelain")
+
+
+class TestSpaceforgePluginAPI:
+    """Test GraphQL API interaction functionality."""
+
+    def test_should_exit_with_error_when_api_disabled(self) -> None:
+        """Should exit with error message when API is not enabled."""
+        # Arrange
+        plugin = SpaceforgePlugin()
+        plugin._api_enabled = False
+
+        # Act & Assert
+        with patch.object(plugin.logger, "error") as mock_error:
+            with pytest.raises(SystemExit):
+                plugin.query_api("query { test }")
+
+        mock_error.assert_called_with(
+            'API is not enabled, please export "SPACELIFT_API_TOKEN" and "TF_VAR_spacelift_graphql_endpoint".'
+        )
+
+    def test_should_make_successful_api_request_with_correct_format(
+        self, mock_api_response: Mock
+    ) -> None:
+        """Should execute GraphQL query with proper authentication and format."""
+        # Arrange
+        plugin = SpaceforgePlugin()
+        plugin._api_enabled = True
+        plugin._api_token = "test_token"
+        plugin._spacelift_domain = "https://test.spacelift.io"
+
+        expected_data = {"data": {"test": "result"}}
+        mock_api_response.read.return_value = json.dumps(expected_data).encode("utf-8")
+
+        # Act
+        with patch("urllib.request.urlopen") as mock_urlopen:
+            with patch("urllib.request.Request") as mock_request:
+                mock_urlopen.return_value.__enter__ = Mock(
+                    return_value=mock_api_response
+                )
+                mock_urlopen.return_value.__exit__ = Mock(return_value=None)
+
+                result = plugin.query_api("query { test }")
+
+        # Assert
+        mock_request.assert_called_once()
+        call_args = mock_request.call_args[0]
+        assert call_args[0] == "https://test.spacelift.io"
+
+        request_data = json.loads(call_args[1].decode("utf-8"))
+        assert request_data["query"] == "query { test }"
+
+        headers = mock_request.call_args[0][2]
+        assert headers["Content-Type"] == "application/json"
+        assert headers["Authorization"] == "Bearer test_token"
+
+        assert result == expected_data
+
+    def test_query_api_with_variables(self) -> None:
+        """Test API query with variables."""
+        plugin = SpaceforgePlugin()
+        plugin._api_enabled = True
+        plugin._api_token = "test_token"
+        plugin._spacelift_domain = "https://test.spacelift.io"
+
+        mock_response_data = {"data": {"test": "result"}}
+        mock_response = Mock()
+        mock_response.read.return_value = json.dumps(mock_response_data).encode("utf-8")
+
+        variables = {"stackId": "test-stack"}
+
+        with patch("urllib.request.urlopen") as mock_urlopen:
+            with patch("urllib.request.Request") as mock_request:
+                mock_urlopen.return_value.__enter__ = Mock(return_value=mock_response)
+                mock_urlopen.return_value.__exit__ = Mock(return_value=None)
+
+                plugin.query_api(
+                    "query ($stackId: ID!) { stack(id: $stackId) { name } }", variables
+                )
+
+        # Verify request data includes variables
+        request_data = json.loads(mock_request.call_args[0][1].decode("utf-8"))
+        assert request_data["variables"] == variables
+
+    def test_query_api_with_errors(self) -> None:
+        """Test API query that returns errors."""
+        plugin = SpaceforgePlugin()
+        plugin._api_enabled = True
+        plugin._api_token = "test_token"
+        plugin._spacelift_domain = "https://test.spacelift.io"
+
+        mock_response_data = {"errors": [{"message": "Test error"}]}
+        mock_response = Mock()
+        mock_response.read.return_value = json.dumps(mock_response_data).encode("utf-8")
+
+        with patch("urllib.request.urlopen") as mock_urlopen:
+            with patch.object(plugin.logger, "error") as mock_error:
+                mock_urlopen.return_value.__enter__ = Mock(return_value=mock_response)
+                mock_urlopen.return_value.__exit__ = Mock(return_value=None)
+
+                result = plugin.query_api("query { test }")
+
+        mock_error.assert_called_with("Error: [{'message': 'Test error'}]")
+        assert result == mock_response_data
+
+
+# File operation tests moved to test_plugin_file_operations.py
+
+
+# Inheritance tests moved to test_plugin_inheritance.py
+
+
+# Edge case tests moved to test_plugin_inheritance.py

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