Normalize host target in snapshot tests

Author: Kobzol

src/bootstrap/src/core/builder/tests.rs

@@ -8,6 +8,7 @@ use super::*;
 use crate::Flags;
 use crate::core::build_steps::doc::DocumentationFormat;
 use crate::core::config::Config;
+use crate::utils::helpers::get_host_target;
 use crate::utils::tests::git::{GitCtx, git_test};
 
 static TEST_TRIPLE_1: &str = "i686-unknown-haiku";
@@ -1235,24 +1236,38 @@ fn any_debug() {
 /// The staging tests use insta for snapshot testing.
 /// See bootstrap's README on how to bless the snapshots.
 mod staging {
+    use crate::Build;
+    use crate::core::builder::Builder;
     use crate::core::builder::tests::{
         TEST_TRIPLE_1, configure, configure_with_args, render_steps, run_build,
     };
+    use crate::utils::tests::ConfigBuilder;
 
     #[test]
     fn build_compiler_stage_1() {
-        let mut cache = run_build(
-            &["compiler".into()],
-            configure_with_args(&["build", "--stage", "1"], &[TEST_TRIPLE_1], &[TEST_TRIPLE_1]),
-        );
-        let steps = cache.into_executed_steps();
-        insta::assert_snapshot!(render_steps(&steps), @r"
-        [build] rustc 0 <target1> -> std 0 <target1>
-        [build] llvm <target1>
-        [build] rustc 0 <target1> -> rustc 1 <target1>
-        [build] rustc 0 <target1> -> rustc 1 <target1>
+        insta::assert_snapshot!(
+            ConfigBuilder::build()
+                .path("compiler")
+                .stage(1)
+                .get_steps(), @r"
+        [build] rustc 0 <host> -> std 0 <host>
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
         ");
     }
+
+    impl ConfigBuilder {
+        fn get_steps(self) -> String {
+            let config = self.create_config();
+
+            let kind = config.cmd.kind();
+            let build = Build::new(config);
+            let builder = Builder::new(&build);
+            builder.run_step_descriptions(&Builder::get_step_descriptions(kind), &builder.paths);
+            render_steps(&builder.cache.into_executed_steps())
+        }
+    }
 }
 
 /// Renders the executed bootstrap steps for usage in snapshot tests with insta.
@@ -1276,19 +1291,14 @@ fn render_steps(steps: &[(Box<dyn Any>, Box<dyn Any>)]) -> String {
                     "[build] {} -> std {} <{}>",
                     render_compiler(std.compiler),
                     std.compiler.stage,
-                    std.target
+                    normalize_target(std.target)
                 ))
             } else if let Some((llvm, output)) = downcast_step::<llvm::Llvm>(step, output) {
-                Some(format!("[build] llvm <{}>", llvm.target))
+                Some(format!("[build] llvm <{}>", normalize_target(llvm.target)))
             } else {
                 None
             }
         })
-        .map(|line| {
-            line.replace(TEST_TRIPLE_1, "target1")
-                .replace(TEST_TRIPLE_2, "target2")
-                .replace(TEST_TRIPLE_3, "target3")
-        })
         .collect::<Vec<_>>()
         .join("\n")
 }
@@ -1306,6 +1316,10 @@ fn downcast_step<'a, S: Step>(
     Some((step, output))
 }
 
+fn normalize_target(target: TargetSelection) -> String {
+    target.to_string().replace(&get_host_target().to_string(), "host")
+}
+
 fn render_compiler(compiler: Compiler) -> String {
-    format!("rustc {} <{}>", compiler.stage, compiler.host)
+    format!("rustc {} <{}>", compiler.stage, normalize_target(compiler.host))
 }

src/bootstrap/src/utils/tests/mod.rs

@@ -1,3 +1,46 @@
 //! This module contains shared utilities for bootstrap tests.
 
+use crate::core::builder::Builder;
+use crate::core::config::DryRun;
+use crate::{Build, Config, Flags};
+
 pub mod git;
+
+/// Used to configure an invocation of bootstrap.
+/// Currently runs in the rustc checkout, long-term it should be switched
+/// to run in a (cache-primed) temporary directory instead.
+pub struct ConfigBuilder {
+    args: Vec<String>,
+}
+
+impl ConfigBuilder {
+    pub fn from_args(args: &[&str]) -> Self {
+        Self::new(args)
+    }
+
+    pub fn build() -> Self {
+        Self::new(&["build"])
+    }
+
+    pub fn path(mut self, path: &str) -> Self {
+        self.args.push(path.to_string());
+        self
+    }
+
+    pub fn stage(mut self, stage: u32) -> Self {
+        self.args.push("--stage".to_string());
+        self.args.push(stage.to_string());
+        self
+    }
+
+    fn new(args: &[&str]) -> Self {
+        Self { args: args.iter().copied().map(String::from).collect() }
+    }
+
+    pub fn create_config(mut self) -> Config {
+        let mut config = Config::parse(Flags::parse(&self.args));
+        // Run in dry-check, otherwise the test would be too slow
+        config.set_dry_run(DryRun::SelfCheck);
+        config
+    }
+}