temp: pass through env

Author: arxanas

cargo-nextest/src/dispatch.rs

@@ -29,6 +29,7 @@ use nextest_runner::{
 use once_cell::sync::OnceCell;
 use owo_colors::{OwoColorize, Style};
 use std::{
+    collections::BTreeMap,
     fmt::Write as _,
     io::{Cursor, Write},
     sync::Arc,
@@ -563,6 +564,7 @@ impl CargoOptions {
         manifest_path: Option<&Utf8Path>,
         output: OutputContext,
         target_triple: Option<TargetTriple>,
+        env: BTreeMap<String, String>,
     ) -> Result<BinaryList> {
         // Don't use the manifest path from the graph to ensure that if the user cd's into a
         // particular crate and runs cargo nextest, then it behaves identically to cargo test.
@@ -586,7 +588,7 @@ impl CargoOptions {
         }
 
         let test_binaries =
-            BinaryList::from_messages(Cursor::new(output.stdout), graph, target_triple)?;
+            BinaryList::from_messages(Cursor::new(output.stdout), graph, target_triple, env)?;
         Ok(test_binaries)
     }
 }
@@ -910,11 +912,13 @@ impl BaseApp {
             None => {
                 let target_triple =
                     discover_target_triple(&self.cargo_configs, self.cargo_opts.target.as_deref());
+                let env = self.cargo_configs.env()?;
                 Arc::new(self.cargo_opts.compute_binary_list(
                     self.graph(),
                     self.manifest_path.as_deref(),
                     self.output,
                     target_triple,
+                    env,
                 )?)
             }
         };

nextest-metadata/src/test_list.rs

@@ -275,6 +275,9 @@ pub struct RustBuildMetaSummary {
     /// The target platform used while compiling the Rust artifacts
     #[serde(default)]
     pub target_platform: Option<String>,
+
+    /// The environment variables to set when running the test.
+    pub env: BTreeMap<String, String>,
 }
 
 /// A non-test Rust binary. Used to set the correct environment
@@ -358,6 +361,9 @@ pub struct RustTestSuiteSummary {
     /// Test cases within this test suite.
     #[serde(rename = "testcases")]
     pub test_cases: BTreeMap<String, RustTestCaseSummary>,
+
+    /// The environment variables to set when running the test.
+    pub env: BTreeMap<String, String>,
 }
 
 fn listed_status() -> RustTestSuiteStatusSummary {
@@ -485,6 +491,7 @@ mod tests {
         non_test_binaries: BTreeMap::new(),
         linked_paths: BTreeSet::new(),
         target_platform: None,
+        env: BTreeMap::new(),
     }; "no target platform")]
     fn test_deserialize_old_rust_build_meta(input: &str, expected: RustBuildMetaSummary) {
         let build_meta: RustBuildMetaSummary =

nextest-runner/src/cargo_config.rs

@@ -241,6 +241,23 @@ impl CargoConfigs {
         &self.cwd
     }
 
+    /// The environment variables to set when running Cargo commands.
+    pub fn env(&self) -> Result<BTreeMap<String, String>, CargoConfigError> {
+        let env = self
+            .discovered_configs()?
+            .filter_map(|config| match config {
+                DiscoveredConfig::CliOption { config, source: _ }
+                | DiscoveredConfig::File { config, source: _ } => Some(config),
+                DiscoveredConfig::Env => None,
+            })
+            .flat_map(|config| {
+                dbg!(config);
+                config.env.iter().map(|(k, v)| (k.to_owned(), v.to_owned()))
+            })
+            .collect();
+        Ok(env)
+    }
+
     pub(crate) fn discovered_configs(
         &self,
     ) -> Result<
@@ -498,6 +515,8 @@ pub(crate) struct CargoConfig {
     #[serde(default)]
     pub(crate) build: CargoConfigBuild,
     pub(crate) target: Option<BTreeMap<String, CargoConfigRunner>>,
+    #[serde(default)]
+    pub(crate) env: BTreeMap<String, String>,
 }
 
 #[derive(Deserialize, Default, Debug)]

nextest-runner/src/list/binary_list.rs

@@ -15,7 +15,7 @@ use nextest_metadata::{
     RustTestBinaryKind, RustTestBinarySummary,
 };
 use owo_colors::OwoColorize;
-use std::{fmt::Write as _, io, io::Write};
+use std::{collections::BTreeMap, fmt::Write as _, io, io::Write};
 
 /// A Rust test binary built by Cargo.
 #[derive(Clone, Debug)]
@@ -51,8 +51,9 @@ impl BinaryList {
         reader: impl io::BufRead,
         graph: &PackageGraph,
         target_triple: Option<TargetTriple>,
+        env: BTreeMap<String, String>,
     ) -> Result<Self, FromMessagesError> {
-        let mut state = BinaryListBuildState::new(graph, target_triple);
+        let mut state = BinaryListBuildState::new(graph, target_triple, env);
 
         for message in Message::parse_stream(reader) {
             let message = message.map_err(FromMessagesError::ReadMessages)?;
@@ -161,13 +162,17 @@ struct BinaryListBuildState<'g> {
 }
 
 impl<'g> BinaryListBuildState<'g> {
-    fn new(graph: &'g PackageGraph, target_triple: Option<TargetTriple>) -> Self {
+    fn new(
+        graph: &'g PackageGraph,
+        target_triple: Option<TargetTriple>,
+        env: BTreeMap<String, String>,
+    ) -> Self {
         let rust_target_dir = graph.workspace().target_directory().to_path_buf();
 
         Self {
             graph,
             rust_binaries: vec![],
-            rust_build_meta: RustBuildMeta::new(rust_target_dir, target_triple),
+            rust_build_meta: RustBuildMeta::new(rust_target_dir, target_triple, env),
         }
     }
 
@@ -393,7 +398,8 @@ mod tests {
             triple: "fake-triple".to_owned(),
             source: TargetTripleSource::CliOption,
         };
-        let mut rust_build_meta = RustBuildMeta::new("/fake/target", Some(fake_triple));
+        let mut rust_build_meta =
+            RustBuildMeta::new("/fake/target", Some(fake_triple), BTreeMap::new());
         rust_build_meta
             .base_output_directories
             .insert("my-profile".into());

nextest-runner/src/list/rust_build_meta.rs

@@ -39,6 +39,9 @@ pub struct RustBuildMeta<State> {
     /// The target triple used while compiling the artifacts
     pub target_triple: Option<TargetTriple>,
 
+    /// The environment variables to set when running the test.
+    pub env: BTreeMap<String, String>,
+
     state: PhantomData<State>,
 }
 
@@ -47,6 +50,7 @@ impl RustBuildMeta<BinaryListState> {
     pub fn new(
         target_directory: impl Into<Utf8PathBuf>,
         target_triple: Option<TargetTriple>,
+        env: BTreeMap<String, String>,
     ) -> Self {
         Self {
             target_directory: target_directory.into(),
@@ -55,6 +59,7 @@ impl RustBuildMeta<BinaryListState> {
             linked_paths: BTreeMap::new(),
             state: PhantomData,
             target_triple,
+            env,
         }
     }
 
@@ -69,8 +74,9 @@ 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(),
+            env: self.env.clone(),
+            state: PhantomData,
         }
     }
 }
@@ -86,6 +92,7 @@ impl RustBuildMeta<TestListState> {
             linked_paths: BTreeMap::new(),
             state: PhantomData,
             target_triple: None,
+            env: BTreeMap::new(),
         }
     }
 
@@ -135,6 +142,7 @@ impl<State> RustBuildMeta<State> {
                 .collect(),
             state: PhantomData,
             target_triple: TargetTriple::deserialize(summary.target_platform),
+            env: summary.env,
         }
     }
 
@@ -146,6 +154,7 @@ impl<State> RustBuildMeta<State> {
             non_test_binaries: self.non_test_binaries.clone(),
             linked_paths: self.linked_paths.keys().cloned().collect(),
             target_platform: TargetTriple::serialize(self.target_triple.as_ref()),
+            env: self.env.clone(),
         }
     }
 }

