fix: return all used variants (#438)

Make sure that all used variants are returned by conda_outputs* fix: return all used variants

Author: Hofer-Julian

Cargo.lock

@@ -253,23 +253,11 @@ where
         // combination of defaults provided by the generator (lowest priority),
         // variants loaded from external files, and finally the user supplied
         // variants (highest priority).
-        let mut variant_config = if let Some(variant_files) = params
-            .variant_files
-            .as_ref()
-            .filter(|files| !files.is_empty())
-        {
-            let mut variant_config =
-                VariantConfig::from_files(variant_files, &selector_config_for_variants)?;
-            variants.append(&mut variant_config.variants);
-            variant_config.variants = variants;
-            variant_config
-        } else {
-            VariantConfig {
-                variants,
-                pin_run_as_build: None,
-                zip_keys: None,
-            }
-        };
+        let variant_files = params.variant_files.unwrap_or_default();
+        let mut variant_config =
+            VariantConfig::from_files(&variant_files, &selector_config_for_variants)?;
+        variants.append(&mut variant_config.variants);
+        variant_config.variants = variants;
 
         let mut param_variants =
             convert_input_variant_configuration(params.variant_configuration.clone())

crates/pixi-build-backend/src/intermediate_backend.rs

@@ -41,18 +41,15 @@ pub(crate) fn remove_empty_values(value: &mut Value) {
     }
 }
 
-/// Calls the `conda/outputs` procedure of the `IntermediateBackend` for the
+/// Prepares and calls the `conda/outputs` procedure of the `IntermediateBackend` for the
 /// given recipe general and with the given project model.
-///
-/// Returns a pretty-printed JSON string of the outputs that can be used for
-/// snapshots
-pub fn intermediate_conda_outputs_snapshot<T>(
+pub async fn intermediate_conda_outputs<T>(
     project_model: Option<pixi_build_types::ProjectModelV1>,
     source_dir: Option<PathBuf>,
     host_platform: Platform,
     variant_configuration: Option<BTreeMap<String, Vec<String>>>,
     variant_files: Option<Vec<PathBuf>>,
-) -> String
+) -> CondaOutputsResult
 where
     T: GenerateRecipe + Default + Clone + Send + Sync + 'static,
     <T as GenerateRecipe>::Config: Send + Sync + 'static,
@@ -61,41 +58,35 @@ where
         Some(dir) => dir.join("pixi.toml"),
         None => PathBuf::from("pixi.toml"),
     };
