fastapi-fullstack 0.1.7__py3-none-any.whl

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/tests/test_agents.py

@@ -0,0 +1,261 @@
+{%- if cookiecutter.enable_ai_agent and cookiecutter.use_pydantic_ai %}
+"""Tests for AI agent module (PydanticAI)."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from app.agents.assistant import AssistantAgent, Deps, get_agent, run_agent
+from app.agents.tools.datetime_tool import get_current_datetime
+
+
+class TestDeps:
+    """Tests for Deps dataclass."""
+
+    def test_deps_default_values(self):
+        """Test Deps has correct default values."""
+        deps = Deps()
+        assert deps.user_id is None
+        assert deps.user_name is None
+        assert deps.metadata == {}
+
+    def test_deps_with_values(self):
+        """Test Deps with custom values."""
+        deps = Deps(user_id="123", user_name="Test User", metadata={"key": "value"})
+        assert deps.user_id == "123"
+        assert deps.user_name == "Test User"
+        assert deps.metadata == {"key": "value"}
+
+
+class TestGetCurrentDatetime:
+    """Tests for get_current_datetime tool."""
+
+    def test_returns_formatted_string(self):
+        """Test get_current_datetime returns formatted string."""
+        result = get_current_datetime()
+        assert isinstance(result, str)
+        # Should contain year, month, day
+        assert len(result) > 10
+
+
+class TestAssistantAgent:
+    """Tests for AssistantAgent class."""
+
+    def test_init_with_defaults(self):
+        """Test AssistantAgent initializes with defaults."""
+        agent = AssistantAgent()
+        assert agent.system_prompt == "You are a helpful assistant."
+        assert agent._agent is None
+
+    def test_init_with_custom_values(self):
+        """Test AssistantAgent with custom configuration."""
+        agent = AssistantAgent(
+            model_name="gpt-4",
+            temperature=0.5,
+            system_prompt="Custom prompt",
+        )
+        assert agent.model_name == "gpt-4"
+        assert agent.temperature == 0.5
+        assert agent.system_prompt == "Custom prompt"
+
+    @patch("app.agents.assistant.OpenAIProvider")
+    @patch("app.agents.assistant.OpenAIChatModel")
+    def test_agent_property_creates_agent(self, mock_model, mock_provider):
+        """Test agent property creates agent on first access."""
+        agent = AssistantAgent()
+        _ = agent.agent
+        assert agent._agent is not None
+        mock_model.assert_called_once()
+
+    @patch("app.agents.assistant.OpenAIProvider")
+    @patch("app.agents.assistant.OpenAIChatModel")
+    def test_agent_property_caches_agent(self, mock_model, mock_provider):
+        """Test agent property caches the agent instance."""
+        agent = AssistantAgent()
+        agent1 = agent.agent
+        agent2 = agent.agent
+        assert agent1 is agent2
+        mock_model.assert_called_once()
+
+
+class TestGetAgent:
+    """Tests for get_agent factory function."""
+
+    def test_returns_assistant_agent(self):
+        """Test get_agent returns AssistantAgent."""
+        agent = get_agent()
+        assert isinstance(agent, AssistantAgent)
+
+
+class TestAgentRoutes:
+    """Tests for agent WebSocket routes."""
+
+    @pytest.mark.anyio
+    async def test_agent_websocket_connection(self, client):
+        """Test WebSocket connection to agent endpoint."""
+        # This test verifies the WebSocket endpoint is accessible
+        # Actual agent testing would require mocking OpenAI
+        pass
+
+
+class TestHistoryConversion:
+    """Tests for conversation history conversion."""
+
+    def test_empty_history(self):
+        """Test with empty history."""
+        _agent = AssistantAgent()  # noqa: F841
+        # History conversion happens inside run/iter methods
+        # We test the structure here
+        history = []
+        assert len(history) == 0
+
+    def test_history_roles(self):
+        """Test history with different roles."""
+        history = [
+            {"role": "user", "content": "Hello"},
+            {"role": "assistant", "content": "Hi there!"},
+            {"role": "system", "content": "You are helpful"},
+        ]
+        assert len(history) == 3
+        assert all("role" in msg and "content" in msg for msg in history)
+{%- elif cookiecutter.enable_ai_agent and cookiecutter.use_langchain %}
+"""Tests for AI agent module (LangChain)."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from app.agents.langchain_assistant import AgentContext, LangChainAssistant, get_agent, run_agent
+from app.agents.tools.datetime_tool import get_current_datetime
+
+
+class TestAgentContext:
+    """Tests for AgentContext TypedDict."""
+
+    def test_context_empty(self):
+        """Test AgentContext can be empty."""
+        context: AgentContext = {}
+        assert "user_id" not in context
+        assert "user_name" not in context
+
+    def test_context_with_values(self):
+        """Test AgentContext with values."""
+        context: AgentContext = {
+            "user_id": "123",
+            "user_name": "Test User",
+            "metadata": {"key": "value"},
+        }
+        assert context["user_id"] == "123"
+        assert context["user_name"] == "Test User"
+        assert context["metadata"] == {"key": "value"}
+
+
+class TestGetCurrentDatetime:
+    """Tests for get_current_datetime tool."""
+
+    def test_returns_formatted_string(self):
+        """Test get_current_datetime returns formatted string."""
+        result = get_current_datetime()
+        assert isinstance(result, str)
+        # Should contain year, month, day
+        assert len(result) > 10
+
+
+class TestLangChainAssistant:
+    """Tests for LangChainAssistant class."""
+
+    def test_init_with_defaults(self):
+        """Test LangChainAssistant initializes with defaults."""
+        agent = LangChainAssistant()
+        assert agent.system_prompt == "You are a helpful assistant."
+        assert agent._agent is None
+
+    def test_init_with_custom_values(self):
+        """Test LangChainAssistant with custom configuration."""
+        agent = LangChainAssistant(
+            model_name="gpt-4",
+            temperature=0.5,
+            system_prompt="Custom prompt",
+        )
+        assert agent.model_name == "gpt-4"
+        assert agent.temperature == 0.5
+        assert agent.system_prompt == "Custom prompt"
+
+    @patch("app.agents.langchain_assistant.ChatOpenAI")
+    @patch("app.agents.langchain_assistant.create_agent")
+    def test_agent_property_creates_agent(self, mock_create_agent, mock_chat):
+        """Test agent property creates agent on first access."""
+        mock_create_agent.return_value = MagicMock()
+        agent = LangChainAssistant()
+        _ = agent.agent
+        assert agent._agent is not None
+        mock_create_agent.assert_called_once()
+
+    @patch("app.agents.langchain_assistant.ChatOpenAI")
+    @patch("app.agents.langchain_assistant.create_agent")
+    def test_agent_property_caches_agent(self, mock_create_agent, mock_chat):
+        """Test agent property caches the agent instance."""
+        mock_create_agent.return_value = MagicMock()
+        agent = LangChainAssistant()
+        agent1 = agent.agent
+        agent2 = agent.agent
+        assert agent1 is agent2
+        mock_create_agent.assert_called_once()
+
+
+class TestGetAgent:
+    """Tests for get_agent factory function."""
+
+    def test_returns_langchain_assistant(self):
+        """Test get_agent returns LangChainAssistant."""
+        agent = get_agent()
+        assert isinstance(agent, LangChainAssistant)
+
+
+class TestAgentRoutes:
+    """Tests for agent WebSocket routes."""
+
+    @pytest.mark.anyio
+    async def test_agent_websocket_connection(self, client):
+        """Test WebSocket connection to agent endpoint."""
+        # This test verifies the WebSocket endpoint is accessible
+        # Actual agent testing would require mocking OpenAI
+        pass
+
+
+class TestHistoryConversion:
+    """Tests for conversation history conversion."""
+
+    def test_empty_history(self):
+        """Test with empty history."""
+        _agent = LangChainAssistant()  # noqa: F841
+        # History conversion happens inside run/stream methods
+        # We test the structure here
+        history = []
+        assert len(history) == 0
+
+    def test_history_roles(self):
+        """Test history with different roles."""
+        history = [
+            {"role": "user", "content": "Hello"},
+            {"role": "assistant", "content": "Hi there!"},
+            {"role": "system", "content": "You are helpful"},
+        ]
+        assert len(history) == 3
+        assert all("role" in msg and "content" in msg for msg in history)
+
+    def test_convert_history(self):
+        """Test _convert_history method."""
+        agent = LangChainAssistant()
+        history = [
+            {"role": "user", "content": "Hello"},
+            {"role": "assistant", "content": "Hi there!"},
+            {"role": "system", "content": "You are helpful"},
+        ]
+        messages = agent._convert_history(history)
+        assert len(messages) == 3
+        from langchain.messages import AIMessage, HumanMessage, SystemMessage
+        assert isinstance(messages[0], HumanMessage)
+        assert isinstance(messages[1], AIMessage)
+        assert isinstance(messages[2], SystemMessage)
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/tests/test_clients.py

