Merge pull request #65 from PCS-Poli-USP/tests/subjects

Create subject routes tests

tests/routes/test_subject.py

@@ -1,79 +1,124 @@
-# import pytest
-# from httpx import AsyncClient
-# from fastapi import status
-# from json import loads
+from fastapi import status
+from fastapi.testclient import TestClient
+from json import loads
+from sqlmodel import Session
+
+from server.repositories.subject_repository import SubjectRepository
+from server.utils.must_be_int import must_be_int
+from tests.utils.building_test_utils import add_building, make_building
+from tests.utils.default_values.test_building_default_values import (
+    BuildingDefaultValues,
+)
+from tests.utils.subject_test_utils import (
+    check_code_exists,
+    create_subject,
+    make_subject_register_input,
+    make_subject_update_input,
+)
+from tests.utils.default_values.test_subject_default_values import SubjectDefaultValues
+
+from server.models.database.subject_db_model import Subject
+from server.models.database.user_db_model import User
+
+MAX_SUBJECT_COUNT = 5
+UPDATED_SUBJECT_CODE = "DEF000U"
+
+
+def test_subject_get_all(db: Session, client: TestClient, user: User) -> None:
+    building = make_building(name=BuildingDefaultValues.NAME, user=user)
+    db.add(building)
+
+    subject_ids = []
+    for i in range(MAX_SUBJECT_COUNT):
+        subject_id = create_subject(
+            session=db,
+            code=f"DEF000{
+                                    i}",
+            buildings=[building],
+        )
+        subject_ids.append(subject_id)
+
+    response = client.get("/subjects")
+    assert response.status_code == status.HTTP_200_OK
+
+    data = response.json()
+    assert len(data) == MAX_SUBJECT_COUNT
+
+    data_ids = [subject["id"] for subject in data]
+    for i in range(len(subject_ids)):
+        assert subject_ids[i] in data_ids
+
+
+def test_subject_get(db: Session, client: TestClient, user: User) -> None:
+    building = make_building(name=BuildingDefaultValues.NAME, user=user)
+    db.add(building)
+    subject_id = create_subject(
+        session=db, code=SubjectDefaultValues.CODE, buildings=[building]
+    )
+    response = client.get(f"/subjects/{subject_id}")
+
+    assert response.status_code == status.HTTP_200_OK
+
+    data = response.json()
+    assert data is not None
+    assert data["name"] == SubjectDefaultValues.NAME
+    assert data["code"] == SubjectDefaultValues.CODE
+    assert data["professors"] == SubjectDefaultValues.PROFESSORS
+
+
+def test_subject_create(db: Session, client: TestClient, user: User) -> None:
+    building_id = add_building(session=db, name=BuildingDefaultValues.NAME, user=user)
+    register = make_subject_register_input(building_ids=[building_id])
+    subject_input = register.model_dump_json()
+
+    response = client.post("/subjects", json=loads(subject_input))
+    assert response.status_code == status.HTTP_200_OK
+
+    data = response.json()
+    id = data["id"]
+    subject = db.get(Subject, id)
+    assert subject is not None
+
+    if subject:
+        assert subject.code == register.code
+        assert subject.name == register.name
+        building_ids = [building.id for building in subject.buildings]
+        assert building_id in building_ids
+
+
+def test_subject_update(db: Session, client: TestClient, user: User) -> None:
+    building = make_building(name=BuildingDefaultValues.NAME, user=user)
+    db.add(building)
+    buildings = [building]
+
+    subject_id = create_subject(
+        session=db, code=SubjectDefaultValues.CODE, buildings=buildings
+    )
+    input = make_subject_update_input(building_ids=[must_be_int(building.id)])
+
+    input.code = UPDATED_SUBJECT_CODE
+    subject_input = input.model_dump_json()
+
+    response = client.put(f"/subjects/{subject_id}", json=loads(subject_input))
+    assert response.status_code == status.HTTP_200_OK
 
