Test/consolidate test suite

.gitignore

@@ -9,3 +9,9 @@ db.txt
 
 .venv
 multiai-c9380-firebase-adminsdk-fbsvc-cb6e5ce41b.json
+
+# Local Test & Debug Files
+.coverage
+dummy.json
+test_output.log
+*.log

app/router/staff/__init__.py

@@ -4,7 +4,7 @@
 from app.router.staff.notifications import router as staff_notifications_router
 from app.router.staff.uploads import router as staff_uploads_router
 
-router = APIRouter(prefix="/stuff", tags=["stuff"])
+router = APIRouter(prefix="/staff", tags=["staff"])
 router.include_router(staff_drive_router)
 router.include_router(staff_notifications_router)
 router.include_router(staff_uploads_router)

app/worker/photo_worker/main.py

@@ -179,9 +179,7 @@ async def _handle_group_photo(self, event: PhotoProcessEvent, faces: list[Detect
                 )
 
         if approvals_created == 0:
-            logger.info("No users matched in group photo %s, auto-approving as public", event.photo_id)
-            await self._photo_querier.update_photo_status(id=event.photo_id, status="approved")
-            await self._photo_querier.update_photo_visibility(id=event.photo_id, visibility="public")
+            logger.info("No users matched in group photo %s, leaving as pending", event.photo_id)
 
 
     async def _create_job(self, event: PhotoProcessEvent) -> models.ProcessingJob | None:

db/generated/photo_approvals.py

@@ -11,6 +11,25 @@
 from db.generated import models
 
 
+EXPIRE_STALE_APPROVALS = """-- name: expire_stale_approvals \\:many
+WITH stale_photos AS (
+    SELECT id FROM photos
+    WHERE status = 'pending'
+      AND created_at < now() - make_interval(days => :p1::int)
+),
+_update_approvals AS (
+    UPDATE photo_approvals
+    SET decision = 'approved', decided_at = now()
+    WHERE photo_id IN (SELECT id FROM stale_photos)
+      AND decision = 'pending'
+)
+UPDATE photos
+SET status = 'approved'
+WHERE id IN (SELECT id FROM stale_photos)
+RETURNING id
+"""
+
+
 CREATE_PHOTO_APPROVAL = """-- name: create_photo_approval \\:one
 INSERT INTO photo_approvals (
     photo_id,
@@ -68,6 +87,11 @@ class AsyncQuerier:
     def __init__(self, conn: sqlalchemy.ext.asyncio.AsyncConnection):
         self._conn = conn
 
+    async def expire_stale_approvals(self, *, timeout_days: int) -> AsyncIterator[uuid.UUID]:
+        result = await self._conn.stream(sqlalchemy.text(EXPIRE_STALE_APPROVALS), {"p1": timeout_days})
+        async for row in result:
+            yield row[0]
+
     async def create_photo_approval(self, *, photo_id: uuid.UUID, user_id: uuid.UUID, decision: str) -> Optional[models.PhotoApproval]:
         row = (await self._conn.execute(sqlalchemy.text(CREATE_PHOTO_APPROVAL), {"p1": photo_id, "p2": user_id, "p3": decision})).first()
         if row is None:

pyproject.toml

@@ -63,7 +63,9 @@ warn_redundant_casts = true
 follow_imports = "silent"
 files = ["app", "db", "migrations"]
 exclude = [
-    "db/generated"
+    "db/generated",
+    "tests",
+    "scripts"
 ]
 [dependency-groups]
 dev = [

scripts/check_ai_results.py

@@ -0,0 +1,23 @@
+import asyncio
+from sqlalchemy.ext.asyncio import create_async_engine
+from app.core.config import settings
+
+async def main():
+    url = f"postgresql+asyncpg://{settings.POSTGRES_USER}:{settings.POSTGRES_PASSWORD}@{settings.POSTGRES_HOST}:{settings.POSTGRES_PORT}/{settings.POSTGRES_DB}"
+    engine = create_async_engine(url)
+
+    async with engine.connect() as conn:
+        import sqlalchemy
+
+        # Check processing jobs
+        jobs = (await conn.execute(sqlalchemy.text("SELECT status, count(*) FROM processing_jobs GROUP BY status"))).fetchall()
+        print("=== PROCESSING JOBS STATUS ===")
+        for j in jobs:
+            print(f"Status: {j[0]}, Count: {j[1]}")
+
+        # Check photo faces
+        faces = (await conn.execute(sqlalchemy.text("SELECT count(*) FROM photo_faces"))).scalar()
+        print("\n=== VISAGES DETECTES ===")
+        print(f"Nombre total de visages isolés et enregistrés par l'IA : {faces}")
+
+asyncio.run(main())

scripts/check_scopes.py

@@ -0,0 +1,17 @@
+import asyncio
+from sqlalchemy.ext.asyncio import create_async_engine
+from app.core.config import settings
+
+async def main():
+    url = f"postgresql+asyncpg://{settings.POSTGRES_USER}:{settings.POSTGRES_PASSWORD}@{settings.POSTGRES_HOST}:{settings.POSTGRES_PORT}/{settings.POSTGRES_DB}"
+    engine = create_async_engine(url)
+
+    async with engine.connect() as conn:
+        import sqlalchemy
+        row = (await conn.execute(sqlalchemy.text("SELECT google_email, scopes FROM staff_drive_connections LIMIT 1"))).fetchone()
+        if row:
+            print(f"Email: {row[0]}, Scopes: {row[1]}")
+        else:
+            print("No connection found")
+
+asyncio.run(main())

scripts/generate_drive_url.py

@@ -0,0 +1,44 @@
+import asyncio
+from sqlalchemy.ext.asyncio import create_async_engine
+from app.core.config import settings
+from db.generated import stuff_user as staff_queries
+from app.infra.redis import RedisClient
+from app.service.staff_drive import StaffDriveService
+from db.generated import staff_drive_connections as drive_queries
+
+async def main():
+    url = f"postgresql+asyncpg://{settings.POSTGRES_USER}:{settings.POSTGRES_PASSWORD}@{settings.POSTGRES_HOST}:{settings.POSTGRES_PORT}/{settings.POSTGRES_DB}"
+    engine = create_async_engine(url)
+
+    # Init redis
+    RedisClient.init(host=settings.REDIS_HOST, port=settings.REDIS_PORT, password=settings.REDIS_PASSWORD or "")
+    redis = RedisClient.get_instance()
+
+    async with engine.connect() as conn:
+        q = staff_queries.AsyncQuerier(conn)
+        import sqlalchemy
+        row = (await conn.execute(sqlalchemy.text("SELECT id FROM staff_users LIMIT 1"))).fetchone()
+
+        if not row:
+            print("No staff user found! Creating one...")
+            res = await q.create_staff_user(email="testadmin@example.com", hashed_password="pw", display_name="Admin", role="admin")
+            staff_user_id = res.id
+        else:
+            staff_user_id = row[0]
+
+        class DummyUser:
+            pass
+        staff_user = DummyUser()
+        staff_user.id = staff_user_id
+
+        drive_service = StaffDriveService(
+            staff_user_querier=q,
+            drive_connection_querier=drive_queries.AsyncQuerier(conn),
+            redis=redis
+        )
+        url, state = await drive_service.create_connect_url(staff_user)
+        print("========================")
+        print("GOOGLE_AUTH_URL:", url)
+        print("========================")
+
+asyncio.run(main())

scripts/list_drive.py

@@ -0,0 +1,50 @@
+import asyncio
+from sqlalchemy.ext.asyncio import create_async_engine
+from app.core.config import settings
+from db.generated import stuff_user as staff_queries
+from app.infra.redis import RedisClient
+from app.infra.google_drive import GoogleDriveClient
+from app.service.staff_drive import StaffDriveService
+from db.generated import staff_drive_connections as drive_queries
+
+async def main():
+    url = f"postgresql+asyncpg://{settings.POSTGRES_USER}:{settings.POSTGRES_PASSWORD}@{settings.POSTGRES_HOST}:{settings.POSTGRES_PORT}/{settings.POSTGRES_DB}"
+    engine = create_async_engine(url)
+
+    # Init redis
+    try:
+        RedisClient.init(host=settings.REDIS_HOST, port=settings.REDIS_PORT, password=settings.REDIS_PASSWORD or "")
+    except RuntimeError:
+        pass
+    redis = RedisClient.get_instance()
+
+    async with engine.connect() as conn:
+        q = staff_queries.AsyncQuerier(conn)
+        import sqlalchemy
+        row = (await conn.execute(sqlalchemy.text("SELECT id FROM staff_users LIMIT 1"))).fetchone()
+        staff_user_id = row[0]
+
+        class DummyUser:
+            pass
+        staff_user = DummyUser()
+        staff_user.id = staff_user_id
+
+        drive_service = StaffDriveService(
+            staff_user_querier=q,
+            drive_connection_querier=drive_queries.AsyncQuerier(conn),
+            redis=redis
+        )
+
+        access_token = await drive_service.get_access_token_for_staff_user(staff_user_id)
+
+        # List root folders
+        print("=== DOSSIERS ET FICHIERS A LA RACINE DU DRIVE ===")
+        items = await GoogleDriveClient.list_folder_contents(access_token=access_token)
+        for i in items[:20]:
+            type_str = "📁 DOSSIER" if i.mime_type == "application/vnd.google-apps.folder" else "📄 FICHIER"
+            print(f"{type_str} | ID: {i.id} | NOM: {i.name}")
+
+        if not items:
+            print("Aucun fichier trouvé.")
+
+asyncio.run(main())

scripts/test_routes.py

@@ -0,0 +1,8 @@
+from fastapi.testclient import TestClient
+from app.main import app
+
+with TestClient(app) as client:
+    resp = client.get("/user/photos")
+    print(f"/user/photos -> {resp.status_code} {resp.text}")
+    resp2 = client.get("/user/photos/")
+    print(f"/user/photos/ -> {resp2.status_code} {resp2.text}")

scripts/trigger_import.py

@@ -0,0 +1,73 @@
+import asyncio
+from sqlalchemy.ext.asyncio import create_async_engine
+from app.core.config import settings
+from db.generated import stuff_user as staff_queries
+from app.infra.redis import RedisClient
+from app.infra.google_drive import GoogleDriveClient
+from app.infra.minio import init_minio_client
+from app.service.staff_drive import StaffDriveService, SelectedDriveFile
+from db.generated import staff_drive_connections as drive_queries
+
+async def main():
+    url = f"postgresql+asyncpg://{settings.POSTGRES_USER}:{settings.POSTGRES_PASSWORD}@{settings.POSTGRES_HOST}:{settings.POSTGRES_PORT}/{settings.POSTGRES_DB}"
+    engine = create_async_engine(url)
+
+    try:
+        RedisClient.init(host=settings.REDIS_HOST, port=settings.REDIS_PORT, password=settings.REDIS_PASSWORD or "")
+    except RuntimeError:
+        pass
+    redis = RedisClient.get_instance()
+
+    # Init minio
+    await init_minio_client(
+        minio_host=settings.MINIO_HOST,
+        minio_port=settings.MINIO_API_PORT,
+        minio_root_user=settings.MINIO_ROOT_USER,
+        minio_root_password=settings.MINIO_ROOT_PASSWORD
+    )
+
+    async with engine.connect() as conn:
+        q = staff_queries.AsyncQuerier(conn)
+        import sqlalchemy
+        row = (await conn.execute(sqlalchemy.text("SELECT id FROM staff_users LIMIT 1"))).fetchone()
+        staff_user_id = row[0]
+
+        class DummyUser:
+            pass
+        staff_user = DummyUser()
+        staff_user.id = staff_user_id
+
+        drive_service = StaffDriveService(
+            staff_user_querier=q,
+            drive_connection_querier=drive_queries.AsyncQuerier(conn),
+            redis=redis
+        )
+
+        access_token = await drive_service.get_access_token_for_staff_user(staff_user_id)
+
+        print("Fetching images from Drive...")
+        items = await GoogleDriveClient.list_folder_contents(access_token=access_token)
+
+        # Filter images
+        image_items = [i for i in items if i.mime_type.startswith("image/")]
+
+        if not image_items:
+            print("No images found to import.")
+            return
+
+        print(f"Found {len(image_items)} images. Initiating import...")
+        selections = [
+            SelectedDriveFile(id=f.id, name=f.name, mime_type=f.mime_type)
+            for f in image_items[:20]  # Let's import up to 20 for this test
+        ]
+
+        results = await drive_service.import_images_from_drive(
+            staff_user=staff_user,
+            selected_files=selections,
+        )
+
+        print(f"Successfully imported {len(results)} images to MinIO!")
+        for r in results:
+            print(f" -> {r.original_file_name} stored as {r.minio_object_name}")
+
+asyncio.run(main())

scripts/trigger_photo_worker.py

@@ -0,0 +1,80 @@
+import asyncio
+import json
+import uuid
+from sqlalchemy.ext.asyncio import create_async_engine
+from app.core.config import settings
+from app.infra.redis import RedisClient
+from app.infra.minio import init_minio_client
+from app.infra.nats import NatsClient, NatsSubjects
+
+async def main():
+    url = f"postgresql+asyncpg://{settings.POSTGRES_USER}:{settings.POSTGRES_PASSWORD}@{settings.POSTGRES_HOST}:{settings.POSTGRES_PORT}/{settings.POSTGRES_DB}"
+    engine = create_async_engine(url)
+
+    try:
+        RedisClient.init(host=settings.REDIS_HOST, port=settings.REDIS_PORT, password=settings.REDIS_PASSWORD or "")
+    except RuntimeError:
+        pass
+
+    await init_minio_client(
+        minio_host=settings.MINIO_HOST,
+        minio_port=settings.MINIO_API_PORT,
+        minio_root_user=settings.MINIO_ROOT_USER,
+        minio_root_password=settings.MINIO_ROOT_PASSWORD
+    )
+
+    await NatsClient.connect(
+        host=settings.NATS_HOST,
+        port=settings.NATS_PORT,
+        user=settings.NATS_USER,
+        password=settings.NATS_PASSWORD
+    )
+
+    async with engine.connect() as conn:
+        # staff_queries not used here but kept for context
+        import sqlalchemy
+        row = (await conn.execute(sqlalchemy.text("SELECT id FROM staff_users LIMIT 1"))).fetchone()
+        staff_user_id = row[0]
+
+        event_row = (await conn.execute(sqlalchemy.text("SELECT id FROM events LIMIT 1"))).fetchone()
+        if not event_row:
+            print("Creating dummy event...")
+            ev_id = uuid.uuid4()
+            await conn.execute(sqlalchemy.text("INSERT INTO events (id, title, date, location) VALUES (:id, 'Test Event', now(), 'Test Location')"), {"id": ev_id})
+            event_id = ev_id
+        else:
+            event_id = event_row[0]
+
+        from app.infra.minio import ImageBucket
+        bucket = ImageBucket(f"staff-drive/{staff_user_id}")
+
+        objects = bucket.client.list_objects(bucket.bucket_name, prefix=bucket.file_prefix + "/", recursive=True)
+        count = 0
+        async for obj in objects:
+            storage_key = obj.object_name
+            print(f"Injecting photo {storage_key} into AI pipeline...")
+
+            # Create photo in DB
+            new_id = uuid.uuid4()
+            await conn.execute(
+                sqlalchemy.text("INSERT INTO photos (id, event_id, storage_key, visibility) VALUES (:id, :event_id, :storage_key, 'public')"),
+                {"id": new_id, "event_id": event_id, "storage_key": storage_key}
+            )
+
+            # Publish event
+            await NatsClient.publish(
+                NatsSubjects.PHOTO_PROCESS,
+                json.dumps({
+                    "photo_id": str(new_id),
+                    "image_ref": storage_key,
+                    "event_id": str(event_id)
+                }).encode("utf-8")
+            )
+            count += 1
+            if count >= 20:
+                break
+
+        await conn.commit()
+        print(f"Successfully injected {count} photos to the AI worker!")
+
+asyncio.run(main())