huskies: merge 987

server/src/agents/merge/squash/tests_basic.rs

@@ -101,21 +101,11 @@ async fn squash_merge_uses_merge_queue_no_conflict_markers_on_master() {
         "master must never contain conflict markers, got:\n{master_content}"
     );
 
-    // The merge should have had conflicts.
-    assert!(result.had_conflicts, "should detect conflicts");
-
-    // Conflicts should have been auto-resolved (both are simple additions).
-    if result.conflicts_resolved {
-        assert!(result.success, "auto-resolved merge should succeed");
-        assert!(
-            master_content.contains("master addition"),
-            "master side should be present"
-        );
-        assert!(
-            master_content.contains("feature addition"),
-            "feature side should be present"
-        );
-    }
+    // The merge should have had conflicts (returned as Conflict variant).
+    assert!(
+        matches!(result, super::MergeResult::Conflict { .. }),
+        "should detect conflicts; got: {result:?}"
+    );
 
     // Verify no leftover merge-queue branch.
     let branches = Command::new("git")
@@ -172,14 +162,15 @@ async fn squash_merge_clean_merge_succeeds() {
 
     let result = run_squash_merge(repo, "feature/story-clean_test", "clean_test").unwrap();
 
-    assert!(result.success, "clean merge should succeed");
     assert!(
-        !result.had_conflicts,
-        "clean merge should have no conflicts"
-    );
-    assert!(
-        !result.conflicts_resolved,
-        "no conflicts means nothing to resolve"
+        matches!(
+            result,
+            super::MergeResult::Success {
+                conflicts_resolved: false,
+                ..
+            }
+        ),
+        "clean merge should succeed without conflicts; got: {result:?}"
     );
     assert!(
         repo.join("new_file.txt").exists(),
@@ -197,7 +188,10 @@ async fn squash_merge_nonexistent_branch_fails() {
 
     let result = run_squash_merge(repo, "feature/story-nope", "nope").unwrap();
 
-    assert!(!result.success, "merge of nonexistent branch should fail");
+    assert!(
+        !matches!(result, super::MergeResult::Success { .. }),
+        "merge of nonexistent branch should fail; got: {result:?}"
+    );
 }
 
 #[tokio::test]
@@ -267,11 +261,10 @@ async fn squash_merge_succeeds_when_master_diverges() {
     let result = run_squash_merge(repo, "feature/story-diverge_test", "diverge_test").unwrap();
 
     assert!(
-        result.success,
-        "squash merge should succeed despite diverged master: {}",
-        result.output
+        matches!(result, super::MergeResult::Success { .. }),
+        "squash merge should succeed despite diverged master: {:?}",
+        result
     );
-    assert!(!result.had_conflicts, "no conflicts expected");
 
     // Verify the feature file landed on master.
     assert!(
@@ -346,9 +339,9 @@ async fn squash_merge_empty_diff_fails() {
     // Either form is a failure — just not success.
     match result {
         Ok(r) => assert!(
-            !r.success,
-            "empty diff merge must fail, not silently succeed: {}",
-            r.output
+            !matches!(r, super::MergeResult::Success { .. }),
+            "empty diff merge must fail, not silently succeed: {:?}",
+            r
         ),
         Err(e) => assert!(
             e.contains("no commits to merge") || e.contains("nothing to commit"),
@@ -417,24 +410,21 @@ async fn idempotent_retry_after_successful_merge_returns_success() {
         .expect("first merge produces Ok");
     // The merge may fail gates in test env (no script/test); only require that
     // the squash applied SOMETHING (cargo gates env-dependent).
-    if r1.success {
+    if matches!(r1, super::MergeResult::Success { .. }) {
         // Second merge of the SAME branch: must report success (idempotent),
         // not merge_failure.  Feature branch's content is already on master so
         // the squash produces "nothing to commit" — bug 777 makes this success.
         let r2 = run_squash_merge(repo, "feature/story-777_idem", "777_idem")
             .expect("second merge produces Ok");
         assert!(
-            r2.success,
-            "idempotent retry must return success: {}",
-            r2.output
-        );
-        assert!(
-            !r2.had_conflicts,
-            "idempotent retry should report no conflicts"
-        );
-        assert!(
-            r2.conflict_details.is_none(),
-            "no conflict_details on idempotent retry"
+            matches!(
+                r2,
+                super::MergeResult::Success {
+                    conflicts_resolved: false,
+                    ..
+                }
+            ),
+            "idempotent retry must return Success without conflicts: {r2:?}"
         );
     }
 }