test: update and extend tests for MergeMode and auto-merge behavior

- test_enums: add TestMergeMode sanity coverage (str, json, coercion)
- test_drift: update no-base tests to expect MERGED+PY_WINS_NO_BASE when
  cell counts match; add structural-mismatch, trailing-empty-cell, and
  two-cell py-wins cases
- test_hooks_pair_drift: split drift_only tests into count-mismatch (deny)
  and content-diff (auto-merge) variants for both pre and post hooks
- test_hooks_pre_commit: update TestDriftOnly and TestIncludeFilter to use
  count-mismatch for deny cases; add content-diff auto-merge case

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: TTTPOB

tests/test_drift.py

@@ -6,6 +6,7 @@
 import nbformat
 import pytest
 
+from jupyter_jcli._enums import MergeMode
 from jupyter_jcli.drift import DriftResult, check_drift, three_way_merge
 from jupyter_jcli.parser import Cell
 
@@ -206,12 +207,15 @@ def test_no_git_base_drift_only_equal(self, tmp_path):
         assert result.status == "in_sync"
 
     def test_no_git_base_drift_only_unequal(self, tmp_path):
-        """No git base + unequal cells -> drift_only."""
+        """No git base + same count but different sources -> merged (py wins)."""
         py, ipynb = _write_pair(tmp_path, ["x = 1"], ["x = 99"])
         with self._patch_git(None, None):
             result = check_drift(py, ipynb)
-        assert result.status == "drift_only"
-        assert len(result.conflict_indices) >= 1
+        assert result.status == "merged"
+        assert result.merge_mode == MergeMode.PY_WINS_NO_BASE
+        assert result.ipynb_needs_update is True
+        assert result.py_needs_update is False
+        assert result.merged_cells[0].source == "x = 1"
 
     def test_both_changed_different_cells_merged(self, tmp_path):
         """Both sides changed different cells -> merged, both files need update."""
@@ -245,17 +249,43 @@ def _side_effect(path: Path) -> str | None:
         assert calls_by_suffix[".py"] >= 1
 
     def test_py_untracked_ipynb_only_exists(self, tmp_path):
-        """With py untracked, any source difference is DRIFT_ONLY regardless of ipynb state."""
+        """With py untracked and same cell count, different sources -> py wins (MERGED)."""
         py, ipynb = _write_pair(tmp_path, ["x = 1"], ["x = 99"])
-        # Only py has no HEAD; we don't even check ipynb HEAD
         with self._patch_git(None):
             result = check_drift(py, ipynb)
-        assert result.status == "drift_only"
-        assert len(result.conflict_indices) >= 1
+        assert result.status == "merged"
+        assert result.merge_mode == MergeMode.PY_WINS_NO_BASE
 
     def test_py_untracked_sources_equal_is_in_sync(self, tmp_path):
         """With py untracked and equal sources -> IN_SYNC."""
         py, ipynb = _write_pair(tmp_path, ["x = 1", "y = 2"], ["x = 1", "y = 2"])
         with self._patch_git(None):
             result = check_drift(py, ipynb)
         assert result.status == "in_sync"
+
+    def test_no_git_base_py_wins_py_canonical(self, tmp_path):
+        """No git base + 2 non-empty cells each, different sources -> MERGED, py wins."""
+        py, ipynb = _write_pair(tmp_path, ["x = 1", "y = 2"], ["x = 99", "y = 88"])
+        with self._patch_git(None):
+            result = check_drift(py, ipynb)
+        assert result.status == "merged"
+        assert result.merge_mode == MergeMode.PY_WINS_NO_BASE
+        assert result.py_needs_update is False
+        assert result.ipynb_needs_update is True
+        assert [c.source for c in result.merged_cells] == ["x = 1", "y = 2"]
+
+    def test_no_git_base_structural_mismatch_stays_drift_only(self, tmp_path):
+        """No git base + cell count mismatch -> DRIFT_ONLY (structural divergence)."""
+        py, ipynb = _write_pair(tmp_path, ["x = 1", "y = 2", "z = 3"], ["x = 99"])
+        with self._patch_git(None):
+            result = check_drift(py, ipynb)
+        assert result.status == "drift_only"
+        assert len(result.conflict_indices) >= 1
+
+    def test_no_git_base_py_trailing_empty_cell_is_in_sync(self, tmp_path):
+        """No git base + py has trailing empty cell -> filtered out, still IN_SYNC."""
+        # _write_pair writes cells as-is; empty string -> empty cell in py
+        py, ipynb = _write_pair(tmp_path, ["x = 1", ""], ["x = 1"])
+        with self._patch_git(None):
+            result = check_drift(py, ipynb)
+        assert result.status == "in_sync"

