1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112

//! Subprocesses spawned by runners

mod exit_status;
mod streams;

pub use self::{
    exit_status::ExitStatus,
    streams::{OutputStream, Stderr, Stdout},
};

use crate::{
    FrameworkError,
    FrameworkErrorKind::{ProcessError, TimeoutError},
};
use std::{
    io::{self, Write},
    process::{Child, ChildStdin},
    sync::MutexGuard,
    time::Duration,
};
use wait_timeout::ChildExt;

/// Mutex guard for a subprocess
pub(super) type Guard<'cmd> = MutexGuard<'cmd, ()>;

/// Subprocess under test spawned by `CargoRunner` or `CmdRunner`
#[derive(Debug)]
pub struct Process<'cmd> {
    /// Child process
    child: Child,

    /// Timeout after which process should complete
    timeout: Duration,

    /// Standard output (if captured)
    stdout: Option<Stdout>,

    /// Standard error (if captured)
    stderr: Option<Stderr>,

    /// Standard input
    stdin: ChildStdin,

    /// Optional mutex guard ensuring exclusive access to this process
    guard: Option<Guard<'cmd>>,
}

impl<'cmd> Process<'cmd> {
    /// Create a process from the given `Child`.
    ///
    /// This gets invoked from `CargoRunner::run`
    pub(super) fn new(mut child: Child, timeout: Duration, guard: Option<Guard<'cmd>>) -> Self {
        let stdout = child.stdout.take().map(Stdout::new);
        let stderr = child.stderr.take().map(Stderr::new);
        let stdin = child.stdin.take().unwrap();

        Self {
            child,
            timeout,
            stdout,
            stderr,
            stdin,
            guard,
        }
    }

    /// Gets a handle to the child's stdout.
    ///
    /// Panics if the child's stdout isn't captured (via `capture_stdout`)
    pub fn stdout(&mut self) -> &mut Stdout {
        self.stdout
            .as_mut()
            .expect("child stdout not captured (use 'capture_stdout' method)")
    }

    /// Gets a handle to the child's stderr.
    ///
    /// Panics if the child's stderr isn't captured (via `capture_stderr`)
    pub fn stderr(&mut self) -> &mut Stderr {
        self.stderr
            .as_mut()
            .expect("child stderr not captured (use 'capture_stderr' method)")
    }

    /// Wait for the child to exit
    pub fn wait(mut self) -> Result<ExitStatus<'cmd>, FrameworkError> {
        match self.child.wait_timeout(self.timeout)? {
            Some(status) => {
                let code = status.code().ok_or_else(|| {
                    format_err!(ProcessError, "no exit status returned from subprocess!")
                })?;

                Ok(ExitStatus::new(code, self.guard))
            }
            None => fail!(
                TimeoutError,
                "operation timed out after {} seconds",
                self.timeout.as_secs()
            ),
        }
    }
}

impl<'cmd> Write for Process<'cmd> {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        self.stdin.write(buf)
    }

    fn flush(&mut self) -> io::Result<()> {
        self.stdin.flush()
    }
}