nextest-runner/src/list/test_list.rs

@@ -59,6 +59,9 @@ pub struct RustTestArtifact<'g> {
     /// The working directory that this test should be executed in.
     pub cwd: Utf8PathBuf,
 
+    /// The environment variables to set when running the test.
+    pub env: BTreeMap<String, String>,
+
     /// The platform for which this test artifact was built.
     pub build_platform: BuildPlatform,
 }
@@ -132,6 +135,7 @@ impl<'g> RustTestArtifact<'g> {
                 kind: binary.kind.clone(),
                 cwd,
                 non_test_binaries,
+                env: rust_build_meta.env.clone(),
                 build_platform: binary.build_platform,
             })
         }
@@ -152,6 +156,7 @@ impl<'g> RustTestArtifact<'g> {
             non_test_binaries,
             cwd,
             build_platform,
+            env,
         } = self;
         (
             binary_path,
@@ -162,6 +167,7 @@ impl<'g> RustTestArtifact<'g> {
                 kind,
                 non_test_binaries,
                 cwd,
+                env,
                 build_platform,
                 status,
             },
@@ -340,6 +346,7 @@ impl<'g> TestList<'g> {
                     cwd: info.cwd.clone(),
                     status,
                     test_cases,
+                    env: info.env.clone(),
                 };
                 (info.binary_id.clone(), testsuite)
             })
@@ -609,6 +616,9 @@ pub struct RustTestSuite<'g> {
     /// will not be changed.
     pub cwd: Utf8PathBuf,
 
+    /// The environment variables to set when running the test.
+    pub env: BTreeMap<String, String>,
+
     /// The platform the test suite is for (host or target).
     pub build_platform: BuildPlatform,
 
