Update container_shim_test to set PATH via export and envs

Author: lyskov

tests/fixtures/mod.rs

@@ -19,11 +19,10 @@ pub struct ContainerPathShim {
 impl ContainerPathShim {
     pub const BIN_SHIMS: [&str; 3] = ["docker", "singularity", "apptainer"];
 
-
-
     pub fn new() -> Self {
-        let root = std::path::PathBuf::from("target/tmp");
-        eprintln!("root:{root:?}");
+        let root = std::path::PathBuf::from("target/fixtures");
+        std::fs::create_dir_all(&root).expect("create fixtures dir");
+        //eprintln!("root:{root:?}");
         let dir = TempDir::new_in(root).expect("create temp dir");
 
         // add a label directory inside for readability
@@ -61,13 +60,15 @@ impl ContainerPathShim {
     /// Example use in a test:
     /// `let cmd = format!("{} && my-runner ...", shim.export_path_cmd());`
     pub fn export_path_cmd(&self) -> String {
-        format!("export PATH='{}'", self.bin_dir().display())
+        format!("export PATH={}:$PATH", self.bin_dir().display())
     }
 
     /// Returns env overrides you can pass to `std::process::Command` directly.
     /// This mirrors what `export_path_cmd()` would do in a shell.
     pub fn env_overrides(&self) -> [(&'static str, String); 1] {
-        [("PATH", self.bin_dir().display().to_string())]
+        let current_path = std::env::var("PATH").unwrap_or_default();
+        let new_path = format!("{}:{}", self.bin_dir().display(), current_path);
+        [("PATH", new_path)]
     }
 }
 

tests/main.rs

@@ -1,7 +1,5 @@
 mod fixtures;
 
-use std::thread::sleep;
-
 use assert_cmd::cargo::cargo_bin_cmd;
 use assert_cmd::prelude::*;
 use predicates::prelude::*;
@@ -32,32 +30,46 @@ fn no_run_no_app() {
 }
 
 #[test]
-fn shim_test() {
-    let s = fixtures::ContainerPathShim::new();
-    let bin = s.install_all();
+fn container_shim_test() {
+    let fixture = fixtures::ContainerPathShim::new();
+    let bin = fixture.install_all();
 
     // Call each shim with dummy arguments and check the invocation logs
     for shim_name in fixtures::ContainerPathShim::BIN_SHIMS {
         let log_file = bin.join(format!("{}.log", shim_name));
         let shim_path = bin.join(shim_name);
 
-        std::process::Command::new(&shim_path)
-            .args(["arg1", "arg2", "--flag"])
-            .env("TEST_INVOCATIONS_LOG", &log_file)
-            .output()
-            .expect("Failed to execute shim");
-
-        // Read the log file and verify it contains the expected command line
-        let log_contents = std::fs::read_to_string(&log_file).expect("Failed to read log file");
-
-        let expected = format!("{} arg1 arg2 --flag", shim_path.display());
-        assert!(
-            log_contents.trim() == expected,
-            "Log file for {} should contain '{}', but got '{}'",
-            shim_name,
-            expected,
-            log_contents.trim()
-        );
+        for cmd in [
+            std::process::Command::new("sh")
+                .args([
+                    "-c",
+                    &format!(
+                        "{} && {shim_name} arg1 arg2 --flag",
+                        fixture.export_path_cmd()
+                    ),
+                ])
+                .env("TEST_INVOCATIONS_LOG", &log_file),
+            std::process::Command::new(shim_name)
+                .args(["arg1", "arg2", "--flag"])
+                .envs(fixture.env_overrides())
+                .env("TEST_INVOCATIONS_LOG", &log_file),
+        ] {
+            let _r = cmd.output().expect("Failed to execute shim");
+            // eprintln!("{_r:?}");
+
+            // Read the log file and verify it contains the expected command line
+            let log_contents = std::fs::read_to_string(&log_file).expect("Failed to read log file");
+
+            let expected = format!("{} arg1 arg2 --flag", shim_path.display());
+            assert!(
+                log_contents.trim() == expected,
+                "Log file for {} should contain '{}', but got '{}'",
+                shim_name,
+                expected,
+                log_contents.trim()
+            );
+            std::fs::remove_file(&log_file).expect("Failed to delete log file");
+        }
     }
-    //sleep(std::time::Duration::from_secs(60));
+    //std::thread::sleep(std::time::Duration::from_secs(60));
 }