-# from tests.utils.subject_test_utils import add_subject, make_subject_register_input
-# from tests.utils.default_values.test_subject_default_values import SubjectDefaultValues
+    data = response.json()
+    assert data is not None
+    assert data["id"] == subject_id
 
-# from server.models.database.subject_db_model import Subject
-# from server.models.database.user_db_model import User
+    subject = SubjectRepository.get_by_id(id=subject_id, session=db)
+    assert subject.code == UPDATED_SUBJECT_CODE
 
-# MAX_SUBJECT_COUNT = 5
-# UPDATED_SUBJECT_CODE = "DEF000U"
 
+def test_subject_delete(db: Session, client: TestClient, user: User) -> None:
+    building = make_building(name=BuildingDefaultValues.NAME, user=user)
+    db.add(building)
 
-# @pytest.mark.asyncio
-# async def test_subject_get_all(client: AsyncClient, user: User) -> None:
-#     for i in range(MAX_SUBJECT_COUNT):
-#         await add_subject(f"DEF000{i}")
+    subject_id = create_subject(
+        session=db, code=SubjectDefaultValues.CODE, buildings=[building]
+    )
 
-#     response = await client.get("/subjects")
-#     assert response.status_code == status.HTTP_200_OK
+    response = client.delete(f"/subjects/{subject_id}")
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
-#     data = response.json()
-#     assert len(data) == MAX_SUBJECT_COUNT
-
-
-# @pytest.mark.asyncio
-# async def test_subject_get(client: AsyncClient, user: User) -> None:
-#     subject_id = await add_subject(SubjectDefaultValues.CODE)
-#     response = await client.get(f"/subjects/{subject_id}")
-
-#     assert response.status_code == status.HTTP_200_OK
-
-
-# @pytest.mark.asyncio
-# async def test_subject_create(client: AsyncClient, user: User) -> None:
-#     register = make_subject_register_input()
-#     subject_input = register.model_dump_json()
-
-#     response = await client.post("/subjects", json=loads(subject_input))
-#     assert response.status_code == status.HTTP_200_OK
-
-#     subject_id = response.json()
-#     assert isinstance(subject_id, str)
-
-#     subject = await Subject.by_id(subject_id)
-#     assert subject.code == register.code
-
-
-# @pytest.mark.asyncio
-# async def test_subject_update(client: AsyncClient, user: User) -> None:
-#     register = make_subject_register_input()
-#     subject_id = await add_subject(register.code)
-
-#     register.code = UPDATED_SUBJECT_CODE
-#     subject_input = register.model_dump_json()
-
-#     response = await client.put(f"/subjects/{subject_id}", json=loads(subject_input))
-#     assert response.status_code == status.HTTP_200_OK
-
-#     updated_id = response.json()
-#     assert isinstance(updated_id, str)
-
-#     subject = await Subject.by_id(updated_id)
-#     assert subject.code == UPDATED_SUBJECT_CODE
-
-
-# @pytest.mark.asyncio
-# async def test_subject_delete(client: AsyncClient, user: User) -> None:
-#     subject_id = await add_subject(SubjectDefaultValues.CODE)
-
-#     response = await client.delete(f"/subjects/{subject_id}")
-#     assert response.status_code == status.HTTP_200_OK
-
-#     data = response.json()
-#     assert isinstance(data, int)
-
-#     assert not await Subject.check_code_exists(SubjectDefaultValues.CODE)
+    assert not check_code_exists(db=db, code=SubjectDefaultValues.CODE)

tests/utils/building_test_utils.py

@@ -1,15 +1,9 @@
-# type: ignore
-
 from datetime import datetime
 
 from sqlmodel import Session, select
 
 from server.models.database.building_db_model import Building
 from server.models.database.user_db_model import User
