Add in unit test of getting features from cargo metadata

Author: Nemo157

src/db/add_package.rs

@@ -434,7 +434,8 @@ where
 mod test {
     use super::*;
     use crate::test::*;
-    use crate::utils::MetadataPackage;
+    use crate::utils::{CargoMetadata, MetadataPackage};
+    use test_case::test_case;
 
     #[test]
     fn new_keywords() {
@@ -691,4 +692,48 @@ mod test {
             Ok(())
         })
     }
+
+    #[test_case("", [])]
+    #[test_case(
+        r#"
+            [features]
+            foo = []
+        "#,
+        [Feature::new("foo".into(), vec![])]
+    )]
+    #[test_case(
+        r#"
+            [dependencies]
+            base64 = { optional = true, version = "=0.13.1" }
+        "#,
+        [Feature::new("base64".into(), vec!["dep:base64".into()])]
+    )]
+    #[test_case(
+        r#"
+            [dependencies]
+            base64 = { optional = true, version = "=0.13.1" }
+            [features]
+            not-base64 = ["dep:base64"]
+        "#,
+        [Feature::new("not-base64".into(), vec!["dep:base64".into()])]
+    )]
+    fn test_get_features(extra: &str, expected: impl AsRef<[Feature]>) -> Result<()> {
+        let dir = tempfile::tempdir()?;
+
+        std::fs::create_dir(dir.path().join("src"))?;
+        std::fs::write(dir.path().join("src/lib.rs"), "")?;
+
+        let base = r#"
+            [package]
+            name = "test"
+            version = "0.0.0"
+        "#;
+
+        std::fs::write(dir.path().join("Cargo.toml"), [base, extra].concat())?;
+        let metadata = CargoMetadata::load_from_host_path(dir.path())?;
+        let features = super::get_features(metadata.root());
+        assert_eq!(features, expected.as_ref());
+
+        Ok(())
+    }
 }

src/docbuilder/rustwide_builder.rs

@@ -311,8 +311,8 @@ impl RustwideBuilder {
 
     pub fn build_local_package(&mut self, path: &Path) -> Result<bool> {
         self.update_toolchain()?;
-        let metadata =
-            CargoMetadata::load(&self.workspace, &self.toolchain, path).map_err(|err| {
+        let metadata = CargoMetadata::load_from_rustwide(&self.workspace, &self.toolchain, path)
+            .map_err(|err| {
                 err.context(format!("failed to load local package {}", path.display()))
             })?;
         let package = metadata.root();
@@ -646,8 +646,11 @@ impl RustwideBuilder {
         metadata: &Metadata,
         create_essential_files: bool,
     ) -> Result<FullBuildResult> {
-        let cargo_metadata =
-            CargoMetadata::load(&self.workspace, &self.toolchain, &build.host_source_dir())?;
+        let cargo_metadata = CargoMetadata::load_from_rustwide(
+            &self.workspace,
+            &self.toolchain,
+            &build.host_source_dir(),
+        )?;
 
         let mut rustdoc_flags = vec![if create_essential_files {
             "--emit=unversioned-shared-resources,toolchain-shared-resources"

src/utils/cargo_metadata.rs

@@ -1,5 +1,5 @@
 use crate::error::Result;
-use anyhow::bail;
+use anyhow::{bail, Context};
 use rustwide::{cmd::Command, Toolchain, Workspace};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -10,7 +10,7 @@ pub(crate) struct CargoMetadata {
 }
 
 impl CargoMetadata {
-    pub(crate) fn load(
+    pub(crate) fn load_from_rustwide(
         workspace: &Workspace,
         toolchain: &Toolchain,
         source_dir: &Path,
@@ -20,21 +20,34 @@ impl CargoMetadata {
             .cd(source_dir)
             .log_output(false)
             .run_capture()?;
-
-        let mut iter = res.stdout_lines().iter();
-        let metadata = if let (Some(serialized), None) = (iter.next(), iter.next()) {
-            serde_json::from_str::<DeserializedMetadata>(serialized)?
-        } else {
-            bail!("invalid output returned by `cargo metadata`");
+        let [metadata] = res.stdout_lines() else {
+            bail!("invalid output returned by `cargo metadata`")
         };
+        Self::load_from_metadata(metadata)
+    }
+
+    #[cfg(test)]
+    pub(crate) fn load_from_host_path(source_dir: &Path) -> Result<Self> {
+        let res = std::process::Command::new("cargo")
+            .args(["metadata", "--format-version", "1", "--offline"])
+            .current_dir(source_dir)
+            .output()?;
+        let status = res.status;
+        if !status.success() {
+            bail!("error returned by `cargo metadata`: {status}")
+        }
+        Self::load_from_metadata(std::str::from_utf8(&res.stdout)?)
+    }
 
+    pub(crate) fn load_from_metadata(metadata: &str) -> Result<Self> {
+        let metadata = serde_json::from_str::<DeserializedMetadata>(metadata)?;
         let root = metadata.resolve.root;
         Ok(CargoMetadata {
             root: metadata
                 .packages
                 .into_iter()
                 .find(|pkg| pkg.id == root)
-                .unwrap(),
+                .context("metadata.packages missing root package")?,
         })
     }