2016-02-05 01:05:41 +00:00
|
|
|
#![deny(warnings)]
|
|
|
|
|
2014-10-17 15:17:17 +00:00
|
|
|
extern crate hamcrest;
|
|
|
|
extern crate cargo;
|
|
|
|
|
|
|
|
use std::collections::HashMap;
|
|
|
|
|
2016-12-13 21:00:15 +00:00
|
|
|
use hamcrest::{assert_that, equal_to, contains, not};
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-12-08 18:46:07 +00:00
|
|
|
use cargo::core::source::{SourceId, GitReference};
|
2015-09-17 03:37:45 +00:00
|
|
|
use cargo::core::dependency::Kind::{self, Development};
|
2014-10-17 15:17:17 +00:00
|
|
|
use cargo::core::{Dependency, PackageId, Summary, Registry};
|
2016-10-07 19:34:00 +00:00
|
|
|
use cargo::util::{CargoResult, ToUrl};
|
2015-01-04 09:02:16 +00:00
|
|
|
use cargo::core::resolver::{self, Method};
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2017-06-05 14:44:16 +00:00
|
|
|
fn resolve(pkg: PackageId, 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(())
|
|
|
|
}
|
2017-05-04 03:33:28 +00:00
|
|
|
fn supports_checksums(&self) -> bool { false }
|
|
|
|
fn requires_precise(&self) -> bool { false }
|
2017-06-05 14:44:16 +00:00
|
|
|
}
|
|
|
|
let mut registry = MyRegistry(registry);
|
2016-05-15 00:14:24 +00:00
|
|
|
let summary = Summary::new(pkg.clone(), deps, HashMap::new()).unwrap();
|
2014-11-19 06:29:19 +00:00
|
|
|
let method = Method::Everything;
|
2017-08-18 17:37:12 +00:00
|
|
|
let resolve = resolver::resolve(&[(summary, method)], &[], &mut registry, None)?;
|
2016-11-04 00:18:48 +00:00
|
|
|
let res = resolve.iter().cloned().collect();
|
|
|
|
Ok(res)
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
trait ToDep {
|
|
|
|
fn to_dep(self) -> Dependency;
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ToDep for &'static str {
|
|
|
|
fn to_dep(self) -> Dependency {
|
|
|
|
let url = "http://example.com".to_url().unwrap();
|
2017-08-11 14:25:19 +00:00
|
|
|
let source_id = SourceId::for_registry(&url).unwrap();
|
2016-10-07 19:34:00 +00:00
|
|
|
Dependency::parse_no_deprecated(self, Some("1.0.0"), &source_id).unwrap()
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ToDep for Dependency {
|
|
|
|
fn to_dep(self) -> Dependency {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
trait ToPkgId {
|
|
|
|
fn to_pkgid(&self) -> PackageId;
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ToPkgId for &'static str {
|
|
|
|
fn to_pkgid(&self) -> PackageId {
|
|
|
|
PackageId::new(*self, "1.0.0", ®istry_loc()).unwrap()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ToPkgId for (&'static str, &'static str) {
|
|
|
|
fn to_pkgid(&self) -> PackageId {
|
|
|
|
let (name, vers) = *self;
|
|
|
|
PackageId::new(name, vers, ®istry_loc()).unwrap()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-19 18:38:32 +00:00
|
|
|
macro_rules! pkg {
|
2014-10-17 15:17:17 +00:00
|
|
|
($pkgid:expr => [$($deps:expr),+]) => ({
|
|
|
|
let d: Vec<Dependency> = vec![$($deps.to_dep()),+];
|
|
|
|
|
|
|
|
Summary::new($pkgid.to_pkgid(), d, HashMap::new()).unwrap()
|
|
|
|
});
|
|
|
|
|
|
|
|
($pkgid:expr) => (
|
|
|
|
Summary::new($pkgid.to_pkgid(), Vec::new(), HashMap::new()).unwrap()
|
|
|
|
)
|
2014-12-19 18:38:32 +00:00
|
|
|
}
|
2014-10-17 15:17:17 +00:00
|
|
|
|
|
|
|
fn registry_loc() -> SourceId {
|
|
|
|
let remote = "http://example.com".to_url().unwrap();
|
2017-08-11 14:25:19 +00:00
|
|
|
SourceId::for_registry(&remote).unwrap()
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn pkg(name: &str) -> Summary {
|
|
|
|
Summary::new(pkg_id(name), Vec::new(), HashMap::new()).unwrap()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn pkg_id(name: &str) -> PackageId {
|
|
|
|
PackageId::new(name, "1.0.0", ®istry_loc()).unwrap()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn pkg_id_loc(name: &str, loc: &str) -> PackageId {
|
|
|
|
let remote = loc.to_url();
|
2014-12-08 18:46:07 +00:00
|
|
|
let master = GitReference::Branch("master".to_string());
|
2017-08-11 14:25:19 +00:00
|
|
|
let source_id = SourceId::for_git(&remote.unwrap(), master).unwrap();
|
2014-10-17 15:17:17 +00:00
|
|
|
|
|
|
|
PackageId::new(name, "1.0.0", &source_id).unwrap()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn pkg_loc(name: &str, loc: &str) -> Summary {
|
|
|
|
Summary::new(pkg_id_loc(name, loc), Vec::new(), HashMap::new()).unwrap()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn dep(name: &str) -> Dependency { dep_req(name, "1.0.0") }
|
|
|
|
fn dep_req(name: &str, req: &str) -> Dependency {
|
|
|
|
let url = "http://example.com".to_url().unwrap();
|
2017-08-11 14:25:19 +00:00
|
|
|
let source_id = SourceId::for_registry(&url).unwrap();
|
2016-10-07 19:34:00 +00:00
|
|
|
Dependency::parse_no_deprecated(name, Some(req), &source_id).unwrap()
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn dep_loc(name: &str, location: &str) -> Dependency {
|
|
|
|
let url = location.to_url().unwrap();
|
2014-12-08 18:46:07 +00:00
|
|
|
let master = GitReference::Branch("master".to_string());
|
2017-08-11 14:25:19 +00:00
|
|
|
let source_id = SourceId::for_git(&url, master).unwrap();
|
2016-10-07 19:34:00 +00:00
|
|
|
Dependency::parse_no_deprecated(name, Some("1.0.0"), &source_id).unwrap()
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
2015-09-17 03:37:45 +00:00
|
|
|
fn dep_kind(name: &str, kind: Kind) -> Dependency {
|
2017-06-02 13:59:16 +00:00
|
|
|
dep(name).set_kind(kind).clone()
|
2015-09-17 03:37:45 +00:00
|
|
|
}
|
2014-10-17 15:17:17 +00:00
|
|
|
|
|
|
|
fn registry(pkgs: Vec<Summary>) -> Vec<Summary> {
|
|
|
|
pkgs
|
|
|
|
}
|
|
|
|
|
|
|
|
fn names<P: ToPkgId>(names: &[P]) -> Vec<PackageId> {
|
|
|
|
names.iter().map(|name| name.to_pkgid()).collect()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn loc_names(names: &[(&'static str, &'static str)]) -> Vec<PackageId> {
|
|
|
|
names.iter()
|
|
|
|
.map(|&(name, loc)| pkg_id_loc(name, loc)).collect()
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_resolving_empty_dependency_list() {
|
|
|
|
let res = resolve(pkg_id("root"), Vec::new(),
|
2015-11-23 16:56:10 +00:00
|
|
|
&mut registry(vec![])).unwrap();
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-11-22 10:04:40 +00:00
|
|
|
assert_that(&res, equal_to(&names(&["root"])));
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_resolving_only_package() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![pkg("foo")]);
|
|
|
|
let res = resolve(pkg_id("root"), vec![dep("foo")], ®);
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-11-22 10:04:40 +00:00
|
|
|
assert_that(&res.unwrap(), contains(names(&["root", "foo"])).exactly());
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_resolving_one_dep() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![pkg("foo"), pkg("bar")]);
|
|
|
|
let res = resolve(pkg_id("root"), vec![dep("foo")], ®);
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-11-22 10:04:40 +00:00
|
|
|
assert_that(&res.unwrap(), contains(names(&["root", "foo"])).exactly());
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_resolving_multiple_deps() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![pkg!("foo"), pkg!("bar"), pkg!("baz")]);
|
2014-10-17 15:17:17 +00:00
|
|
|
let res = resolve(pkg_id("root"), vec![dep("foo"), dep("baz")],
|
2017-06-07 15:23:36 +00:00
|
|
|
®).unwrap();
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-11-22 10:04:40 +00:00
|
|
|
assert_that(&res, contains(names(&["root", "foo", "baz"])).exactly());
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_resolving_transitive_deps() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![pkg!("foo"), pkg!("bar" => ["foo"])]);
|
|
|
|
let res = resolve(pkg_id("root"), vec![dep("bar")], ®).unwrap();
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-11-22 10:04:40 +00:00
|
|
|
assert_that(&res, contains(names(&["root", "foo", "bar"])));
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_resolving_common_transitive_deps() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![pkg!("foo" => ["bar"]), pkg!("bar")]);
|
2014-10-17 15:17:17 +00:00
|
|
|
let res = resolve(pkg_id("root"), vec![dep("foo"), dep("bar")],
|
2017-06-07 15:23:36 +00:00
|
|
|
®).unwrap();
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-11-22 10:04:40 +00:00
|
|
|
assert_that(&res, contains(names(&["root", "foo", "bar"])));
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_resolving_with_same_name() {
|
|
|
|
let list = vec![pkg_loc("foo", "http://first.example.com"),
|
|
|
|
pkg_loc("bar", "http://second.example.com")];
|
|
|
|
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(list);
|
2014-10-17 15:17:17 +00:00
|
|
|
let res = resolve(pkg_id("root"),
|
|
|
|
vec![dep_loc("foo", "http://first.example.com"),
|
|
|
|
dep_loc("bar", "http://second.example.com")],
|
2017-06-07 15:23:36 +00:00
|
|
|
®);
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-11-22 10:04:40 +00:00
|
|
|
let mut names = loc_names(&[("foo", "http://first.example.com"),
|
|
|
|
("bar", "http://second.example.com")]);
|
2014-10-17 15:17:17 +00:00
|
|
|
|
|
|
|
names.push(pkg_id("root"));
|
|
|
|
|
|
|
|
assert_that(&res.unwrap(), contains(names).exactly());
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_resolving_with_dev_deps() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![
|
2015-09-17 03:37:45 +00:00
|
|
|
pkg!("foo" => ["bar", dep_kind("baz", Development)]),
|
|
|
|
pkg!("baz" => ["bat", dep_kind("bam", Development)]),
|
2014-10-17 15:17:17 +00:00
|
|
|
pkg!("bar"),
|
|
|
|
pkg!("bat")
|
2015-11-23 16:56:10 +00:00
|
|
|
]);
|
2014-10-17 15:17:17 +00:00
|
|
|
|
|
|
|
let res = resolve(pkg_id("root"),
|
2015-09-17 03:37:45 +00:00
|
|
|
vec![dep("foo"), dep_kind("baz", Development)],
|
2017-06-07 15:23:36 +00:00
|
|
|
®).unwrap();
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-11-22 10:04:40 +00:00
|
|
|
assert_that(&res, contains(names(&["root", "foo", "bar", "baz"])));
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn resolving_with_many_versions() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![
|
2014-10-17 15:17:17 +00:00
|
|
|
pkg!(("foo", "1.0.1")),
|
|
|
|
pkg!(("foo", "1.0.2")),
|
2015-11-23 16:56:10 +00:00
|
|
|
]);
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2017-06-07 15:23:36 +00:00
|
|
|
let res = resolve(pkg_id("root"), vec![dep("foo")], ®).unwrap();
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-11-22 10:04:40 +00:00
|
|
|
assert_that(&res, contains(names(&[("root", "1.0.0"),
|
|
|
|
("foo", "1.0.2")])));
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn resolving_with_specific_version() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![
|
2014-10-17 15:17:17 +00:00
|
|
|
pkg!(("foo", "1.0.1")),
|
|
|
|
pkg!(("foo", "1.0.2")),
|
2015-11-23 16:56:10 +00:00
|
|
|
]);
|
2014-10-17 15:17:17 +00:00
|
|
|
|
|
|
|
let res = resolve(pkg_id("root"), vec![dep_req("foo", "=1.0.1")],
|
2017-06-07 15:23:36 +00:00
|
|
|
®).unwrap();
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-11-22 10:04:40 +00:00
|
|
|
assert_that(&res, contains(names(&[("root", "1.0.0"),
|
|
|
|
("foo", "1.0.1")])));
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
2016-12-13 21:00:15 +00:00
|
|
|
#[test]
|
|
|
|
fn test_resolving_maximum_version_with_transitive_deps() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![
|
2016-12-13 21:00:15 +00:00
|
|
|
pkg!(("util", "1.2.2")),
|
|
|
|
pkg!(("util", "1.0.0")),
|
|
|
|
pkg!(("util", "1.1.1")),
|
|
|
|
pkg!("foo" => [dep_req("util", "1.0.0")]),
|
|
|
|
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")],
|
2017-06-07 15:23:36 +00:00
|
|
|
®).unwrap();
|
2016-12-13 21:00:15 +00:00
|
|
|
|
|
|
|
assert_that(&res, contains(names(&[("root", "1.0.0"),
|
|
|
|
("foo", "1.0.0"),
|
|
|
|
("bar", "1.0.0"),
|
|
|
|
("util", "1.2.2")])));
|
|
|
|
assert_that(&res, not(contains(names(&[("util", "1.0.1")]))));
|
|
|
|
assert_that(&res, not(contains(names(&[("util", "1.1.1")]))));
|
|
|
|
}
|
|
|
|
|
2014-10-17 15:17:17 +00:00
|
|
|
#[test]
|
|
|
|
fn resolving_incompat_versions() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![
|
2014-10-17 15:17:17 +00:00
|
|
|
pkg!(("foo", "1.0.1")),
|
|
|
|
pkg!(("foo", "1.0.2")),
|
|
|
|
pkg!("bar" => [dep_req("foo", "=1.0.2")]),
|
2015-11-23 16:56:10 +00:00
|
|
|
]);
|
2014-10-17 15:17:17 +00:00
|
|
|
|
|
|
|
assert!(resolve(pkg_id("root"), vec![
|
|
|
|
dep_req("foo", "=1.0.1"),
|
|
|
|
dep("bar"),
|
2017-06-07 15:23:36 +00:00
|
|
|
], ®).is_err());
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn resolving_backtrack() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![
|
2014-10-17 15:17:17 +00:00
|
|
|
pkg!(("foo", "1.0.2") => [dep("bar")]),
|
|
|
|
pkg!(("foo", "1.0.1") => [dep("baz")]),
|
|
|
|
pkg!("bar" => [dep_req("foo", "=2.0.2")]),
|
|
|
|
pkg!("baz"),
|
2015-11-23 16:56:10 +00:00
|
|
|
]);
|
2014-10-17 15:17:17 +00:00
|
|
|
|
|
|
|
let res = resolve(pkg_id("root"), vec![
|
|
|
|
dep_req("foo", "^1"),
|
2017-06-07 15:23:36 +00:00
|
|
|
], ®).unwrap();
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-11-22 10:04:40 +00:00
|
|
|
assert_that(&res, contains(names(&[("root", "1.0.0"),
|
|
|
|
("foo", "1.0.1"),
|
|
|
|
("baz", "1.0.0")])));
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn resolving_allows_multiple_compatible_versions() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![
|
2014-10-17 15:17:17 +00:00
|
|
|
pkg!(("foo", "1.0.0")),
|
|
|
|
pkg!(("foo", "2.0.0")),
|
|
|
|
pkg!(("foo", "0.1.0")),
|
|
|
|
pkg!(("foo", "0.2.0")),
|
|
|
|
|
|
|
|
pkg!("bar" => ["d1", "d2", "d3", "d4"]),
|
|
|
|
pkg!("d1" => [dep_req("foo", "1")]),
|
|
|
|
pkg!("d2" => [dep_req("foo", "2")]),
|
|
|
|
pkg!("d3" => [dep_req("foo", "0.1")]),
|
|
|
|
pkg!("d4" => [dep_req("foo", "0.2")]),
|
2015-11-23 16:56:10 +00:00
|
|
|
]);
|
2014-10-17 15:17:17 +00:00
|
|
|
|
|
|
|
let res = resolve(pkg_id("root"), vec![
|
|
|
|
dep("bar"),
|
2017-06-07 15:23:36 +00:00
|
|
|
], ®).unwrap();
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-11-22 10:04:40 +00:00
|
|
|
assert_that(&res, contains(names(&[("root", "1.0.0"),
|
|
|
|
("foo", "1.0.0"),
|
|
|
|
("foo", "2.0.0"),
|
|
|
|
("foo", "0.1.0"),
|
|
|
|
("foo", "0.2.0"),
|
|
|
|
("d1", "1.0.0"),
|
|
|
|
("d2", "1.0.0"),
|
|
|
|
("d3", "1.0.0"),
|
|
|
|
("d4", "1.0.0"),
|
|
|
|
("bar", "1.0.0")])));
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn resolving_with_deep_backtracking() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![
|
2014-10-17 15:17:17 +00:00
|
|
|
pkg!(("foo", "1.0.1") => [dep_req("bar", "1")]),
|
|
|
|
pkg!(("foo", "1.0.0") => [dep_req("bar", "2")]),
|
|
|
|
|
|
|
|
pkg!(("bar", "1.0.0") => [dep_req("baz", "=1.0.2"),
|
|
|
|
dep_req("other", "1")]),
|
|
|
|
pkg!(("bar", "2.0.0") => [dep_req("baz", "=1.0.1")]),
|
|
|
|
|
|
|
|
pkg!(("baz", "1.0.2") => [dep_req("other", "2")]),
|
|
|
|
pkg!(("baz", "1.0.1")),
|
|
|
|
|
|
|
|
pkg!(("dep_req", "1.0.0")),
|
|
|
|
pkg!(("dep_req", "2.0.0")),
|
2015-11-23 16:56:10 +00:00
|
|
|
]);
|
2014-10-17 15:17:17 +00:00
|
|
|
|
|
|
|
let res = resolve(pkg_id("root"), vec![
|
|
|
|
dep_req("foo", "1"),
|
2017-06-07 15:23:36 +00:00
|
|
|
], ®).unwrap();
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-11-22 10:04:40 +00:00
|
|
|
assert_that(&res, contains(names(&[("root", "1.0.0"),
|
|
|
|
("foo", "1.0.0"),
|
|
|
|
("bar", "2.0.0"),
|
|
|
|
("baz", "1.0.1")])));
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn resolving_but_no_exists() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![
|
2015-11-23 16:56:10 +00:00
|
|
|
]);
|
2014-10-17 15:17:17 +00:00
|
|
|
|
|
|
|
let res = resolve(pkg_id("root"), vec![
|
|
|
|
dep_req("foo", "1"),
|
2017-06-07 15:23:36 +00:00
|
|
|
], ®);
|
2014-10-17 15:17:17 +00:00
|
|
|
assert!(res.is_err());
|
|
|
|
|
2015-01-25 06:03:42 +00:00
|
|
|
assert_eq!(res.err().unwrap().to_string(), "\
|
2015-01-11 07:03:58 +00:00
|
|
|
no matching package named `foo` found (required by `root`)
|
2014-10-17 15:17:17 +00:00
|
|
|
location searched: registry http://example.com/
|
|
|
|
version required: ^1\
|
2015-01-13 16:41:04 +00:00
|
|
|
");
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn resolving_cycle() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![
|
2014-10-17 15:17:17 +00:00
|
|
|
pkg!("foo" => ["foo"]),
|
2015-11-23 16:56:10 +00:00
|
|
|
]);
|
2014-10-17 15:17:17 +00:00
|
|
|
|
2014-10-17 19:23:10 +00:00
|
|
|
let _ = resolve(pkg_id("root"), vec![
|
2014-10-17 15:17:17 +00:00
|
|
|
dep_req("foo", "1"),
|
2017-06-07 15:23:36 +00:00
|
|
|
], ®);
|
2014-10-17 15:17:17 +00:00
|
|
|
}
|
2015-07-13 19:14:05 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn hard_equality() {
|
2017-06-07 15:23:36 +00:00
|
|
|
let reg = registry(vec![
|
2015-07-13 19:14:05 +00:00
|
|
|
pkg!(("foo", "1.0.1")),
|
|
|
|
pkg!(("foo", "1.0.0")),
|
|
|
|
|
|
|
|
pkg!(("bar", "1.0.0") => [dep_req("foo", "1.0.0")]),
|
2015-11-23 16:56:10 +00:00
|
|
|
]);
|
2015-07-13 19:14:05 +00:00
|
|
|
|
|
|
|
let res = resolve(pkg_id("root"), vec![
|
|
|
|
dep_req("bar", "1"),
|
|
|
|
dep_req("foo", "=1.0.0"),
|
2017-06-07 15:23:36 +00:00
|
|
|
], ®).unwrap();
|
2015-07-13 19:14:05 +00:00
|
|
|
|
|
|
|
assert_that(&res, contains(names(&[("root", "1.0.0"),
|
|
|
|
("foo", "1.0.0"),
|
|
|
|
("bar", "1.0.0")])));
|
|
|
|
}
|