Merge branch 'main' into push-nuwzykznqkxz

Author: Hofer-Julian

.github/workflows/ci.yml

@@ -278,6 +278,7 @@ jobs:
       - name: Test pixi
         run: pixi run test-slow --retries 2
         env:
+          CARGO_PROFILE_DEV_DEBUG: 0 # Disable debuginfo only on windows because it takes a lot of space
           CARGO_TARGET_DIR: ${{ env.DEV_DRIVE }}/target
           PIXI_TEST_R2_ACCESS_KEY_ID: ${{ secrets.PIXI_TEST_R2_ACCESS_KEY_ID }}
           PIXI_TEST_R2_SECRET_ACCESS_KEY: ${{ secrets.PIXI_TEST_R2_SECRET_ACCESS_KEY }}

Cargo.lock

@@ -55,7 +55,7 @@ crossbeam-channel = "0.5.14"
 csv = "1.3.1"
 ctrlc = "3.4.5"
 dashmap = "6.1.0"
-deno_task_shell = "0.26.2"
+deno_task_shell = "0.28.0"
 derive_more = "2.0.1"
 dialoguer = "0.12.0"
 digest = "0.10"

Cargo.toml

@@ -195,13 +195,13 @@ impl GeneratedRecipe {
             documentation: derive_value!(documentation).map(Value::Concrete),
             repository: derive_value!(repository).map(Value::Concrete),
             license_file: match model.license_file {
-                Some(v) => Some(Value::Concrete(v.display().to_string())),
+                Some(v) => Some(vec![Value::Concrete(v.display().to_string())]),
                 None => provider
                     .license_files()
                     .map_err(|e| {
                         GenerateRecipeError::MetadataProviderError(String::from("license-files"), e)
                     })?
-                    .map(|files| Value::Concrete(files.join(", "))),
+                    .map(|files| files.into_iter().map(Value::Concrete).collect()),
             },
             summary: provider
                 .summary()

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

@@ -1,5 +1,5 @@
 use fs_err as fs;
-use pixi_build_backend_passthrough::{ObservableBackend, PassthroughBackend};
+use pixi_build_backend_passthrough::{BackendEvent, ObservableBackend, PassthroughBackend};
 use pixi_build_frontend::BackendOverride;
 use pixi_consts::consts;
 use rattler_conda_types::{Platform, package::RunExportsJson};
@@ -812,3 +812,228 @@ test-source-pkg = {{ path = "./source-package" }}
         "Second invocation should report lock-file is already up to date"
     );
 }
