Add base for members

backend/app/tests/api/routes/test_member.py

@@ -0,0 +1,273 @@
+import uuid
+
+from fastapi import status
+from fastapi.testclient import TestClient
+from sqlmodel import Session, select
+
+from app.core.config import settings
+from app.models.member import Member, MemberTeamLink, MemberTeamLinkCreate, MemberRank
+from app.models.user import User
+from app.tests.conftest import EventUserHeader
+from app.tests.utils.team import create_random_team
+from app.tests.utils.member import create_random_member
+from app.tests.utils.user import create_random_user, authentication_token_from_user
+
+
+def test_create_member(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None:
+    data = {
+        "name": "John Do",
+        "scouting_id": "12345678",
+        "allergy": "Do not feed Tomatoes",
+    }
+    response = client.post(
+        f"{settings.API_V1_STR}/members/",
+        headers=superuser_token_headers,
+        json=data,
+    )
+    assert response.status_code == status.HTTP_200_OK
+    content = response.json()
+    assert content["name"] == data["name"]
+    assert content["scouting_id"] == data["scouting_id"]
+    assert content["allergy"] == data["allergy"]
+    assert "contact" in content
+    assert "comment" in content
+    assert "birthday_at" in content
+    assert "canceled_at" in content
+    assert "canceled_reason" in content
+    assert "id" in content
+
+    member_query = select(Member).where(Member.id == content["id"])
+    member_db = db.exec(member_query).first()
+    assert member_db
+    assert member_db.name == data["name"]
+    assert member_db.scouting_id == data["scouting_id"]
+    assert member_db.allergy == data["allergy"]
+
+    user = User.get_by_email(session=db, email=settings.FIRST_SUPERUSER)
+    assert member_db.created_by == user.id
+
+
+def test_create_member_no_permissions(client: TestClient, normal_user_token_headers: dict[str, str], db: Session) -> None:
+    data = {
+        "name": "No John",
+        "scouting_id": "0",
+        "comment": "Is not existing",
+    }
+    response = client.post(
+        f"{settings.API_V1_STR}/members/",
+        headers=normal_user_token_headers,
+        json=data,
+    )
+    assert response.status_code == status.HTTP_403_FORBIDDEN
+    assert response.json()["detail"] == "Not enough permissions"
+
+
+def test_read_member(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None:
+    member = create_random_member(db)
+    response = client.get(
+        f"{settings.API_V1_STR}/members/{member.id}",
+        headers=superuser_token_headers,
+    )
+    assert response.status_code == status.HTTP_200_OK
+    content = response.json()
+    assert content["id"] == str(member.id)
+    assert content["name"] == member.name
+    assert content["contact"] == member.contact
+    assert content["scouting_id"] == member.scouting_id
+    assert content["comment"] == member.comment
+    assert content["allergy"] == member.allergy
+    assert content["birthday_at"] == member.birthday_at
+    assert content["canceled_at"] == member.canceled_at
+    assert content["canceled_reason"] == member.canceled_reason
+
+
+def test_read_member_event_user(client: TestClient, event_user_token_headers: EventUserHeader, db: Session) -> None:
+    team = create_random_team(db, event=event_user_token_headers.event)
+
+    member = create_random_member(db)
+    link = MemberTeamLinkCreate(member_id=member.id, rank=MemberRank.TEAM_MEMBER)
+    MemberTeamLink.create(session=db, create_obj=link, team=team)
+
+    response = client.get(
+        f"{settings.API_V1_STR}/members/{member.id}",
+        headers=event_user_token_headers.headers,
+    )
+    assert response.status_code == status.HTTP_200_OK
+    content = response.json()
+    assert content["id"] == str(member.id)
+    assert content["name"] == member.name
+    assert content["contact"] == member.contact
+    assert content["scouting_id"] == member.scouting_id
+    assert content["comment"] == member.comment
+    assert content["allergy"] == member.allergy
+    assert content["birthday_at"] == member.birthday_at
+    assert content["canceled_at"] == member.canceled_at
+    assert content["canceled_reason"] == member.canceled_reason
+
+
+def test_read_member_own_user(client: TestClient, db: Session) -> None:
+    member = create_random_member(db)
+
+    user = create_random_user(db)
+    user.member_id = member.id
+    db.add(user)
+    db.commit()
+
+    response = client.get(
+        f"{settings.API_V1_STR}/members/{member.id}",
+        headers=authentication_token_from_user(client=client, db=db, user=user),
+    )
+    assert response.status_code == status.HTTP_200_OK
+    content = response.json()
+    assert content["id"] == str(member.id)
+    assert content["name"] == member.name
+    assert content["contact"] == member.contact
+    assert content["scouting_id"] == member.scouting_id
+    assert content["comment"] == member.comment
+    assert content["allergy"] == member.allergy
+    assert content["birthday_at"] == member.birthday_at
+    assert content["canceled_at"] == member.canceled_at
+    assert content["canceled_reason"] == member.canceled_reason
+
+
+def test_read_member_not_found(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None:
+    response = client.get(
+        f"{settings.API_V1_STR}/members/{uuid.uuid4()}",
+        headers=superuser_token_headers,
+    )
+    assert response.status_code == status.HTTP_404_NOT_FOUND
+    assert response.json()["detail"] == "Member not found"
+
+
+def test_read_member_no_permission(client: TestClient, normal_user_token_headers: dict[str, str], db: Session) -> None:
+    member = create_random_member(db)
+    response = client.get(
+        f"{settings.API_V1_STR}/members/{member.id}",
+        headers=normal_user_token_headers,
+    )
+    assert response.status_code == status.HTTP_403_FORBIDDEN
+    assert response.json()["detail"] == "Not enough permissions"
+
+
+def test_read_members(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None:
+    create_random_member(db)
+    create_random_member(db)
+    response = client.get(
+        f"{settings.API_V1_STR}/members/",
+        headers=superuser_token_headers,
+    )
+    assert response.status_code == status.HTTP_200_OK
+    content = response.json()
+    assert "count" in content
+    assert content["count"] >= 2
+    assert "data" in content
+    assert isinstance(content["data"], list)
+    assert len(content["data"]) <= content["count"]
+
+
+def test_read_members_event_user(client: TestClient, event_user_token_headers: EventUserHeader, db: Session) -> None:
+    team = create_random_team(db, event=event_user_token_headers.event)
+
+    member = create_random_member(db)
+    link = MemberTeamLinkCreate(member_id=member.id, rank=MemberRank.TEAM_MEMBER)
+    MemberTeamLink.create(session=db, create_obj=link, team=team)
+
+    response = client.get(
+        f"{settings.API_V1_STR}/members/",
+        headers=event_user_token_headers.headers,
+    )
+    assert response.status_code == status.HTTP_200_OK
+    content = response.json()
+    assert "count" in content
+    assert content["count"] >= 1
+    assert "data" in content
+    assert isinstance(content["data"], list)
+    assert len(content["data"]) <= content["count"]
+
+
+def test_read_members_no_permissions(client: TestClient, normal_user_token_headers: dict[str, str], db: Session) -> None:
+    create_random_member(db)
+    create_random_member(db)
+    response = client.get(
+        f"{settings.API_V1_STR}/divisions/",
+        headers=normal_user_token_headers,
+    )
+    assert response.status_code == status.HTTP_200_OK
+    content = response.json()
+    assert "count" in content
+    assert content["count"] == 0
+    assert "data" in content
+    assert isinstance(content["data"], list)
+    assert len(content["data"]) == 0
+
+
+def test_read_members_self_created(client: TestClient, db: Session) -> None:
+    user = create_random_user(db)
+    member = create_random_member(db)
+    member.created_by = user.id
+    db.add(member)
+    db.commit()
+
+    response = client.get(
+        f"{settings.API_V1_STR}/members/",
+        headers=authentication_token_from_user(client=client, db=db, user=user),
+    )
+    assert response.status_code == status.HTTP_200_OK
+    content = response.json()
+    assert "count" in content
+    assert content["count"] == 1
+    assert "data" in content
+    assert isinstance(content["data"], list)
+    assert len(content["data"]) <= content["count"]
+
+
+def test_update_member(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None:
+    member = create_random_member(db)
+    member_id = member.id
+    data = {
+        "name": "Updated name",
+        "contact": "Updated contact",
+    }
+    response = client.put(
+        f"{settings.API_V1_STR}/members/{member_id}",
+        headers=superuser_token_headers,
+        json=data,
+    )
+    assert response.status_code == status.HTTP_200_OK
+    content = response.json()
+    assert content["id"] == str(member_id)
+    assert content["name"] == data["name"]
+    assert content["contact"] == data["contact"]
+
+    member_query = select(Member).where(Member.id == member_id)
+    member_db = db.exec(member_query).first()
+    assert member_db
+    db.refresh(member_db)
+
+    assert member_db.name == data["name"]
+    assert member_db.contact == data["contact"]
+    assert content["scouting_id"] == member_db.scouting_id
+    assert content["comment"] == member_db.comment
+    assert content["allergy"] == member_db.allergy
+    assert content["birthday_at"] == member_db.birthday_at
+    assert content["canceled_at"] == member_db.canceled_at
+    assert content["canceled_reason"] == member_db.canceled_reason
+
+def test_delete_member(client: TestClient, superuser_token_headers: dict[str, str], db: Session) -> None:
+    member = create_random_member(db)
+    member_id = member.id
+    response = client.delete(
+        f"{settings.API_V1_STR}/members/{member_id}",
+        headers=superuser_token_headers,
+    )
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["message"] == "Member deleted successfully"
+
+    member_query = select(Member).where(Member.id == member_id)
+    member_db = db.exec(member_query).first()
+    assert member_db is None
+
+
+# TODO: Team link tests
+# app/models/member.py                             79      8    90%   91-96
+# app/api/routes/teams.py                         122     26    79%   272-276, 287-310, 318-328, 339-357, 367-378, 386-398

backend/app/tests/api/routes/test_users.py

@@ -172,9 +172,8 @@ def test_retrieve_users(
 def test_update_user_me(
     client: TestClient, normal_user_token_headers: dict[str, str], db: Session
 ) -> None:
-    full_name = "Updated Name"
     email = random_email()
-    data = {"full_name": full_name, "email": email}
+    data = {"email": email}
     r = client.patch(
         f"{settings.API_V1_STR}/users/me",
         headers=normal_user_token_headers,
@@ -183,13 +182,11 @@ def test_update_user_me(
     assert r.status_code == status.HTTP_200_OK
     updated_user = r.json()
     assert updated_user["email"] == email
-    assert updated_user["full_name"] == full_name
 
     user_query = select(User).where(User.email == email)
     user_db = db.exec(user_query).first()
     assert user_db
     assert user_db.email == email
-    assert user_db.full_name == full_name
 
 
 def test_update_password_me(
@@ -311,8 +308,7 @@ def test_update_password_me_same_password_error(
 def test_register_user(client: TestClient, db: Session) -> None:
     username = random_email()
     password = random_lower_string()
-    full_name = random_lower_string()
-    data = {"email": username, "password": password, "full_name": full_name}
+    data = {"email": username, "password": password}
     r = client.post(
         f"{settings.API_V1_STR}/users/signup",
         json=data,
@@ -320,23 +316,19 @@ def test_register_user(client: TestClient, db: Session) -> None:
     assert r.status_code == status.HTTP_200_OK
     created_user = r.json()
     assert created_user["email"] == username
-    assert created_user["full_name"] == full_name
 
     user_query = select(User).where(User.email == username)
     user_db = db.exec(user_query).first()
     assert user_db
     assert user_db.email == username
-    assert user_db.full_name == full_name
     assert verify_password(password, user_db.hashed_password)
 
 
 def test_register_user_already_exists_error(client: TestClient) -> None:
     password = random_lower_string()
-    full_name = random_lower_string()
     data = {
         "email": settings.FIRST_SUPERUSER,
         "password": password,
-        "full_name": full_name,
     }
     r = client.post(
         f"{settings.API_V1_STR}/users/signup",
@@ -346,45 +338,6 @@ def test_register_user_already_exists_error(client: TestClient) -> None:
     assert r.json()["detail"] == "The user with this email already exists in the system"
 
 
-def test_update_user(
-    client: TestClient, superuser_token_headers: dict[str, str], db: Session
-) -> None:
-    username = random_email()
-    password = random_lower_string()
-    user_in = UserCreate(email=username, password=password)
-    user = User.create(session=db, create_obj=user_in)
-
-    data = {"full_name": "Updated_full_name"}
-    r = client.patch(
-        f"{settings.API_V1_STR}/users/{user.id}",
-        headers=superuser_token_headers,
-        json=data,
-    )
-    assert r.status_code == status.HTTP_200_OK
-    updated_user = r.json()
-
-    assert updated_user["full_name"] == "Updated_full_name"
-
-    user_query = select(User).where(User.email == username)
-    user_db = db.exec(user_query).first()
-    db.refresh(user_db)
-    assert user_db
-    assert user_db.full_name == "Updated_full_name"
-
-
-def test_update_user_not_exists(
-    client: TestClient, superuser_token_headers: dict[str, str]
-) -> None:
-    data = {"full_name": "Updated_full_name"}
-    r = client.patch(
-        f"{settings.API_V1_STR}/users/{uuid.uuid4()}",
-        headers=superuser_token_headers,
-        json=data,
-    )
-    assert r.status_code == status.HTTP_404_NOT_FOUND
-    assert r.json()["detail"] == "The user with this id does not exist in the system"
-
-
 def test_update_user_email_exists(
     client: TestClient, superuser_token_headers: dict[str, str], db: Session
 ) -> None:

backend/app/tests/conftest.py

@@ -19,8 +19,8 @@ def db() -> Generator[Session, None, None]:
     with Session(engine) as session:
         init_db(session)
         yield session
-        statement = delete(User)
-        session.execute(statement)
+        # statement = delete(User)
+        # session.execute(statement)
         session.commit()
 
 

backend/app/tests/utils/member.py

@@ -0,0 +1,19 @@
+from sqlmodel import Session
+
+from app.models.team import Team
+from app.models.member import Member, MemberCreate, MemberTeamLink, MemberTeamLinkCreate, MemberRank
+from app.tests.utils.utils import random_lower_string
+
+
+def create_random_member(db: Session) -> Member:
+    member_in = MemberCreate(
+        name=random_lower_string(),
+        contact=random_lower_string(),
+        scouting_id=random_lower_string(),
+        comment=random_lower_string(),
+        allergy=random_lower_string(),
+        # birthday_at=random_datetime(),
+        # canceled_at=random_datetime(),
+        canceled_reason=random_lower_string(),
+    )
+    return Member.create(session=db, create_obj=member_in)