Respect env defined in cargo.toml

Author: arxanas

cargo-nextest/src/dispatch.rs

@@ -12,11 +12,11 @@ use clap::{ArgEnum, Args, Parser, Subcommand};
 use guppy::graph::PackageGraph;
 use itertools::Itertools;
 use nextest_filtering::FilteringExpr;
-use nextest_metadata::{BinaryListSummary, BuildPlatform};
+use nextest_metadata::{BinaryListSummary, BuildPlatform, EnvironmentMap};
 use nextest_runner::{
     cargo_config::{CargoConfigs, TargetTriple},
     config::{NextestConfig, NextestProfile, TestThreads, ToolConfigFile},
-    errors::WriteTestListError,
+    errors::{CargoConfigError, WriteTestListError},
     list::{BinaryList, OutputFormat, RustTestArtifact, SerializableFormat, TestList},
     partition::PartitionerBuilder,
     reporter::{FinalStatusLevel, StatusLevel, TestOutputDisplay, TestReporterBuilder},
@@ -440,6 +440,7 @@ impl TestBuildFilter {
         binary_list: Arc<BinaryList>,
         test_filter_builder: TestFilterBuilder,
         runner: &TargetRunner,
+        env: EnvironmentMap,
         reuse_build: &ReuseBuildInfo,
     ) -> Result<TestList<'g>> {
         let path_mapper = make_path_mapper(
@@ -461,6 +462,7 @@ impl TestBuildFilter {
             rust_build_meta,
             &test_filter_builder,
             runner,
+            env,
             // TODO: do we need to allow customizing this?
             num_cpus::get(),
         )
@@ -765,6 +767,7 @@ struct BaseApp {
 
     cargo_configs: CargoConfigs,
     target_runner: OnceCell<TargetRunner>,
+    env: OnceCell<EnvironmentMap>,
 }
 
 impl BaseApp {
@@ -848,9 +851,14 @@ impl BaseApp {
             cargo_configs,
 
             target_runner: OnceCell::new(),
+            env: OnceCell::new(),
         })
     }
 
+    fn load_env(&self) -> Result<&EnvironmentMap, CargoConfigError> {
+        self.env.get_or_try_init(|| self.cargo_configs.env())
+    }
+
     fn load_runner(&self, triple: Option<&TargetTriple>) -> &TargetRunner {
         self.target_runner
             .get_or_init(|| runner_for_target(&self.cargo_configs, triple))
@@ -971,12 +979,14 @@ impl App {
         binary_list: Arc<BinaryList>,
         test_filter_builder: TestFilterBuilder,
         target_runner: &TargetRunner,
+        env: EnvironmentMap,
     ) -> Result<TestList> {
         self.build_filter.compute_test_list(
             self.base.graph(),
             binary_list,
             test_filter_builder,
             target_runner,
+            env,
             &self.base.reuse_build,
         )
     }
@@ -1031,8 +1041,13 @@ impl App {
                 let target_runner = self
                     .base
                     .load_runner(binary_list.rust_build_meta.target_triple.as_ref());
-                let test_list =
-                    self.build_test_list(binary_list, test_filter_builder, target_runner)?;
+                let env = self.base.load_env()?;
+                let test_list = self.build_test_list(
+                    binary_list,
+                    test_filter_builder,
+                    target_runner,
+                    env.to_owned(),
+                )?;
 
                 let mut writer = output_writer.stdout_writer();
                 test_list.write(
@@ -1067,8 +1082,14 @@ impl App {
         let target_runner = self
             .base
             .load_runner(binary_list.rust_build_meta.target_triple.as_ref());
+        let env = self.base.load_env()?;
 
-        let test_list = self.build_test_list(binary_list, test_filter_builder, target_runner)?;
+        let test_list = self.build_test_list(
+            binary_list,
+            test_filter_builder,
+            target_runner,
+            env.to_owned(),
+        )?;
 
         let output = output_writer.reporter_output();
 

fixtures/nextest-tests/.cargo/config

@@ -12,3 +12,10 @@ replace-with = "vendored-sources"
 
 [source.vendored-sources]
 directory = "vendor"
+
+[env]
+__NEXTEST_ENV_VAR_FOR_TESTING_NOT_IN_PARENT_ENV = "if-this-value-is-present-then-test-passed"
+__NEXTEST_ENV_VAR_FOR_TESTING_IN_PARENT_ENV_NO_OVERRIDE = "if-this-value-is-present-then-test-failed"
+__NEXTEST_ENV_VAR_FOR_TESTING_IN_PARENT_ENV_OVERRIDDEN = { value = "if-this-value-is-present-then-test-passed", force = true }
+__NEXTEST_ENV_VAR_FOR_TESTING_IN_PARENT_ENV_RELATIVE_NO_OVERRIDE = { value = "if-this-value-is-present-then-test-failed", relative = true }
+__NEXTEST_ENV_VAR_FOR_TESTING_IN_PARENT_ENV_RELATIVE_OVERRIDDEN = { value = "if-this-value-is-present-then-test-passed", force = true, relative = true }

fixtures/nextest-tests/tests/basic.rs

@@ -156,6 +156,38 @@ fn test_cargo_env_vars() {
     // CARGO_PRIMARY_PACKAGE is missing at runtime
     // CARGO_TARGET_TMPDIR is missing at runtime
     // Dynamic library paths are tested by actually executing the tests -- they depend on the dynamic library.
+
+    assert_eq!(
+        std::env::var("__NEXTEST_ENV_VAR_FOR_TESTING_NOT_IN_PARENT_ENV",).as_deref(),
+        Ok("if-this-value-is-present-then-test-passed")
+    );
+    assert_eq!(
+        std::env::var("__NEXTEST_ENV_VAR_FOR_TESTING_IN_PARENT_ENV_NO_OVERRIDE",).as_deref(),
+        Ok("if-this-value-is-present-then-test-passed")
+    );
+    assert_eq!(
+        std::env::var("__NEXTEST_ENV_VAR_FOR_TESTING_IN_PARENT_ENV_OVERRIDDEN",).as_deref(),
+        Ok("if-this-value-is-present-then-test-passed")
+    );
+    assert_eq!(
+        std::env::var("__NEXTEST_ENV_VAR_FOR_TESTING_IN_PARENT_ENV_RELATIVE_NO_OVERRIDE",)
+            .as_deref(),
+        Ok("if-this-value-is-present-then-test-passed")
+    );
+    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+    let overridden_path =
+        std::env::var("__NEXTEST_ENV_VAR_FOR_TESTING_IN_PARENT_ENV_RELATIVE_OVERRIDDEN").unwrap();
+    let overridden_path = match overridden_path.strip_prefix(&manifest_dir) {
+        Some(overridden_path) => overridden_path,
+        None => panic!(
+            "Path {overridden_path:?} should start with workspace root {:?}",
+            manifest_dir
+        ),
+    };
+    assert_eq!(
+        overridden_path,
+        "/.cargo/if-this-value-is-present-then-test-passed"
+    );
 }
 
 #[test]

nextest-metadata/src/test_list.rs

@@ -12,6 +12,36 @@ use std::{
     process::Command,
 };
 
+/// An environment variable set in `config.toml`. See https://doc.rust-lang.org/cargo/reference/config.html#env
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+pub struct CargoEnvironmentVariable {
+    /// The source `config.toml` file. See
+    /// https://doc.rust-lang.org/cargo/reference/config.html#hierarchical-structure for the lookup
+    /// order.
+    pub source: Option<Utf8PathBuf>,
+
+    /// The name of the environment variable to set.
+    pub name: String,
+
+    /// The value of the environment variable to set.
+    pub value: String,
+
+    /// If the environment variable is already set in the environment, it is not reassigned unless
+    /// `force` is set to `true`.
+    pub force: bool,
+
+    /// Interpret the environment variable as a path relative to the directory containing the source
+    /// `config.toml` file.
+    pub relative: bool,
+}
+
+/// A list of environment variables to set when running tests.
+///
+/// This is a `Vec` instead of a map because, on Windows, environment variables are case-insensitive
+/// but case-preserving. We produce the environment as-is and let the caller handle the case of
+/// duplicates.
+pub type EnvironmentMap = Vec<CargoEnvironmentVariable>;
+
 /// Command builder for `cargo nextest list`.
 #[derive(Clone, Debug, Default)]
 pub struct ListCommand {

nextest-runner/src/cargo_config.rs

@@ -8,6 +8,7 @@
 
 use crate::errors::{CargoConfigError, InvalidCargoCliConfigReason, TargetTripleError};
 use camino::{Utf8Path, Utf8PathBuf};
+use nextest_metadata::{CargoEnvironmentVariable, EnvironmentMap};
 use once_cell::sync::OnceCell;
 use serde::Deserialize;
 use std::{collections::BTreeMap, fmt};
@@ -241,6 +242,51 @@ impl CargoConfigs {
         &self.cwd
     }
 
+    /// The environment variables to set when running Cargo commands.
+    pub fn env(&self) -> Result<EnvironmentMap, CargoConfigError> {
+        let env = self
+            .discovered_configs()?
+            .rev()
+            .filter_map(|config| match config {
+                DiscoveredConfig::CliOption { config, source }
+                | DiscoveredConfig::File { config, source } => Some((config, source)),
+                DiscoveredConfig::Env => None,
+            })
+            .flat_map(|(config, source)| {
+                let source = match source {
+                    CargoConfigSource::CliOption => None,
+                    CargoConfigSource::File(path) => Some(path.clone()),
+                };
+                config
+                    .env
+                    .clone()
+                    .into_iter()
+                    .map(move |(name, value)| (source.clone(), name, value))
+            })
+            .map(|(source, name, value)| match value {
+                CargoConfigEnv::Value(value) => CargoEnvironmentVariable {
+                    source,
+                    name,
+                    value,
+                    force: false,
+                    relative: false,
+                },
+                CargoConfigEnv::Fields {
+                    value,
+                    force,
+                    relative,
+                } => CargoEnvironmentVariable {
+                    source,
+                    name,
+                    value,
+                    force,
+                    relative,
+                },
+            })
+            .collect();
+        Ok(env)
+    }
+
     pub(crate) fn discovered_configs(
         &self,
     ) -> Result<
@@ -493,11 +539,26 @@ fn load_file(
     Ok((CargoConfigSource::File(path), config))
 }
 
+#[derive(Clone, Deserialize, Debug)]
+#[serde(untagged)]
+pub(crate) enum CargoConfigEnv {
+    Value(String),
+    Fields {
+        value: String,
+        #[serde(default)]
+        force: bool,
+        #[serde(default)]
+        relative: bool,
+    },
+}
+
 #[derive(Deserialize, Debug)]
 pub(crate) struct CargoConfig {
     #[serde(default)]
     pub(crate) build: CargoConfigBuild,
     pub(crate) target: Option<BTreeMap<String, CargoConfigRunner>>,
+    #[serde(default)]
+    pub(crate) env: BTreeMap<String, CargoConfigEnv>,
 }
 
 #[derive(Deserialize, Default, Debug)]

nextest-runner/src/list/rust_build_meta.rs

@@ -53,8 +53,8 @@ impl RustBuildMeta<BinaryListState> {
             base_output_directories: BTreeSet::new(),
             non_test_binaries: BTreeMap::new(),
             linked_paths: BTreeMap::new(),
-            state: PhantomData,
             target_triple,
+            state: PhantomData,
         }
     }
 
@@ -69,8 +69,8 @@ impl RustBuildMeta<BinaryListState> {
             base_output_directories: self.base_output_directories.clone(),
             non_test_binaries: self.non_test_binaries.clone(),
             linked_paths: self.linked_paths.clone(),
-            state: PhantomData,
             target_triple: self.target_triple.clone(),
+            state: PhantomData,
         }
     }
 }