+
+/// Test that verifies changing `[package.build.config]` invalidates the metadata cache
+/// and causes the build backend to be re-queried.
+///
+/// This tests the fix for issue #5309 where changes to build configuration
+/// (like `noarch = true` to `noarch = false`) did not invalidate the metadata cache.
+///
+/// The test uses ObservableBackend to verify that the backend is called again
+/// when the configuration changes.
+#[tokio::test]
+async fn test_build_config_change_invalidates_cache() {
+    setup_tracing();
+
+    // Create an observable passthrough backend to track calls
+    let passthrough = PassthroughBackend::instantiator();
+    let (instantiator, mut observer) = ObservableBackend::instantiator(passthrough);
+    let backend_override = BackendOverride::from_memory(instantiator);
+
+    let pixi = PixiControl::new()
+        .unwrap()
+        .with_backend_override(backend_override);
+
+    // Create a source package directory
+    let source_dir = pixi.workspace_path().join("my-package");
+    fs::create_dir_all(&source_dir).unwrap();
+
+    // Create the source package manifest WITHOUT any [package.build.config] section
+    let source_pixi_toml_no_config = r#"
+[package]
+name = "my-package"
+version = "1.0.0"
+
+[package.build]
+backend = { name = "in-memory", version = "0.1.0" }
+"#;
+    fs::write(source_dir.join("pixi.toml"), source_pixi_toml_no_config).unwrap();
+
+    // Create the workspace manifest
+    let manifest_content = format!(
+        r#"
+[workspace]
+channels = []
+platforms = ["{}"]
+preview = ["pixi-build"]
+
+[dependencies]
+my-package = {{ path = "./my-package" }}
+"#,
+        Platform::current()
+    );
+
+    fs::write(pixi.manifest_path(), manifest_content).unwrap();
+
+    // Helper to filter CondaOutputsCalled events
+    fn count_conda_outputs_events(events: &[BackendEvent]) -> usize {
+        events
+            .iter()
+            .filter(|e| matches!(e, BackendEvent::CondaOutputsCalled))
+            .count()
+    }
+
+    // First invocation: Generate the lock-file (no config section)
+    let workspace = pixi.workspace().unwrap();
+    let (lock_file_data, was_updated) = workspace
+        .update_lock_file(pixi_core::UpdateLockFileOptions::default())
+        .await
+        .expect("First lock file generation should succeed");
+
+    assert!(was_updated, "First invocation should create the lock-file");
+
+    // Verify the package is in the lock-file
+    let lock_file = lock_file_data.into_lock_file();
+    assert!(
+        lock_file.contains_conda_package(
+            consts::DEFAULT_ENVIRONMENT_NAME,
+            Platform::current(),
+            "my-package",
+        ),
+        "Lock file should contain my-package"
+    );
+
+    // Check that conda_outputs was called once
+    let events_after_first = observer.events();
+    assert_eq!(
+        count_conda_outputs_events(&events_after_first),
+        1,
+        "conda_outputs should be called once for first lock file generation"
+    );
+
+    // Now add an EMPTY [package.build.config] section
+    // This should NOT invalidate the cache since empty config hashes the same as no config
+    let source_pixi_toml_empty_config = r#"
+[package]
+name = "my-package"
+version = "1.0.0"
+
+[package.build]
+backend = { name = "in-memory", version = "0.1.0" }
+
+[package.build.config]
+"#;
+    fs::write(source_dir.join("pixi.toml"), source_pixi_toml_empty_config).unwrap();
+
+    // Second invocation with empty config section: Should NOT call backend again (cache hit)
+    let workspace = pixi.workspace().unwrap();
+    let (_lock_file_data, was_updated_empty_config) = workspace
+        .update_lock_file(pixi_core::UpdateLockFileOptions::default())
+        .await
+        .expect("Second lock file check should succeed");
+
+    assert!(
+        !was_updated_empty_config,
+        "Adding empty [package.build.config] should NOT update lock-file"
+    );
+
+    // Verify no additional conda_outputs calls
+    let events_after_empty_config = observer.events();
+    assert_eq!(
+        count_conda_outputs_events(&events_after_empty_config),
+        0,
+        "conda_outputs should NOT be called when adding empty [package.build.config] (cache hit)"
+    );
+
+    // Now add actual configuration values
+    let source_pixi_toml_with_config = r#"
+[package]
+name = "my-package"
+version = "1.0.0"
+
+[package.build]
+backend = { name = "in-memory", version = "0.1.0" }
+
+[package.build.config]
+noarch = true
+"#;
+    fs::write(source_dir.join("pixi.toml"), source_pixi_toml_with_config).unwrap();
+
+    // Third invocation: Should detect config change and call backend again
+    let workspace = pixi.workspace().unwrap();
+    let (_lock_file_data, _was_updated_after_config_added) = workspace
+        .update_lock_file(pixi_core::UpdateLockFileOptions::default())
+        .await
+        .expect("Third lock file generation should succeed");
+
+    // Verify conda_outputs was called again due to config change
+    let events_after_config_added = observer.events();
+    assert_eq!(
+        count_conda_outputs_events(&events_after_config_added),
+        1,
+        "conda_outputs should be called when [package.build.config] gets actual values (cache invalidated)"
+    );
+
+    // Fourth invocation without changes: Should NOT call backend again (cache hit)
+    let workspace = pixi.workspace().unwrap();
+    let (_lock_file_data, was_updated_no_change) = workspace
+        .update_lock_file(pixi_core::UpdateLockFileOptions::default())
+        .await
+        .expect("Fourth lock file check should succeed");
+
+    assert!(
+        !was_updated_no_change,
+        "Fourth invocation without changes should NOT update lock-file"
+    );
+
+    // Verify no additional conda_outputs calls
+    let events_after_no_change = observer.events();
+    assert_eq!(
+        count_conda_outputs_events(&events_after_no_change),
+        0,
+        "conda_outputs should NOT be called again when config hasn't changed (cache hit)"
+    );
+
+    // Now change the build configuration (noarch = true -> noarch = false)
+    let source_pixi_toml_changed_config = r#"
+[package]
+name = "my-package"
+version = "1.0.0"
+
+[package.build]
+backend = { name = "in-memory", version = "0.1.0" }
+
+[package.build.config]
+noarch = false
+"#;
+    fs::write(
+        source_dir.join("pixi.toml"),
+        source_pixi_toml_changed_config,
+    )
+    .unwrap();
+
+    // Fifth invocation: Should detect config change and call backend again
+    let workspace = pixi.workspace().unwrap();
+    let (_lock_file_data, _was_updated_after_config_change) = workspace
+        .update_lock_file(pixi_core::UpdateLockFileOptions::default())
+        .await
+        .expect("Fifth lock file generation should succeed");
+
+    // Verify conda_outputs was called again due to config change
+    let events_after_config_change = observer.events();
+    assert_eq!(
+        count_conda_outputs_events(&events_after_config_change),
+        1,
+        "conda_outputs should be called again when [package.build.config] values change (cache invalidated)"
+    );
+
+    // Sixth invocation: Should NOT call backend again (cache is now fresh)
+    let workspace = pixi.workspace().unwrap();
+    let (_, was_updated_sixth) = workspace
+        .update_lock_file(pixi_core::UpdateLockFileOptions::default())
+        .await
+        .expect("Sixth lock file check should succeed");
+
+    assert!(
+        !was_updated_sixth,
+        "Sixth invocation should NOT update lock-file (cache is now fresh)"
+    );
+
+    // Verify no additional conda_outputs calls
+    let events_after_sixth = observer.events();
+    assert_eq!(
+        count_conda_outputs_events(&events_after_sixth),
+        0,
+        "conda_outputs should NOT be called again after cache is updated"
+    );
+}

crates/pixi/tests/integration_rust/build_tests.rs

@@ -621,6 +621,17 @@ pub struct LockBuilder {
     pub args: lock::Args,
 }
 
+impl LockBuilder {
+    pub fn with_dry_run(mut self, dry_run: bool) -> Self {
+        self.args.dry_run = dry_run;
+        self
+    }
+    pub fn with_check(mut self, check: bool) -> Self {
+        self.args.check = check;
+        self
+    }
+}
+
 impl IntoFuture for LockBuilder {
     type Output = miette::Result<()>;
     type IntoFuture = Pin<Box<dyn Future<Output = Self::Output> + 'static>>;

crates/pixi/tests/integration_rust/common/builders.rs

@@ -718,6 +718,7 @@ impl PixiControl {
                 no_install_config: NoInstallConfig { no_install: false },
                 check: false,
                 json: false,
+                dry_run: false,
             },
         }
     }