Convert TaskQueue tests to use context manager and update installed packages

Author: coordt

docs/specs/02-messaging-update/plan.md

@@ -132,10 +132,10 @@ Use `freezegun` or manual timestamp manipulation to test timeout-based behaviour
 
 ### Checkpoint: Phase 1
 
-- [ ] `uv run pytest --agent-digest=term` — all tests pass
-- [ ] `pre-commit run --all-files` — clean
-- [ ] `TaskQueue` is fully exercised; concurrent-claim test passes
-- [ ] Human review before proceeding
+- [x] `uv run pytest --agent-digest=term` — all tests pass
+- [x] `pre-commit run --all-files` — clean
+- [x] `TaskQueue` is fully exercised; concurrent-claim test passes
+- [x] Human review before proceeding
 
 ### Phase 2: Harness Queue API Endpoints
 
@@ -156,17 +156,17 @@ The router receives a `TaskQueue` instance via FastAPI dependency injection (use
 
 **Acceptance criteria:**
 
-- [ ] `POST /queue/next` returns 200 + `TaskMessage` JSON when a task is available
-- [ ] `POST /queue/next` returns 204 when the queue is empty
-- [ ] `POST /queue/complete` stores the decision and returns 202
-- [ ] `POST /queue/heartbeat` updates `last_heartbeat` and returns 202
-- [ ] All endpoints return 202 immediately (no blocking on downstream work)
-- [ ] Router is included in `app` (registered in `server.py`)
+- [x] `POST /queue/next` returns 200 + `TaskMessage` JSON when a task is available
+- [x] `POST /queue/next` returns 204 when the queue is empty
+- [x] `POST /queue/complete` stores the decision and returns 202
+- [x] `POST /queue/heartbeat` updates `last_heartbeat` and returns 202
+- [x] All endpoints return 202 immediately (no blocking on downstream work)
+- [x] Router is included in `app` (registered in `server.py`)
 
 **Verification:**
 
-- [ ] `uv run pytest --agent-digest=term tests/test_queue_router.py` (written in Task 6)
-- [ ] `pre-commit run --all-files`
+- [x] `uv run pytest --agent-digest=term tests/test_queue_router.py` (written in Task 6)
+- [x] `pre-commit run --all-files`
 
 **Dependencies:** Tasks 2, 3
 
@@ -186,14 +186,14 @@ The trigger mechanism is an `asyncio.Event` set in the background loop and reset
 
 **Acceptance criteria:**
 
-- [ ] `POST /harness/result` accepts `{"task_id": "<uuid>"}` and returns 202 Accepted
-- [ ] Receiving the nudge triggers the drain loop event (verified by inspecting `app.state`)
-- [ ] Router is included in `app`
+- [x] `POST /harness/result` accepts `{"task_id": "<uuid>"}` and returns 202 Accepted
+- [x] Receiving the nudge triggers the drain loop event (verified by inspecting `app.state`)
+- [x] Router is included in `app`
 
 **Verification:**
 
-- [ ] `uv run pytest --agent-digest=term tests/test_result_router.py` (written in Task 6)
-- [ ] `pre-commit run --all-files`
+- [x] `uv run pytest --agent-digest=term tests/test_result_router.py` (written in Task 6)
+- [x] `pre-commit run --all-files`
 
 **Dependencies:** Task 4
 
@@ -212,16 +212,16 @@ Verify HTTP contracts only.
 
 **Acceptance criteria:**
 
-- [ ] `POST /queue/next` — 200 with task body when queue has a task
-- [ ] `POST /queue/next` — 204 when `claim_next()` returns `None`
-- [ ] `POST /queue/complete` — 202; `TaskQueue.complete()` called with correct args
-- [ ] `POST /queue/heartbeat` — 202; `TaskQueue.heartbeat()` called with correct `task_id`
-- [ ] `POST /harness/result` — 202; drain event is set
+- [x] `POST /queue/next` — 200 with task body when queue has a task
+- [x] `POST /queue/next` — 204 when `claim_next()` returns `None`
+- [x] `POST /queue/complete` — 202; `TaskQueue.complete()` called with correct args
+- [x] `POST /queue/heartbeat` — 202; `TaskQueue.heartbeat()` called with correct `task_id`
+- [x] `POST /harness/result` — 202; drain event is set
 
 **Verification:**
 
-- [ ] `uv run pytest --agent-digest=term tests/test_queue_router.py tests/test_result_router.py`
-- [ ] `pre-commit run --all-files`
+- [x] `uv run pytest --agent-digest=term tests/test_queue_router.py tests/test_result_router.py`
+- [x] `pre-commit run --all-files`
 
 **Dependencies:** Tasks 4, 5
 
@@ -234,9 +234,9 @@ Verify HTTP contracts only.
 
 ### Checkpoint: Phase 2
 
-- [ ] `uv run pytest --agent-digest=term` — all tests pass
-- [ ] All three queue endpoints + `/harness/result` exist and return correct status codes
-- [ ] Human review before proceeding
+- [x] `uv run pytest --agent-digest=term` — all tests pass
+- [x] All three queue endpoints + `/harness/result` exist and return correct status codes
+- [x] Human review before proceeding
 
 ### Phase 3: `foreman-client` Package
 

tests/test_memory.py

@@ -35,19 +35,19 @@ def test_action_log_table_exists(self, tmp_path: Path) -> None:
         db_path = tmp_path / "memory.db"
         store = MemoryStore(db_path)
         store.close()
-        with sqlite3.connect(db_path) as conn:
-            rows = conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='action_log'").fetchall()
+        conn = sqlite3.connect(db_path)
+        rows = conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='action_log'").fetchall()
+        conn.close()
         assert rows, "action_log table should exist"
 
     def test_memory_summary_table_exists(self, tmp_path: Path) -> None:
         """memory_summary table is created with the correct schema."""
         db_path = tmp_path / "memory.db"
         store = MemoryStore(db_path)
         store.close()
-        with sqlite3.connect(db_path) as conn:
-            rows = conn.execute(
-                "SELECT name FROM sqlite_master WHERE type='table' AND name='memory_summary'"
-            ).fetchall()
+        conn = sqlite3.connect(db_path)
+        rows = conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='memory_summary'").fetchall()
+        conn.close()
         assert rows, "memory_summary table should exist"
 
 
@@ -71,8 +71,9 @@ def test_log_action_inserts_row(self, store: MemoryStore) -> None:
             actions=[ActionItem(type="add_label", label="bug")],
         )
 
