Merge a74da26 into ccf51e7

Author: D0rs4n

README.md

@@ -1,7 +1,8 @@
 # code-jam-management
 Management microservice for Python Discord Code Jams
 
-## Running tests
-
-To run tests, export `DATABASE_URL` to point to a empty PostgreSQL database.
-Afterwards, you can simply run `pytest` to run tests in the repository.
+## Running tests:
+- Create an `.env` file with:
+```DATABASE_URL=postgresql+asyncpg://codejam_management:codejam_management@localhost:7777```
+- Then, run `docker-compose up`
+- And finally, you can run `pytest` locally.

tests/conftest.py

@@ -10,16 +10,16 @@
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, create_async_engine
 
+from api.constants import DATABASE_URL
 from api.database import Base
 from api.dependencies import get_db_session
-from api.constants import DATABASE_URL
 from api.main import app as main_app
 
 test_engine = create_async_engine(DATABASE_URL, future=True, isolation_level="AUTOCOMMIT")
 
 
 @pytest.fixture(scope="session")
-def event_loop(request) -> Generator:
+def event_loop() -> Generator:
     """Yields back an asyncio event loop, then closes it."""
     loop = asyncio.get_event_loop()
     yield loop
@@ -28,6 +28,7 @@ def event_loop(request) -> Generator:
 
 @pytest.fixture(scope="session")
 async def create_test_database_engine() -> Generator:
+    """Yield back a Database engine object."""
     async with test_engine.begin() as conn:
         await conn.execute(text("CREATE DATABASE test;"))
         test_db_url = urlsplit(DATABASE_URL)._replace(path="/test")
@@ -39,11 +40,7 @@ async def create_test_database_engine() -> Generator:
 
 @pytest.fixture()
 async def session(create_test_database_engine: AsyncEngine) -> AsyncSession:
-    """
-    Yields back an Asynchronous database session
-    This fixture requests `create_test_database_engine` fixture, as its dependency, this way the session
-    will point to the database created using the current worker's id.
-    """
+    """Yields back an Asynchronous database session."""
     async with create_test_database_engine.begin() as conn:
         await conn.run_sync(Base.metadata.drop_all)
         await conn.run_sync(Base.metadata.create_all)
@@ -53,17 +50,18 @@ async def session(create_test_database_engine: AsyncEngine) -> AsyncSession:
 
 
 @pytest.fixture()
-def override_db_session(session: AsyncSession):
-    """Yields back the modified Database session that uses the correspondent Database"""
+def override_db_session(session: AsyncSession) -> AsyncSession:
+    """Yields back the modified Database session that uses the correspondent Database."""
 
-    async def _override_db_session():
+    async def _override_db_session() -> AsyncSession:
         yield session
 
     yield _override_db_session
 
 
 @pytest.fixture()
-def app(override_db_session: Callable):
+def app(override_db_session: Callable) -> FastAPI:
+    """Overrides the default FastAPI app to use the overridden DB session."""
     main_app.dependency_overrides[get_db_session] = override_db_session
     yield main_app
 

tests/routers/conftest.py

@@ -1,12 +1,13 @@
 """Fixtures for tests of the `routers` package."""
 import pytest
+from fastapi import FastAPI
 from httpx import AsyncClient
 from sqlalchemy import delete
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
 
 from api import models
-from api.database import Jam, Team, TeamUser, User
+from api.database import Infraction, Jam, Team, TeamUser, User
 
 
 async def delete_jam(jam: models.CodeJamResponse, session: AsyncSession) -> None:
