merge: align dev branch with main

apps/api/tests/conftest.py

@@ -8,14 +8,16 @@ from unittest.mock import patch
 import pytest
 import pytest_asyncio
 from fastapi.testclient import TestClient
+from sqlalchemy import create_engine, text
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import sessionmaker
 
 # Set test environment BEFORE importing app modules
 os.environ["APP_ENV"] = "testing"
 os.environ["SECRET_KEY"] = "test-secret-key-for-testing-only-do-not-use-in-production"
 os.environ["DATABASE_URL"] = "sqlite+aiosqlite:///:memory:"
 
-from src.config import Settings
+from src.config import Settings, build_database_url
 from src.models.base import Base
 from src.main import app
 from src.auth.dependencies import get_db_session
@@ -45,8 +47,10 @@ def test_client() -> Generator[TestClient, None, None]:
     app.dependency_overrides[get_db_session] = override_get_db_session
     
     # Patch startup events to prevent PostgreSQL connection attempts
-    with patch("src.main.init_database") as mock_init:
+    with patch("src.main.init_database") as mock_init, \
+         patch("src.main.seed_builtin_tool_types") as mock_seed:
         mock_init.return_value = True
+        mock_seed.return_value = None
         
         try:
             with TestClient(app) as client:
@@ -57,31 +61,6 @@ def test_client() -> Generator[TestClient, None, None]:
             asyncio.run(engine.dispose())
 
 
-@pytest_asyncio.fixture
-async def db_session(test_client) -> AsyncGenerator[AsyncSession, None]:
-    """Provide an async database session for unit tests."""
-    # Get the override function from the test_client fixture
-    override_fn = app.dependency_overrides.get(get_db_session)
-    if override_fn:
-        gen = override_fn()
-        session = await gen.asend(None)
-        try:
-            yield session
-        finally:
-            await gen.aclose()
-    else:
-        # Fallback: create a new engine and session
-        engine = create_async_engine(
-            "sqlite+aiosqlite:///:memory:",
-            connect_args={"check_same_thread": False},
-        )
-        async with engine.begin() as conn:
-            await conn.run_sync(Base.metadata.create_all)
-        async with async_sessionmaker(engine, expire_on_commit=False)() as session:
-            yield session
-        await engine.dispose()
-
-
 @pytest.fixture
 def authenticated_client(test_client) -> Generator[TestClient, None, None]:
     """Provide an authenticated test client with a test user."""
@@ -131,65 +110,6 @@ def authenticated_client(test_client) -> Generator[TestClient, None, None]:
     yield test_client
 
 
-@pytest.fixture
-def test_project_and_repo(authenticated_client) -> tuple[str, str]:
-    """Create a project and repository directly in the database."""
-    import uuid
-    from src.models.project import Project
-    from src.models.git_repository import GitRepository
-    
-    project_id = uuid.uuid4()
-    repo_id = uuid.uuid4()
-    user_id = None
-    
-    # Get user ID from session
-    async def get_user_id():
-        nonlocal user_id
-        from src.auth.session import decode_session_cookie
-        settings = Settings()
-        session_cookie = authenticated_client.cookies.get("session")
-        if session_cookie:
-            session = decode_session_cookie(settings=settings, cookie_value=session_cookie)
-            if session:
-                user_id = uuid.UUID(session["user_id"])
-    
-    asyncio.run(get_user_id())
-    
-    if not user_id:
-        raise RuntimeError("Could not get user ID from authenticated client")
-    
-    async def create_project_and_repo():
-        override_fn = app.dependency_overrides.get(get_db_session)
-        if override_fn:
-            gen = override_fn()
-            session = await gen.asend(None)
-            try:
-                project = Project(
-                    id=project_id,
-                    name="test-project",
-                    description="Test project",
-                    owner_id=user_id,
-                )
-                session.add(project)
-                
-                repo = GitRepository(
-                    id=repo_id,
-                    name="test-repo",
-                    path="/tmp/test-repo",
-                    project_id=project_id,
-                    owner_id=user_id,
-                    remote_url="https://github.com/test/repo.git",
-                )
-                session.add(repo)
-                await session.commit()
-            finally:
-                await gen.aclose()
-    
-    asyncio.run(create_project_and_repo())
-    
-    return str(project_id), str(repo_id)
-
-
 @pytest.fixture
 def admin_client(test_client) -> Generator[TestClient, None, None]:
     """Provide an authenticated test client with an admin user."""