@@ -0,0 +1,183 @@
+{%- if cookiecutter.enable_redis %}
+"""Tests for client modules."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from app.clients.redis import RedisClient
+
+
+class TestRedisClient:
+    """Tests for RedisClient."""
+
+    @pytest.fixture
+    def redis_client(self) -> RedisClient:
+        """Create a RedisClient instance."""
+        return RedisClient(url="redis://localhost:6379")
+
+    @pytest.fixture
+    def mock_aioredis(self) -> MagicMock:
+        """Create a mock aioredis client."""
+        mock = MagicMock()
+        mock.get = AsyncMock(return_value="value")
+        mock.set = AsyncMock()
+        mock.delete = AsyncMock(return_value=1)
+        mock.exists = AsyncMock(return_value=1)
+        mock.ping = AsyncMock()
+        mock.close = AsyncMock()
+        return mock
+
+    @pytest.mark.anyio
+    async def test_connect(self, redis_client: RedisClient):
+        """Test Redis connection."""
+        with patch("app.clients.redis.aioredis") as mock_aioredis:
+            mock_client = MagicMock()
+            mock_aioredis.from_url.return_value = mock_client
+
+            await redis_client.connect()
+
+            assert redis_client.client is not None
+            mock_aioredis.from_url.assert_called_once()
+
+    @pytest.mark.anyio
+    async def test_close(self, redis_client: RedisClient, mock_aioredis: MagicMock):
+        """Test closing Redis connection."""
+        redis_client.client = mock_aioredis
+
+        await redis_client.close()
+
+        mock_aioredis.close.assert_called_once()
+        assert redis_client.client is None
+
+    @pytest.mark.anyio
+    async def test_close_when_not_connected(self, redis_client: RedisClient):
+        """Test closing when not connected does nothing."""
+        redis_client.client = None
+
+        await redis_client.close()  # Should not raise
+
+    @pytest.mark.anyio
+    async def test_get(self, redis_client: RedisClient, mock_aioredis: MagicMock):
+        """Test getting a value."""
+        redis_client.client = mock_aioredis
+
+        result = await redis_client.get("test_key")
+
+        assert result == "value"
+        mock_aioredis.get.assert_called_once_with("test_key")
+
+    @pytest.mark.anyio
+    async def test_get_not_connected(self, redis_client: RedisClient):
+        """Test getting when not connected raises error."""
+        redis_client.client = None
+
+        with pytest.raises(RuntimeError, match="not connected"):
+            await redis_client.get("test_key")
+
+    @pytest.mark.anyio
+    async def test_set(self, redis_client: RedisClient, mock_aioredis: MagicMock):
+        """Test setting a value."""
+        redis_client.client = mock_aioredis
+
+        await redis_client.set("test_key", "test_value")
+
+        mock_aioredis.set.assert_called_once_with("test_key", "test_value", ex=None)
+
+    @pytest.mark.anyio
+    async def test_set_with_ttl(self, redis_client: RedisClient, mock_aioredis: MagicMock):
+        """Test setting a value with TTL."""
+        redis_client.client = mock_aioredis
+
+        await redis_client.set("test_key", "test_value", ttl=60)
+
+        mock_aioredis.set.assert_called_once_with("test_key", "test_value", ex=60)
+
+    @pytest.mark.anyio
+    async def test_set_not_connected(self, redis_client: RedisClient):
+        """Test setting when not connected raises error."""
+        redis_client.client = None
+
+        with pytest.raises(RuntimeError, match="not connected"):
+            await redis_client.set("test_key", "test_value")
+
+    @pytest.mark.anyio
+    async def test_delete(self, redis_client: RedisClient, mock_aioredis: MagicMock):
+        """Test deleting a key."""
+        redis_client.client = mock_aioredis
+
+        result = await redis_client.delete("test_key")
+
+        assert result == 1
+        mock_aioredis.delete.assert_called_once_with("test_key")
+
+    @pytest.mark.anyio
+    async def test_delete_not_connected(self, redis_client: RedisClient):
+        """Test deleting when not connected raises error."""
+        redis_client.client = None
+
+        with pytest.raises(RuntimeError, match="not connected"):
+            await redis_client.delete("test_key")
+
+    @pytest.mark.anyio
+    async def test_exists(self, redis_client: RedisClient, mock_aioredis: MagicMock):
+        """Test checking if key exists."""
+        redis_client.client = mock_aioredis
+
+        result = await redis_client.exists("test_key")
+
+        assert result is True
+        mock_aioredis.exists.assert_called_once_with("test_key")
+
+    @pytest.mark.anyio
+    async def test_exists_not_connected(self, redis_client: RedisClient):
+        """Test exists when not connected raises error."""
+        redis_client.client = None
+
+        with pytest.raises(RuntimeError, match="not connected"):
+            await redis_client.exists("test_key")
+
+    @pytest.mark.anyio
+    async def test_ping_connected(self, redis_client: RedisClient, mock_aioredis: MagicMock):
+        """Test ping when connected."""
+        redis_client.client = mock_aioredis
+
+        result = await redis_client.ping()
+
+        assert result is True
+        mock_aioredis.ping.assert_called_once()
+
+    @pytest.mark.anyio
+    async def test_ping_not_connected(self, redis_client: RedisClient):
+        """Test ping when not connected returns False."""
+        redis_client.client = None
+
+        result = await redis_client.ping()
+
+        assert result is False
+
+    @pytest.mark.anyio
+    async def test_ping_exception(self, redis_client: RedisClient, mock_aioredis: MagicMock):
+        """Test ping when exception occurs returns False."""
+        redis_client.client = mock_aioredis
+        mock_aioredis.ping = AsyncMock(side_effect=Exception("Connection error"))
+
+        result = await redis_client.ping()
+
+        assert result is False
+
+    def test_raw_property(self, redis_client: RedisClient, mock_aioredis: MagicMock):
+        """Test accessing raw client."""
+        redis_client.client = mock_aioredis
+
+        result = redis_client.raw
+
+        assert result == mock_aioredis
+
+    def test_raw_property_not_connected(self, redis_client: RedisClient):
+        """Test accessing raw client when not connected raises error."""
+        redis_client.client = None
+
+        with pytest.raises(RuntimeError, match="not connected"):
+            _ = redis_client.raw
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/tests/test_commands.py

@@ -0,0 +1,173 @@
+"""Tests for CLI commands module."""
+
+import click
+from click.testing import CliRunner
+
+from app.commands import (
+    command,
+    discover_commands,
+    error,
+    info,
+    register_commands,
+    success,
+    warning,
+)
+
+
+class TestCommandDecorator:
+    """Tests for the command decorator."""
+
+    def test_command_registers_function(self):
+        """Test that @command decorator registers a click command."""
+        from app.commands import _commands
+
+        initial_count = len(_commands)
+
+        @command("test-cmd", help="Test command")
+        def test_func():
+            pass
+
+        assert len(_commands) == initial_count + 1
+        assert _commands[-1].name == "test-cmd"
+
+    def test_command_uses_function_name_as_default(self):
+        """Test that command name defaults to function name."""
+        from app.commands import _commands
+
+        @command()
+        def my_test_command():
+            pass
+
+        assert _commands[-1].name == "my-test-command"
+
+
+class TestHelperFunctions:
+    """Tests for helper output functions."""
+
+    def test_success_prints_green(self, capsys):
+        """Test success prints in green."""
+        success("Test message")
+        # Click uses escape codes for colors
+        captured = capsys.readouterr()
+        assert "Test message" in captured.out
+
+    def test_error_prints_red(self, capsys):
+        """Test error prints in red."""
+        error("Error message")
+        captured = capsys.readouterr()
+        assert "Error message" in captured.out
+
+    def test_warning_prints_yellow(self, capsys):
+        """Test warning prints in yellow."""
+        warning("Warning message")
+        captured = capsys.readouterr()
+        assert "Warning message" in captured.out
+
+    def test_info_prints_plain(self, capsys):
+        """Test info prints plain text."""
+        info("Info message")
+        captured = capsys.readouterr()
+        assert "Info message" in captured.out
+
+
+class TestDiscoverCommands:
+    """Tests for command discovery."""
+
+    def test_discover_commands_returns_list(self):
+        """Test that discover_commands returns a list."""
+        commands = discover_commands()
+        assert isinstance(commands, list)
+
+    def test_discover_commands_caches_results(self):
+        """Test that discover_commands caches on second call."""
+        commands1 = discover_commands()
+        commands2 = discover_commands()
+        assert commands1 is commands2
+
+
+class TestRegisterCommands:
+    """Tests for registering commands."""
+
+    def test_register_commands_adds_to_group(self):
+        """Test that register_commands adds discovered commands to CLI group."""
+        @click.group()
+        def cli():
+            pass
+
+        register_commands(cli)
+        # After registration, cli should have commands
+        # We can't assert exact count since it depends on what's discovered
+
+
+{%- if cookiecutter.use_database %}
+
+
+class TestSeedCommand:
+    """Tests for the seed command."""
+
+    def test_seed_dry_run(self):
+        """Test seed command with --dry-run."""
+        from app.commands.seed import seed
+
+        runner = CliRunner()
+        result = runner.invoke(seed, ["--dry-run", "--count", "5"])
+        assert result.exit_code == 0
+        assert "[DRY RUN]" in result.output
+        assert "5" in result.output
+
+    def test_seed_dry_run_with_clear(self):
+        """Test seed command with --dry-run and --clear."""
+        from app.commands.seed import seed
+
+        runner = CliRunner()
+        result = runner.invoke(seed, ["--dry-run", "--clear"])
+        assert result.exit_code == 0
+        assert "Would clear existing data" in result.output
+{%- endif %}
+
+
+class TestHelloCommand:
+    """Tests for the hello command."""
+
+    def test_hello_command_runs(self):
+        """Test hello command executes."""
+        from app.commands.example import hello
+
+        runner = CliRunner()
+        result = runner.invoke(hello)
+        assert result.exit_code == 0
+        assert "Hello" in result.output
+
+    def test_hello_command_with_name(self):
+        """Test hello command with --name option."""
+        from app.commands.example import hello
+
+        runner = CliRunner()
+        result = runner.invoke(hello, ["--name", "Alice"])
+        assert result.exit_code == 0
+        assert "Alice" in result.output
+
+
+{%- if cookiecutter.use_database %}
+
+
+class TestCleanupCommand:
+    """Tests for the cleanup command."""
+
+    def test_cleanup_dry_run(self):
+        """Test cleanup command with --dry-run."""
+        from app.commands.cleanup import cleanup
+
+        runner = CliRunner()
+        result = runner.invoke(cleanup, ["--dry-run"])
+        assert result.exit_code == 0
+        assert "[DRY RUN]" in result.output
+
+    def test_cleanup_with_days_option(self):
+        """Test cleanup command with --days option."""
+        from app.commands.cleanup import cleanup
+
+        runner = CliRunner()
+        result = runner.invoke(cleanup, ["--dry-run", "--days", "7"])
+        assert result.exit_code == 0
+{%- endif %}