test: stabilize interpreter subprocess fixtures (Fixes #557)

Use a stable shell with inline commands instead of executing freshly written files that can fail with ETXTBSY under concurrent tests. Preserve typed runner diagnostics and strengthen outcome assertions without changing production fallback behavior.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: karthiknadig

.github/skills/rust-coding-skill/SKILL.md

@@ -93,4 +93,8 @@ assert_eq!(reads.load(Ordering::Relaxed), 1);
 
 For parser helpers, include malformed input, non-ASCII surrounding data, and case variations. For diagnostics, test pattern classification and expansion filtering separately. Keep temp paths unique with `tempfile` or process/counter-based names.
 
-Before every Rust commit, run targeted tests and invoke the `rust-precommit` skill. Keep that skill as the single source of truth for required format and Clippy commands.
+Before every Rust commit, run targeted tests and invoke the `rust-precommit` skill. Keep that skill as the single source of truth for required format and Clippy commands.
+
+## Learnings
+
+Do not execute freshly written scripts as concurrent Unix subprocess fixtures: spawning can fail with `ETXTBSY` (Text file busy). Prefer an existing interpreter such as `/bin/sh -c` with an inline script, or the existing test executable. Assert the typed runner outcome before checking an optional parsed result, so a spawn failure cannot masquerade as a successful negative parsing or timeout test.

crates/pet-python-utils/src/env.rs

@@ -6,6 +6,7 @@ use pet_core::{arch::Architecture, env::PythonEnv, python_environment::PythonEnv
 use serde::{Deserialize, Serialize};
 use std::{
     path::{Path, PathBuf},
+    process::{Command, Output},
     time::{Duration, SystemTime},
 };
 
@@ -101,12 +102,20 @@ fn get_interpreter_details(executable: &Path) -> Option<ResolvedPythonEnv> {
 fn get_interpreter_details_with_timeout(
     executable: &Path,
     timeout: Duration,
+) -> Option<ResolvedPythonEnv> {
+    get_interpreter_details_with_runner(executable, timeout, output)
+}
+
+fn get_interpreter_details_with_runner(
+    executable: &Path,
+    timeout: Duration,
+    run: impl FnOnce(&mut Command, Duration) -> Result<Output, ProcessError>,
 ) -> Option<ResolvedPythonEnv> {
     // Spawn the python exe and get the version, sys.prefix and sys.executable.
     let executable = executable.to_str()?;
     let start = SystemTime::now();
     trace!("Executing Python: {} -c {}", executable, PYTHON_INFO_CMD);
-    let result = output(
+    let result = run(
         new_silent_command(executable).args(["-c", PYTHON_INFO_CMD]),
         timeout,
     );
@@ -194,45 +203,80 @@ fn parse_interpreter_output(
 #[cfg(all(test, unix))]
 mod tests {
     use super::*;
-    use std::{os::unix::fs::PermissionsExt, time::Instant};
+    use std::time::Instant;
 
     // https://github.com/microsoft/python-environment-tools/issues/525:
     // A launcher printing GBK-encoded "文件不存在" must not panic discovery.
     #[test]
-    fn get_interpreter_details_handles_non_utf8_stdout() -> std::io::Result<()> {
-        let directory = tempfile::tempdir()?;
-        let executable = directory.path().join("python");
-        std::fs::write(
-            &executable,
-            "#!/bin/sh\nprintf '\\316\\304\\274\\376\\262\\273\\264\\346\\324\\332: -c\\r\\n'\n",
-        )?;
-        std::fs::set_permissions(&executable, std::fs::Permissions::from_mode(0o755))?;
-        let result = get_interpreter_details_with_timeout(&executable, Duration::from_secs(5));
+    fn get_interpreter_details_handles_non_utf8_stdout() {
+        let result = get_interpreter_details_with_runner(
+            Path::new("/bin/sh"),
+            Duration::from_secs(5),
+            |command, timeout| {
+                assert_eq!(command.get_program(), "/bin/sh");
+                assert!(command.get_args().eq(["-c", PYTHON_INFO_CMD]));
+                let result = output(
+                    new_silent_command("/bin/sh").args([
+                        "-c",
+                        r"printf '\316\304\274\376\262\273\264\346\324\332: -c\r\n'",
+                    ]),
+                    timeout,
+                )
+                .expect("non-UTF-8 interpreter fixture runner must complete");
+                assert!(result.status.success());
+                assert_eq!(
+                    result.stdout,
+                    b"\xce\xc4\xbc\xfe\xb2\xbb\xb4\xe6\xd4\xda: -c\r\n"
+                );
+                Ok(result)
+            },
+        );
         assert!(result.is_none());
-        directory.close()
     }
 
     #[test]
     fn noisy_interpreter_output_resolves_only_on_success() {
-        let directory = tempfile::tempdir().unwrap();
-        let executable = directory.path().join("python");
         let payload = format!(
             "{}\n{}",
             PYTHON_INFO_JSON_SEPARATOR,
             r#"{"version":"3.13.1","sys_prefix":"prefix","executable":"python","is64_bit":true}"#
         );
         for exit_code in [0, 23] {
             let script = format!(
-                "#!/bin/sh\nprintf '%s' '{}' >&2\nprintf '\\377\\376%s\\n' '{}'\nexit {exit_code}\n",
-                "x".repeat(128 * 1024), payload
+                r#"i=0
+while [ "$i" -lt 128 ]; do
+    printf '%1024s' '' >&2
+    i=$((i + 1))
+done
+printf '\377\376%s\n' '{payload}'
+exit {exit_code}
+"#
             );
-            std::fs::write(&executable, script).unwrap();
-            std::fs::set_permissions(&executable, std::fs::Permissions::from_mode(0o755)).unwrap();
             let started = Instant::now();
-            let result = get_interpreter_details_with_timeout(&executable, Duration::from_secs(5));
+            let result = get_interpreter_details_with_runner(
+                Path::new("/bin/sh"),
+                Duration::from_secs(5),
+                |command, timeout| {
+                    assert_eq!(command.get_program(), "/bin/sh");
+                    assert!(command.get_args().eq(["-c", PYTHON_INFO_CMD]));
+                    let result =
+                        output(new_silent_command("/bin/sh").args(["-c", &script]), timeout)
+                            .expect("noisy interpreter fixture runner must complete");
+                    assert_eq!(result.status.code(), Some(exit_code));
+                    assert_eq!(result.stderr.len(), 128 * 1024);
+                    assert!(result.stdout.starts_with(&[0xff, 0xfe]));
+                    assert_eq!(&result.stdout[2..], format!("{payload}\n").as_bytes());
+                    Ok(result)
+                },
+            );
             assert!(started.elapsed() < Duration::from_secs(5));
             if exit_code == 0 {
-                assert_eq!(result.unwrap().version, "3.13.1");
+                assert_eq!(
+                    result
+                        .expect("successful noisy interpreter fixture must resolve")
+                        .version,
+                    "3.13.1"
+                );
             } else {
                 assert!(
                     result.is_none(),
@@ -242,34 +286,28 @@ mod tests {
         }
     }
 
-    /// Regression test for #463: a spawn that never exits must not block the
-    /// resolve path indefinitely. We use a shell script that sleeps far longer
-    /// than the test timeout and assert that the call returns None promptly
-    /// (well under the script's sleep duration).
+    /// Regression test for #463: a spawn that never exits must not block resolve.
     #[test]
     fn get_interpreter_details_times_out_on_hanging_executable() {
-        let tmp_dir = std::env::temp_dir().join(format!(
-            "pet_resolve_timeout_{}_{}",
-            std::process::id(),
-            std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .unwrap()
-                .as_nanos()
-        ));
-        std::fs::create_dir_all(&tmp_dir).unwrap();
-        let fake_exe = tmp_dir.join("hangs");
-        std::fs::write(&fake_exe, "#!/bin/sh\nexec sleep 60\n").unwrap();
-        let mut perms = std::fs::metadata(&fake_exe).unwrap().permissions();
-        perms.set_mode(0o755);
-        std::fs::set_permissions(&fake_exe, perms).unwrap();
-
         let start = Instant::now();
-        let result = get_interpreter_details_with_timeout(&fake_exe, Duration::from_millis(200));
+        let result = get_interpreter_details_with_runner(
+            Path::new("/bin/sh"),
+            Duration::from_millis(200),
+            |command, timeout| {
+                assert_eq!(command.get_program(), "/bin/sh");
+                assert!(command.get_args().eq(["-c", PYTHON_INFO_CMD]));
+                let result = output(
+                    new_silent_command("/bin/sh").args(["-c", "exec sleep 60"]),
+                    timeout,
+                );
+                assert!(
+                    matches!(&result, Err(ProcessError::Timeout(_))),
+                    "{result:?}"
+                );
+                result
+            },
+        );
         let elapsed = start.elapsed();
-
-        let _ = std::fs::remove_file(&fake_exe);
-        let _ = std::fs::remove_dir(&tmp_dir);
-
         assert!(result.is_none(), "hanging spawn must return None");
         assert!(
             elapsed < Duration::from_secs(3),