temp: pass through env

Author: arxanas

cargo-nextest/src/dispatch.rs

@@ -12,7 +12,7 @@ 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},
@@ -563,6 +563,7 @@ impl CargoOptions {
         manifest_path: Option<&Utf8Path>,
         output: OutputContext,
         target_triple: Option<TargetTriple>,
+        env: EnvironmentMap,
     ) -> 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 +587,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 +911,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

@@ -12,6 +12,17 @@ use std::{
     process::Command,
 };
 
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+pub struct CargoEnvironmentVariable {
+    pub source: Option<Utf8PathBuf>,
+    pub name: String,
+    pub value: String,
+    pub force: bool,
+    pub relative: bool,
+}
+
+pub type EnvironmentMap = Vec<CargoEnvironmentVariable>;
+
 /// Command builder for `cargo nextest list`.
 #[derive(Clone, Debug, Default)]
 pub struct ListCommand {
@@ -275,6 +286,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: EnvironmentMap,
 }
 
 /// A non-test Rust binary. Used to set the correct environment
@@ -358,6 +372,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: EnvironmentMap,
 }
 
 fn listed_status() -> RustTestSuiteStatusSummary {
@@ -485,6 +502,7 @@ mod tests {
         non_test_binaries: BTreeMap::new(),
         linked_paths: BTreeSet::new(),
         target_platform: None,
+        env: Vec::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

@@ -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,50 @@ 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() // TODO: necessary? what order are the discovered configs?
+            .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)| match value {
+                        CargoConfigEnv::Value(value) => CargoEnvironmentVariable {
+                            source: source.clone(),
+                            name,
+                            value,
+                            force: false,
+                            relative: false,
+                        },
+                        CargoConfigEnv::Fields {
+                            value,
+                            force,
+                            relative,
+                        } => CargoEnvironmentVariable {
+                            source: source.clone(),
+                            name,
+                            value,
+                            force,
+                            relative,
+                        },
+                    })
+            })
+            .collect();
+        Ok(env)
+    }
+
     pub(crate) fn discovered_configs(
         &self,
     ) -> Result<
@@ -493,11 +538,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/binary_list.rs

@@ -11,8 +11,8 @@ use camino::{Utf8Path, Utf8PathBuf};
 use cargo_metadata::{Artifact, BuildScript, Message, PackageId};
 use guppy::graph::PackageGraph;
 use nextest_metadata::{
-    BinaryListSummary, BuildPlatform, RustNonTestBinaryKind, RustNonTestBinarySummary,
-    RustTestBinaryKind, RustTestBinarySummary,
+    BinaryListSummary, BuildPlatform, EnvironmentMap, RustNonTestBinaryKind,
+    RustNonTestBinarySummary, RustTestBinaryKind, RustTestBinarySummary,
 };
 use owo_colors::OwoColorize;
 use std::{fmt::Write as _, io, io::Write};
@@ -51,8 +51,9 @@ impl BinaryList {
         reader: impl io::BufRead,
         graph: &PackageGraph,
         target_triple: Option<TargetTriple>,
+        env: EnvironmentMap,
     ) -> 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: EnvironmentMap,
+    ) -> 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,7 @@ 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), Vec::new());
         rust_build_meta
             .base_output_directories
             .insert("my-profile".into());

nextest-runner/src/list/rust_build_meta.rs

@@ -8,7 +8,7 @@ use crate::{
     reuse_build::PathMapper,
 };
 use camino::Utf8PathBuf;
-use nextest_metadata::{RustBuildMetaSummary, RustNonTestBinarySummary};
+use nextest_metadata::{EnvironmentMap, RustBuildMetaSummary, RustNonTestBinarySummary};
 use std::{
     collections::{BTreeMap, BTreeSet},
     marker::PhantomData,
@@ -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: EnvironmentMap,
+
     state: PhantomData<State>,
 }
 
@@ -47,6 +50,7 @@ impl RustBuildMeta<BinaryListState> {
     pub fn new(
         target_directory: impl Into<Utf8PathBuf>,
         target_triple: Option<TargetTriple>,
+        env: EnvironmentMap,
     ) -> 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: Vec::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(),
         }
     }
 }