fastapi-fullstack 0.1.7__py3-none-any.whl

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 %}

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

@@ -0,0 +1,118 @@
+"""Tests for pipeline infrastructure."""
+
+import pytest
+
+from app.pipelines.base import BasePipeline, PipelineResult
+
+
+class TestPipelineResult:
+    """Tests for PipelineResult dataclass."""
+
+    def test_success_rate_all_processed(self):
+        """Test success rate when all items processed."""
+        result = PipelineResult(processed=10, failed=0)
+        assert result.success_rate == 100.0
+
+    def test_success_rate_with_failures(self):
+        """Test success rate with some failures."""
+        result = PipelineResult(processed=8, failed=2)
+        assert result.success_rate == 80.0
+
+    def test_success_rate_all_failed(self):
+        """Test success rate when all items failed."""
+        result = PipelineResult(processed=0, failed=10)
+        assert result.success_rate == 0.0
+
+    def test_success_rate_empty(self):
+        """Test success rate with no items."""
+        result = PipelineResult(processed=0, failed=0)
+        assert result.success_rate == 100.0
+
+    def test_has_errors_with_failures(self):
+        """Test has_errors returns True when failures exist."""
+        result = PipelineResult(processed=5, failed=1)
+        assert result.has_errors is True
+
+    def test_has_errors_with_error_messages(self):
+        """Test has_errors returns True when error messages exist."""
+        result = PipelineResult(processed=5, failed=0, errors=["Error 1"])
+        assert result.has_errors is True
+
+    def test_has_errors_no_errors(self):
+        """Test has_errors returns False when no errors."""
+        result = PipelineResult(processed=5, failed=0)
+        assert result.has_errors is False
+
+    def test_default_values(self):
+        """Test default values are set correctly."""
+        result = PipelineResult(processed=5)
+        assert result.failed == 0
+        assert result.errors == []
+        assert result.metadata == {}
+
+
+class TestBasePipeline:
+    """Tests for BasePipeline abstract class."""
+
+    @pytest.mark.anyio
+    async def test_validate_returns_true_by_default(self):
+        """Test validate method returns True by default."""
+
+        class TestPipeline(BasePipeline):
+            async def run(self) -> PipelineResult:
+                return PipelineResult(processed=0)
+
+        pipeline = TestPipeline()
+        assert await pipeline.validate() is True
+
+    @pytest.mark.anyio
+    async def test_cleanup_does_nothing_by_default(self):
+        """Test cleanup method does nothing by default."""
+
+        class TestPipeline(BasePipeline):
+            async def run(self) -> PipelineResult:
+                return PipelineResult(processed=0)
+
+        pipeline = TestPipeline()
+        await pipeline.cleanup()  # Should not raise
+
+    @pytest.mark.anyio
+    async def test_run_must_be_implemented(self):
+        """Test that run method must be implemented by subclasses."""
+        # This test verifies the abstract method requirement
+        with pytest.raises(TypeError, match="Can't instantiate abstract class"):
+            BasePipeline()
+
+    @pytest.mark.anyio
+    async def test_custom_pipeline_implementation(self):
+        """Test a custom pipeline implementation."""
+
+        class MyPipeline(BasePipeline):
+            def __init__(self, items: list):
+                self.items = items
+
+            async def run(self) -> PipelineResult:
+                processed = 0
+                failed = 0
+                errors = []
+
+                for item in self.items:
+                    if item > 0:
+                        processed += 1
+                    else:
+                        failed += 1
+                        errors.append(f"Invalid item: {item}")
+
+                return PipelineResult(
+                    processed=processed,
+                    failed=failed,
+                    errors=errors,
+                )
+
+        pipeline = MyPipeline([1, 2, 3, -1, 5])
+        result = await pipeline.run()
+
+        assert result.processed == 4
+        assert result.failed == 1
+        assert len(result.errors) == 1
+        assert result.success_rate == 80.0

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

