Stream stdout and stderr (#699)

cmillar-trunk · web-flow · commit e5e93e4fd5d5 · 2025-06-25T21:14:51.000Z
Bazel outputs its final summary to stdout, but progress logs to stderr. With stdout&gt;stderr, we end up logging the summary above the progress. Even worse, since we pipe it to a variable before printing, we end up sitting there doing nothing while waiting for the subcommand to print, and then dump the whole thing to the screen. This is fine if you're letting it run and not watching, but is a spooky experience if you are watching. Thus, we switch to passing both streams out directly, which also nicely interleaves them the way bazel expects.
diff --git a/cli-tests/src/test.rs b/cli-tests/src/test.rs
@@ -613,9 +613,9 @@ async fn test_command_can_print_subcommand_output_with_special_characters() {
     .command()
     .assert()
     .success()
-    .stderr(predicate::str::contains("Firstline"))
-    .stderr(predicate::str::contains("AfterNewline"))
-    .stderr(predicate::str::contains("    indented"));
+    .stdout(predicate::str::contains("Firstline"))
+    .stdout(predicate::str::contains("AfterNewline"))
+    .stdout(predicate::str::contains("\r\tindented"));
 }
 
 #[tokio::test(flavor = "multi_thread")]
@@ -640,7 +640,7 @@ async fn test_command_can_print_subcommand_output_with_faux_html() {
     .command()
     .assert()
     .success()
-    .stderr(predicate::str::contains(
+    .stdout(predicate::str::contains(
         "<head>This breaks superconsole</head>",
     ));
 }
diff --git a/cli/src/test_command.rs b/cli/src/test_command.rs
@@ -21,6 +21,22 @@ use crate::{
     upload_command::{run_upload, UploadArgs, UploadRunResult},
 };
 
+enum RunOutput {
+    Title,
+}
+impl EndOutput for RunOutput {
+    fn output(&self) -> anyhow::Result<Vec<Line>> {
+        match self {
+            RunOutput::Title => Ok(vec![
+                Line::from_iter([Span::new_styled(
+                    String::from("📒 Test command outputs").attribute(Attribute::Bold),
+                )?]),
+                Line::default(),
+            ]),
+        }
+    }
+}
+
 #[derive(Args, Clone, Debug)]
 pub struct TestArgs {
     #[command(flatten)]
@@ -80,14 +96,14 @@ impl EndOutput for TestRunResult {
             Line::default(),
         ]);
 
-        for stdout_line in lines_of(self.command_stdout.clone()) {
-            output.push(Line::from_iter([Span::new_unstyled_lossy(stdout_line)]));
+        for stderr_line in lines_of(self.command_stderr.clone()) {
+            output.push(Line::from_iter([Span::new_unstyled_lossy(stderr_line)]));
         }
 
         output.push(Line::default());
 
-        for stderr_line in lines_of(self.command_stderr.clone()) {
-            output.push(Line::from_iter([Span::new_unstyled_lossy(stderr_line)]));
+        for stdout_line in lines_of(self.command_stdout.clone()) {
+            output.push(Line::from_iter([Span::new_unstyled_lossy(stdout_line)]));
         }
 
         Ok(output)
@@ -102,12 +118,7 @@ pub async fn run_test(
     render_sender: Sender<DisplayMessage>,
 ) -> anyhow::Result<UploadRunResult> {
     let token = upload_args.token.clone();
-    let mut test_run_result = run_test_command(&command).await?;
-    let run_result_ptr = Arc::new(test_run_result.clone());
-    send_message(
-        DisplayMessage::Final(run_result_ptr, String::from("test output")),
-        &render_sender,
-    );
+    let mut test_run_result = run_test_command(&command, render_sender.clone()).await?;
     let test_context = gather_initial_test_context(
         upload_args.clone(),
         gather_debug_props(env::args().collect::<Vec<String>>(), token),
@@ -140,8 +151,16 @@ pub async fn run_test(
     }
 }
 
-pub async fn run_test_command<T: AsRef<str>>(command: &[T]) -> anyhow::Result<TestRunResult> {
+pub async fn run_test_command<T: AsRef<str>>(
+    command: &[T],
+    render_sender: Sender<DisplayMessage>,
+) -> anyhow::Result<TestRunResult> {
     let exec_start = SystemTime::now();
+    let title_ptr = Arc::new(RunOutput::Title);
+    send_message(
+        DisplayMessage::Final(title_ptr, String::from("test command title")),
+        &render_sender,
+    );
     let child = Command::new(command.first().map(|s| s.as_ref()).unwrap_or_default())
         .args(
             command
@@ -150,8 +169,8 @@ pub async fn run_test_command<T: AsRef<str>>(command: &[T]) -> anyhow::Result<Te
                 .map(|s| s.as_ref())
                 .collect::<Vec<_>>(),
         )
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
         .spawn()?;
     let exit_result = child.wait_with_output().map_err(|e| {
         tracing::warn!("Error waiting for execution: {}", e);
