test: add new asynchronous tests for course, meme, notification, and statistics functionalities, including error handling for not found scenarios and direct CRUD operations

Author: gainsborouo

backend/tests/api/test_courses.py

@@ -678,6 +678,36 @@ def fake_presigned(object_name: str, *, expires):
             await session.commit()
 
 
+@pytest.mark.asyncio
+async def test_get_archive_preview_url_not_found(
+    client: AsyncClient,
+    make_user,
+):
+    user = await make_user()
+
+    app.dependency_overrides[get_current_user] = _override_user(user)
+    try:
+        response = await client.get("/courses/999/archives/1/preview")
+        assert response.status_code == 404
+    finally:
+        app.dependency_overrides.pop(get_current_user, None)
+
+
+@pytest.mark.asyncio
+async def test_get_archive_download_url_not_found(
+    client: AsyncClient,
+    make_user,
+):
+    user = await make_user()
+
+    app.dependency_overrides[get_current_user] = _override_user(user)
+    try:
+        response = await client.get("/courses/123/archives/456/download")
+        assert response.status_code == 404
+    finally:
+        app.dependency_overrides.pop(get_current_user, None)
+
+
 @pytest.mark.asyncio
 async def test_update_archive_direct_sets_fields(
     session_maker,
@@ -990,6 +1020,46 @@ async def test_delete_course_not_found_direct(session_maker, make_user):
         assert exc.value.status_code == 404
 
 
+@pytest.mark.asyncio
+async def test_admin_delete_course_soft_deletes_archives(
+    client: AsyncClient,
+    session_maker,
+    make_user,
+):
+    admin = await make_user(is_admin=True)
+    course = await _create_course(session_maker)
+    archive = await _create_archive(
+        session_maker,
+        course_id=course.id,
+        uploader_id=admin.id,
+    )
+
+    app.dependency_overrides[get_current_user] = _override_user(admin)
+    try:
+        response = await client.delete(
+            f"/courses/admin/courses/{course.id}"
+        )
+        assert response.status_code == 200
+        body = response.json()
+        assert "1 associated archives" in body["message"]
+
+        async with session_maker() as session:
+            refreshed_course = await session.get(Course, course.id)
+            refreshed_archive = await session.get(Archive, archive.id)
+            assert refreshed_course.deleted_at is not None
+            assert refreshed_archive.deleted_at is not None
+    finally:
+        app.dependency_overrides.pop(get_current_user, None)
+        async with session_maker() as session:
+            await session.execute(
+                delete(Archive).where(Archive.id == archive.id)
+            )
+            await session.execute(
+                delete(Course).where(Course.id == course.id)
+            )
+            await session.commit()
+
+
 @pytest.mark.asyncio
 async def test_list_all_courses_direct_returns_courses(
     session_maker,
@@ -1009,3 +1079,129 @@ async def test_list_all_courses_direct_returns_courses(
         async with session_maker() as session:
             await session.execute(delete(Course).where(Course.id == course.id))
             await session.commit()
+
+
+@pytest.mark.asyncio
+async def test_get_course_archives_not_found_direct(session_maker, make_user):
+    user = await make_user()
+    async with session_maker() as session:
+        with pytest.raises(HTTPException) as exc:
+            await get_course_archives(
+                course_id=999999,
+                current_user=UserRoles(user_id=user.id, is_admin=False),
+                db=session,
+            )
+        assert exc.value.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_get_archive_preview_url_not_found_direct(session_maker, make_user):
+    user = await make_user()
+    async with session_maker() as session:
+        with pytest.raises(HTTPException) as exc:
+            await get_archive_preview_url(
+                course_id=1,
+                archive_id=2,
+                current_user=UserRoles(user_id=user.id, is_admin=False),
+                db=session,
+            )
+        assert exc.value.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_get_archive_download_url_not_found_direct(session_maker, make_user):
+    user = await make_user()
+    async with session_maker() as session:
+        with pytest.raises(HTTPException) as exc:
+            await get_archive_download_url(
+                course_id=1,
+                archive_id=2,
+                current_user=UserRoles(user_id=user.id, is_admin=False),
+                db=session,
+            )
+        assert exc.value.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_update_archive_course_creates_new_course_direct(session_maker, make_user):
+    admin = await make_user(is_admin=True)
+    course = await _create_course(session_maker, name="Direct Course")
+    archive = await _create_archive(
+        session_maker,
+        course_id=course.id,
+        uploader_id=admin.id,
+    )
+
+    async with session_maker() as session:
+        response = await update_archive_course(
+            course_id=course.id,
+            archive_id=archive.id,
+            course_update=ArchiveUpdateCourse(
+                course_name="Brand New Course",
+                course_category=CourseCategory.GRADUATE,
+            ),
+            current_user=UserRoles(user_id=admin.id, is_admin=True),
+            db=session,
+        )
+        new_course_id = response["new_course_id"]
+        new_course = await session.get(Course, new_course_id)
+        assert new_course.name == "Brand New Course"
+
+        await session.execute(delete(Archive).where(Archive.id == archive.id))
+        await session.execute(delete(Course).where(Course.id == course.id))
+        await session.execute(delete(Course).where(Course.id == new_course_id))
+        await session.commit()
+
+
+@pytest.mark.asyncio
+async def test_create_course_duplicate_direct(session_maker, make_user):
+    admin = await make_user(is_admin=True)
+    course = await _create_course(
+        session_maker,
+        name="Duplicate Direct",
+        category=CourseCategory.GENERAL,
+    )
+
+    async with session_maker() as session:
+        with pytest.raises(HTTPException) as exc:
+            await create_course(
+                course_data=CourseCreate(
+                    name="Duplicate Direct",
+                    category=CourseCategory.GENERAL,
+                ),
+                current_user=UserRoles(user_id=admin.id, is_admin=True),
+                db=session,
+            )
+        assert exc.value.status_code == 400
+
+    async with session_maker() as session:
+        await session.execute(delete(Course).where(Course.id == course.id))
+        await session.commit()
+
+
+@pytest.mark.asyncio
+async def test_delete_course_soft_deletes_direct(session_maker, make_user):
+    admin = await make_user(is_admin=True)
+    course = await _create_course(session_maker, name="Delete Direct")
+    archive = await _create_archive(
+        session_maker,
+        course_id=course.id,
+        uploader_id=admin.id,
+    )
+
+    async with session_maker() as session:
+        result = await delete_course(
+            course_id=course.id,
+            current_user=UserRoles(user_id=admin.id, is_admin=True),
+            db=session,
+        )
+        assert "associated archives" in result["message"]
+
+        refreshed_course = await session.get(Course, course.id)
+        refreshed_archive = await session.get(Archive, archive.id)
+        assert refreshed_course.deleted_at is not None
+        assert refreshed_archive.deleted_at is not None
+
+        await session.execute(delete(Archive).where(Archive.id == archive.id))
+        await session.execute(delete(Course).where(Course.id == course.id))
+        await session.commit()

backend/tests/api/test_meme.py

@@ -1,17 +1,37 @@
 import pytest
+from fastapi import HTTPException
 from sqlalchemy import delete, select
 
+from app.api.services.meme import get_random_meme
+
 from app.models.models import Meme
 
 
 @pytest.mark.asyncio
-async def test_get_random_meme_returns_meme(client):
-    response = await client.get("/meme")
-    assert response.status_code == 200
+async def test_get_random_meme_returns_meme(client, session_maker):
+    created_id = None
+    async with session_maker() as session:
+        existing = await session.execute(select(Meme))
+        meme = existing.scalars().first()
+        if meme is None:
+            meme = Meme(content="Seed", language="en")
+            session.add(meme)
+            await session.commit()
+            await session.refresh(meme)
+            created_id = meme.id
 
-    payload = response.json()
-    assert payload["content"]
-    assert payload["language"]
+    try:
+        response = await client.get("/meme")
+        assert response.status_code == 200
+
+        payload = response.json()
+        assert payload["content"]
+        assert payload["language"]
+    finally:
+        if created_id is not None:
+            async with session_maker() as session:
+                await session.execute(delete(Meme).where(Meme.id == created_id))
+                await session.commit()
 
 
 @pytest.mark.asyncio
@@ -38,3 +58,31 @@ async def test_get_random_meme_returns_404_when_empty(client, session_maker):
                     for item in snapshot
                 )
                 await session.commit()
+
+
+@pytest.mark.asyncio
+async def test_get_random_meme_direct_returns_entry(session_maker):
+    async with session_maker() as session:
+        await session.execute(delete(Meme))
+        await session.commit()
+
+        meme = Meme(content="Hi", language="en")
+        session.add(meme)
+        await session.commit()
+        await session.refresh(meme)
+
+        result = await get_random_meme(db=session)
+        assert result.id == meme.id
+
+        await session.execute(delete(Meme).where(Meme.id == meme.id))
+        await session.commit()
+
+
+@pytest.mark.asyncio
+async def test_get_random_meme_direct_raises_when_empty(session_maker):
+    async with session_maker() as session:
+        await session.execute(delete(Meme))
+        await session.commit()
+
+        with pytest.raises(HTTPException):
+            await get_random_meme(db=session)