tests/test_enums.py

@@ -6,7 +6,7 @@
 
 import pytest
 
-from jupyter_jcli._enums import CellType, DriftStatus, OutputType, ResponseStatus
+from jupyter_jcli._enums import CellType, DriftStatus, MergeMode, OutputType, ResponseStatus
 from jupyter_jcli.drift import DriftResult
 
 
@@ -56,6 +56,38 @@ def test_drift_result_invalid_status_raises(self):
 # CellType
 # ---------------------------------------------------------------------------
 
+class TestMergeMode:
+    def test_members_exist(self):
+        assert MergeMode.THREE_WAY
+        assert MergeMode.PY_WINS_NO_BASE
+
+    def test_str_inheritance(self):
+        assert MergeMode.THREE_WAY == "three_way"
+        assert MergeMode.PY_WINS_NO_BASE == "py_wins_no_base"
+        assert isinstance(MergeMode.THREE_WAY, str)
+
+    def test_json_serializable(self):
+        assert json.dumps(MergeMode.THREE_WAY) == '"three_way"'
+
+    def test_invalid_raises(self):
+        with pytest.raises(ValueError):
+            MergeMode("bogus")
+
+    def test_coerce_from_string(self):
+        assert MergeMode("three_way") is MergeMode.THREE_WAY
+        assert MergeMode("py_wins_no_base") is MergeMode.PY_WINS_NO_BASE
+
+    def test_drift_result_coerces_merge_mode(self):
+        from jupyter_jcli.drift import DriftResult
+        r = DriftResult(status="merged", merge_mode="py_wins_no_base")
+        assert r.merge_mode is MergeMode.PY_WINS_NO_BASE
+
+    def test_drift_result_defaults_to_three_way(self):
+        from jupyter_jcli.drift import DriftResult
+        r = DriftResult(status="in_sync")
+        assert r.merge_mode is MergeMode.THREE_WAY
+
+
 class TestCellType:
     def test_members_exist(self):
         assert CellType.CODE

tests/test_hooks_pair_drift.py

@@ -263,18 +263,30 @@ def _git_side(path: Path) -> str | None:
         assert "Pre-existing conflict" in reason or "pre-existing" in reason.lower()
         assert "git diff" in reason
 
-    def test_drift_only_returns_deny(self, tmp_path):
-        """No git base + unequal cells -> deny."""
-        py, ipynb = _make_pair(tmp_path, ["x = 1"], ["x = 99"])
+    def test_drift_only_count_mismatch_returns_deny(self, tmp_path):
+        """No git base + cell count mismatch -> deny."""
+        py, ipynb = _make_pair(tmp_path, ["x = 1", "y = 2"], ["x = 99"])
         with patch("jupyter_jcli.drift._get_git_base_text", return_value=None):
             code, out = _invoke({"tool_name": "Edit", "tool_input": {"file_path": str(py)}})
         assert code == 0
         assert _decision(out) == "deny"
         reason = _reason(out)
-        # New message: "not yet committed" and "git log --oneline"
         assert "not yet committed" in reason
         assert "git log" in reason
 
+    def test_drift_only_content_diff_auto_merges(self, tmp_path):
+        """No git base + same count but different sources -> silent allow + ipynb rewritten."""
+        import nbformat as nbf
+
+        py, ipynb = _make_pair(tmp_path, ["x = 1"], ["x = 99"])
+        with patch("jupyter_jcli.drift._get_git_base_text", return_value=None):
+            code, out = _invoke({"tool_name": "Edit", "tool_input": {"file_path": str(py)}})
+        assert code == 0
+        assert _decision(out) is None  # silent allow
+        nb = nbf.read(str(ipynb), as_version=4)
+        non_empty = [c.source for c in nb.cells if c.source.strip()]
+        assert non_empty == ["x = 1"]
+
 
 # ---------------------------------------------------------------------------
 # Fail-open on bad input / exceptions
@@ -477,9 +489,9 @@ def _git_side(path: Path) -> str | None:
         assert "j-cli convert" in reason
         assert _event_name(out) == "PostToolUse"
 
