test(cli): cover stage reuse, reclamation, and stray update hashes

Interrupted installs are asserted to reuse one deterministic staging
path; a stale stage left by a dead process is reclaimed without leaking
its contents into the published toolchain; and a stray update hash is
ignored during a staged install and refreshed after publication.

Author: cachebag

tests/suite/cli_crash.rs

@@ -1,5 +1,9 @@
 use std::{fs, path::PathBuf, process::Command, time::Duration};
 
+use rustup::dist::manifestation::CHECKPOINT_UPDATE_BEFORE_METADATA;
+use rustup::install::{
+    CHECKPOINT_INSTALL_AFTER_PUBLISH, CHECKPOINT_INSTALL_BEFORE_PUBLISH, STAGING_DIR_PREFIX,
+};
 use rustup::test::{CliTestContext, Scenario, this_host_tuple};
 use wait_timeout::ChildExt;
 
@@ -30,6 +34,13 @@ fn nightly_update_hash_path(cx: &CliTestContext) -> PathBuf {
         .join(format!("nightly-{}", this_host_tuple()))
 }
 
+fn nightly_staging_root(cx: &CliTestContext) -> PathBuf {
+    cx.config
+        .rustupdir
+        .join("toolchains")
+        .join(format!("{STAGING_DIR_PREFIX}nightly-{}", this_host_tuple()))
+}
+
 fn staging_paths(cx: &CliTestContext) -> Vec<PathBuf> {
     fs::read_dir(cx.config.rustupdir.join("toolchains"))
         .expect("failed to read toolchains directory")
@@ -66,15 +77,13 @@ rustc-[HOST_TUPLE]
 
 async fn assert_unpublished_install_can_be_retried(checkpoint: &str) {
     let cx = CliTestContext::new(Scenario::SimpleV2).await;
-    let command = cx.config.cmd("rustup", ["toolchain", "install", "nightly"]);
-
-    let status = cx.kill_at_checkpoint(command, checkpoint);
+    let status = cx.kill_at(checkpoint, ["rustup", "toolchain", "install", "nightly"]);
     assert!(!status.success());
     assert!(
         !nightly_path(&cx).exists(),
         "an interrupted staging operation published the toolchain"
     );
-    assert_eq!(staging_paths(&cx).len(), 1);
+    assert_eq!(staging_paths(&cx), vec![nightly_staging_root(&cx)]);
     cx.config
         .expect(["rustup", "toolchain", "list"])
         .await
@@ -89,12 +98,50 @@ async fn assert_unpublished_install_can_be_retried(checkpoint: &str) {
 
 #[tokio::test]
 async fn interrupted_install_can_be_retried() {
-    assert_unpublished_install_can_be_retried(BEFORE_METADATA).await;
+    assert_unpublished_install_can_be_retried(CHECKPOINT_UPDATE_BEFORE_METADATA).await;
 }
 
 #[tokio::test]
 async fn interrupted_install_before_publication_can_be_retried() {
-    assert_unpublished_install_can_be_retried(BEFORE_PUBLISH).await;
+    assert_unpublished_install_can_be_retried(CHECKPOINT_INSTALL_BEFORE_PUBLISH).await;
+}
+
+#[tokio::test]
+async fn interrupted_installs_do_not_accumulate_stages() {
+    let cx = CliTestContext::new(Scenario::SimpleV2).await;
+
+    for _ in 0..2 {
+        let status = cx.kill_at(
+            CHECKPOINT_INSTALL_BEFORE_PUBLISH,
+            ["rustup", "toolchain", "install", "nightly"],
+        );
+        assert!(!status.success());
+        assert_eq!(staging_paths(&cx), vec![nightly_staging_root(&cx)]);
+    }
+
+    assert_completes_successfully(cx.config.cmd("rustup", ["toolchain", "install", "nightly"]));
+    assert!(staging_paths(&cx).is_empty());
+    assert_nightly_is_complete(&cx).await;
+}
+
+#[tokio::test]
+async fn stale_stage_is_reclaimed_by_the_next_install() {
+    let cx = CliTestContext::new(Scenario::SimpleV2).await;
+    let junk = nightly_staging_root(&cx)
+        .join("toolchain")
+        .join("bin")
+        .join("stale-junk");
+    fs::create_dir_all(junk.parent().unwrap()).unwrap();
+    fs::write(&junk, "junk").unwrap();
+    fs::write(nightly_staging_root(&cx).join("update-hash"), "stale-hash").unwrap();
+
+    assert_completes_successfully(cx.config.cmd("rustup", ["toolchain", "install", "nightly"]));
+    assert!(staging_paths(&cx).is_empty());
+    assert!(
+        !nightly_path(&cx).join("bin").join("stale-junk").exists(),
+        "contents of a stale stage leaked into the published toolchain"
+    );
+    assert_nightly_is_complete(&cx).await;
 }
 
 #[tokio::test]
@@ -104,8 +151,10 @@ async fn unpublished_install_does_not_change_update_hash() {
     fs::create_dir_all(update_hash.parent().unwrap()).unwrap();
     fs::write(&update_hash, "stale-hash").unwrap();
 
-    let command = cx.config.cmd("rustup", ["toolchain", "install", "nightly"]);
-    let status = cx.kill_at_checkpoint(command, BEFORE_PUBLISH);
+    let status = cx.kill_at(
+        CHECKPOINT_INSTALL_BEFORE_PUBLISH,
+        ["rustup", "toolchain", "install", "nightly"],
+    );
 
     assert!(!status.success());
     assert_eq!(fs::read_to_string(update_hash).unwrap(), "stale-hash");
@@ -115,9 +164,10 @@ async fn unpublished_install_does_not_change_update_hash() {
 #[tokio::test]
 async fn interrupted_install_after_publication_is_complete() {
     let cx = CliTestContext::new(Scenario::SimpleV2).await;
-    let command = cx.config.cmd("rustup", ["toolchain", "install", "nightly"]);
-
-    let status = cx.kill_at_checkpoint(command, AFTER_PUBLISH);
+    let status = cx.kill_at(
+        CHECKPOINT_INSTALL_AFTER_PUBLISH,
+        ["rustup", "toolchain", "install", "nightly"],
+    );
     assert!(!status.success());
     assert!(nightly_path(&cx).is_dir());
     assert!(staging_paths(&cx).is_empty());
@@ -163,16 +213,13 @@ async fn interrupted_update_can_be_retried() {
         .is_ok();
 
     cx.config.set_current_dist_date("2015-01-02");
-    let command = cx.config.cmd("rustup", ["update", "nightly"]);
-    let status = cx.kill_at_checkpoint(command, BEFORE_METADATA);
+    let status = cx.kill_at(
+        CHECKPOINT_UPDATE_BEFORE_METADATA,
+        ["rustup", "update", "nightly"],
+    );
     assert!(!status.success());
 
     assert_completes_successfully(cx.config.cmd("rustup", ["update", "nightly"]));
 
     assert_nightly_is_complete(&cx).await;
 }
-
-const BEFORE_METADATA: &str = "manifestation-update-before-metadata";
-const BEFORE_PUBLISH: &str = "install-before-publish";
-const AFTER_PUBLISH: &str = "install-after-publish";
-const STAGING_DIR_PREFIX: &str = "+rustup-staging-";

tests/suite/cli_v2.rs

@@ -1949,9 +1949,11 @@ async fn remove_target_missing_update_hash() {
         .is_ok();
 }
 
-// Issue #1777
+// Issue #1777: a stray hash file must not prevent installation. Staged
+// installs never consult the alias-scoped hash, so it is silently refreshed
+// after publication rather than removed up front.
 #[tokio::test]
-async fn warn_about_and_remove_stray_hash() {
+async fn stray_hash_is_ignored_and_refreshed() {
     let mut cx = CliTestContext::new(Scenario::None).await;
     let mut hash_path = cx.config.rustupdir.join("update-hashes");
     fs::create_dir_all(&hash_path).expect("Unable to make the update-hashes directory");
@@ -1965,12 +1967,13 @@ async fn warn_about_and_remove_stray_hash() {
     cx.config
         .expect(["rustup", "toolchain", "install", "nightly"])
         .await
-        .with_stderr(snapbox::str![[r#"
-...
-warn: removing stray hash file in order to continue: [..]/update-hashes/nightly-[HOST_TUPLE]
-...
-"#]])
         .is_ok();
+
+    let refreshed = fs::read_to_string(&hash_path).expect("Unable to read update-hash file");
+    assert_ne!(
+        refreshed, "LEGITHASH",
+        "stray hash file was not refreshed after installation"
+    );
 }
 
 fn make_component_unavailable(config: &Config, name: &str, target: String) {