test: Improve test coverage configuration and parallel execution

pyproject.toml

@@ -124,5 +124,36 @@ module = [
 ]
 ignore_missing_imports = true
 
+[tool.coverage.run]
+parallel = true
+branch = false
+source = ["tetra_rp"]
+omit = [
+    "*/tests/*",
+    "*/test_*.py",
+    "*/__pycache__/*",
+    "*/site-packages/*",
+]
+
+[tool.coverage.report]
+precision = 2
+show_missing = true
+skip_covered = false
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+    "@abstractmethod",
+]
+
+[tool.coverage.paths]
+source = [
+    "src/tetra_rp",
+    "*/site-packages/tetra_rp",
+]
+
 [tool.uv.sources]
 runpod = { git = "https://github.com/runpod/runpod-python", rev = "main" }

src/tetra_rp/core/utils/json.py

@@ -0,0 +1,46 @@
+"""Utilities for normalizing data structures for JSON serialization."""
+
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel
+
+
+def normalize_for_json(obj: Any) -> Any:
+    """Normalize an object for JSON serialization.
+
+    Converts Pydantic models to dicts and Enum values to their values,
+    while recursively processing collections.
+
+    Args:
+        obj: The object to normalize.
+
+    Returns:
+        A JSON-serializable version of the object.
+    """
+    # Handle primitives
+    if obj is None or isinstance(obj, (bool, int, float, str)):
+        return obj
+
+    # Handle Enum
+    if isinstance(obj, Enum):
+        return obj.value
+
+    # Handle Pydantic BaseModel
+    if isinstance(obj, BaseModel):
+        return normalize_for_json(obj.model_dump())
+
+    # Handle dict
+    if isinstance(obj, dict):
+        return {key: normalize_for_json(value) for key, value in obj.items()}
+
+    # Handle tuple
+    if isinstance(obj, tuple):
+        return tuple(normalize_for_json(item) for item in obj)
+
+    # Handle list
+    if isinstance(obj, list):
+        return [normalize_for_json(item) for item in obj]
+
+    # For any other type, return as-is
+    return obj

tests/unit/cli/commands/test_init.py

