refactor ExecutableMock

Author: soenkehahn

src/lib.rs

@@ -23,6 +23,7 @@ pub mod utils;
 use crate::context::Context;
 use crate::recorder::{hole_recorder::run_against_tests, Recorder};
 use crate::test_checker::executable_mock;
+use crate::test_checker::executable_mock::ExecutableMock;
 use crate::test_spec::yaml::write_yaml;
 use crate::test_spec::Tests;
 use crate::tracer::stdio_redirecting::CaptureStderr;
@@ -80,7 +81,7 @@ pub fn run_main(context: &Context, args: &cli::Args) -> R<ExitCode> {
     Ok(match args {
         cli::Args::ExecutableMock {
             executable_mock_path,
-        } => executable_mock::run(context, &executable_mock_path)?,
+        } => ExecutableMock::run(context, &executable_mock_path)?,
         cli::Args::Scriptkeeper {
             script_path,
             record,
@@ -97,20 +98,19 @@ pub fn run_main(context: &Context, args: &cli::Args) -> R<ExitCode> {
 #[cfg(test)]
 mod run_main {
     use super::*;
-    use executable_mock::create_mock_executable;
+    use crate::test_checker::executable_mock;
     use test_utils::TempFile;
 
     #[test]
     fn when_passed_executable_mock_flag_behaves_like_executable_mock() -> R<()> {
         let context = Context::new_mock();
-        let executable_contents = create_mock_executable(
+        let executable_mock = ExecutableMock::new(
             &context,
             executable_mock::Config {
                 stdout: b"foo".to_vec(),
                 exitcode: 0,
             },
         )?;
-        let executable_mock = TempFile::write_temp_script(&executable_contents)?;
         run_main(
             &context,
             &cli::Args::ExecutableMock {

src/test_checker/executable_mock.rs

@@ -1,44 +1,74 @@
 use crate::context::Context;
+use crate::tracer::tracee_memory;
+use crate::utils::short_temp_files::ShortTempFile;
 use crate::{ExitCode, R};
 use bincode::{deserialize, serialize};
+use libc::user_regs_struct;
+use nix::unistd::Pid;
 use std::fs;
 use std::io::Write;
 use std::os::unix::ffi::OsStrExt;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Config {
     pub stdout: Vec<u8>,
     pub exitcode: i32,
 }
 
-pub fn create_mock_executable(context: &Context, config: Config) -> R<Vec<u8>> {
-    let mut result = b"#!".to_vec();
-    result.append(
-        &mut context
-            .scriptkeeper_executable()
-            .as_os_str()
-            .as_bytes()
-            .to_vec(),
-    );
-    result.append(&mut b" --executable-mock\n".to_vec());
-    result.append(&mut serialize(&config)?);
-    Ok(result)
+#[derive(Debug)]
+pub struct ExecutableMock {
+    temp_file: ShortTempFile,
 }
 
-pub fn run(context: &Context, executable_mock_path: &Path) -> R<ExitCode> {
-    let config: Config = deserialize(&skip_hashbang_line(fs::read(executable_mock_path)?))?;
-    context.stdout().write_all(&config.stdout)?;
-    Ok(ExitCode(config.exitcode))
-}
+impl ExecutableMock {
+    pub fn new(context: &Context, mock_config: Config) -> R<ExecutableMock> {
+        let mut contents = b"#!".to_vec();
+        contents.append(
+            &mut context
+                .scriptkeeper_executable()
+                .as_os_str()
+                .as_bytes()
+                .to_vec(),
+        );
+        contents.append(&mut b" --executable-mock\n".to_vec());
+        contents.append(&mut serialize(&mock_config)?);
+        let temp_file = ShortTempFile::new(&contents)?;
+        Ok(ExecutableMock { temp_file })
+    }
 
-fn skip_hashbang_line(input: Vec<u8>) -> Vec<u8> {
-    input
-        .clone()
-        .into_iter()
-        .skip_while(|char: &u8| *char != b'\n')
-        .skip(1)
-        .collect()
+    pub fn path(&self) -> PathBuf {
+        self.temp_file.path()
+    }
+
+    pub fn poke_for_execve_syscall(
+        pid: Pid,
+        registers: &user_regs_struct,
+        executable_mock_path: PathBuf,
+    ) -> R<()> {
+        tracee_memory::poke_single_word_string(
+            pid,
+            registers.rdi,
+            &executable_mock_path.as_os_str().as_bytes(),
+        )
+    }
+
+    pub fn run(context: &Context, executable_mock_path: &Path) -> R<ExitCode> {
+        let config: Config = deserialize(&ExecutableMock::skip_hashbang_line(fs::read(
+            executable_mock_path,
+        )?))?;
+        context.stdout().write_all(&config.stdout)?;
+        Ok(ExitCode(config.exitcode))
+    }
+
+    fn skip_hashbang_line(input: Vec<u8>) -> Vec<u8> {
+        input
+            .clone()
+            .into_iter()
+            .skip_while(|char: &u8| *char != b'\n')
+            .skip(1)
+            .collect()
+    }
 }
 
 #[cfg(test)]
@@ -48,28 +78,28 @@ mod test {
     use test_utils::TempFile;
 
     #[test]
-    fn renders_an_executable_that_outputs_the_given_stdout() -> R<()> {
-        let mock_executable = TempFile::write_temp_script(&create_mock_executable(
+    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(())
     }
 
     #[test]
-    fn renders_an_executable_that_exits_with_the_given_exitcode() -> R<()> {
-        let mock_executable = TempFile::write_temp_script(&create_mock_executable(
+    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(())

src/test_checker/mod.rs

@@ -9,6 +9,7 @@ use crate::tracer::{tracee_memory, SyscallMock};
 use crate::utils::short_temp_files::ShortTempFile;
 use crate::R;
 use checker_result::CheckerResult;
+use executable_mock::ExecutableMock;
 use libc::{c_ulonglong, user_regs_struct};
 use nix::sys::ptrace;
 use nix::unistd::Pid;
@@ -22,7 +23,7 @@ pub struct TestChecker {
     pub test: Test,
     pub unmocked_commands: Vec<PathBuf>,
     pub result: CheckerResult,
-    temporary_executables: Vec<ShortTempFile>,
+    temporary_executables: Vec<ExecutableMock>,
 }
 
 impl TestChecker {
@@ -62,11 +63,9 @@ impl TestChecker {
                 TestChecker::allow_failing_scripts_to_continue()
             }
         };
-        let mock_executable_contents =
-            executable_mock::create_mock_executable(&self.context, mock_config)?;
-        let temp_executable = ShortTempFile::new(&mock_executable_contents)?;
-        let path = temp_executable.path();
-        self.temporary_executables.push(temp_executable);
+        let executable_mock = ExecutableMock::new(&self.context, mock_config)?;
+        let path = executable_mock.path();
+        self.temporary_executables.push(executable_mock);
         Ok(path)
     }
 
@@ -102,15 +101,11 @@ impl SyscallMock for TestChecker {
             .iter()
             .any(|unmocked_command| test_spec::compare_executables(unmocked_command, &executable));
         if !is_unmocked_command {
-            let mock_executable_path = self.handle_step(test_spec::Command {
+            let executable_mock_path = self.handle_step(test_spec::Command {
                 executable,
                 arguments,
             })?;
-            tracee_memory::poke_single_word_string(
-                pid,
-                registers.rdi,
-                &mock_executable_path.as_os_str().as_bytes(),
-            )?;
+            ExecutableMock::poke_for_execve_syscall(pid, registers, executable_mock_path)?;
         }
         Ok(())
     }