-from tests.utils.default_values.test_building_default_values import (
-    BuildingDefaultValues,
-)
-from tests.utils.user_test_utils import get_test_admin_user
 
 
 def make_building(name: str, user: User) -> Building:
@@ -22,16 +16,6 @@ def make_building(name: str, user: User) -> Building:
     return building
 
 
-async def get_testing_building() -> Building:
-    if await Building.check_name_exits(BuildingDefaultValues.NAME):
-        building: Building = await Building.by_name(BuildingDefaultValues.NAME)
-        return building
-    user = await get_test_admin_user()
-    building = make_building(BuildingDefaultValues.NAME, user)
-    await building.create()
-    return building
-
-
 def add_building(session: Session, name: str, user: User) -> int:
     building = make_building(name, user)
     session.add(building)
@@ -43,8 +27,3 @@ def check_name_exists(db: Session, name: str) -> bool:
     statement = select(Building).where(Building.name == name)
     result = db.exec(statement).first()
     return result is not None
-
-
-async def remove_building(id: str) -> None:
-    building = await Building.by_id(id)
-    await building.delete()  # type: ignore

tests/utils/subject_test_utils.py

@@ -1,13 +1,16 @@
-# type: ignore
-
+from sqlmodel import Session, select, col
+from server.models.database.building_db_model import Building
 from server.models.database.subject_db_model import Subject
-from server.models.http.requests.subject_request_models import SubjectRegister
-from server.routes.restricted.subject_routes import SubjectCodeAlreadyExists
+from server.models.http.requests.subject_request_models import (
+    SubjectRegister,
+    SubjectUpdate,
+)
 from tests.utils.default_values.test_subject_default_values import SubjectDefaultValues
 
 
-def make_subject(code: str) -> Subject:
+def make_subject(code: str, buildings: list[Building]) -> Subject:
     subject = Subject(
+        buildings=buildings,
         code=code,
         name=SubjectDefaultValues.NAME,
         professors=SubjectDefaultValues.PROFESSORS,
@@ -19,10 +22,25 @@ def make_subject(code: str) -> Subject:
     return subject
 
 
-def make_subject_register_input() -> SubjectRegister:
+def make_subject_register_input(building_ids: list[int]) -> SubjectRegister:
     register = SubjectRegister(
         code=SubjectDefaultValues.CODE,
         name=SubjectDefaultValues.NAME,
+        building_ids=building_ids,
+        professors=SubjectDefaultValues.PROFESSORS,
+        type=SubjectDefaultValues.TYPE,
+        class_credit=SubjectDefaultValues.CLASS_CREDIT,
+        work_credit=SubjectDefaultValues.WORK_CREDIT,
+        activation=SubjectDefaultValues.ACTIVATION,
+    )
+    return register
+
+
+def make_subject_update_input(building_ids: list[int]) -> SubjectUpdate:
+    register = SubjectUpdate(
+        code=SubjectDefaultValues.CODE,
+        name=SubjectDefaultValues.NAME,
+        building_ids=building_ids,
         professors=SubjectDefaultValues.PROFESSORS,
         type=SubjectDefaultValues.TYPE,
         class_credit=SubjectDefaultValues.CLASS_CREDIT,
@@ -32,9 +50,15 @@ def make_subject_register_input() -> SubjectRegister:
     return register
 
 
-async def add_subject(code: str) -> str:
-    if await Subject.check_code_exists(code):
-        raise SubjectCodeAlreadyExists(code)
-    subject = make_subject(code)
-    await subject.create()
-    return str(subject.id)
+def create_subject(session: Session, code: str, buildings: list[Building]) -> int:
+    """Create a default subject with code and buildings"""
+    subject = make_subject(code, buildings)
+    session.add(subject)
+    session.commit()
+    return subject.id  # type: ignore
+
+
+def check_code_exists(db: Session, code: str) -> bool:
+    statement = select(Subject).where(col(Subject.code) == code)
+    result = db.exec(statement).first()
+    return result is not None