fastapi-fullstack 0.1.7__py3-none-any.whl

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

@@ -0,0 +1,363 @@
+{%- if cookiecutter.use_jwt %}
+"""Tests for service layer."""
+{%- if cookiecutter.use_postgresql or cookiecutter.use_mongodb %}
+
+from unittest.mock import AsyncMock, patch
+{%- elif cookiecutter.use_sqlite %}
+
+from unittest.mock import MagicMock, patch
+{%- endif %}
+from uuid import uuid4
+
+import pytest
+
+from app.core.exceptions import AlreadyExistsError, AuthenticationError, NotFoundError
+from app.schemas.user import UserCreate, UserUpdate
+from app.services.user import UserService
+
+
+class MockUser:
+    """Mock user for testing."""
+
+    def __init__(
+        self,
+        id=None,
+        email="test@example.com",
+        full_name="Test User",
+        hashed_password="$2b$12$hashedpassword",
+        is_active=True,
+        is_superuser=False,
+    ):
+{%- if cookiecutter.use_postgresql %}
+        self.id = id or uuid4()
+{%- else %}
+        self.id = id or str(uuid4())
+{%- endif %}
+        self.email = email
+        self.full_name = full_name
+        self.hashed_password = hashed_password
+        self.is_active = is_active
+        self.is_superuser = is_superuser
+
+
+{%- if cookiecutter.use_postgresql %}
+
+
+class TestUserServicePostgresql:
+    """Tests for UserService with PostgreSQL."""
+
+    @pytest.fixture
+    def mock_db(self) -> AsyncMock:
+        """Create mock database session."""
+        return AsyncMock()
+
+    @pytest.fixture
+    def user_service(self, mock_db: AsyncMock) -> UserService:
+        """Create UserService instance with mock db."""
+        return UserService(mock_db)
+
+    @pytest.fixture
+    def mock_user(self) -> MockUser:
+        """Create a mock user."""
+        return MockUser()
+
+    @pytest.mark.anyio
+    async def test_get_by_id_success(self, user_service: UserService, mock_user: MockUser):
+        """Test getting user by ID successfully."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_id = AsyncMock(return_value=mock_user)
+
+            result = await user_service.get_by_id(mock_user.id)
+
+            assert result == mock_user
+            mock_repo.get_by_id.assert_called_once()
+
+    @pytest.mark.anyio
+    async def test_get_by_id_not_found(self, user_service: UserService):
+        """Test getting non-existent user raises NotFoundError."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_id = AsyncMock(return_value=None)
+
+            with pytest.raises(NotFoundError):
+                await user_service.get_by_id(uuid4())
+
+    @pytest.mark.anyio
+    async def test_get_by_email(self, user_service: UserService, mock_user: MockUser):
+        """Test getting user by email."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_email = AsyncMock(return_value=mock_user)
+
+            result = await user_service.get_by_email("test@example.com")
+
+            assert result == mock_user
+
+    @pytest.mark.anyio
+    async def test_get_multi(self, user_service: UserService, mock_user: MockUser):
+        """Test getting multiple users."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_multi = AsyncMock(return_value=[mock_user])
+
+            result = await user_service.get_multi(skip=0, limit=10)
+
+            assert len(result) == 1
+            assert result[0] == mock_user
+
+    @pytest.mark.anyio
+    async def test_register_success(self, user_service: UserService, mock_user: MockUser):
+        """Test registering a new user."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_email = AsyncMock(return_value=None)
+            mock_repo.create = AsyncMock(return_value=mock_user)
+
+            user_in = UserCreate(
+                email="new@example.com",
+                password="password123",
+                full_name="New User",
+            )
+            result = await user_service.register(user_in)
+
+            assert result == mock_user
+            mock_repo.create.assert_called_once()
+
+    @pytest.mark.anyio
+    async def test_register_duplicate_email(self, user_service: UserService, mock_user: MockUser):
+        """Test registering with existing email raises AlreadyExistsError."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_email = AsyncMock(return_value=mock_user)
+
+            user_in = UserCreate(
+                email="existing@example.com",
+                password="password123",
+                full_name="Test",
+            )
+
+            with pytest.raises(AlreadyExistsError):
+                await user_service.register(user_in)
+
+    @pytest.mark.anyio
+    async def test_authenticate_success(self, user_service: UserService, mock_user: MockUser):
+        """Test successful authentication."""
+        with (
+            patch("app.services.user.user_repo") as mock_repo,
+            patch("app.services.user.verify_password", return_value=True),
+        ):
+            mock_repo.get_by_email = AsyncMock(return_value=mock_user)
+
+            result = await user_service.authenticate("test@example.com", "password123")
+
+            assert result == mock_user
+
+    @pytest.mark.anyio
+    async def test_authenticate_invalid_password(self, user_service: UserService, mock_user: MockUser):
+        """Test authentication with wrong password."""
+        with (
+            patch("app.services.user.user_repo") as mock_repo,
+            patch("app.services.user.verify_password", return_value=False),
+        ):
+            mock_repo.get_by_email = AsyncMock(return_value=mock_user)
+
+            with pytest.raises(AuthenticationError):
+                await user_service.authenticate("test@example.com", "wrongpassword")
+
+    @pytest.mark.anyio
+    async def test_authenticate_user_not_found(self, user_service: UserService):
+        """Test authentication with non-existent user."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_email = AsyncMock(return_value=None)
+
+            with pytest.raises(AuthenticationError):
+                await user_service.authenticate("unknown@example.com", "password")
+
+    @pytest.mark.anyio
+    async def test_authenticate_inactive_user(self, user_service: UserService):
+        """Test authentication with inactive user."""
+        inactive_user = MockUser(is_active=False)
+        with (
+            patch("app.services.user.user_repo") as mock_repo,
+            patch("app.services.user.verify_password", return_value=True),
+        ):
+            mock_repo.get_by_email = AsyncMock(return_value=inactive_user)
+
+            with pytest.raises(AuthenticationError):
+                await user_service.authenticate("test@example.com", "password")
+
+    @pytest.mark.anyio
+    async def test_update_success(self, user_service: UserService, mock_user: MockUser):
+        """Test updating user."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_id = AsyncMock(return_value=mock_user)
+            mock_repo.update = AsyncMock(return_value=mock_user)
+
+            user_update = UserUpdate(full_name="Updated Name")
+            result = await user_service.update(mock_user.id, user_update)
+
+            assert result == mock_user
+
+    @pytest.mark.anyio
+    async def test_update_with_password(self, user_service: UserService, mock_user: MockUser):
+        """Test updating user with password change."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_id = AsyncMock(return_value=mock_user)
+            mock_repo.update = AsyncMock(return_value=mock_user)
+
+            user_update = UserUpdate(password="newpassword123")
+            result = await user_service.update(mock_user.id, user_update)
+
+            assert result == mock_user
+            # Verify hashed_password was passed to update
+            call_args = mock_repo.update.call_args
+            assert "hashed_password" in call_args[1]["update_data"]
+
+    @pytest.mark.anyio
+    async def test_delete_success(self, user_service: UserService, mock_user: MockUser):
+        """Test deleting user."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.delete = AsyncMock(return_value=mock_user)
+
+            result = await user_service.delete(mock_user.id)
+
+            assert result == mock_user
+
+    @pytest.mark.anyio
+    async def test_delete_not_found(self, user_service: UserService):
+        """Test deleting non-existent user."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.delete = AsyncMock(return_value=None)
+
+            with pytest.raises(NotFoundError):
+                await user_service.delete(uuid4())
+{%- endif %}
+
+
+{%- if cookiecutter.use_sqlite %}
+
+
+class TestUserServiceSQLite:
+    """Tests for UserService with SQLite."""
+
+    @pytest.fixture
+    def mock_db(self) -> MagicMock:
+        """Create mock database session."""
+        return MagicMock()
+
+    @pytest.fixture
+    def user_service(self, mock_db: MagicMock) -> UserService:
+        """Create UserService instance with mock db."""
+        return UserService(mock_db)
+
+    @pytest.fixture
+    def mock_user(self) -> MockUser:
+        """Create a mock user."""
+        return MockUser()
+
+    def test_get_by_id_success(self, user_service: UserService, mock_user: MockUser):
+        """Test getting user by ID successfully."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_id = MagicMock(return_value=mock_user)
+
+            result = user_service.get_by_id(mock_user.id)
+
+            assert result == mock_user
+
+    def test_get_by_id_not_found(self, user_service: UserService):
+        """Test getting non-existent user raises NotFoundError."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_id = MagicMock(return_value=None)
+
+            with pytest.raises(NotFoundError):
+                user_service.get_by_id("nonexistent")
+
+    def test_authenticate_success(self, user_service: UserService, mock_user: MockUser):
+        """Test successful authentication."""
+        with (
+            patch("app.services.user.user_repo") as mock_repo,
+            patch("app.services.user.verify_password", return_value=True),
+        ):
+            mock_repo.get_by_email = MagicMock(return_value=mock_user)
+
+            result = user_service.authenticate("test@example.com", "password123")
+
+            assert result == mock_user
+
+    def test_register_success(self, user_service: UserService, mock_user: MockUser):
+        """Test registering a new user."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_email = MagicMock(return_value=None)
+            mock_repo.create = MagicMock(return_value=mock_user)
+
+            user_in = UserCreate(
+                email="new@example.com",
+                password="password123",
+                full_name="New User",
+            )
+            result = user_service.register(user_in)
+
+            assert result == mock_user
+{%- endif %}
+
+
+{%- if cookiecutter.use_mongodb %}
+
+
+class TestUserServiceMongoDB:
+    """Tests for UserService with MongoDB."""
+
+    @pytest.fixture
+    def user_service(self) -> UserService:
+        """Create UserService instance."""
+        return UserService()
+
+    @pytest.fixture
+    def mock_user(self) -> MockUser:
+        """Create a mock user."""
+        return MockUser()
+
+    @pytest.mark.anyio
+    async def test_get_by_id_success(self, user_service: UserService, mock_user: MockUser):
+        """Test getting user by ID successfully."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_id = AsyncMock(return_value=mock_user)
+
+            result = await user_service.get_by_id(mock_user.id)
+
+            assert result == mock_user
+
+    @pytest.mark.anyio
+    async def test_get_by_id_not_found(self, user_service: UserService):
+        """Test getting non-existent user raises NotFoundError."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_id = AsyncMock(return_value=None)
+
+            with pytest.raises(NotFoundError):
+                await user_service.get_by_id("nonexistent")
+
+    @pytest.mark.anyio
+    async def test_authenticate_success(self, user_service: UserService, mock_user: MockUser):
+        """Test successful authentication."""
+        with (
+            patch("app.services.user.user_repo") as mock_repo,
+            patch("app.services.user.verify_password", return_value=True),
+        ):
+            mock_repo.get_by_email = AsyncMock(return_value=mock_user)
+
+            result = await user_service.authenticate("test@example.com", "password123")
+
+            assert result == mock_user
+
+    @pytest.mark.anyio
+    async def test_register_success(self, user_service: UserService, mock_user: MockUser):
+        """Test registering a new user."""
+        with patch("app.services.user.user_repo") as mock_repo:
+            mock_repo.get_by_email = AsyncMock(return_value=None)
+            mock_repo.create = AsyncMock(return_value=mock_user)
+
+            user_in = UserCreate(
+                email="new@example.com",
+                password="password123",
+                full_name="New User",
+            )
+            result = await user_service.register(user_in)
+
+            assert result == mock_user
+{%- endif %}
+{%- endif %}

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