@@ -58,4 +59,27 @@ async def created_codejam(
     created_jam = response.json()
     parsed = models.CodeJamResponse(**created_jam)
     yield parsed
-    await delete_jam(parsed, session)
+
+
+@pytest.fixture
+async def created_infraction(
+        client: AsyncClient,
+        app: FastAPI,
+        session: AsyncSession,
+        created_codejam: models.CodeJamResponse
+) -> models.InfractionResponse:
+    """Create a test Infraction via the API and yield it."""
+    # Select one of the test users, so that we can issue an infraction to that user
+    user_id = created_codejam.teams[0].users[0].user_id
+    jam_id = created_codejam.id
+    response = await client.post(
+        app.url_path_for("create_infraction"),
+        json={"user_id": user_id, "jam_id": jam_id, "reason": "Too good to be true", "infraction_type": "warning"}
+    )
+    parsed_infraction = models.InfractionResponse(**response.json())
+    assert response.status_code == 200
+    # Check whether the infraction was actually created, and insterted into the db
+    assert (
+        await (session.execute(select(Infraction).where(Infraction.id == parsed_infraction.id)))
+    ).unique().scalars().one_or_none(), "Failed to create Infraction"
+    yield parsed_infraction

tests/routers/test_codejams.py

@@ -2,8 +2,11 @@
 import pytest
 from fastapi import FastAPI
 from httpx import AsyncClient
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
 
 from api import models
+from api.database import User
 
 pytestmark = pytest.mark.asyncio
 
@@ -12,31 +15,39 @@
 # If the database has entries in it, cleanup was not performed properly!
 async def test_list_codejams_without_db_entries(client: AsyncClient, app: FastAPI) -> None:
     """No codejams should be returned when the database is empty."""
-    response = await client.get('/codejams')
+    response = await client.get(app.url_path_for("get_codejams"))
     jams = response.json()
 
     assert response.status_code == 200
     assert not jams
 
 
-async def test_get_nonexistent_code_jam(client: AsyncClient) -> None:
+async def test_get_nonexistent_code_jam(client: AsyncClient, app: FastAPI) -> None:
     """Getting a nonexistent code jam should return a 404."""
-    response = await client.get('/codejams/41902')
+    response = await client.get(app.url_path_for("get_codejam", codejam_id=41902))
     assert response.status_code == 404
 
 
-async def test_get_existing_code_jam(client: AsyncClient, created_codejam: models.CodeJamResponse) -> None:
+async def test_get_existing_code_jam(
+        client: AsyncClient,
+        created_codejam: models.CodeJamResponse,
+        app: FastAPI
+) -> None:
     """Getting an existing code jam should return 200."""
-    response = await client.get(f'/codejams/{created_codejam.id}')
+    response = await client.get(app.url_path_for("get_codejam", codejam_id=created_codejam.id))
     assert response.status_code == 200
     raw = response.json()
     jam = models.CodeJamResponse(**raw)
     assert jam == created_codejam
 
 
-async def test_list_codejams_with_existing_jam(client: AsyncClient, created_codejam: models.CodeJamResponse) -> None:
+async def test_list_codejams_with_existing_jam(
+        client: AsyncClient,
+        created_codejam: models.CodeJamResponse,
+        app: FastAPI
+) -> None:
     """Listing all code jams should return the created jam."""
-    response = await client.get('/codejams')
+    response = await client.get(app.url_path_for("get_codejams"))
     assert response.status_code == 200
     raw = response.json()
 
@@ -47,3 +58,24 @@ async def test_list_codejams_with_existing_jam(client: AsyncClient, created_code
     # Ensure the code jam in the "single jam" endpoint matches the
     # code jam we get returned from the API here.
     assert jam == created_codejam
+
+
+async def test_create_codejams_rejects_invalid_data(client: AsyncClient, app: FastAPI) -> None:
+    """Posting invalid JSON data should return 422."""
+    response = await client.post(app.url_path_for("create_codejam"), json={"name": "test"})
+    assert response.status_code == 422
+
+
+async def test_create_codejams_accepts_valid_data_and_creates_user(
+        client: AsyncClient,
+        app: FastAPI, session: AsyncSession
+) -> None:
+    """Posting a valid JSON data should return 200 and the record should exitst in the DB."""
+    response = await client.post(app.url_path_for("create_codejam"), json={
+        "name": "CodeJam Test",
+        "teams": [{"name": "Dramatic Dragonflies", "users": [{"user_id": 1, "is_leader": True}]}]
+    })
+    assert response.status_code == 200
+
+    # Checks whether the previously added user was actually inserted into the database.
+    assert (await session.execute(select(User).where(User.id == 1))).scalars().unique().one_or_none()

tests/routers/test_infractions.py

@@ -0,0 +1,38 @@
+"""Tests for the infractions router."""
+import pytest
+from fastapi import FastAPI
+from httpx import AsyncClient
+
+from api import models
+
+pytestmark = pytest.mark.asyncio
+
+
+async def test_list_infractions_without_db_entries(client: AsyncClient, app: FastAPI) -> None:
+    """No infractions should be returned when the database is empty."""
+    response = await client.get(app.url_path_for("get_infractions"))
+    infractions = response.json()
+    assert response.status_code == 200
+    assert not infractions
+
+
+async def test_get_nonexsistent_infraction(client: AsyncClient, app: FastAPI) -> None:
+    """Getting a nonexistent infraction should return a 404."""
+    response = await client.get(app.url_path_for("get_infraction", infraction_id=41902))
+    assert response.status_code == 404
+
+
+async def test_get_existent_infraction(
+        client: AsyncClient,
+        app: FastAPI,
+        created_infraction: models.InfractionResponse
+) -> None:
+    """Getting an existing infraction should return 200."""
+    response = await client.get(app.url_path_for("get_infraction", infraction_id=created_infraction.id))
+    assert response.status_code == 200
+
+
+async def test_create_infractions_rejects_invalid_data(client: AsyncClient, app: FastAPI) -> None:
+    """Posting invalid JSON data should return 422."""
+    response = await client.post(app.url_path_for("create_infraction"), json={"reason": "Yes"})
+    assert response.status_code == 422

tests/routers/test_users.py

@@ -1,43 +1,48 @@
 """Tests for the users router."""
 import pytest
+from fastapi import FastAPI
 from httpx import AsyncClient
 
 from api import models
 
 pytestmark = pytest.mark.asyncio
 
 
-async def test_list_users_without_db_entries(client: AsyncClient) -> None:
+async def test_list_users_without_db_entries(client: AsyncClient, app: FastAPI) -> None:
     """No users should be returned when the database is empty."""
-    response = await client.get('/users')
+    response = await client.get(app.url_path_for("get_users"))
 
     assert response.status_code == 200
     users = response.json()
     assert not users
 
 
-async def test_get_nonexistent_user(client: AsyncClient) -> None:
+async def test_get_nonexistent_user(client: AsyncClient, app: FastAPI) -> None:
     """Getting a nonexistent user should return a 404."""
-    response = await client.get('/users/129841')
+    response = await client.get(app.url_path_for("get_user", user_id=129841))
     assert response.status_code == 404
 
 
-async def test_list_users_with_existing_jam(client: AsyncClient, created_codejam: models.CodeJamResponse) -> None:
+async def test_list_users_with_existing_jam(
+        client: AsyncClient,
+        created_codejam: models.CodeJamResponse,
+        app: FastAPI
+) -> None:
     """Listing users with an existing jam should display the users in the jam."""
-    response = await client.get('/users')
+    response = await client.get(app.url_path_for("get_users"))
     assert response.status_code == 200
     raw = response.json()
     users = [models.UserResponse(**user) for user in raw]
     assert users
 
 
 async def test_get_users_from_existing_jam(
-        client: AsyncClient, codejam: models.CodeJam, created_codejam: models.CodeJamResponse
+        client: AsyncClient, codejam: models.CodeJam, created_codejam: models.CodeJamResponse, app: FastAPI
 ) -> None:
     """Getting users from an existing jam should return the users properly."""
     for team in codejam.teams:
         for user in team.users:
-            response = await client.get(f'/users/{user.user_id}')
+            response = await client.get(app.url_path_for("get_user", user_id=user.user_id))
             assert response.status_code == 200
             raw = response.json()
             parsed = models.UserResponse(**raw)

tox.ini

@@ -3,7 +3,7 @@ max-line-length=120
 docstring-convention=all
 import-order-style=pycharm
 application_import_names=api
-exclude=.cache,.venv,.git,alembic/*,tests/*
+exclude=.cache,.venv,.git,alembic/*
 ignore=
     B311,W503,E226,S311,T000,B008
     # Missing Docstrings