diff --git a/crates/resolver-tests/src/lib.rs b/crates/resolver-tests/src/lib.rs
index f13cfb723..63750c285 100644
--- a/crates/resolver-tests/src/lib.rs
+++ b/crates/resolver-tests/src/lib.rs
@@ -17,16 +17,11 @@ use proptest::sample::Index;
 use proptest::string::string_regex;
 use varisat::{self, ExtendFormula};
 
-pub fn resolve(
-    pkg: PackageId,
-    deps: Vec<Dependency>,
-    registry: &[Summary],
-) -> CargoResult<Vec<PackageId>> {
-    resolve_with_config(pkg, deps, registry, None)
+pub fn resolve(deps: Vec<Dependency>, registry: &[Summary]) -> CargoResult<Vec<PackageId>> {
+    resolve_with_config(deps, registry, None)
 }
 
 pub fn resolve_and_validated(
-    pkg: PackageId,
     deps: Vec<Dependency>,
     registry: &[Summary],
     sat_resolve: Option<&mut SatResolve>,
@@ -36,11 +31,11 @@ pub fn resolve_and_validated(
     } else {
         SatResolve::new(registry).sat_resolve(&deps)
     };
-    let resolve = resolve_with_config_raw(pkg, deps, registry, None);
+    let resolve = resolve_with_config_raw(deps, registry, None);
     assert_eq!(resolve.is_ok(), should_resolve);
 
     let resolve = resolve?;
-    let mut stack = vec![pkg];
+    let mut stack = vec![pkg_id("root")];
     let mut used = HashSet::new();
     let mut links = HashSet::new();
     while let Some(p) = stack.pop() {
@@ -92,17 +87,15 @@ pub fn resolve_and_validated(
 }
 
 pub fn resolve_with_config(
-    pkg: PackageId,
     deps: Vec<Dependency>,
     registry: &[Summary],
     config: Option<&Config>,
 ) -> CargoResult<Vec<PackageId>> {
-    let resolve = resolve_with_config_raw(pkg, deps, registry, config)?;
+    let resolve = resolve_with_config_raw(deps, registry, config)?;
     Ok(resolve.sort())
 }
 
 pub fn resolve_with_config_raw(
-    pkg: PackageId,
     deps: Vec<Dependency>,
     registry: &[Summary],
     config: Option<&Config>,
@@ -158,7 +151,7 @@ pub fn resolve_with_config_raw(
         used: HashSet::new(),
     };
     let summary = Summary::new(
-        pkg,
+        pkg_id("root"),
         deps,
         &BTreeMap::<String, Vec<String>>::new(),
         None::<String>,
@@ -856,7 +849,6 @@ fn meta_test_deep_trees_from_strategy() {
         let reg = registry(input.clone());
         for this in input.iter().rev().take(10) {
             let res = resolve(
-                pkg_id("root"),
                 vec![dep_req(&this.name(), &format!("={}", this.version()))],
                 &reg,
             );
@@ -898,7 +890,6 @@ fn meta_test_multiple_versions_strategy() {
         let reg = registry(input.clone());
         for this in input.iter().rev().take(10) {
             let res = resolve(
-                pkg_id("root"),
                 vec![dep_req(&this.name(), &format!("={}", this.version()))],
                 &reg,
             );
diff --git a/crates/resolver-tests/tests/resolve.rs b/crates/resolver-tests/tests/resolve.rs
index 6efe6d711..cc2fe7a34 100644
--- a/crates/resolver-tests/tests/resolve.rs
+++ b/crates/resolver-tests/tests/resolve.rs
@@ -6,8 +6,8 @@ use cargo::util::Config;
 
 use resolver_tests::{
     assert_contains, assert_same, dep, dep_kind, dep_loc, dep_req, dep_req_kind, loc_names, names,
-    pkg, pkg_id, pkg_loc, registry, registry_strategy, remove_dep, resolve,
-    resolve_and_validated, resolve_with_config, PrettyPrintRegistry, SatResolve, ToDep, ToPkgId,
+    pkg, pkg_id, pkg_loc, registry, registry_strategy, remove_dep, resolve, resolve_and_validated,
+    resolve_with_config, PrettyPrintRegistry, SatResolve, ToDep, ToPkgId,
 };
 
 use proptest::prelude::*;
@@ -45,7 +45,6 @@ proptest! {
         // So we try some of the most complicated.
         for this in input.iter().rev().take(20) {
             let _ = resolve_and_validated(
-                pkg_id("root"),
                 vec![dep_req(&this.name(), &format!("={}", this.version()))],
                 &reg,
                 Some(&mut sat_resolve),
@@ -82,13 +81,11 @@ proptest! {
             // minimal-versions change what order the candidates
             // are tried but not the existence of a solution
             let res = resolve(
-                pkg_id("root"),
                 vec![dep_req(&this.name(), &format!("={}", this.version()))],
                 &reg,
             );
 
             let mres = resolve_with_config(
-                pkg_id("root"),
                 vec![dep_req(&this.name(), &format!("={}", this.version()))],
                 &reg,
                 Some(&config),
@@ -128,13 +125,11 @@ proptest! {
         // So we try some of the most complicated.
         for this in input.iter().rev().take(10) {
             if resolve(
-                pkg_id("root"),
                 vec![dep_req(&this.name(), &format!("={}", this.version()))],
                 &reg,
             ).is_ok() {
                 prop_assert!(
                     resolve(
-                        pkg_id("root"),
                         vec![dep_req(&this.name(), &format!("={}", this.version()))],
                         &removed_reg,
                     ).is_ok(),
@@ -158,7 +153,6 @@ proptest! {
         // So we try some of the most complicated.
         for this in input.iter().rev().take(10) {
             let res = resolve(
-                pkg_id("root"),
                 vec![dep_req(&this.name(), &format!("={}", this.version()))],
                 &reg,
             );
@@ -184,7 +178,6 @@ proptest! {
                         );
 
                         let res = resolve(
-                            pkg_id("root"),
                             vec![dep_req(&this.name(), &format!("={}", this.version()))],
                             &new_reg,
                         );
@@ -218,7 +211,6 @@ proptest! {
                     );
 
                     let res = resolve(
-                        pkg_id("root"),
                         vec![dep_req(&this.name(), &format!("={}", this.version()))],
                         &new_reg,
                     );
@@ -245,7 +237,7 @@ fn pub_fail() {
         pkg!(("kB", "0.0.3") => [dep_req("a", ">= 0.0.5"),dep("e"),]),
     ];
     let reg = registry(input.clone());
-    assert!(resolve_and_validated(pkg_id("root"), vec![dep("kB")], &reg, None).is_err());
+    assert!(resolve_and_validated(vec![dep("kB")], &reg, None).is_err());
 }
 
 #[test]
@@ -257,7 +249,7 @@ fn basic_public_dependency() {
         pkg!("C" => [dep("A"), dep("B")]),
     ]);
 
-    let res = resolve_and_validated(pkg_id("root"), vec![dep("C")], &reg, None).unwrap();
+    let res = resolve_and_validated(vec![dep("C")], &reg, None).unwrap();
     assert_same(
         &res,
         &names(&[
@@ -293,7 +285,7 @@ fn public_dependency_filling_in() {
         pkg!("d" => [dep("c"), dep("a"), dep("b")]),
     ]);
 
-    let res = resolve_and_validated(pkg_id("root"), vec![dep("d")], &reg, None).unwrap();
+    let res = resolve_and_validated(vec![dep("d")], &reg, None).unwrap();
     assert_same(
         &res,
         &names(&[
@@ -328,7 +320,7 @@ fn public_dependency_filling_in_and_update() {
         pkg!("C" => [dep("A"),dep("B")]),
         pkg!("D" => [dep("B"),dep("C")]),
     ]);
-    let res = resolve_and_validated(pkg_id("root"), vec![dep("D")], &reg, None).unwrap();
+    let res = resolve_and_validated(vec![dep("D")], &reg, None).unwrap();
     assert_same(
         &res,
         &names(&[
@@ -355,7 +347,7 @@ fn public_dependency_skipping() {
     ];
     let reg = registry(input);
 
-    resolve_and_validated(pkg_id("root"), vec![dep("c")], &reg, None).unwrap();
+    resolve_and_validated(vec![dep("c")], &reg, None).unwrap();
 }
 
 #[test]
@@ -375,7 +367,7 @@ fn public_dependency_skipping_in_backtracking() {
     ];
     let reg = registry(input);
 
-    resolve_and_validated(pkg_id("root"), vec![dep("C")], &reg, None).unwrap();
+    resolve_and_validated(vec![dep("C")], &reg, None).unwrap();
 }
 
 #[test]
@@ -389,7 +381,7 @@ fn public_sat_topological_order() {
     ];
 
     let reg = registry(input);
-    assert!(resolve_and_validated(pkg_id("root"), vec![dep("A")], &reg, None).is_err());
+    assert!(resolve_and_validated(vec![dep("A")], &reg, None).is_err());
 }
 
 #[test]
@@ -403,7 +395,7 @@ fn public_sat_unused_makes_things_pub() {
     ];
     let reg = registry(input);
 
-    resolve_and_validated(pkg_id("root"), vec![dep("c")], &reg, None).unwrap();
+    resolve_and_validated(vec![dep("c")], &reg, None).unwrap();
 }
 
 #[test]
@@ -418,7 +410,7 @@ fn public_sat_unused_makes_things_pub_2() {
     ];
     let reg = registry(input);
 
-    resolve_and_validated(pkg_id("root"), vec![dep("A")], &reg, None).unwrap();
+    resolve_and_validated(vec![dep("A")], &reg, None).unwrap();
 }
 
 #[test]
@@ -430,7 +422,7 @@ fn test_dependency_with_empty_name() {
 
 #[test]
 fn test_resolving_empty_dependency_list() {
-    let res = resolve(pkg_id("root"), Vec::new(), &registry(vec![])).unwrap();
+    let res = resolve(Vec::new(), &registry(vec![])).unwrap();
 
     assert_eq!(res, names(&["root"]));
 }
@@ -438,28 +430,28 @@ fn test_resolving_empty_dependency_list() {
 #[test]
 fn test_resolving_only_package() {
     let reg = registry(vec![pkg!("foo")]);
-    let res = resolve(pkg_id("root"), vec![dep("foo")], &reg).unwrap();
+    let res = resolve(vec![dep("foo")], &reg).unwrap();
     assert_same(&res, &names(&["root", "foo"]));
 }
 
 #[test]
 fn test_resolving_one_dep() {
     let reg = registry(vec![pkg!("foo"), pkg!("bar")]);
-    let res = resolve(pkg_id("root"), vec![dep("foo")], &reg).unwrap();
+    let res = resolve(vec![dep("foo")], &reg).unwrap();
     assert_same(&res, &names(&["root", "foo"]));
 }
 
 #[test]
 fn test_resolving_multiple_deps() {
     let reg = registry(vec![pkg!("foo"), pkg!("bar"), pkg!("baz")]);
-    let res = resolve(pkg_id("root"), vec![dep("foo"), dep("baz")], &reg).unwrap();
+    let res = resolve(vec![dep("foo"), dep("baz")], &reg).unwrap();
     assert_same(&res, &names(&["root", "foo", "baz"]));
 }
 
 #[test]
 fn test_resolving_transitive_deps() {
     let reg = registry(vec![pkg!("foo"), pkg!("bar" => ["foo"])]);
-    let res = resolve(pkg_id("root"), vec![dep("bar")], &reg).unwrap();
+    let res = resolve(vec![dep("bar")], &reg).unwrap();
 
     assert_same(&res, &names(&["root", "foo", "bar"]));
 }
@@ -467,7 +459,7 @@ fn test_resolving_transitive_deps() {
 #[test]
 fn test_resolving_common_transitive_deps() {
     let reg = registry(vec![pkg!("foo" => ["bar"]), pkg!("bar")]);
-    let res = resolve(pkg_id("root"), vec![dep("foo"), dep("bar")], &reg).unwrap();
+    let res = resolve(vec![dep("foo"), dep("bar")], &reg).unwrap();
 
     assert_same(&res, &names(&["root", "foo", "bar"]));
 }
@@ -481,7 +473,6 @@ fn test_resolving_with_same_name() {
 
     let reg = registry(list);
     let res = resolve(
-        pkg_id("root"),
         vec![
             dep_loc("foo", "https://first.example.com"),
             dep_loc("bar", "https://second.example.com"),
@@ -508,12 +499,7 @@ fn test_resolving_with_dev_deps() {
         pkg!("bat"),
     ]);
 
-    let res = resolve(
-        pkg_id("root"),
-        vec![dep("foo"), dep_kind("baz", Kind::Development)],
-        &reg,
-    )
-    .unwrap();
+    let res = resolve(vec![dep("foo"), dep_kind("baz", Kind::Development)], &reg).unwrap();
 
     assert_same(&res, &names(&["root", "foo", "bar", "baz", "bat"]));
 }
@@ -522,7 +508,7 @@ fn test_resolving_with_dev_deps() {
 fn resolving_with_many_versions() {
     let reg = registry(vec![pkg!(("foo", "1.0.1")), pkg!(("foo", "1.0.2"))]);
 
-    let res = resolve(pkg_id("root"), vec![dep("foo")], &reg).unwrap();
+    let res = resolve(vec![dep("foo")], &reg).unwrap();
 
     assert_same(&res, &names(&[("root", "1.0.0"), ("foo", "1.0.2")]));
 }
@@ -531,7 +517,7 @@ fn resolving_with_many_versions() {
 fn resolving_with_specific_version() {
     let reg = registry(vec![pkg!(("foo", "1.0.1")), pkg!(("foo", "1.0.2"))]);
 
-    let res = resolve(pkg_id("root"), vec![dep_req("foo", "=1.0.1")], &reg).unwrap();
+    let res = resolve(vec![dep_req("foo", "=1.0.1")], &reg).unwrap();
 
     assert_same(&res, &names(&[("root", "1.0.0"), ("foo", "1.0.1")]));
 }
@@ -546,12 +532,7 @@ fn test_resolving_maximum_version_with_transitive_deps() {
         pkg!("bar" => [dep_req("util", ">=1.0.1")]),
     ]);
 
-    let res = resolve(
-        pkg_id("root"),
-        vec![dep_req("foo", "1.0.0"), dep_req("bar", "1.0.0")],
-        &reg,
-    )
-    .unwrap();
+    let res = resolve(vec![dep_req("foo", "1.0.0"), dep_req("bar", "1.0.0")], &reg).unwrap();
 
     assert_contains(
         &res,
@@ -596,7 +577,6 @@ fn test_resolving_minimum_version_with_transitive_deps() {
         .unwrap();
 
     let res = resolve_with_config(
-        pkg_id("root"),
         vec![dep_req("foo", "1.0.0"), dep_req("bar", "1.0.0")],
         &reg,
         Some(&config),
@@ -624,12 +604,7 @@ fn resolving_incompat_versions() {
         pkg!("bar" => [dep_req("foo", "=1.0.2")]),
     ]);
 
-    assert!(resolve(
-        pkg_id("root"),
-        vec![dep_req("foo", "=1.0.1"), dep("bar")],
-        &reg
-    )
-    .is_err());
+    assert!(resolve(vec![dep_req("foo", "=1.0.1"), dep("bar")], &reg).is_err());
 }
 
 #[test]
@@ -640,7 +615,7 @@ fn resolving_wrong_case_from_registry() {
     // This test documents the current behavior.
     let reg = registry(vec![pkg!(("foo", "1.0.0")), pkg!("bar" => ["Foo"])]);
 
-    assert!(resolve(pkg_id("root"), vec![dep("bar")], &reg).is_err());
+    assert!(resolve(vec![dep("bar")], &reg).is_err());
 }
 
 #[test]
@@ -651,7 +626,7 @@ fn resolving_mis_hyphenated_from_registry() {
     // This test documents the current behavior.
     let reg = registry(vec![pkg!(("fo-o", "1.0.0")), pkg!("bar" => ["fo_o"])]);
 
-    assert!(resolve(pkg_id("root"), vec![dep("bar")], &reg).is_err());
+    assert!(resolve(vec![dep("bar")], &reg).is_err());
 }
 
 #[test]
@@ -663,7 +638,7 @@ fn resolving_backtrack() {
         pkg!("baz"),
     ]);
 
-    let res = resolve(pkg_id("root"), vec![dep_req("foo", "^1")], &reg).unwrap();
+    let res = resolve(vec![dep_req("foo", "^1")], &reg).unwrap();
 
     assert_contains(
         &res,
@@ -683,7 +658,7 @@ fn resolving_backtrack_features() {
         pkg!("bar"),
     ]);
 
-    let res = resolve(pkg_id("root"), vec![dep_req("foo", "^1")], &reg).unwrap();
+    let res = resolve(vec![dep_req("foo", "^1")], &reg).unwrap();
 
     assert_contains(
         &res,
@@ -705,7 +680,7 @@ fn resolving_allows_multiple_compatible_versions() {
         pkg!("d4" => [dep_req("foo", "0.2")]),
     ]);
 
-    let res = resolve(pkg_id("root"), vec![dep("bar")], &reg).unwrap();
+    let res = resolve(vec![dep("bar")], &reg).unwrap();
 
     assert_same(
         &res,
@@ -738,7 +713,7 @@ fn resolving_with_deep_backtracking() {
         pkg!(("dep_req", "2.0.0")),
     ]);
 
-    let res = resolve(pkg_id("root"), vec![dep_req("foo", "1")], &reg).unwrap();
+    let res = resolve(vec![dep_req("foo", "1")], &reg).unwrap();
 
     assert_same(
         &res,
@@ -765,12 +740,7 @@ fn resolving_with_sys_crates() {
         pkg!(("r", "1.0.0") => [dep_req("l-sys", "0.9"), dep_req("l", "0.9")]),
     ]);
 
-    let res = resolve(
-        pkg_id("root"),
-        vec![dep_req("d", "1"), dep_req("r", "1")],
-        &reg,
-    )
-    .unwrap();
+    let res = resolve(vec![dep_req("d", "1"), dep_req("r", "1")], &reg).unwrap();
 
     assert_same(
         &res,
@@ -819,7 +789,7 @@ fn resolving_with_constrained_sibling_backtrack_parent() {
     }
     let reg = registry(reglist);
 
-    let res = resolve(pkg_id("root"), vec![dep_req("foo", "1")], &reg).unwrap();
+    let res = resolve(vec![dep_req("foo", "1")], &reg).unwrap();
 
     assert_contains(
         &res,
@@ -854,7 +824,7 @@ fn resolving_with_many_equivalent_backtracking() {
 
     let reg = registry(reglist.clone());
 
-    let res = resolve(pkg_id("root"), vec![dep("level0")], &reg);
+    let res = resolve(vec![dep("level0")], &reg);
 
     assert!(res.is_err());
 
@@ -864,7 +834,7 @@ fn resolving_with_many_equivalent_backtracking() {
 
     let reg = registry(reglist.clone());
 
-    let res = resolve(pkg_id("root"), vec![dep("level0")], &reg).unwrap();
+    let res = resolve(vec![dep("level0")], &reg).unwrap();
 
     assert_contains(&res, &names(&[("root", "1.0.0"), ("level0", "1.0.0")]));
 
@@ -877,12 +847,7 @@ fn resolving_with_many_equivalent_backtracking() {
 
     let reg = registry(reglist.clone());
 
-    let res = resolve(
-        pkg_id("root"),
-        vec![dep("level0"), dep("constrained")],
-        &reg,
-    )
-    .unwrap();
+    let res = resolve(vec![dep("level0"), dep("constrained")], &reg).unwrap();
 
     assert_contains(
         &res,
@@ -895,12 +860,7 @@ fn resolving_with_many_equivalent_backtracking() {
 
     let reg = registry(reglist.clone());
 
-    let res = resolve(
-        pkg_id("root"),
-        vec![dep_req("level0", "1.0.1"), dep("constrained")],
-        &reg,
-    )
-    .unwrap();
+    let res = resolve(vec![dep_req("level0", "1.0.1"), dep("constrained")], &reg).unwrap();
 
     assert_contains(
         &res,
@@ -914,7 +874,6 @@ fn resolving_with_many_equivalent_backtracking() {
     let reg = registry(reglist);
 
     let res = resolve(
-        pkg_id("root"),
         vec![dep_req("level0", "1.0.1"), dep_req("constrained", "1.1.0")],
         &reg,
     );
@@ -956,11 +915,7 @@ fn resolving_with_deep_traps() {
 
     let reg = registry(reglist);
 
-    let res = resolve(
-        pkg_id("root"),
-        vec![dep("backtrack_trap0"), dep("cloaking")],
-        &reg,
-    );
+    let res = resolve(vec![dep("backtrack_trap0"), dep("cloaking")], &reg);
 
     assert!(res.is_err());
 }
@@ -1009,7 +964,6 @@ fn resolving_with_constrained_cousins_backtrack() {
     // but `constrained= "2.0.1"` is already picked.
     // Only then to try and solve `constrained= "~1.0.0"` which is incompatible.
     let res = resolve(
-        pkg_id("root"),
         vec![
             dep("backtrack_trap0"),
             dep_req("constrained", "2.0.1"),
@@ -1038,20 +992,11 @@ fn resolving_with_constrained_cousins_backtrack() {
 
     let reg = registry(reglist);
 
-    let res = resolve(
-        pkg_id("root"),
-        vec![dep("level0"), dep_req("constrained", "2.0.1")],
-        &reg,
-    );
+    let res = resolve(vec![dep("level0"), dep_req("constrained", "2.0.1")], &reg);
 
     assert!(res.is_err());
 
-    let res = resolve(
-        pkg_id("root"),
-        vec![dep("level0"), dep_req("constrained", "2.0.0")],
-        &reg,
-    )
-    .unwrap();
+    let res = resolve(vec![dep("level0"), dep_req("constrained", "2.0.0")], &reg).unwrap();
 
     assert_contains(
         &res,
@@ -1091,7 +1036,7 @@ fn resolving_with_constrained_sibling_backtrack_activation() {
     }
     let reg = registry(reglist);
 
-    let res = resolve(pkg_id("root"), vec![dep_req("foo", "1")], &reg).unwrap();
+    let res = resolve(vec![dep_req("foo", "1")], &reg).unwrap();
 
     assert_contains(
         &res,
@@ -1137,7 +1082,7 @@ fn resolving_with_constrained_sibling_transitive_dep_effects() {
         pkg!(("D", "1.0.105")),
     ]);
 
-    let res = resolve(pkg_id("root"), vec![dep_req("A", "1")], &reg).unwrap();
+    let res = resolve(vec![dep_req("A", "1")], &reg).unwrap();
 
     assert_same(
         &res,
@@ -1183,7 +1128,7 @@ fn incomplete_information_skipping() {
     ];
     let reg = registry(input.clone());
 
-    let res = resolve(pkg_id("root"), vec![dep("g")], &reg).unwrap();
+    let res = resolve(vec![dep("g")], &reg).unwrap();
     let package_to_yank = "to_yank".to_pkgid();
     // this package is not used in the resolution.
     assert!(!res.contains(&package_to_yank));
@@ -1197,7 +1142,7 @@ fn incomplete_information_skipping() {
     );
     assert_eq!(input.len(), new_reg.len() + 1);
     // it should still build
-    assert!(resolve(pkg_id("root"), vec![dep("g")], &new_reg).is_ok());
+    assert!(resolve(vec![dep("g")], &new_reg).is_ok());
 }
 
 #[test]
@@ -1252,7 +1197,7 @@ fn incomplete_information_skipping_2() {
     ];
     let reg = registry(input.clone());
 
-    let res = resolve(pkg_id("root"), vec![dep("i")], &reg).unwrap();
+    let res = resolve(vec![dep("i")], &reg).unwrap();
     let package_to_yank = ("to_yank", "8.8.1").to_pkgid();
     // this package is not used in the resolution.
     assert!(!res.contains(&package_to_yank));
@@ -1266,7 +1211,7 @@ fn incomplete_information_skipping_2() {
     );
     assert_eq!(input.len(), new_reg.len() + 1);
     // it should still build
-    assert!(resolve(pkg_id("root"), vec![dep("i")], &new_reg).is_ok());
+    assert!(resolve(vec![dep("i")], &new_reg).is_ok());
 }
 
 #[test]
@@ -1302,7 +1247,7 @@ fn incomplete_information_skipping_3() {
     ];
     let reg = registry(input.clone());
 
-    let res = resolve(pkg_id("root"), vec![dep("b")], &reg).unwrap();
+    let res = resolve(vec![dep("b")], &reg).unwrap();
     let package_to_yank = ("to_yank", "3.0.3").to_pkgid();
     // this package is not used in the resolution.
     assert!(!res.contains(&package_to_yank));
@@ -1316,14 +1261,14 @@ fn incomplete_information_skipping_3() {
     );
     assert_eq!(input.len(), new_reg.len() + 1);
     // it should still build
-    assert!(resolve(pkg_id("root"), vec![dep("b")], &new_reg).is_ok());
+    assert!(resolve(vec![dep("b")], &new_reg).is_ok());
 }
 
 #[test]
 fn resolving_but_no_exists() {
     let reg = registry(vec![]);
 
-    let res = resolve(pkg_id("root"), vec![dep_req("foo", "1")], &reg);
+    let res = resolve(vec![dep_req("foo", "1")], &reg);
     assert!(res.is_err());
 
     assert_eq!(
@@ -1340,7 +1285,7 @@ fn resolving_but_no_exists() {
 fn resolving_cycle() {
     let reg = registry(vec![pkg!("foo" => ["foo"])]);
 
-    let _ = resolve(pkg_id("root"), vec![dep_req("foo", "1")], &reg);
+    let _ = resolve(vec![dep_req("foo", "1")], &reg);
 }
 
 #[test]
@@ -1351,12 +1296,7 @@ fn hard_equality() {
         pkg!(("bar", "1.0.0") => [dep_req("foo", "1.0.0")]),
     ]);
 
-    let res = resolve(
-        pkg_id("root"),
-        vec![dep_req("bar", "1"), dep_req("foo", "=1.0.0")],
-        &reg,
-    )
-    .unwrap();
+    let res = resolve(vec![dep_req("bar", "1"), dep_req("foo", "=1.0.0")], &reg).unwrap();
 
     assert_same(
         &res,
@@ -1390,7 +1330,7 @@ fn large_conflict_cache() {
         }
     }
     let reg = registry(input);
-    let _ = resolve(pkg_id("root"), root_deps, &reg);
+    let _ = resolve(root_deps, &reg);
 }
 
 #[test]
@@ -1430,7 +1370,7 @@ fn conflict_store_bug() {
     ];
 
     let reg = registry(input);
-    let _ = resolve_and_validated(pkg_id("root"), vec![dep("j")], &reg, None);
+    let _ = resolve_and_validated(vec![dep("j")], &reg, None);
 }
 
 #[test]
@@ -1458,5 +1398,5 @@ fn conflict_store_more_then_one_match() {
         ]),
     ];
     let reg = registry(input);
-    let _ = resolve_and_validated(pkg_id("root"), vec![dep("nA")], &reg, None);
+    let _ = resolve_and_validated(vec![dep("nA")], &reg, None);
 }