@@ -0,0 +1,181 @@
+{%- if cookiecutter.use_database %}
+"""Tests for repository layer."""
+
+from unittest.mock import AsyncMock, MagicMock
+from uuid import uuid4
+
+import pytest
+from pydantic import BaseModel
+
+from app.repositories.base import BaseRepository
+
+
+class MockModel:
+    """Mock SQLAlchemy model for testing."""
+
+    def __init__(self, **kwargs):
+        self.id = kwargs.get("id", uuid4())
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+
+class MockCreateSchema(BaseModel):
+    """Mock create schema."""
+
+    name: str
+
+
+class MockUpdateSchema(BaseModel):
+    """Mock update schema."""
+
+    name: str | None = None
+
+
+class TestBaseRepository:
+    """Tests for BaseRepository."""
+
+    @pytest.fixture
+    def repository(self):
+        """Create a test repository."""
+        return BaseRepository[MockModel, MockCreateSchema, MockUpdateSchema](MockModel)
+
+    @pytest.fixture
+    def mock_session(self):
+        """Create a mock async session."""
+        session = MagicMock()
+        session.get = AsyncMock()
+        session.execute = AsyncMock()
+        session.add = MagicMock()
+        session.flush = AsyncMock()
+        session.refresh = AsyncMock()
+        session.delete = AsyncMock()
+        return session
+
+    @pytest.mark.anyio
+    async def test_get_returns_model(self, repository, mock_session):
+        """Test get returns a model by ID."""
+        mock_obj = MockModel(name="test")
+        mock_session.get.return_value = mock_obj
+
+        result = await repository.get(mock_session, mock_obj.id)
+
+        assert result == mock_obj
+        mock_session.get.assert_called_once_with(MockModel, mock_obj.id)
+
+    @pytest.mark.anyio
+    async def test_get_returns_none_when_not_found(self, repository, mock_session):
+        """Test get returns None when not found."""
+        mock_session.get.return_value = None
+
+        result = await repository.get(mock_session, uuid4())
+
+        assert result is None
+
+    # Note: test_get_multi_returns_list is skipped because it requires a real
+    # SQLAlchemy model. The select() function cannot work with a mock class.
+    # For proper integration testing, use actual SQLAlchemy models with a test DB.
+
+    @pytest.mark.anyio
+    async def test_create_adds_and_returns_model(self, repository, mock_session):
+        """Test create adds a new model."""
+        create_data = MockCreateSchema(name="new item")
+
+        # Mock the model creation
+        async def refresh_side_effect(obj):
+            obj.id = uuid4()
+
+        mock_session.refresh.side_effect = refresh_side_effect
+
+        result = await repository.create(mock_session, obj_in=create_data)
+
+        assert result.name == "new item"
+        mock_session.add.assert_called_once()
+        mock_session.flush.assert_called_once()
+        mock_session.refresh.assert_called_once()
+
+    @pytest.mark.anyio
+    async def test_update_with_schema(self, repository, mock_session):
+        """Test update with Pydantic schema."""
+        db_obj = MockModel(name="old name")
+        update_data = MockUpdateSchema(name="new name")
+
+        result = await repository.update(mock_session, db_obj=db_obj, obj_in=update_data)
+
+        assert result.name == "new name"
+        mock_session.add.assert_called_once()
+        mock_session.flush.assert_called_once()
+
+    @pytest.mark.anyio
+    async def test_update_with_dict(self, repository, mock_session):
+        """Test update with dictionary."""
+        db_obj = MockModel(name="old name")
+        update_data = {"name": "new name"}
+
+        result = await repository.update(mock_session, db_obj=db_obj, obj_in=update_data)
+
+        assert result.name == "new name"
+
+    @pytest.mark.anyio
+    async def test_delete_removes_and_returns_model(self, repository, mock_session):
+        """Test delete removes and returns model."""
+        mock_obj = MockModel(name="to delete")
+        mock_session.get.return_value = mock_obj
+
+        result = await repository.delete(mock_session, id=mock_obj.id)
+
+        assert result == mock_obj
+        mock_session.delete.assert_called_once_with(mock_obj)
+        mock_session.flush.assert_called_once()
+
+    @pytest.mark.anyio
+    async def test_delete_returns_none_when_not_found(self, repository, mock_session):
+        """Test delete returns None when not found."""
+        mock_session.get.return_value = None
+
+        result = await repository.delete(mock_session, id=uuid4())
+
+        assert result is None
+        mock_session.delete.assert_not_called()
+
+
+{%- if cookiecutter.use_jwt %}
+
+
+class TestUserRepository:
+    """Tests for user repository functions."""
+
+    @pytest.fixture
+    def mock_session(self):
+        """Create a mock async session."""
+        session = MagicMock()
+        session.execute = AsyncMock()
+        return session
+
+    @pytest.mark.anyio
+    async def test_get_by_email(self, mock_session):
+        """Test get_by_email returns user."""
+        from app.repositories import user as user_repo
+
+        mock_user = MagicMock()
+        mock_result = MagicMock()
+        mock_result.scalar_one_or_none.return_value = mock_user
+        mock_session.execute.return_value = mock_result
+
+        result = await user_repo.get_by_email(mock_session, "test@example.com")
+
+        assert result == mock_user
+
+    @pytest.mark.anyio
+    async def test_get_by_email_not_found(self, mock_session):
+        """Test get_by_email returns None when not found."""
+        from app.repositories import user as user_repo
+
+        mock_result = MagicMock()
+        mock_result.scalar_one_or_none.return_value = None
+        mock_session.execute.return_value = mock_result
+
+        result = await user_repo.get_by_email(mock_session, "notfound@example.com")
+
+        assert result is None
+{%- endif %}
+{%- endif %}

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

