Add tests to show the conflict graph

Author: prsabahrami

src/conflict.rs

@@ -201,6 +201,7 @@ impl Conflict {
                         for &candidate_id in requirement_candidates {
                             let candidate_node =
                                 Self::add_node(&mut graph, &mut nodes, candidate_id.into());
+
                             graph.add_edge(
                                 package_node,
                                 candidate_node,
@@ -333,6 +334,8 @@ pub(crate) enum ConflictCause {
     ForbidMultipleInstances,
     /// The node was excluded
     Excluded,
+    /// The condition for the dependency is not met
+    ConditionNotMet(VersionSetId),
 }
 
 /// Represents a node that has been merged with others
@@ -402,7 +405,7 @@ impl ConflictGraph {
                     ConflictEdge::ConditionalRequires(_, _)
                         if target != ConflictNode::UnresolvedDependency =>
                     {
-                        "blue"
+                        "blue" // This indicates that the requirement has candidates, but the condition is not met
                     }
                     _ => "red",
                 };
@@ -414,10 +417,16 @@ impl ConflictGraph {
                     ConflictEdge::ConditionalRequires(condition_version_set_id, requirement) => {
                         format!(
                             "if {} then {}",
-                            interner.display_version_set(*condition_version_set_id),
+                            Requirement::from(*condition_version_set_id).display(interner),
                             requirement.display(interner)
                         )
                     }
+                    ConflictEdge::Conflict(ConflictCause::ConditionNotMet(version_set_id)) => {
+                        format!(
+                            "condition not met: {}",
+                            interner.display_version_set(*version_set_id)
+                        )
+                    }
                     ConflictEdge::Conflict(ConflictCause::Constrains(version_set_id)) => {
                         interner.display_version_set(*version_set_id).to_string()
                     }
@@ -1123,6 +1132,13 @@ impl<'i, I: Interner> fmt::Display for DisplayUnsat<'i, I> {
                             self.interner.display_merged_solvables(&[solvable_id]),
                         )?;
                     }
+                    ConflictCause::ConditionNotMet(version_set_id) => {
+                        writeln!(
+                            f,
+                            "{indent}condition not met: {}",
+                            self.interner.display_version_set(*version_set_id),
+                        )?;
+                    }
                     ConflictCause::Excluded => continue,
                 };
             }

tests/solver.rs

@@ -1679,6 +1679,53 @@ fn test_conditional_requirements_multiple_versions_met() {
         "###);
 }
 
+#[test]
+fn test_conditional_requirements_conflict() {
+    let mut provider = BundleBoxProvider::new();
+
+    // Add multiple versions of package b
+    provider.add_package("b", 1.into(), &[], &[]);
+    provider.add_package("b", 2.into(), &[], &[]);
+    provider.add_package("b", 3.into(), &[], &[]);
+
+    // Package c has two versions with different dependencies
+    provider.add_package("c", 1.into(), &["d 1"], &[]); // c v1 requires d v1
+    provider.add_package("c", 2.into(), &["d 2"], &[]); // c v2 requires d v2
+
+    // Package d has incompatible versions
+    provider.add_package("d", 1.into(), &[], &[]);
+    provider.add_package("d", 2.into(), &[], &[]);
+
+    provider.add_package("a", 1.into(), &["b 1", "c 1; if b 1", "d 2", "c 2; if b 2"], &[]);
+
+    let requirements = provider.requirements(&[
+        "a", // Require package a
+    ]);
+
+    let mut solver = Solver::new(provider);
+    let problem = Problem::new().requirements(requirements);
+
+    // This should fail to solve because:
+    // 1. When b=1 is chosen, it triggers the conditional requirement for c 1
+    // 2. c 1 requires d 1, but a requires d 2
+    // 3. d 1 and d 2 cannot be installed together
+
+    let solved = solver.solve(problem);
+    assert!(solved.is_err());
+
+    let conflict = solved.unwrap_err();
+    match conflict {
+        UnsolvableOrCancelled::Unsolvable(conflict) => {
+            let graph = conflict.graph(&solver);
+            let mut output = stderr();
+            graph
+                .graphviz(&mut output, solver.provider(), true)
+                .unwrap();
+        }
+        _ => panic!("Expected a conflict"),
+    }
+}
+
 /// In this test, the resolver installs the highest available version of b which is b 2
 /// However, the conditional requirement is that if b 1..2 is installed, require c
 /// Since b 2 is installed, c should not be installed