@@ -0,0 +1,85 @@
+{%- if cookiecutter.use_celery %}
+"""Tests for Celery worker tasks."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+class TestExampleTask:
+    """Tests for example_task."""
+
+    def test_example_task_success(self):
+        """Test example_task completes successfully."""
+        from app.worker.tasks.examples import example_task
+
+        # Create a mock for self (the task)
+        mock_self = MagicMock()
+        mock_self.request.id = "test-task-id"
+
+        with patch("app.worker.tasks.examples.time.sleep"):
+            result = example_task.run(mock_self, "test message")
+
+        assert result["status"] == "completed"
+        assert "test message" in result["message"]
+        assert result["task_id"] == "test-task-id"
+
+    def test_example_task_retry_on_error(self):
+        """Test example_task retries on error."""
+        from app.worker.tasks.examples import example_task
+
+        mock_self = MagicMock()
+        mock_self.request.id = "test-task-id"
+        mock_self.request.retries = 0
+
+        with patch("app.worker.tasks.examples.time.sleep", side_effect=Exception("Test error")):
+            mock_self.retry = MagicMock(side_effect=Exception("Retry"))
+            with pytest.raises(Exception, match="Retry"):
+                example_task.run(mock_self, "test message")
+            mock_self.retry.assert_called_once()
+
+
+class TestLongRunningTask:
+    """Tests for long_running_task."""
+
+    def test_long_running_task_completes(self):
+        """Test long_running_task completes with progress."""
+        from app.worker.tasks.examples import long_running_task
+
+        mock_self = MagicMock()
+        mock_self.request.id = "test-task-id"
+
+        with patch("app.worker.tasks.examples.time.sleep"):
+            result = long_running_task.run(mock_self, duration=3)
+
+        assert result["status"] == "completed"
+        assert result["duration"] == 3
+        # Check progress updates were made
+        assert mock_self.update_state.call_count == 3
+
+
+class TestSendEmailTask:
+    """Tests for send_email_task."""
+
+    def test_send_email_task_success(self):
+        """Test send_email_task sends email."""
+        from app.worker.tasks.examples import send_email_task
+
+        with patch("app.worker.tasks.examples.time.sleep"):
+            result = send_email_task("test@example.com", "Subject", "Body")
+
+        assert result["status"] == "sent"
+        assert result["to"] == "test@example.com"
+        assert result["subject"] == "Subject"
+
+
+class TestCeleryAppConfiguration:
+    """Tests for Celery app configuration."""
+
+    def test_celery_app_exists(self):
+        """Test Celery app is configured."""
+        from app.worker.celery_app import celery_app
+
+        assert celery_app is not None
+        assert celery_app.main == "{{ cookiecutter.project_slug }}"
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/docker-compose.dev.yml

@@ -0,0 +1,242 @@
+{%- if cookiecutter.enable_docker %}
+# Development configuration (alias for docker-compose.yml)
+# Usage: docker-compose -f docker-compose.dev.yml up -d
+#
+# This file is identical to docker-compose.yml for explicit naming preference.
+# Use docker-compose.yml for default development.
+
+services:
+  app:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    container_name: {{ cookiecutter.project_slug }}_backend
+    ports:
+      - "{{ cookiecutter.backend_port }}:{{ cookiecutter.backend_port }}"
+    volumes:
+      - ./backend/app:/app/app:ro
+      - ./backend/cli:/app/cli:ro
+    env_file:
+      - ./backend/.env
+    environment:
+      - DEBUG=true
+      - ENVIRONMENT=local
+{%- if cookiecutter.use_postgresql %}
+      - POSTGRES_HOST=db
+{%- endif %}
+{%- if cookiecutter.enable_redis %}
+      - REDIS_HOST=redis
+{%- endif %}
+{%- if cookiecutter.use_celery %}
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+{%- endif %}
+{%- if cookiecutter.use_taskiq %}
+      - TASKIQ_BROKER_URL=redis://redis:6379/1
+      - TASKIQ_RESULT_BACKEND=redis://redis:6379/1
+{%- endif %}
+    command: uvicorn app.main:app --host 0.0.0.0 --port {{ cookiecutter.backend_port }} --reload
+    networks:
+      - backend
+{%- if cookiecutter.use_postgresql or cookiecutter.enable_redis %}
+    depends_on:
+{%- if cookiecutter.use_postgresql %}
+      db:
+        condition: service_healthy
+{%- endif %}
+{%- if cookiecutter.enable_redis %}
+      redis:
+        condition: service_healthy
+{%- endif %}
+{%- endif %}
+    restart: unless-stopped
+
+{%- if cookiecutter.use_postgresql %}
+
+  db:
+    image: postgres:16-alpine
+    container_name: {{ cookiecutter.project_slug }}_db
+    environment:
+      - POSTGRES_USER=${POSTGRES_USER:-postgres}
+      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-postgres}
+      - POSTGRES_DB=${POSTGRES_DB:-{{ cookiecutter.project_slug }}}
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"
+    networks:
+      - backend
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-postgres}"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+{%- endif %}
+
+{%- if cookiecutter.enable_redis %}
+
+  redis:
+    image: redis:7-alpine
+    container_name: {{ cookiecutter.project_slug }}_redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    networks:
+      - backend
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+{%- endif %}
+
+{%- if cookiecutter.use_celery %}
+
+  celery_worker:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    container_name: {{ cookiecutter.project_slug }}_celery_worker
+    volumes:
+      - ./backend/app:/app/app:ro
+    command: celery -A app.worker.celery_app worker --loglevel=debug
+    env_file:
+      - ./backend/.env
+    environment:
+      - DEBUG=true
+{%- if cookiecutter.use_postgresql %}
+      - POSTGRES_HOST=db
+{%- endif %}
+      - REDIS_HOST=redis
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+    networks:
+      - backend
+    depends_on:
+      redis:
+        condition: service_healthy
+{%- if cookiecutter.use_postgresql %}
+      db:
+        condition: service_healthy
+{%- endif %}
+    restart: unless-stopped
+
+  celery_beat:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    container_name: {{ cookiecutter.project_slug }}_celery_beat
+    volumes:
+      - ./backend/app:/app/app:ro
+    command: celery -A app.worker.celery_app beat --loglevel=debug
+    env_file:
+      - ./backend/.env
+    environment:
+      - DEBUG=true
+      - REDIS_HOST=redis
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+    networks:
+      - backend
+    depends_on:
+      redis:
+        condition: service_healthy
+    restart: unless-stopped
+
+  flower:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    container_name: {{ cookiecutter.project_slug }}_flower
+    command: celery -A app.worker.celery_app flower --port=5555
+    ports:
+      - "5555:5555"
+    env_file:
+      - ./backend/.env
+    environment:
+      - DEBUG=true
+      - REDIS_HOST=redis
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+    networks:
+      - backend
+    depends_on:
+      redis:
+        condition: service_healthy
+    restart: unless-stopped
+{%- endif %}
+
+{%- if cookiecutter.use_taskiq %}
+
+  taskiq_worker:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    container_name: {{ cookiecutter.project_slug }}_taskiq_worker
+    volumes:
+      - ./backend/app:/app/app:ro
+    command: taskiq worker app.worker.taskiq_app:broker --workers 1 --reload
+    env_file:
+      - ./backend/.env
+    environment:
+      - DEBUG=true
+{%- if cookiecutter.use_postgresql %}
+      - POSTGRES_HOST=db
+{%- endif %}
+      - REDIS_HOST=redis
+      - TASKIQ_BROKER_URL=redis://redis:6379/1
+      - TASKIQ_RESULT_BACKEND=redis://redis:6379/1
+    networks:
+      - backend
+    depends_on:
+      redis:
+        condition: service_healthy
+{%- if cookiecutter.use_postgresql %}
+      db:
+        condition: service_healthy
+{%- endif %}
+    restart: unless-stopped
+
+  taskiq_scheduler:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    container_name: {{ cookiecutter.project_slug }}_taskiq_scheduler
+    volumes:
+      - ./backend/app:/app/app:ro
+    command: taskiq scheduler app.worker.taskiq_app:scheduler
+    env_file:
+      - ./backend/.env
+    environment:
+      - DEBUG=true
+      - REDIS_HOST=redis
+      - TASKIQ_BROKER_URL=redis://redis:6379/1
+      - TASKIQ_RESULT_BACKEND=redis://redis:6379/1
+    networks:
+      - backend
+    depends_on:
+      redis:
+        condition: service_healthy
+    restart: unless-stopped
+{%- endif %}
+
+networks:
+  backend:
+    driver: bridge
+
+{%- if cookiecutter.use_postgresql or cookiecutter.enable_redis %}
+
+volumes:
+{%- if cookiecutter.use_postgresql %}
+  postgres_data:
+{%- endif %}
+{%- if cookiecutter.enable_redis %}
+  redis_data:
+{%- endif %}
+{%- endif %}
+{%- else %}
+# Docker is disabled for this project
+{%- endif %}