-        with sqlite3.connect(store.db_path) as conn:
-            rows = conn.execute("SELECT * FROM action_log").fetchall()
+        conn = sqlite3.connect(store.db_path)
+        rows = conn.execute("SELECT * FROM action_log").fetchall()
+        conn.close()
         assert len(rows) == 1
 
     def test_log_action_stores_correct_values(self, store: MemoryStore) -> None:
@@ -87,10 +88,9 @@ def test_log_action_stores_correct_values(self, store: MemoryStore) -> None:
             actions=actions,
         )
 
-        with sqlite3.connect(store.db_path) as conn:
-            row = conn.execute(
-                "SELECT repo, issue_id, task_type, decision, rationale, actions FROM action_log"
-            ).fetchone()
+        conn = sqlite3.connect(store.db_path)
+        row = conn.execute("SELECT repo, issue_id, task_type, decision, rationale, actions FROM action_log").fetchone()
+        conn.close()
 
         assert row[0] == "owner/repo"
         assert row[1] == 7
@@ -113,8 +113,9 @@ def test_log_action_multiple_entries(self, store: MemoryStore) -> None:
                 actions=[],
             )
 
-        with sqlite3.connect(store.db_path) as conn:
-            count = conn.execute("SELECT COUNT(*) FROM action_log").fetchone()[0]
+        conn = sqlite3.connect(store.db_path)
+        count = conn.execute("SELECT COUNT(*) FROM action_log").fetchone()[0]
+        conn.close()
         assert count == 3
 
     def test_log_action_null_rationale(self, store: MemoryStore) -> None:
@@ -128,8 +129,9 @@ def test_log_action_null_rationale(self, store: MemoryStore) -> None:
             actions=[],
         )
 
-        with sqlite3.connect(store.db_path) as conn:
-            row = conn.execute("SELECT rationale FROM action_log").fetchone()
+        conn = sqlite3.connect(store.db_path)
+        row = conn.execute("SELECT rationale FROM action_log").fetchone()
+        conn.close()
         assert row[0] is None
 
 