-    def test_drift_only_after_edit_warns(self, tmp_path):
-        """py has no git baseline after agent's edit -> warn with convert hint."""
-        py, ipynb = _make_pair(tmp_path, ["x = 10"], ["x = 99"])
+    def test_drift_only_count_mismatch_after_edit_warns(self, tmp_path):
+        """py has no git baseline + count mismatch after agent's edit -> warn with convert hint."""
+        py, ipynb = _make_pair(tmp_path, ["x = 10", "y = 20"], ["x = 99"])
 
         with patch("jupyter_jcli.drift._get_git_base_text", return_value=None):
             code, out = _invoke_post({"tool_name": "Edit", "tool_input": {"file_path": str(py)}})
@@ -491,6 +503,20 @@ def test_drift_only_after_edit_warns(self, tmp_path):
         assert "j-cli convert" in reason
         assert _event_name(out) == "PostToolUse"
 
+    def test_drift_only_content_diff_after_edit_syncs(self, tmp_path):
+        """py has no git baseline + same count, different sources -> allow + reason explains."""
+        py, ipynb = _make_pair(tmp_path, ["x = 10"], ["x = 99"])
+
+        with patch("jupyter_jcli.drift._get_git_base_text", return_value=None):
+            code, out = _invoke_post({"tool_name": "Edit", "tool_input": {"file_path": str(py)}})
+
+        assert code == 0
+        assert _decision(out) == "allow"
+        reason = _reason(out)
+        assert "no git baseline" in reason
+        assert "outputs preserved" in reason
+        assert _event_name(out) == "PostToolUse"
+
     def test_non_paired_file_is_silent(self, tmp_path):
         """Files without a paired counterpart are silently ignored."""
         solo = tmp_path / "script.py"

tests/test_hooks_pre_commit.py

@@ -267,9 +267,9 @@ def test_conflict_exits_1_with_cell_index(self, git_repo, monkeypatch):
 class TestDriftOnly:
     def test_drift_only_exits_1(self, git_repo, monkeypatch):
         monkeypatch.chdir(git_repo)
-        # No commit → no git base
-        _make_py(git_repo / "nb.py", "x = 1")
-        _make_ipynb(git_repo / "nb.ipynb", "x = 99")  # different
+        # No commit → no git base; use count mismatch to stay DRIFT_ONLY
+        _make_py(git_repo / "nb.py", "x = 1", "y = 2")
+        _make_ipynb(git_repo / "nb.ipynb", "x = 99")  # count mismatch
         _git(git_repo, "git", "add", "nb.py")
 
         runner = CliRunner()
@@ -280,6 +280,21 @@ def test_drift_only_exits_1(self, git_repo, monkeypatch):
         assert "git base" in combined or "pick a side" in combined.lower()
         assert "j-cli convert" in combined
 
+    def test_content_diff_same_count_auto_merges(self, git_repo, monkeypatch):
+        """No git base + same count but different content -> auto-merge, exit 0."""
+        monkeypatch.chdir(git_repo)
+        _make_py(git_repo / "nb.py", "x = 1")
+        _make_ipynb(git_repo / "nb.ipynb", "x = 99")  # same count, different content
+        _git(git_repo, "git", "add", "nb.py")
+
+        runner = CliRunner()
+        result = _invoke(runner)
+
+        assert result.exit_code == 0
+        nb = nbformat.read(str(git_repo / "nb.ipynb"), as_version=4)
+        non_empty = [c for c in nb.cells if c.source.strip()]
+        assert non_empty[0].source == "x = 1"
+
 
 # ---------------------------------------------------------------------------
 # Two sides change different cells -> merged, both written, exit 0
@@ -323,8 +338,8 @@ def test_include_matching_processes_file(self, git_repo, monkeypatch):
         monkeypatch.chdir(git_repo)
         sub = git_repo / "nb"
         sub.mkdir()
-        _make_py(sub / "script.py", "x = 1")
-        _make_ipynb(sub / "script.ipynb", "x = 99")  # drift → exit 1
+        _make_py(sub / "script.py", "x = 1", "y = 2")
+        _make_ipynb(sub / "script.ipynb", "x = 99")  # count mismatch → drift_only → exit 1
         _git(git_repo, "git", "add", "nb/script.py")
 
         runner = CliRunner()