[FIX] update test cases - coverage 79.65%

Author: bnbong

tests/test_backends/test_main.py

@@ -7,11 +7,14 @@
 import subprocess
 import tempfile
 from pathlib import Path
-from unittest.mock import MagicMock, patch
+from unittest.mock import MagicMock, mock_open, patch
 
 import pytest
 
 from fastapi_fastkit.backend.main import (
+    _parse_setup_dependencies,
+    _process_config_file,
+    _process_setup_file,
     add_new_route,
     create_venv,
     find_template_core_modules,
@@ -63,6 +66,16 @@ def test_create_venv_failure(self, mock_subprocess: MagicMock) -> None:
         with pytest.raises(BackendExceptions, match="Failed to create venv"):
             create_venv(str(self.project_path))
 
+    @patch("subprocess.run")
+    def test_create_venv_os_error(self, mock_subprocess: MagicMock) -> None:
+        """Test create_venv function with OSError."""
+        # given
+        mock_subprocess.side_effect = OSError("Permission denied")
+
+        # when & then
+        with pytest.raises(BackendExceptions, match="Failed to create venv"):
+            create_venv(str(self.project_path))
+
     def test_find_template_core_modules(self) -> None:
         """Test find_template_core_modules function."""
         # given
@@ -122,6 +135,47 @@ def test_install_dependencies_success(self, mock_subprocess: MagicMock) -> None:
         # Should be called twice: pip upgrade and install requirements
         assert mock_subprocess.call_count == 2
 
+    @patch("subprocess.run")
+    def test_install_dependencies_pip_upgrade_failure(
+        self, mock_subprocess: MagicMock
+    ) -> None:
+        """Test install_dependencies function with pip upgrade failure."""
+        # given
+        requirements_txt = self.project_path / "requirements.txt"
+        requirements_txt.write_text("fastapi==0.104.1")
+        venv_path = str(self.project_path / ".venv")
+        (self.project_path / ".venv").mkdir()
+        mock_subprocess.side_effect = subprocess.CalledProcessError(
+            1, ["pip", "install", "--upgrade", "pip"]
+        )
+
+        # when & then
+        with pytest.raises(BackendExceptions, match="Failed to install dependencies"):
+            install_dependencies(str(self.project_path), venv_path)
+
+    @patch("subprocess.run")
+    def test_install_dependencies_requirements_failure(
+        self, mock_subprocess: MagicMock
+    ) -> None:
+        """Test install_dependencies function with requirements installation failure."""
+        # given
+        requirements_txt = self.project_path / "requirements.txt"
+        requirements_txt.write_text("fastapi==0.104.1")
+        venv_path = str(self.project_path / ".venv")
+        (self.project_path / ".venv").mkdir()
+
+        # Mock successful pip upgrade but failed requirements install
+        mock_subprocess.side_effect = [
+            MagicMock(returncode=0),  # successful pip upgrade
+            subprocess.CalledProcessError(
+                1, ["pip", "install", "-r", "requirements.txt"]
+            ),  # failed requirements install
+        ]
+
+        # when & then
+        with pytest.raises(BackendExceptions, match="Failed to install dependencies"):
+            install_dependencies(str(self.project_path), venv_path)
+
     def test_inject_project_metadata(self) -> None:
         """Test inject_project_metadata function."""
         # given
@@ -163,6 +217,26 @@ def test_inject_project_metadata(self) -> None:
         config_content = config_py.read_text()
         assert 'PROJECT_NAME = "test-project"' in config_content
 
+    @patch("fastapi_fastkit.backend.main.find_template_core_modules")
+    def test_inject_project_metadata_with_exception(
+        self, mock_find_modules: MagicMock
+    ) -> None:
+        """Test inject_project_metadata function with exception handling."""
+        # given
+        mock_find_modules.side_effect = Exception("Mock error")
+
+        # when & then
+        with pytest.raises(
+            BackendExceptions, match="Failed to inject project metadata"
+        ):
+            inject_project_metadata(
+                str(self.project_path),
+                "test-project",
+                "Test Author",
+                "[email protected]",
+                "Test description",
+            )
+
     def test_read_template_stack(self) -> None:
         """Test read_template_stack function."""
         # given
@@ -199,7 +273,212 @@ def test_read_template_stack(self) -> None:
         finally:
             import shutil
 
-            shutil.rmtree(template_path)
+            shutil.rmtree(str(template_path))
+
+    def test_read_template_stack_requirements_file(self) -> None:
+        """Test read_template_stack function with requirements.txt file."""
+        # given
+        template_path = Path(tempfile.mkdtemp())
+        try:
+            requirements_txt = template_path / "requirements.txt-tpl"
+            requirements_txt.write_text(
+                "fastapi>=0.100.0\nuvicorn[standard]>=0.23.0\npydantic>=2.0.0"
+            )
+
+            # when
+            result = read_template_stack(str(template_path))
+
+            # then
+            assert len(result) == 3
+            assert "fastapi>=0.100.0" in result
+            assert "uvicorn[standard]>=0.23.0" in result
+            assert "pydantic>=2.0.0" in result
+
+        finally:
+            import shutil
+
+            shutil.rmtree(str(template_path))
+
+    @patch("builtins.open", mock_open(read_data="fastapi>=0.100.0"))
+    @patch("os.path.exists", return_value=True)
+    def test_read_template_stack_file_read_error(self, mock_exists: MagicMock) -> None:
+        """Test read_template_stack function with file read error."""
+        # given
+        template_path = "/fake/path"
+
+        # Mock file read error
+        with patch("builtins.open", side_effect=OSError("Permission denied")):
+            # when
+            result = read_template_stack(template_path)
+
+            # then
+            assert result == []
+
+    @patch("builtins.open", mock_open(read_data="fastapi>=0.100.0"))
+    @patch("os.path.exists", return_value=True)
+    def test_read_template_stack_unicode_error(self, mock_exists: MagicMock) -> None:
+        """Test read_template_stack function with unicode decode error."""
+        # given
+        template_path = "/fake/path"
+
+        # Mock unicode decode error
+        with patch(
+            "builtins.open",
+            side_effect=UnicodeDecodeError("utf-8", b"", 0, 1, "invalid start byte"),
+        ):
+            # when
+            result = read_template_stack(template_path)
+
+            # then
+            assert result == []
+
+    def test_parse_setup_dependencies_list_format(self) -> None:
+        """Test _parse_setup_dependencies function with list format."""
+        # given
+        content = """
+install_requires: list[str] = [
+    "fastapi>=0.100.0",
+    "uvicorn>=0.23.0",
+    # "commented-out-package",
+    "pydantic>=2.0.0",
+]
+"""
+
+        # when
+        result = _parse_setup_dependencies(content)
+
+        # then
+        assert len(result) == 3
+        assert "fastapi>=0.100.0" in result
+        assert "uvicorn>=0.23.0" in result
+        assert "pydantic>=2.0.0" in result
+
+    def test_parse_setup_dependencies_traditional_format(self) -> None:
+        """Test _parse_setup_dependencies function with traditional format."""
+        # given
+        content = """
+install_requires = [
+    'fastapi>=0.100.0',
+    'uvicorn>=0.23.0',
+    'pydantic>=2.0.0',
+]
+"""
+
+        # when
+        result = _parse_setup_dependencies(content)
+
+        # then
+        assert len(result) == 3
+        assert "fastapi>=0.100.0" in result
+        assert "uvicorn>=0.23.0" in result
+        assert "pydantic>=2.0.0" in result
+
+    def test_parse_setup_dependencies_empty_content(self) -> None:
+        """Test _parse_setup_dependencies function with empty content."""
+        # given
+        content = ""
+
+        # when
+        result = _parse_setup_dependencies(content)
+
+        # then
+        assert result == []
+
+    def test_process_setup_file_success(self) -> None:
+        """Test _process_setup_file function with successful processing."""
+        # given
+        setup_py = self.project_path / "setup.py"
+        setup_py.write_text(
+            """
+setup(
+    name="<project_name>",
+    author="<author>",
+    author_email="<author_email>",
+    description="<description>",
+)
+"""
+        )
+
+        # when
+        _process_setup_file(
+            str(setup_py),
+            "test-project",
+            "Test Author",
+            "[email protected]",
+            "Test description",
+        )
+
+        # then
+        content = setup_py.read_text()
+        assert "test-project" in content
+        assert "Test Author" in content
+        assert "[email protected]" in content
+        assert "Test description" in content
+
+    def test_process_setup_file_missing_file(self) -> None:
+        """Test _process_setup_file function with missing file."""
+        # given
+        setup_py = str(self.project_path / "nonexistent.py")
+
+        # when & then (should not raise exception)
+        _process_setup_file(
+            setup_py,
+            "test-project",
+            "Test Author",
+            "[email protected]",
+            "Test description",
+        )
+
+    def test_process_setup_file_read_error(self) -> None:
+        """Test _process_setup_file function with file read error."""
+        # given
+        setup_py = self.project_path / "setup.py"
+        setup_py.write_text("content")
+
+        # when & then
+        with patch("builtins.open", side_effect=OSError("Permission denied")):
+            with pytest.raises(BackendExceptions, match="Failed to process setup.py"):
+                _process_setup_file(
+                    str(setup_py),
+                    "test-project",
+                    "Test Author",
+                    "[email protected]",
+                    "Test description",
+                )
+
+    def test_process_config_file_success(self) -> None:
+        """Test _process_config_file function with successful processing."""
+        # given
+        config_py = self.project_path / "config.py"
+        config_py.write_text('PROJECT_NAME = "<project_name>"')
+
+        # when
+        _process_config_file(str(config_py), "test-project")
+
+        # then
+        content = config_py.read_text()
+        assert 'PROJECT_NAME = "test-project"' in content
+
+    def test_process_config_file_missing_file(self) -> None:
+        """Test _process_config_file function with missing file."""
+        # given
+        config_py = str(self.project_path / "nonexistent.py")
+
+        # when & then (should not raise exception)
+        _process_config_file(config_py, "test-project")
+
+    def test_process_config_file_read_error(self) -> None:
+        """Test _process_config_file function with file read error."""
+        # given
+        config_py = self.project_path / "config.py"
+        config_py.write_text("content")
+
+        # when & then
+        with patch("builtins.open", side_effect=OSError("Permission denied")):
+            with pytest.raises(
+                BackendExceptions, match="Failed to process config file"
+            ):
+                _process_config_file(str(config_py), "test-project")
 
     @patch("fastapi_fastkit.backend.main._ensure_project_structure")
     @patch("fastapi_fastkit.backend.main._create_route_files")
@@ -214,15 +493,14 @@ def test_add_new_route(
     ) -> None:
         """Test add_new_route function."""
         # given
-        route_name = "user"
         mock_ensure_structure.return_value = {
-            "api": "/fake/api",
+            "api_routes": "/fake/api/routes",
             "crud": "/fake/crud",
             "schemas": "/fake/schemas",
         }
 
         # when
-        add_new_route(str(self.project_path), route_name)
+        add_new_route(str(self.project_path), "test_route")
 
         # then
         mock_ensure_structure.assert_called_once()