@@ -676,6 +686,7 @@ impl<'g> RustTestArtifact<'g> {
             &self.package,
             dylib_path,
             &self.non_test_binaries,
+            &self.env,
         );
         let mut cmd = tokio::process::Command::from(cmd);
         match cmd.output().await {
@@ -837,6 +848,7 @@ impl<'a> TestInstance<'a> {
             &self.suite_info.package,
             test_list.updated_dylib_path(),
             &self.suite_info.non_test_binaries,
+            &self.suite_info.env,
         )
     }
 }
@@ -849,6 +861,7 @@ pub(crate) fn make_test_command(
     package: &PackageMetadata<'_>,
     dylib_path: &OsStr,
     non_test_binaries: &BTreeSet<(String, Utf8PathBuf)>,
+    env: &BTreeMap<String, String>,
 ) -> std::process::Command {
     // This is a workaround for a macOS SIP issue:
     // https://github.com/nextest-rs/nextest/pull/84
@@ -952,6 +965,8 @@ pub(crate) fn make_test_command(
         cmd.env(format!("NEXTEST_BIN_EXE_{}", name), &path);
     }
 
+    cmd.envs(env);
+
     cmd
 }
 
@@ -1006,6 +1021,7 @@ mod tests {
             kind: RustTestBinaryKind::LIB,
             non_test_binaries: BTreeSet::new(),
             build_platform: BuildPlatform::Target,
+            env: BTreeMap::new(),
         };
 
         let skipped_binary_name = "skipped-binary".to_owned();
@@ -1019,14 +1035,15 @@ mod tests {
             kind: RustTestBinaryKind::PROC_MACRO,
             non_test_binaries: BTreeSet::new(),
             build_platform: BuildPlatform::Host,
+            env: BTreeMap::new(),
         };
 
         let fake_triple = TargetTriple {
             triple: "fake-triple".to_owned(),
             source: TargetTripleSource::CliOption,
         };
-        let rust_build_meta =
-            RustBuildMeta::new("/fake", Some(fake_triple)).map_paths(&PathMapper::noop());
+        let rust_build_meta = RustBuildMeta::new("/fake", Some(fake_triple), BTreeMap::new())
+            .map_paths(&PathMapper::noop());
         let test_list = TestList::new_with_outputs(
             [
                 (test_binary, &non_ignored_output, &ignored_output),
@@ -1079,6 +1096,7 @@ mod tests {
                     binary_id: fake_binary_id,
                     kind: RustTestBinaryKind::LIB,
                     non_test_binaries: BTreeSet::new(),
+                    env: BTreeMap::new(),
                 },
                 "/fake/skipped-binary".into() => RustTestSuite {
                     status: RustTestSuiteStatus::Skipped,
@@ -1089,6 +1107,7 @@ mod tests {
                     binary_id: skipped_binary_id,
                     kind: RustTestBinaryKind::PROC_MACRO,
                     non_test_binaries: BTreeSet::new(),
+                    env: BTreeMap::new(),
                 },
             }
         );

nextest-runner/tests/integration/basic.rs

@@ -16,16 +16,20 @@ use nextest_runner::{
     test_filter::{RunIgnored, TestFilterBuilder},
 };
 use pretty_assertions::assert_eq;
-use std::{io::Cursor, time::Duration};
+use std::{collections::BTreeMap, io::Cursor, time::Duration};
 use test_case::test_case;
 
 #[test]
 fn test_list_binaries() -> Result<()> {
     set_rustflags();
 
     let graph = &*PACKAGE_GRAPH;
-    let binary_list =
-        BinaryList::from_messages(Cursor::new(&*FIXTURE_RAW_CARGO_TEST_OUTPUT), graph, None)?;
+    let binary_list = BinaryList::from_messages(
+        Cursor::new(&*FIXTURE_RAW_CARGO_TEST_OUTPUT),
+        graph,
+        None,
+        BTreeMap::new(),
+    )?;
 
     for (id, name, platform_is_target) in &EXPECTED_BINARY_LIST {
         let bin = binary_list
@@ -571,3 +575,29 @@ fn test_termination() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_set_env_vars() -> Result<()> {
+    set_rustflags();
+
+    let test_filter = TestFilterBuilder::any(RunIgnored::Default);
+    let test_list = FIXTURE_TARGETS.make_test_list(&test_filter, &TargetRunner::empty());
+    let config = load_config();
+    let profile = config
+        .profile(NextestConfig::DEFAULT_PROFILE)
+        .expect("default config is valid");
+
+    let mut runner = TestRunnerBuilder::default()
+        .build(
+            &test_list,
+            profile,
+            SignalHandlerKind::Noop,
+            TargetRunner::empty(),
+        )
+        .unwrap();
+
+    let (instance_statuses, run_stats) = execute_collect(&mut runner);
+    todo!("test this somehow");
+
+    Ok(())
+}