claude-multiacc 2.0.56 → 2.0.57

package/tests/test_autoresume_handoff_history.py

@@ -0,0 +1,115 @@
+"""Cross-provider history must identify one real main conversation before any restart."""
+
+import copy
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+
+import test_autoresume as fixtures
+import autoresume_handoff as handoff
+
+
+class HandoffHistoryTests(unittest.TestCase):
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory(prefix="ar-handoff-history-")
+        self.addCleanup(temporary.cleanup)
+        self.home = Path(temporary.name).resolve()
+        self.cwd = self.home / "project with 'quotes'"
+        self.cwd.mkdir()
+
+    def source(self, provider, records=None):
+        sid = fixtures.SID if provider == "claude" else fixtures.CX_SID
+        directory = self.home / provider / ("projects/project" if provider == "claude" else "sessions/2026/10/11")
+        directory.mkdir(parents=True, exist_ok=True)
+        filename = sid + ".jsonl" if provider == "claude" else "rollout-test-" + sid + ".jsonl"
+        path = directory / filename
+        if records is None:
+            records = [fixtures.cc_user(1000, "Source task content.", cwd=str(self.cwd))] if provider == "claude" else [
+                fixtures.cx_meta(1000, cwd=str(self.cwd)),
+                fixtures.cx_event(1001, {"type": "user_message", "message": "Source task content."})]
+        path.write_text("".join(json.dumps(record) + "\n" for record in records))
+        return sid, path
+
+    def test_both_main_history_formats_return_exact_file_identity(self):
+        for provider in ("claude", "codex"):
+            with self.subTest(provider=provider):
+                sid, path = self.source(provider)
+                result = handoff.validate_source(provider, sid, str(path), str(self.cwd))
+                self.assertIsNotNone(result)
+                self.assertEqual((result["provider"], result["sid"], result["cwd"]),
+                                 (provider, sid, str(self.cwd)))
+                self.assertEqual((result["path"], result["inode"], result["offset"]),
+                                 (str(path.resolve()), path.stat().st_ino, path.stat().st_size))
+
+    def test_wrong_session_and_replaced_inode_are_rejected(self):
+        for provider in ("claude", "codex"):
+            with self.subTest(provider=provider):
+                sid, path = self.source(provider)
+                self.assertIsNone(handoff.validate_source(provider, fixtures.SID2, str(path), str(self.cwd)))
+                inode = path.stat().st_ino
+                replacement = path.with_suffix(".replacement")
+                replacement.write_bytes(path.read_bytes())
+                replacement.replace(path)
+                self.assertNotEqual(path.stat().st_ino, inode)
+                self.assertIsNone(handoff.validate_source(provider, sid, str(path), str(self.cwd), inode=inode))
+
+    def test_codex_subagent_and_noninteractive_histories_are_rejected(self):
+        original = fixtures.cx_meta(1000, cwd=str(self.cwd))
+        alterations = ({"session_id": fixtures.CX_SID2}, {"source": {"subagent": "spawn"}},
+                       {"originator": "codex_exec"}, {"thread_source": "subagent"})
+        for change in alterations:
+            with self.subTest(change=change):
+                record = copy.deepcopy(original)
+                record["payload"].update(change)
+                sid, path = self.source("codex", [record])
+                self.assertIsNone(handoff.validate_source("codex", sid, str(path), str(self.cwd)))
+
+    def test_claude_sidechain_only_and_foreign_conversation_are_rejected(self):
+        records = [fixtures.cc_user(1000, "Subagent task.", cwd=str(self.cwd), isSidechain=True),
+                   fixtures.cc_user(1000, "Other conversation.", cwd=str(self.cwd), sessionId=fixtures.SID2)]
+        for record in records:
+            with self.subTest(sidechain=record["isSidechain"]):
+                sid, path = self.source("claude", [record])
+                self.assertIsNone(handoff.validate_source("claude", sid, str(path), str(self.cwd)))
+
+    def test_missing_directory_empty_and_malformed_histories_are_rejected(self):
+        for provider in ("claude", "codex"):
+            sid, path = self.source(provider)
+            fifo = path.parent / "not-a-history-fifo"
+            os.mkfifo(fifo)
+            for candidate in (path.parent / "absent.jsonl", path.parent, fifo):
+                with self.subTest(provider=provider, candidate=candidate.name):
+                    self.assertIsNone(handoff.validate_source(provider, sid, str(candidate), str(self.cwd)))
+            for text in ("", "not json\n", "[]\n", '{"type":"session_meta","payload":null}\n'):
+                with self.subTest(provider=provider, malformed=text):
+                    path.write_text(text)
+                    self.assertIsNone(handoff.validate_source(provider, sid, str(path), str(self.cwd)))
+
+    def test_shared_history_symlink_resolves_to_the_exact_source(self):
+        for provider in ("claude", "codex"):
+            with self.subTest(provider=provider):
+                sid, path = self.source(provider)
+                link = self.home / (provider + "-account-history.jsonl")
+                link.symlink_to(path)
+                result = handoff.validate_source(provider, sid, str(link), str(self.cwd))
+                self.assertIsNotNone(result)
+                self.assertEqual(result["path"], str(path.resolve()))
+
+    def test_invalid_provider_id_and_missing_working_directory_are_rejected(self):
+        sid, path = self.source("claude")
+        for provider, target_sid, cwd in (("other", sid, str(self.cwd)), ("claude", "--last", str(self.cwd)),
+                                          ("claude", sid, str(self.home / "absent"))):
+            with self.subTest(provider=provider, sid=target_sid, cwd=cwd):
+                self.assertIsNone(handoff.validate_source(provider, target_sid, str(path), cwd))
+
+    def test_claude_leading_progress_does_not_hide_valid_main_history(self):
+        records = [{"type": "progress", "data": {"type": "hook_progress"}},
+                   fixtures.cc_user(1000, "Main task.", cwd=str(self.cwd))]
+        sid, path = self.source("claude", records)
+        self.assertIsNotNone(handoff.validate_source("claude", sid, str(path), str(self.cwd)))
+
+
+if __name__ == "__main__":
+    unittest.main()