test: separate resolver tests into multiple files

Author: x-hgg-x

crates/resolver-tests/src/helpers.rs

@@ -0,0 +1,213 @@
+use std::collections::BTreeMap;
+use std::fmt::Debug;
+use std::sync::OnceLock;
+
+use cargo::core::dependency::DepKind;
+use cargo::core::{Dependency, GitReference, PackageId, SourceId, Summary};
+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;
+}
+
+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 {
+        let mut dep = self.to_dep();
+        dep.set_optional(true);
+        dep
+    }
+    fn to_dep_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
+    }
+}
+
+impl ToDep for Dependency {
+    fn to_dep(self) -> Dependency {
+        self
+    }
+    fn to_opt_dep(mut self) -> Dependency {
+        self.set_optional(true);
+        self
+    }
+    fn to_dep_with(mut self, features: &[&'static str]) -> Dependency {
+        self.set_default_features(false);
+        self.set_features(features.into_iter().copied());
+        self
+    }
+}
+
+pub trait ToPkgId {
+    fn to_pkgid(&self) -> PackageId;
+}
+
+impl ToPkgId for PackageId {
+    fn to_pkgid(&self) -> PackageId {
+        *self
+    }
+}
+
+impl<'a> ToPkgId for &'a str {
+    fn to_pkgid(&self) -> PackageId {
+        PackageId::try_new(*self, "1.0.0", registry_loc()).unwrap()
+    }
+}
+
+impl<T: AsRef<str>, U: AsRef<str>> ToPkgId for (T, U) {
+    fn to_pkgid(&self) -> PackageId {
+        let (name, vers) = self;
+        PackageId::try_new(name.as_ref(), vers.as_ref(), registry_loc()).unwrap()
+    }
+}
+
+#[macro_export]
+macro_rules! pkg {
+    ($pkgid:expr => [$($deps:expr),* $(,)? ]) => ({
+        use $crate::helpers::ToDep;
+        let d: Vec<Dependency> = vec![$($deps.to_dep()),*];
+        $crate::helpers::pkg_dep($pkgid, d)
+    });
+
+    ($pkgid:expr) => ({
+        $crate::helpers::pkg($pkgid)
+    })
+}
+
+fn registry_loc() -> SourceId {
+    static EXAMPLE_DOT_COM: OnceLock<SourceId> = OnceLock::new();
+    let example_dot = EXAMPLE_DOT_COM.get_or_init(|| {
+        SourceId::for_registry(&"https://example.com".into_url().unwrap()).unwrap()
+    });
+    *example_dot
+}
+
+pub fn pkg<T: ToPkgId>(name: T) -> Summary {
+    pkg_dep(name, Vec::new())
+}
+
+pub fn pkg_dep<T: ToPkgId>(name: T, dep: Vec<Dependency>) -> Summary {
+    let pkgid = name.to_pkgid();
+    let link = if pkgid.name().ends_with("-sys") {
+        Some(pkgid.name())
+    } else {
+        None
+    };
+    Summary::new(name.to_pkgid(), dep, &BTreeMap::new(), link, None).unwrap()
+}
+
+pub fn pkg_dep_with<T: ToPkgId>(
+    name: T,
+    dep: Vec<Dependency>,
+    features: &[(&'static str, &[&'static str])],
+) -> Summary {
+    let pkgid = name.to_pkgid();
+    let link = if pkgid.name().ends_with("-sys") {
+        Some(pkgid.name())
+    } else {
+        None
+    };
+    let features = features
+        .into_iter()
+        .map(|&(name, values)| (name.into(), values.into_iter().map(|&v| v.into()).collect()))
+        .collect();
+    Summary::new(name.to_pkgid(), dep, &features, link, None).unwrap()
+}
+
+pub fn pkg_id(name: &str) -> PackageId {
+    PackageId::try_new(name, "1.0.0", registry_loc()).unwrap()
+}
+
+fn pkg_id_loc(name: &str, loc: &str) -> PackageId {
+    let remote = loc.into_url();
+    let master = GitReference::Branch("master".to_string());
+    let source_id = SourceId::for_git(&remote.unwrap(), master).unwrap();
+
+    PackageId::try_new(name, "1.0.0", source_id).unwrap()
+}
+
+pub fn pkg_loc(name: &str, loc: &str) -> Summary {
+    let link = if name.ends_with("-sys") {
+        Some(name)
+    } else {
+        None
+    };
+    Summary::new(
+        pkg_id_loc(name, loc),
+        Vec::new(),
+        &BTreeMap::new(),
+        link,
+        None,
+    )
+    .unwrap()
+}
+
+pub fn remove_dep(sum: &Summary, ind: usize) -> Summary {
+    let mut deps = sum.dependencies().to_vec();
+    deps.remove(ind);
+    // note: more things will need to be copied over in the future, but it works for now.
+    Summary::new(sum.package_id(), deps, &BTreeMap::new(), sum.links(), None).unwrap()
+}
+
+pub fn dep(name: &str) -> Dependency {
+    dep_req(name, "*")
+}
+
+pub fn dep_req(name: &str, req: &str) -> Dependency {
+    Dependency::parse(name, Some(req), registry_loc()).unwrap()
+}
+
+pub fn dep_req_kind(name: &str, req: &str, kind: DepKind) -> Dependency {
+    let mut dep = dep_req(name, req);
+    dep.set_kind(kind);
+    dep
+}
+
+pub fn dep_loc(name: &str, location: &str) -> Dependency {
+    let url = location.into_url().unwrap();
+    let master = GitReference::Branch("master".to_string());
+    let source_id = SourceId::for_git(&url, master).unwrap();
+    Dependency::parse(name, Some("1.0.0"), source_id).unwrap()
+}
+
+pub fn dep_kind(name: &str, kind: DepKind) -> Dependency {
+    dep(name).set_kind(kind).clone()
+}
+
+pub fn registry(pkgs: Vec<Summary>) -> Vec<Summary> {
+    pkgs
+}
+
+pub fn names<P: ToPkgId>(names: &[P]) -> Vec<PackageId> {
+    names.iter().map(|name| name.to_pkgid()).collect()
+}
+
+pub fn loc_names(names: &[(&'static str, &'static str)]) -> Vec<PackageId> {
+    names
+        .iter()
+        .map(|&(name, loc)| pkg_id_loc(name, loc))
+        .collect()
+}
+
+/// Assert `xs` contains `elems`
+#[track_caller]
+pub fn assert_contains<A: PartialEq + Debug>(xs: &[A], elems: &[A]) {
+    for elem in elems {
+        assert!(
+            xs.contains(elem),
+            "missing element\nset: {xs:?}\nmissing: {elem:?}"
+        );
+    }
+}
+
+#[track_caller]
+pub fn assert_same<A: PartialEq + Debug>(a: &[A], b: &[A]) {
+    assert_eq!(a.len(), b.len(), "not equal\n{a:?}\n{b:?}");
+    assert_contains(b, a);
+}