@misterhuydo/sentinel 1.5.63 → 1.6.1

package/python/tests/test_patch_parser.py

@@ -0,0 +1,250 @@
+"""
+test_patch_parser.py — Unit tests for parse_multi_repo_patch().
+
+The parser splits a combined diff (paths prefixed `repos/<repo-name>/...`)
+into per-repo sub-patches with the prefix stripped. It is the linchpin of
+the multi-repo apply flow — these tests cover edge cases exhaustively.
+"""
+import pytest
+
+from sentinel.git_manager import parse_multi_repo_patch
+
+
+# ── happy path ────────────────────────────────────────────────────────────────
+
+def test_parse_single_repo_patch():
+    diff = (
+        "diff --git a/repos/repo-a/src/Foo.java b/repos/repo-a/src/Foo.java\n"
+        "index 1111..2222 100644\n"
+        "--- a/repos/repo-a/src/Foo.java\n"
+        "+++ b/repos/repo-a/src/Foo.java\n"
+        "@@ -1,3 +1,3 @@\n"
+        " line1\n"
+        "-old\n"
+        "+new\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    assert result["affected_repos"] == ["repo-a"]
+    assert "repo-a" in result["patches"]
+    sub = result["patches"]["repo-a"]
+    assert "diff --git a/src/Foo.java b/src/Foo.java" in sub
+    assert "--- a/src/Foo.java" in sub
+    assert "+++ b/src/Foo.java" in sub
+    assert "repos/repo-a" not in sub
+
+
+def test_parse_two_repo_patch_preserves_chunks():
+    diff = (
+        "diff --git a/repos/lib/src/A.java b/repos/lib/src/A.java\n"
+        "--- a/repos/lib/src/A.java\n"
+        "+++ b/repos/lib/src/A.java\n"
+        "@@ -1,1 +1,1 @@\n"
+        "-old-a\n"
+        "+new-a\n"
+        "diff --git a/repos/consumer/pom.xml b/repos/consumer/pom.xml\n"
+        "--- a/repos/consumer/pom.xml\n"
+        "+++ b/repos/consumer/pom.xml\n"
+        "@@ -1,1 +1,1 @@\n"
+        "-1.0\n"
+        "+1.1\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    assert set(result["affected_repos"]) == {"lib", "consumer"}
+    assert "new-a" in result["patches"]["lib"]
+    assert "+1.1" in result["patches"]["consumer"]
+    # No cross-contamination
+    assert "pom.xml" not in result["patches"]["lib"]
+    assert "A.java" not in result["patches"]["consumer"]
+
+
+def test_parse_multiple_files_same_repo():
+    diff = (
+        "diff --git a/repos/r1/a.txt b/repos/r1/a.txt\n"
+        "--- a/repos/r1/a.txt\n"
+        "+++ b/repos/r1/a.txt\n"
+        "@@ -1 +1 @@\n"
+        "-x\n+y\n"
+        "diff --git a/repos/r1/b.txt b/repos/r1/b.txt\n"
+        "--- a/repos/r1/b.txt\n"
+        "+++ b/repos/r1/b.txt\n"
+        "@@ -1 +1 @@\n"
+        "-p\n+q\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    assert result["affected_repos"] == ["r1"]
+    sub = result["patches"]["r1"]
+    # Both file diffs are in the same repo's patch
+    assert sub.count("diff --git") == 2
+    assert "a.txt" in sub
+    assert "b.txt" in sub
+
+
+# ── header parsing ────────────────────────────────────────────────────────────
+
+def test_affected_repos_header_sets_order():
+    diff = (
+        "# Affected repos: consumer, lib\n"
+        "\n"
+        "diff --git a/repos/lib/x b/repos/lib/x\n"
+        "--- a/repos/lib/x\n+++ b/repos/lib/x\n@@ -1 +1 @@\n-a\n+b\n"
+        "diff --git a/repos/consumer/y b/repos/consumer/y\n"
+        "--- a/repos/consumer/y\n+++ b/repos/consumer/y\n@@ -1 +1 @@\n-c\n+d\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    # Header defines order even though `lib` appears first in the diffs
+    assert result["affected_repos"] == ["consumer", "lib"]
+
+
+def test_affected_repos_header_case_insensitive():
+    diff = (
+        "# affected REPOS: r1\n"
+        "diff --git a/repos/r1/f b/repos/r1/f\n"
+        "--- a/repos/r1/f\n+++ b/repos/r1/f\n@@ -1 +1 @@\n-a\n+b\n"
+    )
+    assert parse_multi_repo_patch(diff)["affected_repos"] == ["r1"]
+
+
+def test_no_header_falls_back_to_diff_order():
+    diff = (
+        "diff --git a/repos/zebra/x b/repos/zebra/x\n"
+        "--- a/repos/zebra/x\n+++ b/repos/zebra/x\n@@ -1 +1 @@\n-a\n+b\n"
+        "diff --git a/repos/alpha/y b/repos/alpha/y\n"
+        "--- a/repos/alpha/y\n+++ b/repos/alpha/y\n@@ -1 +1 @@\n-c\n+d\n"
+    )
+    assert parse_multi_repo_patch(diff)["affected_repos"] == ["zebra", "alpha"]
+
+
+def test_header_with_repo_not_in_diffs_is_dropped():
+    """A header may overpromise; only repos with actual diffs end up in patches."""
+    diff = (
+        "# Affected repos: ghost, real\n"
+        "diff --git a/repos/real/f b/repos/real/f\n"
+        "--- a/repos/real/f\n+++ b/repos/real/f\n@@ -1 +1 @@\n-a\n+b\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    assert "ghost" not in result["patches"]
+    assert "real" in result["patches"]
+    # ghost is removed from affected_repos as well — patches dict is the source of truth
+    assert "ghost" not in result["affected_repos"]
+
+
+# ── special diff formats ──────────────────────────────────────────────────────
+
+def test_new_file_mode_strips_only_b_path():
+    """new-file diffs use /dev/null on the - side; only the +++ b/ path needs stripping."""
+    diff = (
+        "diff --git a/repos/r1/new.java b/repos/r1/new.java\n"
+        "new file mode 100644\n"
+        "index 0000000..abcd\n"
+        "--- /dev/null\n"
+        "+++ b/repos/r1/new.java\n"
+        "@@ -0,0 +1,2 @@\n"
+        "+line one\n"
+        "+line two\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    sub = result["patches"]["r1"]
+    assert "new file mode 100644" in sub
+    assert "--- /dev/null" in sub
+    assert "+++ b/new.java" in sub
+    assert "diff --git a/new.java b/new.java" in sub
+    assert "repos/r1" not in sub
+
+
+def test_deleted_file_strips_only_a_path():
+    diff = (
+        "diff --git a/repos/r1/gone.java b/repos/r1/gone.java\n"
+        "deleted file mode 100644\n"
+        "index abcd..0000000\n"
+        "--- a/repos/r1/gone.java\n"
+        "+++ /dev/null\n"
+        "@@ -1,1 +0,0 @@\n"
+        "-bye\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    sub = result["patches"]["r1"]
+    assert "deleted file mode" in sub
+    assert "--- a/gone.java" in sub
+    assert "+++ /dev/null" in sub
+    assert "repos/r1" not in sub
+
+
+def test_rename_strips_both_paths():
+    diff = (
+        "diff --git a/repos/r1/old.java b/repos/r1/new.java\n"
+        "similarity index 100%\n"
+        "rename from repos/r1/old.java\n"
+        "rename to repos/r1/new.java\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    sub = result["patches"]["r1"]
+    assert "diff --git a/old.java b/new.java" in sub
+    assert "rename from old.java" in sub
+    assert "rename to new.java" in sub
+    assert "repos/r1" not in sub
+
+
+def test_nested_path_in_repo():
+    diff = (
+        "diff --git a/repos/r1/src/main/java/com/x/Foo.java b/repos/r1/src/main/java/com/x/Foo.java\n"
+        "--- a/repos/r1/src/main/java/com/x/Foo.java\n"
+        "+++ b/repos/r1/src/main/java/com/x/Foo.java\n"
+        "@@ -1 +1 @@\n-a\n+b\n"
+    )
+    sub = parse_multi_repo_patch(diff)["patches"]["r1"]
+    assert "diff --git a/src/main/java/com/x/Foo.java b/src/main/java/com/x/Foo.java" in sub
+    assert "--- a/src/main/java/com/x/Foo.java" in sub
+    assert "+++ b/src/main/java/com/x/Foo.java" in sub
+
+
+def test_repo_name_with_dashes_and_digits():
+    diff = (
+        "diff --git a/repos/1881-SSOLoginWebApp/src/F.java b/repos/1881-SSOLoginWebApp/src/F.java\n"
+        "--- a/repos/1881-SSOLoginWebApp/src/F.java\n"
+        "+++ b/repos/1881-SSOLoginWebApp/src/F.java\n"
+        "@@ -1 +1 @@\n-a\n+b\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    assert "1881-SSOLoginWebApp" in result["patches"]
+    assert "diff --git a/src/F.java" in result["patches"]["1881-SSOLoginWebApp"]
+
+
+# ── empty / malformed input ───────────────────────────────────────────────────
+
+def test_empty_patch_returns_empty():
+    result = parse_multi_repo_patch("")
+    assert result["affected_repos"] == []
+    assert result["patches"] == {}
+
+
+def test_only_header_no_diffs():
+    result = parse_multi_repo_patch("# Affected repos: r1\n")
+    assert result["affected_repos"] == []
+    assert result["patches"] == {}
+
+
+def test_diff_without_repos_prefix_is_rejected():
+    """A diff path that doesn't start with repos/<name>/ has no repo to route to."""
+    diff = (
+        "diff --git a/src/Loose.java b/src/Loose.java\n"
+        "--- a/src/Loose.java\n+++ b/src/Loose.java\n@@ -1 +1 @@\n-a\n+b\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    # No repos identified → empty result
+    assert result["affected_repos"] == []
+    assert result["patches"] == {}
+
+
+def test_summary_lines_above_header_preserved():
+    diff = (
+        "Trim and broaden FirstName/LastName regex.\n"
+        "Reason: CRM names with diacritics were rejected.\n"
+        "\n"
+        "# Affected repos: r1\n"
+        "diff --git a/repos/r1/F.java b/repos/r1/F.java\n"
+        "--- a/repos/r1/F.java\n+++ b/repos/r1/F.java\n@@ -1 +1 @@\n-a\n+b\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    assert "diacritics" in result["summary"]
+    assert "# Affected repos:" not in result["summary"]
+    assert "diff --git" not in result["summary"]

package/python/tests/test_project_lock.py

@@ -0,0 +1,85 @@
+"""
+test_project_lock.py — Tests for the per-project asyncio.Lock helper.
+
+The lock is what guarantees "one Claude session at a time per project" — a
+regression here means concurrent fix attempts can race on the working tree.
+"""
+import asyncio
+import pytest
+
+from sentinel.main import _project_lock, _project_locks
+
+
+@pytest.fixture(autouse=True)
+def _clear_locks():
+    """Each test starts with an empty lock registry."""
+    _project_locks.clear()
+    yield
+    _project_locks.clear()
+
+
+def test_same_project_returns_same_lock():
+    a = _project_lock("proj-1")
+    b = _project_lock("proj-1")
+    assert a is b
+
+
+def test_different_projects_get_different_locks():
+    a = _project_lock("proj-a")
+    b = _project_lock("proj-b")
+    assert a is not b
+
+
+def test_lock_is_an_asyncio_lock():
+    assert isinstance(_project_lock("p"), asyncio.Lock)
+
+
+def test_lock_is_lazily_created():
+    assert "lazy" not in _project_locks
+    _project_lock("lazy")
+    assert "lazy" in _project_locks
+
+
+def test_serializes_concurrent_async_tasks():
+    """Two coroutines acquiring the same project's lock must run sequentially."""
+    sequence: list[str] = []
+
+    async def worker(label: str):
+        async with _project_lock("p"):
+            sequence.append(f"{label}:start")
+            # yield control so the other task gets a chance to interleave (it shouldn't)
+            await asyncio.sleep(0)
+            sequence.append(f"{label}:end")
+
+    async def driver():
+        await asyncio.gather(worker("A"), worker("B"))
+
+    asyncio.run(driver())
+
+    # Whichever started first must finish before the other starts —
+    # no interleaving allowed.
+    assert sequence in [
+        ["A:start", "A:end", "B:start", "B:end"],
+        ["B:start", "B:end", "A:start", "A:end"],
+    ], f"unexpected interleave: {sequence}"
+
+
+def test_does_not_serialize_across_projects():
+    """Two coroutines acquiring DIFFERENT project locks may interleave."""
+    sequence: list[str] = []
+
+    async def worker(label: str, project: str):
+        async with _project_lock(project):
+            sequence.append(f"{label}:start")
+            await asyncio.sleep(0)  # let the other task run
+            sequence.append(f"{label}:end")
+
+    async def driver():
+        await asyncio.gather(worker("A", "proj-a"), worker("B", "proj-b"))
+
+    asyncio.run(driver())
+
+    # Different locks → tasks may interleave. We expect interleaving here
+    # because each task awaits asyncio.sleep(0) which yields control.
+    assert sequence == ["A:start", "B:start", "A:end", "B:end"] or \
+           sequence == ["B:start", "A:start", "B:end", "A:end"]

package/python/tests/test_state_store.py

@@ -126,3 +126,90 @@ def test_get_all_user_stats(store):
     assert len(stats) == 2
     ids = {s["user_id"] for s in stats}
     assert ids == {"U1", "U2"}
+
+
+# ── Multi-repo fix tracking (fix_repos table) ─────────────────────────────────
+
+def test_fix_repos_record_single(store):
+    store.record_fix_repo("fp1", "repo-a", branch="sentinel/fix-fp1",
+                          commit_hash="abc", pr_url="https://x/pr/1",
+                          pr_state="open", apply_order=0)
+    rows = store.get_fix_repos("fp1")
+    assert len(rows) == 1
+    assert rows[0]["repo_name"] == "repo-a"
+    assert rows[0]["pr_state"] == "open"
+    assert rows[0]["apply_order"] == 0
+
+
+def test_fix_repos_record_multiple_ordered(store):
+    store.record_fix_repo("fp1", "lib-typeib",  branch="b1", apply_order=0)
+    store.record_fix_repo("fp1", "consumer-svc", branch="b2", apply_order=1)
+    rows = store.get_fix_repos("fp1")
+    assert [r["repo_name"] for r in rows] == ["lib-typeib", "consumer-svc"]
+    assert [r["apply_order"] for r in rows] == [0, 1]
+
+
+def test_fix_repos_upsert_overwrites(store):
+    store.record_fix_repo("fp1", "repo-a", pr_state="open", apply_order=0)
+    store.record_fix_repo("fp1", "repo-a", pr_state="merged", apply_order=0,
+                          commit_hash="def")
+    rows = store.get_fix_repos("fp1")
+    assert len(rows) == 1
+    assert rows[0]["pr_state"] == "merged"
+    assert rows[0]["commit_hash"] == "def"
+
+
+def test_fix_repos_empty_for_unknown_fingerprint(store):
+    assert store.get_fix_repos("unknown-fp") == []
+
+
+def test_fix_repos_update_state(store):
+    store.record_fix_repo("fp1", "repo-a", pr_state="open", apply_order=0)
+    store.update_fix_repo_state("fp1", "repo-a", pr_state="merged",
+                                commit_hash="xyz")
+    rows = store.get_fix_repos("fp1")
+    assert rows[0]["pr_state"] == "merged"
+    assert rows[0]["commit_hash"] == "xyz"
+
+
+# ── Per-project Claude session tracking ───────────────────────────────────────
+
+def test_claude_session_unset_returns_none(store):
+    assert store.get_claude_session("proj-x") is None
+
+
+def test_claude_session_set_and_get(store):
+    store.set_claude_session("proj-x", "session-uuid-1", cost_delta=0.05)
+    s = store.get_claude_session("proj-x")
+    assert s["session_id"] == "session-uuid-1"
+    assert s["total_cost_usd"] == pytest.approx(0.05)
+    assert s["turn_count"] == 1
+
+
+def test_claude_session_accumulates_cost_and_turns(store):
+    store.set_claude_session("proj-x", "session-1", cost_delta=0.10)
+    store.set_claude_session("proj-x", "session-1", cost_delta=0.07)
+    s = store.get_claude_session("proj-x")
+    assert s["total_cost_usd"] == pytest.approx(0.17)
+    assert s["turn_count"] == 2
+
+
+def test_claude_session_replaces_session_id(store):
+    store.set_claude_session("proj-x", "session-1", cost_delta=0.10)
+    store.set_claude_session("proj-x", "session-2", cost_delta=0.05)
+    s = store.get_claude_session("proj-x")
+    assert s["session_id"] == "session-2"
+    assert s["total_cost_usd"] == pytest.approx(0.15)
+
+
+def test_claude_session_isolated_per_project(store):
+    store.set_claude_session("proj-a", "sess-a", cost_delta=0.10)
+    store.set_claude_session("proj-b", "sess-b", cost_delta=0.20)
+    assert store.get_claude_session("proj-a")["session_id"] == "sess-a"
+    assert store.get_claude_session("proj-b")["session_id"] == "sess-b"
+
+
+def test_claude_session_clear(store):
+    store.set_claude_session("proj-x", "sess-1", cost_delta=0.05)
+    store.clear_claude_session("proj-x")
+    assert store.get_claude_session("proj-x") is None