fastapi-fullstack 0.1.2__py3-none-any.whl

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

@@ -0,0 +1,121 @@
+{%- if cookiecutter.enable_ai_agent %}
+"""Tests for AI agent module."""
+
+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)
+{%- 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 %}

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

@@ -0,0 +1,143 @@
+"""Tests for core modules."""
+
+from app.core.config import settings
+from app.core.exceptions import (
+    AlreadyExistsError,
+    AppException,
+    AuthenticationError,
+    AuthorizationError,
+    NotFoundError,
+    ValidationError,
+)
+
+
+class TestSettings:
+    """Tests for settings configuration."""
+
+    def test_project_name_is_set(self):
+        """Test project name is configured."""
+        assert settings.PROJECT_NAME == "{{ cookiecutter.project_name }}"
+
+    def test_api_v1_str_is_set(self):
+        """Test API version string is set."""
+        assert settings.API_V1_STR == "/api/v1"
+
+    def test_debug_mode_default(self):
+        """Test debug mode has default value."""
+        assert isinstance(settings.DEBUG, bool)
+
+{%- if cookiecutter.enable_cors %}
+    def test_cors_origins_is_list(self):
+        """Test CORS origins is a list."""
+        assert isinstance(settings.CORS_ORIGINS, list)
+{%- endif %}
+
+
+class TestExceptions:
+    """Tests for custom exceptions."""
+
+    def test_app_exception(self):
+        """Test AppException initialization."""
+        error = AppException(message="Test error", code="TEST_ERROR")
+        assert error.message == "Test error"
+        assert error.code == "TEST_ERROR"
+        assert str(error) == "Test error"
+
+    def test_not_found_error(self):
+        """Test NotFoundError."""
+        error = NotFoundError(message="Item not found")
+        assert error.status_code == 404
+        assert error.code == "NOT_FOUND"
+
+    def test_already_exists_error(self):
+        """Test AlreadyExistsError."""
+        error = AlreadyExistsError(message="Item already exists")
+        assert error.status_code == 409
+        assert error.code == "ALREADY_EXISTS"
+
+    def test_authentication_error(self):
+        """Test AuthenticationError."""
+        error = AuthenticationError(message="Invalid credentials")
+        assert error.status_code == 401
+        assert error.code == "AUTHENTICATION_ERROR"
+
+    def test_authorization_error(self):
+        """Test AuthorizationError."""
+        error = AuthorizationError(message="Not authorized")
+        assert error.status_code == 403
+        assert error.code == "AUTHORIZATION_ERROR"
+
+    def test_validation_error(self):
+        """Test ValidationError."""
+        error = ValidationError(message="Invalid input")
+        assert error.status_code == 422
+        assert error.code == "VALIDATION_ERROR"
+
+
+{%- if cookiecutter.enable_redis %}
+
+
+class TestCacheSetup:
+    """Tests for cache setup."""
+
+    def test_setup_cache_function_exists(self):
+        """Test setup_cache function exists."""
+        from app.core.cache import setup_cache
+
+        assert setup_cache is not None
+        assert callable(setup_cache)
+{%- endif %}
+
+
+class TestMiddleware:
+    """Tests for middleware."""
+
+    def test_request_id_middleware_exists(self):
+        """Test request ID middleware is configured."""
+        from app.core.middleware import RequestIDMiddleware
+
+        assert RequestIDMiddleware is not None
+
+
+{%- if cookiecutter.enable_rate_limiting %}
+
+
+class TestRateLimit:
+    """Tests for rate limiting."""
+
+    def test_limiter_exists(self):
+        """Test rate limiter is configured."""
+        from app.core.rate_limit import limiter
+
+        assert limiter is not None
+{%- endif %}
+
+
+{%- if cookiecutter.enable_logfire %}
+
+
+from unittest.mock import patch  # noqa: E402
+
+
+class TestLogfireSetup:
+    """Tests for Logfire setup."""
+
+    @patch("app.core.logfire_setup.logfire")
+    def test_setup_logfire_configures(self, mock_logfire):
+        """Test setup_logfire calls configure."""
+        from app.core.logfire_setup import setup_logfire
+
+        setup_logfire()
+        mock_logfire.configure.assert_called_once()
+
+    @patch("app.core.logfire_setup.logfire")
+    def test_instrument_app_instruments_fastapi(self, mock_logfire):
+        """Test instrument_app instruments FastAPI."""
+        from fastapi import FastAPI
+
+        from app.core.logfire_setup import instrument_app
+
+        app = FastAPI()
+        instrument_app(app)
+        mock_logfire.instrument_fastapi.assert_called()
+{%- endif %}