@@ -0,0 +1,124 @@
+{%- if cookiecutter.use_jwt %}
+"""Tests for security module."""
+
+from datetime import timedelta
+
+from app.core.security import (
+    create_access_token,
+    create_refresh_token,
+    get_password_hash,
+    verify_password,
+    verify_token,
+)
+
+
+class TestPasswordHashing:
+    """Tests for password hashing functions."""
+
+    def test_hash_password(self):
+        """Test password hashing."""
+        password = "mysecretpassword"
+        hashed = get_password_hash(password)
+
+        assert hashed != password
+        assert len(hashed) > 0
+        assert hashed.startswith("$2")  # bcrypt prefix
+
+    def test_verify_password_correct(self):
+        """Test verifying correct password."""
+        password = "mysecretpassword"
+        hashed = get_password_hash(password)
+
+        assert verify_password(password, hashed) is True
+
+    def test_verify_password_incorrect(self):
+        """Test verifying incorrect password."""
+        password = "mysecretpassword"
+        wrong_password = "wrongpassword"
+        hashed = get_password_hash(password)
+
+        assert verify_password(wrong_password, hashed) is False
+
+
+class TestAccessToken:
+    """Tests for access token functions."""
+
+    def test_create_access_token(self):
+        """Test creating access token."""
+        subject = "user123"
+        token = create_access_token(subject)
+
+        assert isinstance(token, str)
+        assert len(token) > 0
+
+    def test_create_access_token_with_expires_delta(self):
+        """Test creating access token with custom expiration."""
+        subject = "user123"
+        expires = timedelta(hours=2)
+        token = create_access_token(subject, expires_delta=expires)
+
+        assert isinstance(token, str)
+        payload = verify_token(token)
+        assert payload is not None
+        assert payload["sub"] == subject
+        assert payload["type"] == "access"
+
+    def test_verify_access_token(self):
+        """Test verifying access token."""
+        subject = "user123"
+        token = create_access_token(subject)
+        payload = verify_token(token)
+
+        assert payload is not None
+        assert payload["sub"] == subject
+        assert payload["type"] == "access"
+
+    def test_verify_invalid_token(self):
+        """Test verifying invalid token."""
+        payload = verify_token("invalid.token.here")
+
+        assert payload is None
+
+    def test_verify_expired_token(self):
+        """Test verifying expired token."""
+        subject = "user123"
+        # Create token that expires immediately
+        token = create_access_token(subject, expires_delta=timedelta(seconds=-1))
+        payload = verify_token(token)
+
+        assert payload is None
+
+
+class TestRefreshToken:
+    """Tests for refresh token functions."""
+
+    def test_create_refresh_token(self):
+        """Test creating refresh token."""
+        subject = "user123"
+        token = create_refresh_token(subject)
+
+        assert isinstance(token, str)
+        assert len(token) > 0
+
+    def test_create_refresh_token_with_expires_delta(self):
+        """Test creating refresh token with custom expiration."""
+        subject = "user123"
+        expires = timedelta(days=7)
+        token = create_refresh_token(subject, expires_delta=expires)
+
+        assert isinstance(token, str)
+        payload = verify_token(token)
+        assert payload is not None
+        assert payload["sub"] == subject
+        assert payload["type"] == "refresh"
+
+    def test_verify_refresh_token(self):
+        """Test verifying refresh token."""
+        subject = "user123"
+        token = create_refresh_token(subject)
+        payload = verify_token(token)
+
+        assert payload is not None
+        assert payload["sub"] == subject
+        assert payload["type"] == "refresh"
+{%- endif %}