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

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)

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._api_endpoint 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._api_endpoint == "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._api_endpoint == "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._api_endpoint == "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._api_endpoint = "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._api_endpoint = "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._api_endpoint = "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