Test cleanup

Author: jeffmaki

api/src/tasking/audit/repository.py

@@ -145,15 +145,16 @@ async def list_project_events(
         page, page_size = _clamp_page(page, page_size, max_page_size=200)
         order_dir = _normalise_dir(order_dir)
 
-        # `task_number` is stored inside `details` JSONB rather than as a
-        # column, so filter via the typed accessor.
+        # The task number is stored inside `details` JSONB rather than as a
+        # column, under the camelCase key `taskNumber` that the task
+        # repository emits, so filter via the typed accessor on that key.
         where = ["project_id = :pid"]
         params: dict = {"pid": project_id}
         if event_type is not None:
             where.append("event_type = :et")
             params["et"] = event_type.value
         if task_number is not None:
-            where.append("(details->>'task_number')::int = :tn")
+            where.append("(details->>'taskNumber')::int = :tn")
             params["tn"] = task_number
         if actor_user_id is not None:
             where.append("actor_user_auth_uid = :au")
@@ -215,14 +216,14 @@ async def list_task_events(
         page, page_size = _clamp_page(page, page_size, max_page_size=200)
         order_dir = _normalise_dir(order_dir)
 
-        # Match either `task_id = :tid` or the `task_number` in `details`
+        # Match either `task_id = :tid` or the `taskNumber` in `details`
         # — early audit rows for task creation set task_id but later
         # rows that reference a task (e.g. project-level lock-extensions)
-        # may only persist the task_number. Both forms point at the
+        # may only persist the taskNumber. Both forms point at the
         # same task, so OR them.
         where = [
             "project_id = :pid",
-            "(task_id = :tid OR (details->>'task_number')::int = :tn)",
+            "(task_id = :tid OR (details->>'taskNumber')::int = :tn)",
         ]
         params: dict = {"pid": project_id, "tid": task_id, "tn": task_number}
         if event_type is not None:

pyproject.toml

@@ -53,6 +53,14 @@ asyncio_default_fixture_loop_scope = "function"
 markers = [
     "integration: tests that require a live PostGIS database (Docker + testcontainers)",
 ]
+filterwarnings = [
+    # SQLModel deprecates `session.execute()` in favour of `session.exec()`,
+    # but many repository queries are raw `text()` SQL where `execute()` is the
+    # correct call. Silence this one nudge rather than rewrite ~85 call sites;
+    # every other warning still surfaces. (?s) lets `.*` span the multi-line
+    # warning body.
+    "ignore:(?s).*You probably want to use .session.exec:DeprecationWarning",
+]
 
 [tool.black]
 line-length = 88

tests/integration/conftest.py

@@ -389,32 +389,53 @@ def _clear_token() -> None:
 
 
 @pytest.fixture
-def app():
-    """Real app for the integration suite.
-
-    Overrides the unit-suite ``app`` fixture (tests/conftest.py), which swaps
-    in ``FakeSession`` objects for the DB dependencies. Here we want the real
-    engines wired up by the autouse ``_per_test_db_sessions`` fixture, so this
-    just yields the actual FastAPI app untouched. The shared ``client``
-    fixture depends on ``app`` by name and picks this up for integration
-    tests. Per-test overrides (sessions, ``validate_token``) are installed and
-    torn down by their own fixtures.
+def app(request, task_session, osm_session):
+    """App fixture for everything under ``tests/integration/``.
+
+    This directory hosts two kinds of test that share one conftest:
+
+    * **Container-backed** tests (marked ``integration``) run against a real
+      PostGIS database; their DB sessions are the real engines wired by the
+      autouse ``_per_test_db_sessions`` fixture, so we hand back the app
+      untouched here.
+    * **FakeSession-backed** tests (unmarked — the CLAUDE.md data-fetcher
+      model) run the real routes/repositories but fake the ``AsyncSession``.
+      For those we wire the fakes in exactly like the unit-suite ``app``
+      fixture this shadows.
+
+    Keying on the ``integration`` marker keeps the container machinery from
+    leaking onto the FakeSession tests (which need no Docker).
     """
+    from api.core.database import get_osm_session, get_task_session
     from api.main import app as fastapi_app
 
-    return fastapi_app
+    if request.node.get_closest_marker("integration"):
+        yield fastapi_app
+        return
+
+    fastapi_app.dependency_overrides[get_task_session] = lambda: task_session
+    fastapi_app.dependency_overrides[get_osm_session] = lambda: osm_session
+    yield fastapi_app
+    fastapi_app.dependency_overrides.clear()
 
 
 @pytest.fixture(autouse=True)
-async def _per_test_db_sessions(_pg_urls):
+async def _per_test_db_sessions(request):
+    # Only container-backed (``integration``-marked) tests need real DB
+    # sessions; for FakeSession tests this fixture is a no-op so they never
+    # pull in ``_pg_urls`` (which would boot / require the testcontainer).
+    if not request.node.get_closest_marker("integration"):
+        yield
+        return
+
     from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
     from sqlalchemy.pool import NullPool
     from sqlmodel.ext.asyncio.session import AsyncSession
 
     from api.core.database import get_osm_session, get_task_session
     from api.main import app
 
-    task_url, osm_url = _pg_urls
+    task_url, osm_url = request.getfixturevalue("_pg_urls")
 
     # NullPool disables connection reuse: each session checkout opens a
     # fresh connection on the current event loop and disposes it on