implement executable_mock wrapper that executes given commands

Author: soenkehahn

Justfile

@@ -23,6 +23,11 @@ dev:
   clear ; printf "\e[3J"
   cargo test --all --color=always --features 'dev test' -- --test-threads=1 --quiet
 
+unit_test:
+  clear ; printf "\e[3J"
+  cargo build --color=always --features=dev
+  cargo test --lib --all --color=always --features 'dev test' -- --test-threads=1 --quiet
+
 run_bigger:
   cargo run -- tests/examples/bigger/script
 

src/executable_mock.rs

@@ -9,11 +9,12 @@ use std::fs;
 use std::io::Write;
 use std::os::unix::ffi::OsStrExt;
 use std::path::{Path, PathBuf};
+use std::process::Command;
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct Config {
-    pub stdout: Vec<u8>,
-    pub exitcode: i32,
+pub enum Config {
+    Config { stdout: Vec<u8>, exitcode: i32 },
+    Wrapper { executable: PathBuf },
 }
 
 #[derive(Debug)]
@@ -37,6 +38,15 @@ impl ExecutableMock {
         Ok(ExecutableMock { temp_file })
     }
 
+    fn wrapper(context: &Context, executable: &Path) -> R<ExecutableMock> {
+        ExecutableMock::new(
+            context,
+            Config::Wrapper {
+                executable: executable.to_owned(),
+            },
+        )
+    }
+
     pub fn path(&self) -> PathBuf {
         self.temp_file.path()
     }
@@ -57,8 +67,16 @@ impl ExecutableMock {
         let config: Config = deserialize(&ExecutableMock::skip_hashbang_line(fs::read(
             executable_mock_path,
         )?))?;
-        context.stdout().write_all(&config.stdout)?;
-        Ok(ExitCode(config.exitcode))
+        match config {
+            Config::Config { stdout, exitcode } => {
+                context.stdout().write_all(&stdout)?;
+                Ok(ExitCode(exitcode))
+            }
+            Config::Wrapper { executable } => {
+                Command::new(&executable).output()?;
+                Ok(ExitCode(0))
+            }
+        }
     }
 
     fn skip_hashbang_line(input: Vec<u8>) -> Vec<u8> {
@@ -75,33 +93,63 @@ impl ExecutableMock {
 mod test {
     use super::*;
     use std::process::Command;
-    use test_utils::TempFile;
+    use test_utils::{trim_margin, TempFile};
 
-    #[test]
-    fn creates_an_executable_that_outputs_the_given_stdout() -> R<()> {
-        let mock_executable = ExecutableMock::new(
-            &Context::new_mock(),
-            Config {
-                stdout: b"foo".to_vec(),
-                exitcode: 0,
-            },
-        )?;
-        let output = Command::new(mock_executable.path()).output()?;
-        assert_eq!(output.stdout, b"foo");
-        Ok(())
+    mod new {
+        use super::*;
+
+        #[test]
+        fn creates_an_executable_that_outputs_the_given_stdout() -> R<()> {
+            let executable_mock = ExecutableMock::new(
+                &Context::new_mock(),
+                Config::Config {
+                    stdout: b"foo".to_vec(),
+                    exitcode: 0,
+                },
+            )?;
+            let output = Command::new(&executable_mock.path()).output();
+            assert_eq!(output?.stdout, b"foo");
+            Ok(())
+        }
+
+        #[test]
+        fn creates_an_executable_that_exits_with_the_given_exitcode() -> R<()> {
+            let executable_mock = ExecutableMock::new(
+                &Context::new_mock(),
+                Config::Config {
+                    stdout: b"foo".to_vec(),
+                    exitcode: 42,
+                },
+            )?;
+            let output = Command::new(executable_mock.path()).output()?;
+            assert_eq!(output.status.code(), Some(42));
+            Ok(())
+        }
     }
 
-    #[test]
-    fn creates_an_executable_that_exits_with_the_given_exitcode() -> R<()> {
-        let mock_executable = ExecutableMock::new(
-            &Context::new_mock(),
-            Config {
-                stdout: b"foo".to_vec(),
-                exitcode: 42,
-            },
-        )?;
-        let output = Command::new(mock_executable.path()).output()?;
-        assert_eq!(output.status.code(), Some(42));
-        Ok(())
+    mod wrapper {
+        use super::*;
+        use crate::utils::path_to_string;
+        use tempdir::TempDir;
+
+        #[test]
+        fn executes_the_given_command() -> R<()> {
+            let temp_dir = TempDir::new("test")?;
+            let path = temp_dir.path().join("foo.txt");
+            let script = TempFile::write_temp_script(
+                trim_margin(&format!(
+                    "
+                        |#!/usr/bin/env bash
+                        |echo foo > {}
+                    ",
+                    path_to_string(&path)?
+                ))?
+                .as_bytes(),
+            )?;
+            let executable_mock = ExecutableMock::wrapper(&Context::new_mock(), &script.path())?;
+            Command::new(executable_mock.path()).status()?;
+            assert_eq!(String::from_utf8(fs::read(&path)?)?, "foo\n");
+            Ok(())
+        }
     }
 }

src/lib.rs

@@ -106,7 +106,7 @@ mod run_main {
         let context = Context::new_mock();
         let executable_mock = ExecutableMock::new(
             &context,
-            executable_mock::Config {
+            executable_mock::Config::Config {
                 stdout: b"foo".to_vec(),
                 exitcode: 0,
             },

src/test_checker/mod.rs

@@ -7,7 +7,6 @@ use crate::test_spec;
 use crate::test_spec::Test;
 use crate::tracer::stdio_redirecting::Redirector;
 use crate::tracer::{tracee_memory, SyscallMock};
-use crate::utils::short_temp_files::ShortTempFile;
 use crate::R;
 use checker_result::CheckerResult;
 use libc::{c_ulonglong, user_regs_struct};
@@ -38,7 +37,7 @@ impl TestChecker {
     }
 
     fn allow_failing_scripts_to_continue() -> executable_mock::Config {
-        executable_mock::Config {
+        executable_mock::Config::Config {
             stdout: vec![],
             exitcode: 0,
         }
@@ -53,7 +52,7 @@ impl TestChecker {
                         &received.format(),
                     );
                 }
-                executable_mock::Config {
+                executable_mock::Config::Config {
                     stdout: next_test_step.stdout,
                     exitcode: next_test_step.exitcode,
                 }