-    let runtime = tokio::runtime::Builder::new_current_thread()
-        .build()
-        .unwrap();
-    runtime.block_on(async move {
-        let (protocol, _result) = IntermediateBackendInstantiator::<T>::new(
-            LoggingOutputHandler::default(),
-            Arc::new(T::default()),
-        )
-        .initialize(InitializeParams {
-            workspace_root: None,
-            source_dir,
-            manifest_path,
-            project_model: project_model.map(Into::into),
-            configuration: None,
-            target_configuration: None,
-            cache_directory: None,
-        })
-        .await
-        .unwrap();
-
-        let current_dir = std::env::current_dir().unwrap();
-        let result = protocol
-            .conda_outputs(CondaOutputsParams {
-                channels: vec![],
-                host_platform,
-                build_platform: host_platform,
-                variant_configuration,
-                variant_files,
-                work_directory: current_dir,
-            })
-            .await
-            .unwrap();
 
-        conda_outputs_snapshot(result)
+    let (protocol, _result) = IntermediateBackendInstantiator::<T>::new(
+        LoggingOutputHandler::default(),
+        Arc::new(T::default()),
+    )
+    .initialize(InitializeParams {
+        workspace_root: None,
+        source_dir,
+        manifest_path,
+        project_model: project_model.map(Into::into),
+        configuration: None,
+        target_configuration: None,
+        cache_directory: None,
     })
+    .await
+    .unwrap();
+
+    let current_dir = std::env::current_dir().unwrap();
+    protocol
+        .conda_outputs(CondaOutputsParams {
+            channels: vec![],
+            host_platform,
+            build_platform: host_platform,
+            variant_configuration,
+            variant_files,
+            work_directory: current_dir,
+        })
+        .await
+        .unwrap()
 }
 
 /// A function to convert a `CondaOutputsResult` into a pretty-printed JSON

crates/pixi-build-backend/src/utils/test.rs

@@ -26,3 +26,5 @@ tokio = { workspace = true, features = ["macros"] }
 insta = { workspace = true, features = ["yaml", "redactions", "filters"] }
 rstest = { workspace = true }
 strum = { workspace = true }
+tempfile = { workspace = true }
+fs-err = { workspace = true }

crates/pixi-build-cmake/Cargo.toml

@@ -156,13 +156,16 @@ mod tests {
     use std::path::PathBuf;
 
     use indexmap::IndexMap;
-    use pixi_build_backend::protocol::ProtocolInstantiator;
+    use pixi_build_backend::{
+        protocol::ProtocolInstantiator, utils::test::intermediate_conda_outputs,
+    };
     use pixi_build_types::{
         ProjectModelV1,
         procedures::{conda_outputs::CondaOutputsParams, initialize::InitializeParams},
     };
     use rattler_build::console_utils::LoggingOutputHandler;
     use recipe_stage0::recipe::{Item, Value};
+    use tokio::fs;
 
     use super::*;
 
@@ -396,6 +399,91 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn test_intermediate_conda_outputs_snapshot() {
+        let project_model = project_fixture!({
+            "name": "foobar",
+            "version": "0.1.0",
+            "targets": {
+                "defaultTarget": {
+                   "buildDependencies": {
+                        "boltons": {
+                            "binary": {
+                                "version": "*"
+                            }
+                        }
+                    }
+                },
+            }
+        });
+
+        let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
+
+        let variant_configuration =
+            BTreeMap::from([("boltons".to_string(), Vec::from(["==1.0.0".to_string()]))]);
+
+        let result = intermediate_conda_outputs::<CMakeGenerator>(
+            Some(project_model),
+            Some(temp_dir.path().to_path_buf()),
+            Platform::Linux64,
+            Some(variant_configuration),
+            None,
+        )
+        .await;
+
+        assert_eq!(result.outputs[0].metadata.variant["boltons"], "==1.0.0");
+        assert_eq!(
+            result.outputs[0].metadata.variant["target_platform"],
+            "linux-64"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_variant_files_are_applied() {
+        let project_model = project_fixture!({
+            "name": "foobar",
+            "version": "0.1.0",
+            "targets": {
+                "defaultTarget": {
+                   "buildDependencies": {
+                        "boltons": {
+                            "binary": {
+                                "version": "*"
+                            }
+                        }
+                    }
+                },
+            }
+        });
+
+        let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
+
+        let variant_file = temp_dir.path().join("variants.yaml");
+        fs::write(
+            &variant_file,
+            r#"boltons:
+  - "==2.0.0"
+"#,
+        )
+        .await
+        .expect("Failed to write variants file");
+
+        let result = intermediate_conda_outputs::<CMakeGenerator>(
+            Some(project_model),
+            Some(temp_dir.path().to_path_buf()),
+            Platform::Linux64,
+            None,
+            Some(vec![variant_file]),
+        )
+        .await;
+
+        assert_eq!(result.outputs[0].metadata.variant["boltons"], "==2.0.0");
+        assert_eq!(
+            result.outputs[0].metadata.variant["target_platform"],
+            "linux-64"
+        );
+    }
+
     #[test]
     fn test_multiple_compilers_configuration() {
         let project_model = project_fixture!({

crates/pixi-build-cmake/src/main.rs

@@ -272,8 +272,12 @@ pub async fn main() {
 
 #[cfg(test)]
 mod tests {
+    use std::collections::BTreeMap;
+
     use indexmap::IndexMap;
+    use pixi_build_backend::utils::test::intermediate_conda_outputs;
     use recipe_stage0::recipe::{Item, Value};
+    use tokio::fs;
 
     use super::*;
 
@@ -313,6 +317,129 @@ mod tests {
         };
     }
 
+    #[tokio::test]
+    async fn test_intermediate_conda_outputs_snapshot() {
+        let project_model = project_fixture!({
+            "name": "foobar",
+            "version": "0.1.0",
+            "targets": {
+                "defaultTarget": {
+                   "buildDependencies": {
+                        "boltons": {
+                            "binary": {
+                                "version": "*"
+                            }
+                        }
+                    }
+                },
+            }
+        });
+
+        let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
+
+        fs::write(
+            temp_dir.path().join("pyproject.toml"),
+            r#"[project]
+name = "foobar"
+version = "0.1.0"
+"#,
+        )
+        .await
+        .expect("Failed to write pyproject.toml");
+        fs::write(
+            temp_dir.path().join("pixi.toml"),
+            r#"[project]
+name = "foobar"
+version = "0.1.0"
+"#,
+        )
+        .await
+        .expect("Failed to write pixi.toml");
+
+        let variant_configuration =
+            BTreeMap::from([("boltons".to_string(), Vec::from(["==1.0.0".to_string()]))]);
+
+        let result = intermediate_conda_outputs::<PythonGenerator>(
+            Some(project_model),
+            Some(temp_dir.path().to_path_buf()),
+            Platform::Linux64,
+            Some(variant_configuration),
+            None,
+        )
+        .await;
+
+        assert_eq!(result.outputs[0].metadata.variant["boltons"], "==1.0.0");
+        assert_eq!(
+            result.outputs[0].metadata.variant["target_platform"],
+            "noarch"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_variant_files_are_applied() {
+        let project_model = project_fixture!({
+            "name": "foobar",
+            "version": "0.1.0",
+            "targets": {
+                "defaultTarget": {
+                   "buildDependencies": {
+                        "boltons": {
+                            "binary": {
+                                "version": "*"
+                            }
+                        }
+                    }
+                },
+            }
+        });
+
+        let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
+
+        fs::write(
+            temp_dir.path().join("pyproject.toml"),
+            r#"[project]
+name = "foobar"
+version = "0.1.0"
+"#,
+        )
+        .await
+        .expect("Failed to write pyproject.toml");
+        fs::write(
+            temp_dir.path().join("pixi.toml"),
+            r#"[project]
+name = "foobar"
+version = "0.1.0"
+"#,
+        )
+        .await
+        .expect("Failed to write pixi.toml");
+
+        let variant_file = temp_dir.path().join("variants.yaml");
+        fs::write(
+            &variant_file,
+            r#"boltons:
+  - "==2.0.0"
+"#,
+        )
+        .await
+        .expect("Failed to write variants file");
+
+        let result = intermediate_conda_outputs::<PythonGenerator>(
+            Some(project_model),
+            Some(temp_dir.path().to_path_buf()),
+            Platform::Linux64,
+            None,
+            Some(vec![variant_file]),
+        )
+        .await;
+
+        assert_eq!(result.outputs[0].metadata.variant["boltons"], "==2.0.0");
+        assert_eq!(
+            result.outputs[0].metadata.variant["target_platform"],
+            "noarch"
+        );
+    }
+
     #[test]
     fn test_pip_is_in_host_requirements() {
         let project_model = project_fixture!({