Add test that "not a dir" errors are allowed

Author: tmfink

Cargo.lock

@@ -59,6 +59,9 @@ unicode-properties = { version = "0.1", default-features = false, features = ["g
 rustfmt-config_proc_macro = { version = "0.3", path = "config_proc_macro" }
 semver = "1.0.21"
 
+[dev-dependencies]
+tempfile = "3.23.0"
+
 # Rustc dependencies are loaded from the sysroot, Cargo doesn't know about them.
 
 [package.metadata.rust-analyzer]

Cargo.toml

@@ -1,28 +1,38 @@
 //! Integration tests for rustfmt.
 
 use std::env;
-use std::fs::remove_file;
+use std::fs::{File, remove_file};
 use std::path::Path;
 use std::process::Command;
 
 use rustfmt_config_proc_macro::{nightly_only_test, rustfmt_only_ci_test};
 
-/// Run the rustfmt executable and return its output.
-fn rustfmt(args: &[&str]) -> (String, String) {
+/// Run the rustfmt executable with environment vars set and return its output.
+fn rustfmt_with_extra(
+    args: &[&str],
+    working_dir: Option<&str>,
+    envs: &[(&str, &str)],
+) -> (String, String) {
     let mut bin_dir = env::current_exe().unwrap();
     bin_dir.pop(); // chop off test exe name
     if bin_dir.ends_with("deps") {
         bin_dir.pop();
     }
-    let cmd = bin_dir.join(format!("rustfmt{}", env::consts::EXE_SUFFIX));
+    let rustfmt_exe = bin_dir.join(format!("rustfmt{}", env::consts::EXE_SUFFIX));
 
     // Ensure the rustfmt binary runs from the local target dir.
     let path = env::var_os("PATH").unwrap_or_default();
     let mut paths = env::split_paths(&path).collect::<Vec<_>>();
     paths.insert(0, bin_dir);
     let new_path = env::join_paths(paths).unwrap();
-
-    match Command::new(&cmd).args(args).env("PATH", new_path).output() {
+    let mut cmd = Command::new(rustfmt_exe);
+    cmd.args(args)
+        .env("PATH", new_path)
+        .envs(envs.iter().copied());
+    if let Some(working_dir) = working_dir {
+        cmd.current_dir(working_dir);
+    }
+    match cmd.output() {
         Ok(output) => (
             String::from_utf8(output.stdout).expect("utf-8"),
             String::from_utf8(output.stderr).expect("utf-8"),
@@ -31,6 +41,10 @@ fn rustfmt(args: &[&str]) -> (String, String) {
     }
 }
 
+fn rustfmt(args: &[&str]) -> (String, String) {
+    rustfmt_with_extra(args, None, &[])
+}
+
 macro_rules! assert_that {
     ($args:expr, $($check:ident $check_args:tt)&&+) => {
         let (stdout, stderr) = rustfmt($args);
@@ -232,3 +246,34 @@ fn rustfmt_error_improvement_regarding_invalid_toml() {
 
     assert!(stderr.contains(&expected_error_message));
 }
+
+#[test]
+fn rustfmt_allow_not_a_dir_errors() {
+    // See also https://github.com/rust-lang/rustfmt/pull/6624
+
+    // To get a proper test, we need to make sure that neither the working dir
+    // nor the input file have a "rustfmt.toml" file in any ancestor dirs. Since
+    // this project has a "rustfmt.toml" in the root dir, we can't use a temp
+    // dir in the target/ dir, which includes the directory given by
+    // CARGO_TARGET_TMPDIR. Thus, we need the OS-specific temp dir which is
+    // closer to the "root" directory which is less likely to have a
+    // "rustfmt.toml".
+    let fake_home = tempfile::tempdir().unwrap();
+    let fake_home_str = fake_home.path().to_str().unwrap();
+
+    // create .config file
+    let dot_config_file = fake_home.path().join(".config");
+    let _ = File::create(dot_config_file).unwrap();
+
+    // create empty.rs
+    let empty_rs = fake_home.path().join("empty.rs");
+    let _ = File::create(&empty_rs).unwrap();
+
+    let args = [empty_rs.to_str().unwrap()];
+    let envs = &[("HOME", fake_home_str)];
+    let (stdout, stderr) = rustfmt_with_extra(&args, Some(fake_home_str), envs);
+
+    // Should pass without any errors
+    assert_eq!(stdout, "");
+    assert_eq!(stderr, "");
+}