switchroom 0.19.19 → 0.19.23

package/vendor/hindsight-memory/tests/test_drain_pending.py

@@ -1,5 +1,6 @@
 """Tests for drain_pending.drain() (#1071)."""
 
+import io
 import json
 import os
 import sys
@@ -14,6 +15,21 @@ if SCRIPTS_DIR not in sys.path:
     sys.path.insert(0, SCRIPTS_DIR)
 
 
+def _dead_marker(path: str) -> str:
+    """Where `mark_dead` puts the marker for the queue entry at `path`.
+
+    NOT `<path>.dead` any more: a marker is the only remaining copy of its
+    memory, so it leaves the live queue directory for the `pending-dead/`
+    sibling rather than sitting in the directory external janitors glob
+    (switchroom #3697). Asserting the old spelling made this suite red on a
+    deliberate change -- invisibly, because CI discovers only
+    `scripts/tests/`.
+    """
+    from lib.pending import dead_dir
+
+    return os.path.join(dead_dir(), os.path.basename(path) + ".dead")
+
+
 class FakeOk:
     """Minimal urlopen() context-manager stand-in for a 200 OK."""
 
@@ -212,20 +228,45 @@ class DrainPendingTest(unittest.TestCase):
         self.assertEqual(entry["attempt_count"], 2)
         self.assertIn("last_attempt_at", entry)
 
-    def test_drain_max_attempts_marks_dead(self):
+    def test_drain_max_attempts_marks_dead_on_a_permanent_failure(self):
+        """Exhausting the budget on a 4xx still retires the entry."""
         from lib.pending import MAX_ATTEMPTS
 
         path = _seed_entry(self._pending, attempt=MAX_ATTEMPTS)
         import drain_pending
 
         def boom(*a, **kw):
-            raise urllib.error.URLError("still down")
+            raise urllib.error.HTTPError(
+                "http://h/v1/x", 400, "Bad Request", {}, io.BytesIO(b"bad payload")
+            )
 
         with patch("urllib.request.urlopen", side_effect=boom):
             summary = drain_pending.drain({})
         self.assertEqual(summary["dead"], 1)
         self.assertFalse(os.path.exists(path))
-        self.assertTrue(os.path.exists(path + ".dead"))
+        self.assertTrue(os.path.exists(_dead_marker(path)))
+
+    def test_drain_max_attempts_keeps_the_memory_on_a_transient_failure(self):
+        """A dead upstream must never retire a memory, however many attempts.
+
+        ``URLError`` is what an unreachable daemon raises. Before the
+        permanence gate this retired the entry at MAX_ATTEMPTS — i.e. an
+        outage destroyed memory that was perfectly saveable.
+        """
+        from lib.pending import MAX_ATTEMPTS
+
+        path = _seed_entry(self._pending, attempt=MAX_ATTEMPTS)
+        import drain_pending
+
+        def boom(*a, **kw):
+            raise urllib.error.URLError("still down")
+
+        with patch("urllib.request.urlopen", side_effect=boom):
+            summary = drain_pending.drain({})
+        self.assertEqual(summary["dead"], 0)
+        self.assertEqual(summary["retried"], 1)
+        self.assertTrue(os.path.exists(path))
+        self.assertFalse(os.path.exists(_dead_marker(path)))
 
     def test_drain_stall_guard_stops_after_threshold(self):
         # Seed 10 entries; with a same-error-class stream, the stall

package/vendor/hindsight-memory/tests/test_pending.py

@@ -38,7 +38,10 @@ class PendingQueueTest(unittest.TestCase):
             "api_url": "http://fake:9077",
             "api_token": None,
             "bank_id": "test-bank",
-            "content": "user: hello\nassistant: hi",
+            # Distinct per document: the queue's dedupe key is
+            # (bank_id, part_position, sha256(content)) since switchroom
+            # #3688, so a shared body would collapse these into one entry.
+            "content": f"user: hello\nassistant: hi ({document_id})",
             "document_id": document_id,
             "context": "claude-code",
             "metadata": {"session_id": "sess-1"},
@@ -59,7 +62,7 @@ class PendingQueueTest(unittest.TestCase):
         with open(path) as f:
             entry = json.load(f)
         self.assertEqual(entry["bank_id"], "test-bank")
-        self.assertEqual(entry["content"], "user: hello\nassistant: hi")
+        self.assertEqual(entry["content"], self._sample_payload()["content"])
         self.assertEqual(entry["document_id"], "doc-1")
         self.assertEqual(entry["error_class"], "ValueError")
         self.assertEqual(entry["error_message"], "nope")
@@ -200,8 +203,13 @@ class PendingQueueTest(unittest.TestCase):
             self.assertNotIn(
                 "dead_at", e, "a live queue entry must never carry dead_at"
             )
-        # The .dead marker exists and carries dead_at.
-        dead = path + ".dead"
+        # The .dead marker exists and carries dead_at. It lives in the
+        # `pending-dead/` SIBLING, not in the live queue directory: a marker
+        # is the only remaining copy of its memory, and the queue dir is the
+        # one external janitors glob (switchroom #3697).
+        dead = os.path.join(
+            pending_mod.dead_dir(), os.path.basename(path) + ".dead"
+        )
         self.assertTrue(os.path.isfile(dead))
         with open(dead) as f:
             self.assertIn("dead_at", json.load(f))