fix(resolver): Preserve lock file when sorting for minimal versions, document tests

diff --git a/src/cargo/core/resolver/mod.rs b/src/cargo/core/resolver/mod.rs
index 58a2746e6a2abfa0a719d9edcb7766572e484ec8..ec5f376debe0474d2f882f9cb4d29400959dbf86 100644 (file)
--- a/src/cargo/core/resolver/mod.rs
+++ b/src/cargo/core/resolver/mod.rs
@@ -805,11 +805,19 @@ impl<'a> RegistryQueryer<'a> {
         ret.sort_unstable_by(|a, b| {
             let a_in_previous = self.try_to_use.contains(a.summary.package_id());
             let b_in_previous = self.try_to_use.contains(b.summary.package_id());
-            let a = (a_in_previous, a.summary.version());
-            let b = (b_in_previous, b.summary.version());
-            match self.minimal_versions {
-                true => a.cmp(&b),
-                false => a.cmp(&b).reverse(),
+            let previous_cmp = a_in_previous.cmp(&b_in_previous).reverse();
+            match previous_cmp {
+                Ordering::Equal => {
+                    let cmp = a.summary.version().cmp(&b.summary.version());
+                    if self.minimal_versions == true {
+                        // Lower version ordered first.
+                        cmp
+                    } else {
+                        // Higher version ordered first.
+                        cmp.reverse()
+                    }
+                },
+                _ => previous_cmp,
             }
         });
 

diff --git a/tests/testsuite/resolve.rs b/tests/testsuite/resolve.rs
index 2f7a4943b744cd5c2e037aea21b603899e058f2d..38ac58e5c4b8de8bce6496c4ed7f4d5efc1a4b57 100644 (file)
--- a/tests/testsuite/resolve.rs
+++ b/tests/testsuite/resolve.rs
@@ -13,44 +13,14 @@ fn resolve(
     deps: Vec<Dependency>,
     registry: &[Summary],
 ) -> CargoResult<Vec<PackageId>> {
-    struct MyRegistry<'a>(&'a [Summary]);
-    impl<'a> Registry for MyRegistry<'a> {
-        fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
-            for summary in self.0.iter() {
-                if dep.matches(summary) {
-                    f(summary.clone());
-                }
-            }
-            Ok(())
-        }
-        fn supports_checksums(&self) -> bool {
-            false
-        }
-        fn requires_precise(&self) -> bool {
-            false
-        }
-    }
-    let mut registry = MyRegistry(registry);
-    let summary = Summary::new(pkg.clone(), deps, BTreeMap::new(), None).unwrap();
-    let method = Method::Everything;
-    let resolve = resolver::resolve(
-        &[(summary, method)],
-        &[],
-        &mut registry,
-        &HashSet::new(),
-        None,
-        false,
-    )?;
-    let res = resolve.iter().cloned().collect();
-    Ok(res)
+    resolve_with_config(pkg, deps, registry, None)
 }
 
-// Clone of resolve() from above that also passes down a Config instance.
 fn resolve_with_config(
     pkg: &PackageId,
     deps: Vec<Dependency>,
     registry: &[Summary],
-    config: &Config,
+    config: Option<&Config>,
 ) -> CargoResult<Vec<PackageId>> {
     struct MyRegistry<'a>(&'a [Summary]);
     impl<'a> Registry for MyRegistry<'a> {
@@ -77,7 +47,7 @@ fn resolve_with_config(
         &[],
         &mut registry,
         &HashSet::new(),
-        Some(config),
+        config,
         false,
     )?;
     let res = resolve.iter().cloned().collect();
@@ -361,6 +331,10 @@ fn test_resolving_maximum_version_with_transitive_deps() {
 
 #[test]
 fn test_resolving_minimum_version_with_transitive_deps() {
+    // When the minimal-versions config option is specified then the lowest
+    // possible version of a package should be selected. "util 1.0.0" can't be
+    // selected because of the requirements of "bar", so the minimum version
+    // must be 1.1.1.
     let reg = registry(vec![
         pkg!(("util", "1.2.2")),
         pkg!(("util", "1.0.0")),
@@ -385,7 +359,7 @@ fn test_resolving_minimum_version_with_transitive_deps() {
         &pkg_id("root"),
         vec![dep_req("foo", "1.0.0"), dep_req("bar", "1.0.0")],
         &reg,
-        &config,
+        Some(&config),
     ).unwrap();
 
     assert_that(