Implement test for 11036 cargo changes

Author: smoelius

tests/testsuite/rustup.rs

@@ -8,8 +8,9 @@ use std::path::{Path, PathBuf};
 
 use crate::prelude::*;
 use crate::utils::cargo_process;
-use cargo_test_support::paths::{home, root};
-use cargo_test_support::{process, project, str};
+use cargo_test_support::install::assert_has_installed_exe;
+use cargo_test_support::paths::{cargo_home, home, root};
+use cargo_test_support::{execs, process, project, str};
 
 /// Helper to generate an executable.
 fn make_exe(dest: &Path, name: &str, contents: &str, env: &[(&str, PathBuf)]) -> PathBuf {
@@ -99,7 +100,13 @@ fn real_rustc_wrapper(bin_dir: &Path, message: &str) -> PathBuf {
 /// Creates a simulation of a rustup environment with `~/.cargo/bin` and
 /// `~/.rustup` directories populated with some executables that simulate
 /// rustup.
-fn simulated_rustup_environment() -> RustupEnvironment {
+///
+/// Arguments
+///
+/// - `proxy_calls_cargo`: if true, the cargo proxy calls the cargo under test;
+///    otherwise, the cargo proxy calls an executable that panics immediately
+/// - `env_setup`: environment variable setup the proxy should perform
+fn simulated_rustup_environment(proxy_calls_cargo: bool, env_setup: &str) -> RustupEnvironment {
     // Set up ~/.rustup/toolchains/test-toolchain/bin with a custom rustc and cargo.
     let rustup_home = home().join(".rustup");
     let toolchain_bin = rustup_home
@@ -108,42 +115,58 @@ fn simulated_rustup_environment() -> RustupEnvironment {
         .join("bin");
     toolchain_bin.mkdir_p();
     let rustc_toolchain_exe = real_rustc_wrapper(&toolchain_bin, "real rustc running");
-    let cargo_toolchain_exe = make_exe(
-        &toolchain_bin,
-        "cargo",
-        r#"panic!("cargo toolchain should not be called");"#,
-        &[],
-    );
+    let cargo_toolchain_exe = if proxy_calls_cargo {
+        crate::utils::cargo_exe()
+    } else {
+        make_exe(
+            &toolchain_bin,
+            "cargo",
+            r#"panic!("cargo toolchain should not be called");"#,
+            &[],
+        )
+    };
 
     // Set up ~/.cargo/bin with a typical set of rustup proxies.
     let cargo_bin = home().join(".cargo").join("bin");
     cargo_bin.mkdir_p();
 
-    let rustc_proxy = make_exe(
+    let proxy = make_exe(
         &cargo_bin,
         "rustc",
         &format!(
             r#"
-                match std::env::args().next().unwrap().as_ref() {{
-                    "rustc" => {{}}
-                    arg => panic!("proxy only supports rustc, got {{arg:?}}"),
-                }}
-                eprintln!("rustc proxy running");
-                let r = std::process::Command::new(env!("CARGO_RUSTUP_TEST_rustc_toolchain_exe"))
+                let file_stem = std::path::PathBuf::from(std::env::args().next().unwrap())
+                    .file_stem()
+                    .map(ToOwned::to_owned)
+                    .unwrap();
+                let program = match file_stem.to_str().unwrap() {{
+                    "cargo" => env!("CARGO_RUSTUP_TEST_cargo_toolchain_exe"),
+                    "rustc" => env!("CARGO_RUSTUP_TEST_rustc_toolchain_exe"),
+                    arg => panic!("proxy only supports cargo and rustc, got {{arg:?}}"),
+                }};
+                eprintln!("`{{program}}` proxy running");
+                let r = std::process::Command::new(program)
                     .args(std::env::args_os().skip(1))
+                    {env_setup}
                     .status();
                 std::process::exit(r.unwrap().code().unwrap_or(2));
             "#
         ),
-        &[("CARGO_RUSTUP_TEST_rustc_toolchain_exe", rustc_toolchain_exe)],
+        &[
+            ("CARGO_RUSTUP_TEST_rustc_toolchain_exe", rustc_toolchain_exe),
+            (
+                "CARGO_RUSTUP_TEST_cargo_toolchain_exe",
+                cargo_toolchain_exe.clone(),
+            ),
+        ],
     );
     fs::hard_link(
-        &rustc_proxy,
+        &proxy,
         cargo_bin.join("cargo").with_extension(EXE_EXTENSION),
     )
     .unwrap();
     fs::hard_link(
-        &rustc_proxy,
+        &proxy,
         cargo_bin.join("rustup").with_extension(EXE_EXTENSION),
     )
     .unwrap();
@@ -162,7 +185,7 @@ fn typical_rustup() {
         cargo_bin,
         rustup_home,
         cargo_toolchain_exe,
-    } = simulated_rustup_environment();
+    } = simulated_rustup_environment(false, "");
 
     // Set up a project and run a normal cargo build.
     let p = project().file("src/lib.rs", "").build();
@@ -212,7 +235,7 @@ fn custom_calls_other_cargo() {
         cargo_bin,
         rustup_home,
         cargo_toolchain_exe: _,
-    } = simulated_rustup_environment();
+    } = simulated_rustup_environment(false, "");
 
     // Create a directory with a custom toolchain (outside of the rustup universe).
     let custom_bin = root().join("custom-bin");
@@ -271,3 +294,43 @@ custom toolchain rustc running
 "#]])
         .run();
 }
+
+/// Performs a `cargo install` with a non-default toolchain in a simulated
+/// rustup environment. The purpose is to verify the warning that is emitted.
+#[cargo_test]
+fn cargo_install_with_non_default_toolchain() {
+    let RustupEnvironment {
+        cargo_bin,
+        rustup_home: _,
+        cargo_toolchain_exe: _,
+    } = simulated_rustup_environment(
+        true,
+        ".env(\"RUSTUP_TOOLCHAIN_SOURCE\", \"env\")
+         .env(\"RUSTUP_TOOLCHAIN\", \"test-toolchain\")",
+    );
+
+    crate::utils::pkg("foo", "0.0.1");
+
+    let mut p = process(cargo_bin.join("cargo"));
+    p.arg_line("install foo");
+    execs()
+        .with_process_builder(p)
+        .with_stderr_data(str![[r#"
+`[..]/cargo[EXE]` proxy running
+[UPDATING] `dummy-registry` index
+[DOWNLOADING] crates ...
+[DOWNLOADED] foo v0.0.1 (registry `dummy-registry`)
+[INSTALLING] foo v0.0.1
+[WARNING] using non-default toolchain `test-toolchain` overridden by env
+  |
+  = [HELP] Use `cargo +stable install` if you meant to use the stable toolchain.
+[COMPILING] foo v0.0.1
+[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s
+[INSTALLING] [ROOT]/home/.cargo/bin/foo[EXE]
+[INSTALLED] package `foo v0.0.1` (executable `foo[EXE]`)
+[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries
+
+"#]])
+        .run();
+    assert_has_installed_exe(cargo_home(), "foo");
+}