@@ -0,0 +1,240 @@
+"""Tests for flash init command."""
+
+from unittest.mock import MagicMock, Mock, patch
+
+import pytest
+
+from tetra_rp.cli.commands.init import init_command
+
+
+@pytest.fixture
+def mock_context(monkeypatch):
+    """Set up mocks for init command testing."""
+    mocks = {
+        "console": MagicMock(),
+        "detect_conflicts": MagicMock(return_value=[]),
+        "create_skeleton": MagicMock(),
+    }
+
+    mocks["console"].status = MagicMock()
+    mocks["console"].status.return_value.__enter__ = Mock(return_value=None)
+    mocks["console"].status.return_value.__exit__ = Mock(return_value=False)
+
+    patches = [
+        patch("tetra_rp.cli.commands.init.console", mocks["console"]),
+        patch(
+            "tetra_rp.cli.commands.init.detect_file_conflicts",
+            mocks["detect_conflicts"],
+        ),
+        patch(
+            "tetra_rp.cli.commands.init.create_project_skeleton",
+            mocks["create_skeleton"],
+        ),
+    ]
+
+    for p in patches:
+        p.start()
+
+    yield mocks
+
+    for p in patches:
+        p.stop()
+
+
+class TestInitCommandNewDirectory:
+    """Tests for init command when creating a new directory."""
+
+    def test_create_new_directory(self, mock_context, tmp_path, monkeypatch):
+        """Test creating new project directory."""
+        monkeypatch.chdir(tmp_path)
+
+        init_command("my_project")
+
+        # Verify directory was created
+        assert (tmp_path / "my_project").exists()
+
+        # Verify skeleton was created
+        mock_context["create_skeleton"].assert_called_once()
+
+        # Verify console output
+        mock_context["console"].print.assert_called()
+
+    def test_create_nested_directory(self, mock_context, tmp_path, monkeypatch):
+        """Test creating project in nested directory structure."""
+        monkeypatch.chdir(tmp_path)
+
+        init_command("path/to/my_project")
+
+        # Verify nested directory was created
+        assert (tmp_path / "path/to/my_project").exists()
+
+    def test_force_flag_skips_confirmation(self, mock_context, tmp_path, monkeypatch):
+        """Test that force flag bypasses conflict prompts."""
+        monkeypatch.chdir(tmp_path)
+        mock_context["detect_conflicts"].return_value = ["main.py", "requirements.txt"]
+
+        init_command("my_project", force=True)
+
+        # Verify skeleton was created
+        mock_context["create_skeleton"].assert_called_once()
+
+
+class TestInitCommandCurrentDirectory:
+    """Tests for init command when using current directory."""
+
+    @patch("pathlib.Path.cwd")
+    def test_init_current_directory_with_none(self, mock_cwd, mock_context, tmp_path):
+        """Test initialization in current directory with None argument."""
+        mock_cwd.return_value = tmp_path
+
+        init_command(None)
+
+        # Verify skeleton was created
+        mock_context["create_skeleton"].assert_called_once()
+
+    @patch("pathlib.Path.cwd")
+    def test_init_current_directory_with_dot(self, mock_cwd, mock_context, tmp_path):
+        """Test initialization in current directory with '.' argument."""
+        mock_cwd.return_value = tmp_path
+
+        init_command(".")
+
+        # Verify skeleton was created
+        mock_context["create_skeleton"].assert_called_once()
+
+
+class TestInitCommandConflictDetection:
+    """Tests for init command file conflict detection and resolution."""
+
+    def test_no_conflicts_no_prompt(self, mock_context, tmp_path, monkeypatch):
+        """Test that prompt is skipped when no conflicts exist."""
+        monkeypatch.chdir(tmp_path)
+        mock_context["detect_conflicts"].return_value = []
+
+        init_command("my_project")
+
+        # Verify skeleton was created
+        mock_context["create_skeleton"].assert_called_once()
+
+    def test_console_called_multiple_times(self, mock_context, tmp_path, monkeypatch):
+        """Test that console prints multiple outputs."""
+        monkeypatch.chdir(tmp_path)
+
+        init_command("my_project")
+
+        # Verify console.print was called multiple times
+        assert mock_context["console"].print.call_count > 0
+
+
+class TestInitCommandOutput:
+    """Tests for init command output messages."""
+
+    def test_panel_title_for_new_directory(self, mock_context, tmp_path, monkeypatch):
+        """Test that panel output is created for new directory."""
+        monkeypatch.chdir(tmp_path)
+
+        init_command("my_project")
+
+        # Verify console.print was called multiple times
+        assert mock_context["console"].print.call_count > 0
+
+    @patch("pathlib.Path.cwd")
+    def test_panel_title_for_current_directory(self, mock_cwd, mock_context, tmp_path):
+        """Test that panel output is created for current directory."""
+        mock_cwd.return_value = tmp_path
+
+        init_command(".")
+
+        # Verify console.print was called
+        assert mock_context["console"].print.call_count > 0
+
+    def test_next_steps_displayed(self, mock_context, tmp_path, monkeypatch):
+        """Test next steps are displayed."""
+        monkeypatch.chdir(tmp_path)
+
+        init_command("my_project")
+
+        # Verify console.print was called with next steps text
+        assert any(
+            "Next steps" in str(c) for c in mock_context["console"].print.call_args_list
+        )
+
+    @patch("pathlib.Path.cwd")
+    def test_api_key_docs_link_displayed(self, mock_cwd, mock_context, tmp_path):
+        """Test API key documentation link is displayed."""
+        mock_cwd.return_value = tmp_path
+
+        init_command(".")
+
+        # Verify console.print was called with API key link
+        assert any(
+            "runpod.io" in str(c) for c in mock_context["console"].print.call_args_list
+        )
+
+    def test_status_message_for_new_directory(
+        self, mock_context, tmp_path, monkeypatch
+    ):
+        """Test status message while creating new directory."""
+        monkeypatch.chdir(tmp_path)
+
+        init_command("my_project")
+
+        # Check that status was called with appropriate message
+        mock_context["console"].status.assert_called_once()
+        status_msg = mock_context["console"].status.call_args[0][0]
+        assert "Creating Flash project" in status_msg
+
+    @patch("pathlib.Path.cwd")
+    def test_status_message_for_current_directory(
+        self, mock_cwd, mock_context, tmp_path
+    ):
+        """Test status message while initializing current directory."""
+        mock_cwd.return_value = tmp_path
+
+        init_command(".")
+
+        # Check that status was called with "current directory" message
+        mock_context["console"].status.assert_called_once()
+        status_msg = mock_context["console"].status.call_args[0][0]
+        assert "current directory" in status_msg
+
+
+class TestInitCommandProjectNameHandling:
+    """Tests for project name handling."""
+
+    def test_special_characters_in_project_name(
+        self, mock_context, tmp_path, monkeypatch
+    ):
+        """Test project name with special characters."""
+        monkeypatch.chdir(tmp_path)
+
+        init_command("my-project_123")
+
+        # Verify directory was created with the exact name
+        assert (tmp_path / "my-project_123").exists()
+
+    def test_console_called_with_panels_and_tables(
+        self, mock_context, tmp_path, monkeypatch
+    ):
+        """Test that console prints panels and tables."""
+        monkeypatch.chdir(tmp_path)
+
+        init_command("test_project")
+
+        # Verify console.print was called multiple times
+        assert (
+            mock_context["console"].print.call_count >= 4
+        )  # Panel, "Next steps:", Table, API key info
+
+    def test_directory_created_matches_argument(
+        self, mock_context, tmp_path, monkeypatch
+    ):
+        """Test that directory created matches the argument."""
+        monkeypatch.chdir(tmp_path)
+
+        init_command("my_awesome_project")
+
+        # Verify directory was created with exact name
+        assert (tmp_path / "my_awesome_project").exists()
+        # Verify it's a directory
+        assert (tmp_path / "my_awesome_project").is_dir()