[nextest-runner] display run ID and profile name during runs

We're going to make the run ID more prominent soon, so display it.

Also display the profile name since I think it's useful information.

In the future we're also going to record the command arguments.

Author: sunshowers

nextest-runner/src/config/config_impl.rs

@@ -522,6 +522,7 @@ impl NextestConfig {
             .chain(self.compiled.default.clone());
 
         Ok(NextestProfile {
+            name: name.to_owned(),
             store_dir,
             default_profile: &self.inner.default_profile,
             custom_profile,
@@ -573,6 +574,7 @@ pub struct FinalConfig {
 /// Returned by [`NextestConfig::profile`].
 #[derive(Clone, Debug)]
 pub struct NextestProfile<'cfg, State = FinalConfig> {
+    name: String,
     store_dir: Utf8PathBuf,
     default_profile: &'cfg DefaultProfileImpl,
     custom_profile: Option<&'cfg CustomProfileImpl>,
@@ -583,6 +585,11 @@ pub struct NextestProfile<'cfg, State = FinalConfig> {
 }
 
 impl<'cfg, State> NextestProfile<'cfg, State> {
+    /// Returns the name of the profile.
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
     /// Returns the absolute profile-specific store directory.
     pub fn store_dir(&self) -> &Utf8Path {
         &self.store_dir
@@ -612,6 +619,7 @@ impl<'cfg> NextestProfile<'cfg, PreBuildPlatform> {
     pub fn apply_build_platforms(self, build_platforms: &BuildPlatforms) -> NextestProfile<'cfg> {
         let compiled_data = self.compiled_data.apply_build_platforms(build_platforms);
         NextestProfile {
+            name: self.name,
             store_dir: self.store_dir,
             default_profile: self.default_profile,
             custom_profile: self.custom_profile,

nextest-runner/src/reporter.rs

@@ -594,7 +594,11 @@ impl<'a> TestReporterImpl<'a> {
         writer: &mut dyn Write,
     ) -> io::Result<()> {
         match &event.kind {
-            TestEventKind::RunStarted { test_list, .. } => {
+            TestEventKind::RunStarted {
+                test_list,
+                run_id,
+                profile_name,
+            } => {
                 write!(writer, "{:>12} ", "Starting".style(self.styles.pass))?;
 
                 let count_style = self.styles.count;
@@ -611,9 +615,18 @@ impl<'a> TestReporterImpl<'a> {
 
                 let skip_count = test_list.skip_count();
                 if skip_count > 0 {
-                    write!(writer, " ({} skipped)", skip_count.style(count_style))?;
+                    write!(writer, " ({} skipped; ", skip_count.style(count_style))?;
+                } else {
+                    write!(writer, " (")?;
                 }
 
+                write!(
+                    writer,
+                    "run ID: {}, nextest profile: {})",
+                    run_id.style(self.styles.count),
+                    profile_name.style(self.styles.count),
+                )?;
+
                 writeln!(writer)?;
             }
             TestEventKind::SetupScriptStarted {
@@ -1659,6 +1672,9 @@ pub enum TestEventKind<'a> {
 
         /// The UUID for this run.
         run_id: Uuid,
+
+        /// The nextest profile chosen for this run.
+        profile_name: String,
     },
 
     /// A setup script started.

nextest-runner/src/runner.rs

@@ -285,6 +285,7 @@ impl<'a> TestRunnerInner<'a> {
         let mut ctx = CallbackContext::new(
             callback,
             self.run_id,
+            self.profile.name(),
             self.test_list.run_count(),
             self.fail_fast,
         );
@@ -1679,6 +1680,7 @@ enum ShutdownForwardEvent {
 struct CallbackContext<F, E> {
     callback: F,
     run_id: Uuid,
+    profile_name: String,
     stopwatch: StopwatchStart,
     run_stats: RunStats,
     fail_fast: bool,
@@ -1693,11 +1695,18 @@ impl<'a, F, E> CallbackContext<F, E>
 where
     F: FnMut(TestEvent<'a>) -> Result<(), E> + Send,
 {
-    fn new(callback: F, run_id: Uuid, initial_run_count: usize, fail_fast: bool) -> Self {
+    fn new(
+        callback: F,
+        run_id: Uuid,
+        profile_name: &str,
+        initial_run_count: usize,
+        fail_fast: bool,
+    ) -> Self {
         Self {
             callback,
             run_id,
             stopwatch: crate::time::stopwatch(),
+            profile_name: profile_name.to_owned(),
             run_stats: RunStats {
                 initial_run_count,
                 ..RunStats::default()
@@ -1715,6 +1724,7 @@ where
         self.basic_callback(TestEventKind::RunStarted {
             test_list,
             run_id: self.run_id,
+            profile_name: self.profile_name.clone(),
         })
     }