✨ [feat][backend] event entry crud tests

Author: tomy0000000

backend/kayman/tests/conftest.py

@@ -1,16 +1,27 @@
 import os
 from collections.abc import Generator
+from typing import Any
 from uuid import uuid4
 
 import pytest
 from factory.alchemy import SQLAlchemyModelFactory
 from fastapi.testclient import TestClient
+from sqlalchemy import event as sa_event
+from sqlalchemy.engine import Engine
 from sqlmodel import Session, SQLModel, create_engine
 from sqlmodel.pool import StaticPool
 
 from kayman.main import app
 
 
+def _enable_sqlite_fk(engine: Engine) -> None:
+    """Enforce foreign keys on SQLite, which defaults them off per connection."""
+
+    @sa_event.listens_for(engine, "connect")
+    def _set_sqlite_pragma(dbapi_connection: Any, *_: Any) -> None:
+        dbapi_connection.execute("PRAGMA foreign_keys=ON")
+
+
 @pytest.fixture(scope="function")
 def db_uri() -> Generator[str, None, None]:
     db_file = f"/tmp/kayman-test-{str(uuid4())}.db"
@@ -31,6 +42,7 @@ def session(db_uri) -> Generator[Session, None, None]:
         connect_args={"check_same_thread": False},
         poolclass=StaticPool,
     )
+    _enable_sqlite_fk(engine)
     SQLModel.metadata.create_all(engine)
     session = Session(engine)
 
@@ -53,6 +65,7 @@ def session_2(db_uri) -> Generator[Session, None, None]:
         connect_args={"check_same_thread": False},
         poolclass=StaticPool,
     )
+    _enable_sqlite_fk(engine)
     session = Session(engine)
 
     yield session

backend/kayman/tests/crud/test_event_entry.py

@@ -1,66 +1,68 @@
+import pytest
+from sqlalchemy.exc import IntegrityError
 from sqlmodel import Session
 
 from kayman.crud.event_entry import create_event_entries
 from kayman.schemas.event_entry import EventEntry, EventEntryBase
-from kayman.tests.factories import EventFactory
+from kayman.tests.factories import (
+    CategoryFactory,
+    CurrencyFactory,
+    EventEntryFactory,
+    EventFactory,
+)
 
 
 def test_create_event_entries(session: Session):
-    entry_creates = EventFactory.build_details(entry_num=3).entries
-    event_entries = []
-    for entry_index, entry in enumerate(entry_creates):
-        event_entries.append(
-            EventEntryBase.model_validate(
-                entry,
-                update={
-                    "event_id": 1,
-                    "index": entry_index,
-                },
-            )
+    event = EventFactory()
+    category = CategoryFactory()
+    currency = CurrencyFactory()
+    entries = [
+        EventEntryBase.model_validate(entry)
+        for entry in EventEntryFactory.build_batch(
+            3,
+            event_id=event.id,
+            category_id=category.id,
+            currency_code=currency.code,
         )
-    db_entries = create_event_entries(session, event_entries)
+    ]
 
-    assert len(db_entries) == 3
+    db_entries = create_event_entries(session, entries)
 
-    for i, db_entry in enumerate(db_entries):
-        assert db_entry.amount == event_entries[i].amount
-        assert db_entry.category_id == event_entries[i].category_id
-        assert db_entry.currency_code == event_entries[i].currency_code
-        assert db_entry.description == event_entries[i].description
-        assert db_entry.index == event_entries[i].index
+    assert len(db_entries) == 3
+    for db_entry, entry in zip(db_entries, entries, strict=True):
         assert db_entry.id is not None
-        assert db_entry.event_id == event_entries[i].event_id
-        assert db_entry.quantity == event_entries[i].quantity
+        assert db_entry.event_id == event.id
+        assert db_entry.category_id == category.id
+        assert db_entry.currency_code == currency.code
+        assert db_entry.amount == entry.amount
+        assert db_entry.quantity == entry.quantity
+        assert db_entry.description == entry.description
+        assert db_entry.index == entry.index
+
+
+def test_create_event_entries_empty(session: Session):
+    assert create_event_entries(session, []) == []
 
 
 def test_create_event_entries_no_commit(session: Session, session_2: Session):
-    entry_create = EventFactory.build_details().entries[0]
-    event_entry = EventEntryBase.model_validate(
-        entry_create,
-        update={
-            "event_id": 1,
-            "index": 0,
-        },
+    event = EventFactory()
+    category = CategoryFactory()
+    currency = CurrencyFactory()
+    entry = EventEntryBase.model_validate(
+        EventEntryFactory.build(
+            event_id=event.id,
+            category_id=category.id,
+            currency_code=currency.code,
+        )
     )
 
     # The entry should be created in the session
-    session_entry = create_event_entries(
-        session,
-        [event_entry],
-        commit=False,
-    )[0]
+    session_entry = create_event_entries(session, [entry], commit=False)[0]
     assert session_entry.id is not None  # Auto int should be set
-    assert session_entry.amount == event_entry.amount
-    assert session_entry.category_id == event_entry.category_id
-    assert session_entry.currency_code == event_entry.currency_code
-    assert session_entry.description == event_entry.description
-    assert session_entry.index == event_entry.index
-    assert session_entry.event_id == event_entry.event_id
-    assert session_entry.quantity == event_entry.quantity
+    assert session_entry.event_id == event.id
 
     # The entry should not be visible to other sessions (yet)
-    session_2_entry = session_2.get(EventEntry, session_entry.id)
-    assert session_2_entry is None
+    assert session_2.get(EventEntry, session_entry.id) is None
 
     # Commit the entry from main session
     session.commit()
@@ -69,10 +71,21 @@ def test_create_event_entries_no_commit(session: Session, session_2: Session):
     session_2_entry = session_2.get(EventEntry, session_entry.id)
     assert session_2_entry is not None
     assert session_2_entry.id == session_entry.id
-    assert session_2_entry.amount == session_entry.amount
-    assert session_2_entry.category_id == session_entry.category_id
-    assert session_2_entry.currency_code == session_entry.currency_code
-    assert session_2_entry.description == session_entry.description
-    assert session_2_entry.index == session_entry.index
-    assert session_2_entry.event_id == session_entry.event_id
-    assert session_2_entry.quantity == session_entry.quantity
+    assert session_2_entry.event_id == event.id
+    assert session_2_entry.category_id == category.id
+    assert session_2_entry.currency_code == currency.code
+
+
+def test_create_event_entries_event_not_found(session: Session):
+    category = CategoryFactory()
+    currency = CurrencyFactory()
+    entry = EventEntryBase.model_validate(
+        EventEntryFactory.build(
+            event_id=999999,
+            category_id=category.id,
+            currency_code=currency.code,
+        )
+    )
+
+    with pytest.raises(IntegrityError):
+        create_event_entries(session, [entry])