Initial Commit 🚀 🚀

api/conftest.py

@@ -0,0 +1,182 @@
+"""
+Shared pytest fixtures for the API tests.
+This file contains database setup, test client configuration, and utility fixtures
+that can be reused across all test files.
+"""
+
+import os
+import subprocess
+import uuid
+
+import pytest_asyncio
+from httpx import ASGITransport, AsyncClient
+from loguru import logger
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+
+from api.app import app
+from api.db import db_client
+
+# Test database setup globals
+TEST_DATABASE_NAME = None
+TEST_DATABASE_URL = None
+
+
+@pytest_asyncio.fixture
+async def test_database():
+    """
+    Set up a temporary PostgreSQL database for testing.
+    This fixture creates a unique test database, runs migrations, and cleans up afterward.
+    """
+    global TEST_DATABASE_NAME, TEST_DATABASE_URL
+
+    # Generate a unique test database name
+    TEST_DATABASE_NAME = f"test_dograh_{uuid.uuid4().hex[:8]}"
+
+    # Get the base DATABASE_URL and parse it
+    base_url = os.environ.get("DATABASE_URL")
+    # Extract connection parts and replace database name
+    url_parts = base_url.split("/")
+    base_connection = "/".join(url_parts[:-1])
+    TEST_DATABASE_URL = f"{base_connection}/{TEST_DATABASE_NAME}"
+
+    # Create a connection to the default postgres database to create our test database
+    default_engine = create_async_engine(base_url)
+
+    try:
+        # Create the test database
+        async with default_engine.connect() as conn:
+            # Use autocommit mode to create database
+            await conn.execute(text("COMMIT"))
+            await conn.execute(text(f"CREATE DATABASE {TEST_DATABASE_NAME}"))
+
+        await default_engine.dispose()
+
+        # Run migrations on the test database
+        env = os.environ.copy()
+        env["DATABASE_URL"] = TEST_DATABASE_URL
+        # Add the parent directory to PYTHONPATH so alembic can find the api module
+        parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        env["PYTHONPATH"] = parent_dir + ":" + env.get("PYTHONPATH", "")
+
+        # Run alembic upgrade to create all tables
+        result = subprocess.run(
+            [
+                "conda",
+                "run",
+                "-n",
+                "dograh",
+                "python",
+                "-m",
+                "alembic",
+                "-c",
+                "alembic.ini",
+                "upgrade",
+                "head",
+            ],
+            env=env,
+            capture_output=True,
+            text=True,
+        )
+
+        if result.returncode != 0:
+            logger.error(f"Alembic stderr: {result.stderr}")
+            logger.error(f"Alembic stdout: {result.stdout}")
+            raise RuntimeError(f"Alembic migration failed: {result.stderr}")
+
+        logger.info(f"Created test database: {TEST_DATABASE_NAME}")
+        yield TEST_DATABASE_URL
+
+    finally:
+        # Cleanup: Drop the test database
+        cleanup_engine = create_async_engine(base_url)
+        try:
+            async with cleanup_engine.connect() as conn:
+                # Terminate any connections to the test database
+                await conn.execute(text("COMMIT"))
+                await conn.execute(
+                    text(f"""
+                    SELECT pg_terminate_backend(pid)
+                    FROM pg_stat_activity
+                    WHERE datname = '{TEST_DATABASE_NAME}' AND pid <> pg_backend_pid()
+                """)
+                )
+                await conn.execute(
+                    text(f"DROP DATABASE IF EXISTS {TEST_DATABASE_NAME}")
+                )
+            logger.info(f"Cleaned up test database: {TEST_DATABASE_NAME}")
+        except Exception as e:
+            logger.error(
+                f"Warning: Could not clean up test database {TEST_DATABASE_NAME}: {e}"
+            )
+        finally:
+            await cleanup_engine.dispose()
+
+
+@pytest_asyncio.fixture
+async def db_session(test_database):
+    """
+    Create a test database client that uses the temporary database.
+    This fixture replaces the global db_client with a test version.
+    """
+    original_engine = db_client.engine
+    original_session = db_client.async_session
+
+    # Replace the database client's engine and session with test ones
+    test_engine = create_async_engine(test_database)
+    test_session_maker = async_sessionmaker(bind=test_engine)
+
+    db_client.engine = test_engine
+    db_client.async_session = test_session_maker
+
+    yield db_client
+
+    # Restore original database client
+    await test_engine.dispose()
+    db_client.engine = original_engine
+    db_client.async_session = original_session
+
+
+@pytest_asyncio.fixture
+async def test_client_factory(db_session):
+    """
+    Factory fixture that creates test clients for specific users.
+    This allows tests to create custom users and test clients on demand.
+
+    Usage:
+        async def test_something(test_client_factory, db_session):
+            # Create a custom user
+            user = await db_session.get_or_create_user_by_provider_id("custom_user_123")
+
+            # Create a test client for this user
+            async with test_client_factory(user) as client:
+                # Use the client in your test
+                response = await client.get("/some/endpoint")
+    """
+    from contextlib import asynccontextmanager
+
+    from api.services.auth.depends import get_user
+
+    @asynccontextmanager
+    async def _create_client_for_user(user):
+        # Create mock auth dependency for this user
+        async def mock_get_user():
+            return user
+
+        # Override the dependency
+        original_override = app.dependency_overrides.get(get_user)
+        app.dependency_overrides[get_user] = mock_get_user
+
+        try:
+            async with AsyncClient(
+                transport=ASGITransport(app=app), base_url="http://test"
+            ) as client:
+                yield client
+        finally:
+            # Clean up the override
+            if original_override:
+                app.dependency_overrides[get_user] = original_override
+            else:
+                app.dependency_overrides.pop(get_user, None)
+
+    return _create_client_for_user