[dropshot-api-manager] write output to a writer to make rendering testable (#92)

In upcoming work we're going to change some of this rendering. Make it
testable by writing to a `&mut dyn io::Write`, and add an expectorate
snapshot test.

Author: sunshowers

Cargo.lock

@@ -30,6 +30,7 @@ dropshot = "0.17.0"
 dropshot-api-manager = { path = "crates/dropshot-api-manager", version = "0.7.1" }
 dropshot-api-manager-types = { path = "crates/dropshot-api-manager-types", version = "0.7.1" }
 e2e-example-apis = { path = "e2e-example/apis" }
+expectorate = "1.2.0"
 fs-err = "3.1.1"
 git-stub = "1.0.0"
 git-stub-vcs = "0.1.0"

Cargo.toml

@@ -4,56 +4,74 @@ use crate::{
     apis::ManagedApis,
     environment::{BlessedSource, GeneratedSource, ResolvedEnv},
     output::{
-        CheckResult, OutputOpts, display_load_problems, display_resolution,
+        CheckResult, Styles, display_load_problems, display_resolution,
         headers::*,
     },
     resolved::{ProblemSummary, Resolved},
 };
+use std::io;
 
 pub(crate) fn check_impl(
+    writer: &mut dyn io::Write,
     apis: &ManagedApis,
     env: &ResolvedEnv,
     blessed_source: &BlessedSource,
     generated_source: &GeneratedSource,
-    output: &OutputOpts,
+    styles: &Styles,
 ) -> anyhow::Result<CheckResult> {
     let (result, _summaries) = check_impl_with_summaries(
+        writer,
         apis,
         env,
         blessed_source,
         generated_source,
-        output,
+        styles,
     )?;
     Ok(result)
 }
 
+/// Run the check pipeline, rendering all user-visible output to `writer`.
+///
+/// Production callers (the CLI dispatch path) pass `&mut
+/// std::io::stderr().lock()` along with [`OutputOpts::styles`]; tests pass a
+/// `Vec<u8>` and `Styles::default()` to capture the same output into a
+/// `String`.
 pub(crate) fn check_impl_with_summaries(
+    writer: &mut dyn io::Write,
     apis: &ManagedApis,
     env: &ResolvedEnv,
     blessed_source: &BlessedSource,
     generated_source: &GeneratedSource,
-    output: &OutputOpts,
+    styles: &Styles,
 ) -> anyhow::Result<(CheckResult, Vec<ProblemSummary>)> {
-    let styles = output.styles(supports_color::Stream::Stderr);
+    writeln!(writer, "{:>HEADER_WIDTH$}", SEPARATOR)?;
 
-    eprintln!("{:>HEADER_WIDTH$}", SEPARATOR);
-
-    let (generated, errors) =
-        generated_source.load(apis, &styles, &env.repo_root, &env.vcs)?;
-    display_load_problems(&errors, &styles)?;
+    let (generated, errors) = generated_source.load(
+        writer,
+        apis,
+        styles,
+        &env.repo_root,
+        &env.vcs,
+    )?;
+    display_load_problems(writer, &errors, styles)?;
 
-    let (local_files, errors) =
-        env.local_source.load(apis, &styles, &env.repo_root, &env.vcs)?;
-    display_load_problems(&errors, &styles)?;
+    let (local_files, errors) = env.local_source.load(
+        writer,
+        apis,
+        styles,
+        &env.repo_root,
+        &env.vcs,
+    )?;
+    display_load_problems(writer, &errors, styles)?;
 
     let (blessed, errors) =
-        blessed_source.load(&env.repo_root, apis, &styles, &env.vcs)?;
-    display_load_problems(&errors, &styles)?;
+        blessed_source.load(writer, &env.repo_root, apis, styles, &env.vcs)?;
+    display_load_problems(writer, &errors, styles)?;
 
     let resolved = Resolved::new(env, apis, &blessed, &generated, &local_files);
 
-    eprintln!("{:>HEADER_WIDTH$}", SEPARATOR);
-    let result = display_resolution(env, apis, &resolved, &styles)?;
+    writeln!(writer, "{:>HEADER_WIDTH$}", SEPARATOR)?;
+    let result = display_resolution(writer, env, apis, &resolved, styles)?;
 
     // Extract owned summaries before dropping the borrowed resolved state.
     let summaries = resolved.problem_summaries();

crates/dropshot-api-manager/src/cmd/check.rs

@@ -20,21 +20,37 @@ pub(crate) fn debug_impl(
     output: &OutputOpts,
 ) -> anyhow::Result<()> {
     let styles = output.styles(supports_color::Stream::Stderr);
+    let mut stderr = std::io::stderr().lock();
 
     // Print information about local files.
 
-    let (local_files, errors) =
-        env.local_source.load(apis, &styles, &env.repo_root, &env.vcs)?;
+    let (local_files, errors) = env.local_source.load(
+        &mut stderr,
+        apis,
+        &styles,
+        &env.repo_root,
+        &env.vcs,
+    )?;
     dump_structure(&local_files, &errors);
 
     // Print information about what we found in VCS history.
-    let (blessed, errors) =
-        blessed_source.load(&env.repo_root, apis, &styles, &env.vcs)?;
+    let (blessed, errors) = blessed_source.load(
+        &mut stderr,
+        &env.repo_root,
+        apis,
+        &styles,
+        &env.vcs,
+    )?;
     dump_structure(&blessed, &errors);
 
     // Print information about generated files.
-    let (generated, errors) =
-        generated_source.load(apis, &styles, &env.repo_root, &env.vcs)?;
+    let (generated, errors) = generated_source.load(
+        &mut stderr,
+        apis,
+        &styles,
+        &env.repo_root,
+        &env.vcs,
+    )?;
     dump_structure(&generated, &errors);
 
     // Print result of resolving the differences.

crates/dropshot-api-manager/src/cmd/debug.rs

@@ -13,7 +13,7 @@ use crate::{
 use anyhow::Result;
 use camino::Utf8PathBuf;
 use clap::{Args, Parser, Subcommand};
-use std::process::ExitCode;
+use std::{io::Write as _, process::ExitCode};
 
 /// Manage OpenAPI documents for this repository.
 ///
@@ -41,7 +41,13 @@ impl App {
         match result {
             Ok(exit_code) => exit_code,
             Err(error) => {
-                eprintln!("failure: {:#}", error);
+                // Best-effort: if even the error report fails to write,
+                // we still want to exit with FAILURE.
+                let _ = writeln!(
+                    &mut std::io::stderr().lock(),
+                    "failure: {:#}",
+                    error,
+                );
                 ExitCode::FAILURE
             }
         }
@@ -300,8 +306,16 @@ impl CheckArgs {
         let env = env.resolve(self.local.dir)?;
         let blessed_source = self.blessed.to_blessed_source(&env)?;
         let generated_source = GeneratedSource::from(self.generated);
-        Ok(check_impl(apis, &env, &blessed_source, &generated_source, output)?
-            .to_exit_code())
+        let styles = output.styles(supports_color::Stream::Stderr);
+        Ok(check_impl(
+            &mut std::io::stderr().lock(),
+            apis,
+            &env,
+            &blessed_source,
+            &generated_source,
+            &styles,
+        )?
+        .to_exit_code())
     }
 }