tests/test_queue.py

@@ -69,7 +69,8 @@ def test_index_exists(self, queue: TaskQueue) -> None:
     def test_db_file_created(self, tmp_path: Path) -> None:
         """DB file and parent directories are auto-created."""
         db_path = tmp_path / "nested" / "dir" / "queue.db"
-        TaskQueue(db_path=db_path)
+        with TaskQueue(db_path=db_path):
+            pass
         assert db_path.exists()
 
 
@@ -216,24 +217,24 @@ class TestRequeueStale:
 
     def test_requeue_stale_re_enqueues_timed_out_task(self, tmp_path: Path) -> None:
         """A claimed task past the timeout is re-enqueued and retry_count incremented."""
-        q = TaskQueue(db_path=tmp_path / "queue.db", claim_timeout_seconds=1)
-        task = _make_task("t1")
-        q.enqueue(task, agent_url="http://agent:9001")
-        q.claim_next(agent_url="http://agent:9001")
+        with TaskQueue(db_path=tmp_path / "queue.db", claim_timeout_seconds=1) as q:
+            task = _make_task("t1")
+            q.enqueue(task, agent_url="http://agent:9001")
+            q.claim_next(agent_url="http://agent:9001")
 
-        # Force both claimed_at and last_heartbeat into the past to simulate timeout
-        past = time.time() - 10
-        q._conn.execute(
-            "UPDATE task_queue SET claimed_at = ?, last_heartbeat = ? WHERE task_id = 't1'",
-            (past, past),
-        )
+            # Force both claimed_at and last_heartbeat into the past to simulate timeout
+            past = time.time() - 10
+            q._conn.execute(
+                "UPDATE task_queue SET claimed_at = ?, last_heartbeat = ? WHERE task_id = 't1'",
+                (past, past),
+            )
 
-        count = q.requeue_stale()
-        assert count == 1
+            count = q.requeue_stale()
+            assert count == 1
 
-        row = q._conn.execute("SELECT status, retry_count FROM task_queue WHERE task_id = 't1'").fetchone()
-        assert row[0] == "pending"
-        assert row[1] == 1
+            row = q._conn.execute("SELECT status, retry_count FROM task_queue WHERE task_id = 't1'").fetchone()
+            assert row[0] == "pending"
+            assert row[1] == 1
 
     def test_requeue_stale_ignores_fresh_claims(self, queue: TaskQueue) -> None:
         """A recently claimed task is not re-enqueued."""
@@ -245,21 +246,21 @@ def test_requeue_stale_ignores_fresh_claims(self, queue: TaskQueue) -> None:
 
     def test_requeue_stale_ignores_heartbeated_task(self, tmp_path: Path) -> None:
         """A task with a recent heartbeat is not re-enqueued even if claimed_at is old."""
-        q = TaskQueue(db_path=tmp_path / "queue.db", claim_timeout_seconds=1)
-        task = _make_task("t1")
-        q.enqueue(task, agent_url="http://agent:9001")
-        q.claim_next(agent_url="http://agent:9001")
-
-        # Age the claimed_at but keep last_heartbeat fresh
-        now = time.time()
-        q._conn.execute(
-            "UPDATE task_queue SET claimed_at = ?, last_heartbeat = ? WHERE task_id = 't1'",
-            (now - 10, now),
-        )
-        q._conn.commit()
-
-        count = q.requeue_stale()
-        assert count == 0
+        with TaskQueue(db_path=tmp_path / "queue.db", claim_timeout_seconds=1) as q:
+            task = _make_task("t1")
+            q.enqueue(task, agent_url="http://agent:9001")
+            q.claim_next(agent_url="http://agent:9001")
+
+            # Age the claimed_at but keep last_heartbeat fresh
+            now = time.time()
+            q._conn.execute(
+                "UPDATE task_queue SET claimed_at = ?, last_heartbeat = ? WHERE task_id = 't1'",
+                (now - 10, now),
+            )
+            q._conn.commit()
+
+            count = q.requeue_stale()
+            assert count == 0
 
 
 # ---------------------------------------------------------------------------