Added cringe ai tests for whitelist just in case

app/routes/player.py

@@ -56,7 +56,7 @@ async def is_token_valid(session: Session, token: str):
     Checks if the given state token is valid for the given ckey.
     """
     token_entry = session.exec(select(OneTimeToken).where(
-        OneTimeToken.token == token and OneTimeToken.expiry > datetime.datetime.now())).first()
+        OneTimeToken.token == token).where(OneTimeToken.expiry > datetime.datetime.now())).first()
     return token_entry is not None
 
 

app/routes/whitelist.py

@@ -17,10 +17,10 @@
 async def create_whitelist(session: SessionDep, wl: Whitelist, ignore_bans: bool = False) -> Whitelist:
     if not ignore_bans:
         bans = session.exec(select(WhitelistBan).where(
-            WhitelistBan.player_id == wl.player_id
-            and WhitelistBan.valid is True
-            and WhitelistBan.type == wl.type
-            and WhitelistBan.issue_time + WhitelistBan.duration < wl.issue_time)).first()
+            WhitelistBan.player_id == wl.player_id).where(
+            WhitelistBan.valid is True).where(
+            WhitelistBan.type == wl.type).where(
+            WhitelistBan.issue_time + WhitelistBan.duration < wl.issue_time)).first()
         if bans is not None:
             raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Player is banned",
                             headers={"X-Retry-After": str(WhitelistBan.issue_time + WhitelistBan.duration)})
@@ -34,13 +34,13 @@ async def create_whitelist(session: SessionDep, wl: Whitelist, ignore_bans: bool
 @router.get("/ckey/{ckey}", status_code=status.HTTP_200_OK)
 async def get_whitelist_by_ckey(session: SessionDep, ckey: str, valid: bool = True) -> list[Whitelist]:
     result = session.exec(select(Whitelist).join(Player, onclause=Player.discord_id == Whitelist.player_id)
-                          .where(Player.ckey == ckey and Whitelist.valid == valid))
+                          .where(Player.ckey == ckey).where(Whitelist.valid == valid))
     return result.all()
 
 @router.get("/discord/{discord_id}", status_code=status.HTTP_200_OK)
 async def get_whitelist_by_discord(session: SessionDep, discord_id: str, valid: bool = True) -> list[Whitelist]:
     result = session.exec(select(Whitelist).join(Player, onclause=Player.discord_id == Whitelist.player_id)
-                          .where(Player.discord_id == discord_id and Whitelist.valid == valid))
+                          .where(Player.discord_id == discord_id).where(Whitelist.valid == valid))
     return result.all()
 
 @router.post("/ban", dependencies=[Depends(verify_bearer)], status_code=status.HTTP_201_CREATED)
@@ -59,9 +59,9 @@ async def ban_whitelist(session: SessionDep, ban: WhitelistBan, invalidate_old_w
 @router.get("/ban/discord/{discord_id}", status_code=status.HTTP_200_OK)
 async def get_whitelist_bans_by_discord(session: SessionDep, discord_id: str, only_active: bool = True) -> list[WhitelistBan]:
     result = session.exec(select(WhitelistBan).where(
-        WhitelistBan.player_id == discord_id
-        and WhitelistBan.valid == only_active
-        and WhitelistBan.issue_time + WhitelistBan.duration > datetime.datetime.now()))
+        WhitelistBan.player_id == discord_id).where(
+        WhitelistBan.valid == only_active).where(
+        WhitelistBan.issue_time + WhitelistBan.duration > datetime.datetime.now()))
     return result.all()
 
 @router.patch("/ban", dependencies=[Depends(verify_bearer)], status_code=status.HTTP_202_ACCEPTED)

app/tests/ai_made/test_whitelist_route.py

@@ -0,0 +1,140 @@
+import pytest
+from datetime import datetime, timedelta
+from fastapi import HTTPException, status
+from sqlmodel import Session, select
+from unittest.mock import Mock
+
+from app.database.models import Whitelist, WhitelistBan, Player
+from app.routes.whitelist import (
+    create_whitelist, 
+    get_whitelist_by_ckey, 
+    get_whitelist_by_discord, 
+    ban_whitelist, 
+    get_whitelist_bans_by_discord, 
+    pardon_whitelist_ban
+)
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("test_input", [
+    {
+        "id": "valid_whitelist_creation",
+        "player_id": "discord123",
+        "type": "antag",
+        "issue_time": datetime.now(),
+        "ignore_bans": False,
+        "expected_status": status.HTTP_201_CREATED
+    },
+    {
+        "id": "whitelist_creation_with_ignore_bans",
+        "player_id": "discord456",
+        "type": "admin",
+        "issue_time": datetime.now(),
+        "ignore_bans": True,
+        "expected_status": status.HTTP_201_CREATED
+    }
+])
+async def test_create_whitelist(test_input, mocker):
+    # Arrange
+    session_mock = Mock(spec=Session)
+    session_mock.exec.return_value.first.return_value = None
+    wl = Whitelist(
+        player_id=test_input["player_id"], 
+        type=test_input["type"], 
+        issue_time=test_input["issue_time"]
+    )
+
+    # Act
+    result = await create_whitelist(
+        session=session_mock, 
+        wl=wl, 
+        ignore_bans=test_input["ignore_bans"]
+    )
+
+    # Assert
+    assert result == wl
+    session_mock.add.assert_called_once_with(wl)
+    session_mock.commit.assert_called_once()
+    session_mock.refresh.assert_called_once_with(wl)
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("test_input", [
+    {
+        "id": "banned_player_without_ignore",
+        "player_id": "discord789",
+        "type": "antag",
+        "issue_time": datetime.now(),
+        "ignore_bans": False,
+        "existing_ban": WhitelistBan(
+            player_id="discord789", 
+            type="antag", 
+            valid=True, 
+            issue_time=datetime.now() - timedelta(days=1), 
+            duration=timedelta(days=7)
+        )
+    }
+])
+
+@pytest.mark.asyncio
+async def test_create_whitelist_with_active_ban(test_input, mocker):
+    # Arrange
+    session_mock = Mock(spec=Session)
+    session_mock.exec.return_value.first.return_value = test_input["existing_ban"]
+    wl = Whitelist(
+        player_id=test_input["player_id"], 
+        type=test_input["type"], 
+        issue_time=test_input["issue_time"]
+    )
+
+    # Act & Assert
+    with pytest.raises(HTTPException) as exc_info:
+        await create_whitelist(
+            session=session_mock, 
+            wl=wl, 
+            ignore_bans=test_input["ignore_bans"]
+        )
+
+    assert exc_info.value.status_code == status.HTTP_409_CONFLICT
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("test_input", [
+    {
+        "id": "get_whitelist_by_existing_ckey",
+        "ckey": "player1",
+        "valid": True,
+        "expected_count": 2
+    },
+    {
+        "id": "get_whitelist_by_nonexistent_ckey",
+        "ckey": "nonexistent",
+        "valid": True,
+        "expected_count": 0
+    }
+])
+async def test_get_whitelist_by_ckey(test_input, mocker):
+    # Arrange
+    session_mock = Mock(spec=Session)
+
+    # AI isnt capable of joins, lol
+    if test_input["ckey"] == "player1":
+        mock_whitelists = [
+            Whitelist(id=1, player_id="discord1", valid=True),
+            Whitelist(id=2, player_id="discord2", valid=True)
+        ]
+    else:
+        mock_whitelists = []
+
+    session_mock.exec.return_value.all.return_value = mock_whitelists
+
+    # Act
+    result = await get_whitelist_by_ckey(
+        session=session_mock, 
+        ckey=test_input["ckey"], 
+        valid=test_input["valid"]
+    )
+
+    # Assert
+    assert len(result) == test_input["expected_count"]
+
+
+
+# Additional tests for other routes would follow similar patterns