Implement machinery for writing unit tests of the resolver

Author: mkaput

murek/src/core/manifest/mod.rs

@@ -53,7 +53,7 @@ impl Summary {
 }
 
 /// Subset of a [`Manifest`] that contains package metadata.
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
 pub struct ManifestMetadata {
     pub authors: Option<Vec<String>>,
     pub urls: Option<BTreeMap<String, String>>,

murek/src/core/package/id.rs

@@ -44,6 +44,37 @@ impl PackageId {
         };
         Self(CACHE.intern(inner))
     }
+
+    #[cfg(test)]
+    pub(crate) fn from_display_str(string: &str) -> Result<Self> {
+        use anyhow::{anyhow, bail};
+
+        let mut s = string.splitn(3, ' ');
+
+        let name = s.next().unwrap().into();
+
+        let Some(version) = s.next() else {
+            bail!("invalid displayed PackageId: missing version");
+        };
+        let Some(version) = version.strip_prefix('v') else {
+            bail!("invalid displayed PackageId: version does not start with letter `v`");
+        };
+        let version = version
+            .to_version()
+            .map_err(|err| anyhow!("invalid displayed PackageId: {}", err))?;
+
+        let Some(source_id) = s.next() else {
+            todo!("Default SourceId is not implemented yet.")
+        };
+        let source_id = if source_id.starts_with('(') && source_id.ends_with(')') {
+            &source_id[1..source_id.len() - 1]
+        } else {
+            bail!("invalid displayed PackageId: source url is not wrapped with parentheses",);
+        };
+        let source_id = SourceId::from_display_str(source_id)?;
+
+        Ok(PackageId::pure(name, version, source_id))
+    }
 }
 
 impl Deref for PackageId {

murek/src/core/registry/mod.rs

@@ -14,3 +14,159 @@ pub trait Registry {
     /// Fetch full package by its ID.
     async fn download(&mut self, package_id: PackageId) -> Result<Package>;
 }
+
+#[cfg(test)]
+pub(crate) mod mock {
+    use std::collections::hash_map::Entry;
+    use std::collections::{HashMap, HashSet};
+    use std::path::PathBuf;
+
+    use anyhow::{anyhow, bail, Result};
+    use async_trait::async_trait;
+    use itertools::Itertools;
+
+    use crate::core::package::PackageName;
+    use crate::core::registry::Registry;
+    use crate::core::{Manifest, ManifestDependency, Package, PackageId, SourceId, Summary};
+
+    #[derive(Clone, Debug, Default)]
+    pub struct MockRegistry {
+        index: HashMap<(PackageName, SourceId), HashSet<PackageId>>,
+        dependencies: HashMap<PackageId, Vec<ManifestDependency>>,
+        packages: HashMap<PackageId, Package>,
+    }
+
+    impl MockRegistry {
+        pub fn new() -> Self {
+            Default::default()
+        }
+
+        pub fn put(&mut self, package_id: PackageId, mut dependencies: Vec<ManifestDependency>) {
+            assert!(
+                !self.has_package(package_id),
+                "Package {} is already in registry",
+                package_id
+            );
+
+            self.index
+                .entry((package_id.name.clone(), package_id.source_id))
+                .or_default()
+                .insert(package_id);
+
+            self.dependencies
+                .entry(package_id)
+                .or_default()
+                .append(&mut dependencies);
+        }
+
+        pub fn has_package(&self, package_id: PackageId) -> bool {
+            self.dependencies.contains_key(&package_id)
+        }
+
+        pub fn get_package(&mut self, package_id: PackageId) -> Result<Package> {
+            if !self.has_package(package_id) {
+                bail!("MockRegistry/get_package: unknown package {package_id}");
+            }
+
+            match self.packages.entry(package_id) {
+                Entry::Occupied(entry) => Ok(entry.get().clone()),
+                Entry::Vacant(entry) => {
+                    let summary = Summary::new(package_id, self.dependencies[&package_id].clone());
+                    let manifest = Box::new(Manifest {
+                        summary,
+                        metadata: Default::default(),
+                    });
+                    let package = Package::new(package_id, PathBuf::new(), manifest);
+                    entry.insert(package.clone());
+                    Ok(package)
+                }
+            }
+        }
+    }
+
+    #[async_trait(?Send)]
+    impl Registry for MockRegistry {
+        async fn query(&mut self, dependency: &ManifestDependency) -> Result<Vec<Summary>> {
+            Ok(self
+                .index
+                .get(&(dependency.name.clone(), dependency.source_id))
+                .ok_or_else(|| {
+                    anyhow!(
+                        "MockRegistry/query: unknown package {} ({})",
+                        dependency.name,
+                        dependency.source_id
+                    )
+                })?
+                .iter()
+                .copied()
+                .filter(|id| dependency.version_req.matches(&id.version))
+                .sorted_unstable_by(|a, b| b.version.cmp(&a.version))
+                .map(|id| self.get_package(id).unwrap().manifest.summary.clone())
+                .collect())
+        }
+
+        async fn download(&mut self, package_id: PackageId) -> Result<Package> {
+            self.get_package(package_id)
+        }
+    }
+
+    macro_rules! registry {
+        [$($x:tt),* $(,)?] => {{
+            #[allow(unused_imports)]
+            use $crate::core::registry::mock;
+            #[allow(unused_mut)]
+            let mut registry = mock::MockRegistry::new();
+            $({
+                let (package_id, dependencies) = mock::registry_entry!($x);
+                registry.put(package_id, dependencies);
+            })*
+            registry
+        }};
+    }
+
+    pub(crate) use registry;
+
+    macro_rules! registry_entry {
+        (($p:literal, [ $($d:tt),* $(,)? ] $(,)?)) => {{
+            #[allow(unused_imports)]
+            use $crate::core::registry::mock;
+            let package_id = $crate::core::PackageId::from_display_str($p).unwrap();
+            let dependencies = mock::deps![$($d),*].iter().cloned().collect();
+            (package_id, dependencies)
+        }};
+    }
+
+    pub(crate) use registry_entry;
+
+    macro_rules! deps {
+        [$($x:tt),* $(,)?] => (
+            &[
+                $($crate::core::registry::mock::dep!($x)),*
+            ]
+        );
+    }
+
+    pub(crate) use deps;
+
+    macro_rules! dep {
+        (($n:literal, $v:literal, $s:literal)) => {
+            $crate::core::ManifestDependency {
+                name: ($n).into(),
+                version_req: ::semver::VersionReq::parse($v).unwrap(),
+                source_id: $crate::core::SourceId::from_display_str($s).unwrap(),
+            }
+        };
+    }
+
+    pub(crate) use dep;
+
+    macro_rules! pkgs {
+        [$($x:expr),* $(,)?] => (
+            &[
+                $($crate::core::PackageId::from_display_str($x).unwrap()),*
+            ]
+        );
+    }
+
+    pub(crate) use pkgs;
+}

murek/src/core/resolver.rs

@@ -9,6 +9,7 @@ use crate::core::PackageId;
 /// Represents a fully-resolved package dependency graph.
 ///
 /// Each node in the graph is a package and edges represent dependencies between packages.
+#[derive(Debug)]
 pub struct Resolve {
     /// Directional graph representing package dependencies.
     ///

murek/src/core/source/id.rs

@@ -10,7 +10,6 @@ use url::Url;
 use crate::core::source::Source;
 use crate::core::Config;
 use crate::internal::static_hash_cache::StaticHashCache;
-use crate::sources::PathSource;
 
 /// Unique identifier for a source of packages.
 ///
@@ -153,8 +152,18 @@ impl SourceId {
         }
     }
 
+    #[cfg(test)]
+    pub(crate) fn from_display_str(string: &str) -> Result<Self> {
+        if string.starts_with('/') {
+            Self::for_path(&PathBuf::try_from(string)?)
+        } else {
+            Self::from_pretty_url(string)
+        }
+    }
+
     /// Creates an implementation of `Source` corresponding to this ID.
     pub fn load<'c>(self, config: &'c Config) -> Result<Box<dyn Source + 'c>> {
+        use crate::sources::*;
         match self.kind {
             SourceKind::Path => Ok(Box::new(PathSource::new(self, config))),
             SourceKind::Git(_) => todo!("Git sources are not implemented yet"),