test: add more resolver helper trait methods

Author: x-hgg-x

crates/resolver-tests/src/helpers.rs

@@ -8,40 +8,60 @@ use cargo::util::IntoUrl;
 
 pub trait ToDep {
     fn to_dep(self) -> Dependency;
-    fn to_opt_dep(self) -> Dependency;
-    fn to_dep_with(self, features: &[&'static str]) -> Dependency;
+    fn opt(self) -> Dependency;
+    fn with(self, features: &[&'static str]) -> Dependency;
+    fn with_default(self) -> Dependency;
+    fn rename(self, name: &str) -> Dependency;
 }
 
 impl ToDep for &'static str {
     fn to_dep(self) -> Dependency {
         Dependency::parse(self, Some("1.0.0"), registry_loc()).unwrap()
     }
-    fn to_opt_dep(self) -> Dependency {
+    fn opt(self) -> Dependency {
         let mut dep = self.to_dep();
         dep.set_optional(true);
         dep
     }
-    fn to_dep_with(self, features: &[&'static str]) -> Dependency {
+    fn with(self, features: &[&'static str]) -> Dependency {
         let mut dep = self.to_dep();
         dep.set_default_features(false);
         dep.set_features(features.into_iter().copied());
         dep
     }
+    fn with_default(self) -> Dependency {
+        let mut dep = self.to_dep();
+        dep.set_default_features(true);
+        dep
+    }
+    fn rename(self, name: &str) -> Dependency {
+        let mut dep = self.to_dep();
+        dep.set_explicit_name_in_toml(name);
+        dep
+    }
 }
 
 impl ToDep for Dependency {
     fn to_dep(self) -> Dependency {
         self
     }
-    fn to_opt_dep(mut self) -> Dependency {
+    fn opt(mut self) -> Dependency {
         self.set_optional(true);
         self
     }
-    fn to_dep_with(mut self, features: &[&'static str]) -> Dependency {
+    fn with(mut self, features: &[&'static str]) -> Dependency {
         self.set_default_features(false);
         self.set_features(features.into_iter().copied());
         self
     }
+    fn with_default(mut self) -> Dependency {
+        self.set_default_features(true);
+        self
+    }
+    fn rename(mut self, name: &str) -> Dependency {
+        self.set_explicit_name_in_toml(name);
+        self
+    }
 }
 
 pub trait ToPkgId {
@@ -120,10 +140,23 @@ pub fn pkg_dep_with<T: ToPkgId>(
     Summary::new(name.to_pkgid(), dep, &features, link, None).unwrap()
 }
 
+pub fn pkg_dep_link<T: ToPkgId>(name: T, link: &str, dep: Vec<Dependency>) -> Summary {
+    Summary::new(name.to_pkgid(), dep, &BTreeMap::new(), Some(link), None).unwrap()
+}
+
 pub fn pkg_id(name: &str) -> PackageId {
     PackageId::try_new(name, "1.0.0", registry_loc()).unwrap()
 }
 
+pub fn pkg_id_source(name: &str, source: &str) -> PackageId {
+    PackageId::try_new(
+        name,
+        "1.0.0",
+        SourceId::for_registry(&source.into_url().unwrap()).unwrap(),
+    )
+    .unwrap()
+}
+
 fn pkg_id_loc(name: &str, loc: &str) -> PackageId {
     let remote = loc.into_url();
     let master = GitReference::Branch("master".to_string());

crates/resolver-tests/src/lib.rs

@@ -37,14 +37,27 @@ pub fn resolve(deps: Vec<Dependency>, registry: &[Summary]) -> CargoResult<Vec<P
     )
 }
 
-// Verify that the resolution of cargo resolver can pass the verification of SAT
 pub fn resolve_and_validated(
     deps: Vec<Dependency>,
     registry: &[Summary],
     sat_resolver: &mut SatResolver,
 ) -> CargoResult<Vec<(PackageId, Vec<InternedString>)>> {
-    let resolve =
-        resolve_with_global_context_raw(deps.clone(), registry, &GlobalContext::default().unwrap());
+    resolve_and_validated_raw(deps, registry, pkg_id("root"), sat_resolver)
+}
+
+// Verify that the resolution of cargo resolver can pass the verification of SAT
+pub fn resolve_and_validated_raw(
+    deps: Vec<Dependency>,
+    registry: &[Summary],
+    root_pkg_id: PackageId,
+    sat_resolver: &mut SatResolver,
+) -> CargoResult<Vec<(PackageId, Vec<InternedString>)>> {
+    let resolve = resolve_with_global_context_raw(
+        deps.clone(),
+        registry,
+        root_pkg_id,
+        &GlobalContext::default().unwrap(),
+    );
 
     match resolve {
         Err(e) => {
@@ -57,7 +70,7 @@ pub fn resolve_and_validated(
             Err(e)
         }
         Ok(resolve) => {
-            let mut stack = vec![pkg_id("root")];
+            let mut stack = vec![root_pkg_id];
             let mut used = HashSet::new();
             let mut links = HashSet::new();
             while let Some(p) = stack.pop() {
@@ -102,13 +115,14 @@ pub fn resolve_with_global_context(
     registry: &[Summary],
     gctx: &GlobalContext,
 ) -> CargoResult<Vec<(PackageId, Vec<InternedString>)>> {
-    let resolve = resolve_with_global_context_raw(deps, registry, gctx)?;
+    let resolve = resolve_with_global_context_raw(deps, registry, pkg_id("root"), gctx)?;
     Ok(collect_features(&resolve))
 }
 
 pub fn resolve_with_global_context_raw(
     deps: Vec<Dependency>,
     registry: &[Summary],
+    root_pkg_id: PackageId,
     gctx: &GlobalContext,
 ) -> CargoResult<Resolve> {
     struct MyRegistry<'a> {
@@ -171,14 +185,8 @@ pub fn resolve_with_global_context_raw(
         used: HashSet::new(),
     };
 
-    let root_summary = Summary::new(
-        pkg_id("root"),
-        deps,
-        &BTreeMap::new(),
-        None::<&String>,
-        None,
-    )
-    .unwrap();
+    let root_summary =
+        Summary::new(root_pkg_id, deps, &BTreeMap::new(), None::<&String>, None).unwrap();
 
     let opts = ResolveOpts::everything();
 

crates/resolver-tests/tests/resolve.rs

@@ -5,7 +5,7 @@ use cargo::util::GlobalContext;
 use resolver_tests::{
     helpers::{
         assert_contains, assert_same, dep, dep_kind, dep_loc, dep_req, loc_names, names, pkg_id,
-        pkg_loc, registry, ToDep, ToPkgId,
+        pkg_loc, registry, ToPkgId,
     },
     pkg, resolve, resolve_with_global_context,
 };
@@ -14,7 +14,7 @@ use resolver_tests::{
 #[should_panic(expected = "assertion failed: !name.is_empty()")]
 fn test_dependency_with_empty_name() {
     // Bug 5229, dependency-names must not be empty
-    "".to_dep();
+    dep("");
 }
 
 #[test]

crates/resolver-tests/tests/validated.rs

@@ -129,20 +129,16 @@ fn registry_with_features() {
         pkg!("b"),
         pkg_dep_with(
             "image",
-            vec!["a".to_opt_dep(), "b".to_opt_dep(), "jpg".to_dep()],
+            vec!["a".opt(), "b".opt(), "jpg".to_dep()],
             &[("default", &["a"]), ("b", &["dep:b"])],
         ),
         pkg!("jpg"),
         pkg!("log"),
         pkg!("man"),
-        pkg_dep_with("rgb", vec!["man".to_opt_dep()], &[("man", &["dep:man"])]),
+        pkg_dep_with("rgb", vec!["man".opt()], &[("man", &["dep:man"])]),
         pkg_dep_with(
             "dep",
-            vec![
-                "image".to_dep_with(&["b"]),
-                "log".to_opt_dep(),
-                "rgb".to_opt_dep(),
-            ],
+            vec!["image".with(&["b"]), "log".opt(), "rgb".opt()],
             &[
                 ("default", &["log", "image/default"]),
                 ("man", &["rgb?/man"]),
@@ -151,11 +147,11 @@ fn registry_with_features() {
     ]);
 
     for deps in [
-        vec!["dep".to_dep_with(&["default", "man", "log", "rgb"])],
-        vec!["dep".to_dep_with(&["default"])],
-        vec!["dep".to_dep_with(&[])],
-        vec!["dep".to_dep_with(&["man"])],
-        vec!["dep".to_dep_with(&["man", "rgb"])],
+        vec!["dep".with(&["default", "man", "log", "rgb"])],
+        vec!["dep".with(&["default"])],
+        vec!["dep".with(&[])],
+        vec!["dep".with(&["man"])],
+        vec!["dep".with(&["man", "rgb"])],
     ] {
         let mut sat_resolver = SatResolver::new(&reg);
         assert!(resolve_and_validated(deps, &reg, &mut sat_resolver).is_ok());
@@ -166,7 +162,7 @@ fn registry_with_features() {
 fn missing_feature() {
     let reg = registry(vec![pkg!("a")]);
     let mut sat_resolver = SatResolver::new(&reg);
-    assert!(resolve_and_validated(vec!["a".to_dep_with(&["f"])], &reg, &mut sat_resolver).is_err());
+    assert!(resolve_and_validated(vec!["a".with(&["f"])], &reg, &mut sat_resolver).is_err());
 }
 
 #[test]
@@ -187,7 +183,7 @@ fn conflict_feature_and_sys() {
         pkg_dep("dep", vec![dep_req("a", "2.0.0")]),
     ]);
 
-    let deps = vec![dep_req("a", "*").to_dep_with(&["f"]), dep("dep")];
+    let deps = vec![dep_req("a", "*").with(&["f"]), dep("dep")];
     let mut sat_resolver = SatResolver::new(&reg);
     assert!(resolve_and_validated(deps, &reg, &mut sat_resolver).is_err());
 }
@@ -197,16 +193,16 @@ fn conflict_weak_features() {
     let reg = registry(vec![
         pkg(("a-sys", "1.0.0")),
         pkg(("a-sys", "2.0.0")),
-        pkg_dep("a1", vec![dep_req("a-sys", "1.0.0").to_opt_dep()]),
-        pkg_dep("a2", vec![dep_req("a-sys", "2.0.0").to_opt_dep()]),
+        pkg_dep("a1", vec![dep_req("a-sys", "1.0.0").opt()]),
+        pkg_dep("a2", vec![dep_req("a-sys", "2.0.0").opt()]),
         pkg_dep_with(
             "dep",
-            vec!["a1".to_opt_dep(), "a2".to_opt_dep()],
+            vec!["a1".opt(), "a2".opt()],
             &[("a1", &["a1?/a-sys"]), ("a2", &["a2?/a-sys"])],
         ),
     ]);
 
-    let deps = vec![dep("dep").to_dep_with(&["a1", "a2"])];
+    let deps = vec![dep("dep").with(&["a1", "a2"])];
 
     // The following asserts should be updated when support for weak dependencies
     // is added to the dependency resolver.