Struct ScriptedRunner 

pub struct ScriptedRunner { /* private fields */ }

A ProcessRunner that returns canned Replys for matched commands.

Rules are tried in registration order; the first match wins. With no match, the fallback reply is used, or an error is returned.

Example

Drive a command through scripted replies — hermetic (no real subprocess), so this example actually runs in cargo test on every OS:

use processkit::{Command, ProcessRunner};
use processkit::testing::{Reply, ScriptedRunner};

let rt = tokio::runtime::Builder::new_current_thread()
    .enable_all()
    .build()
    .unwrap();
rt.block_on(async {
    let runner = ScriptedRunner::new()
        .on(["tool", "--version"], Reply::ok("tool 1.2.3"))
        .fallback(Reply::fail(1, "unexpected command"));

    let out = runner
        .output_string(&Command::new("tool").arg("--version"))
        .await
        .expect("scripted reply");
    assert!(out.is_success());
    assert_eq!(out.stdout().trim(), "tool 1.2.3");
});

Implementations

impl ScriptedRunner

pub fn new() -> Self

An empty runner (every command misses until rules are added).

pub fn on<I, S>(self, prefix: I, reply: Reply) -> Self

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Reply with reply when the command’s program name + arguments start with prefix (the first element is the program). For example .on(["git", "status"]) answers for git status …, not rm status.

pub fn on_sequence<I, S, R>(self, prefix: I, replies: R) -> Self

where I: IntoIterator<Item = S>, S: AsRef<OsStr>, R: IntoIterator<Item = Reply>,

Reply with each of replies in turn — the first match gets the first reply, the second the second, and so on; once exhausted, the last reply repeats forever. The declarative form for retry scenarios (fail once, then succeed), matching a cassette’s “replay in order, then repeat the last” model. Matches like on (program + arg prefix).

The sequence advances once per matching call via a relaxed atomic counter, so the “first call gets reply 0, second gets reply 1, …” ordering is well-defined only for sequential calls. Concurrent calls to the same rule still each get a distinct, in-bounds reply, but which call sees which reply is unspecified — don’t rely on the order across overlapping tasks.

Panics

If replies is empty.

pub fn when<F>(self, predicate: F, reply: Reply) -> Self

where F: Fn(&Command) -> bool + Send + Sync + 'static,

Reply with reply when predicate accepts the command.

pub fn fallback(self, reply: Reply) -> Self

Reply with reply for any command no rule matched.

Trait Implementations

impl Debug for ScriptedRunner

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ScriptedRunner

fn default() -> ScriptedRunner

Returns the “default value” for a type.

impl ProcessRunner for ScriptedRunner

fn start<'life0, 'life1, 'async_trait>( &'life0 self, command: &'life1 Command, ) -> Pin<Box<dyn Future<Output = Result<RunningProcess>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Start a scripted live handle: the canned stdout/stderr flow through the command’s real pump machinery (handlers, encodings, buffer policy), so stdout_lines / wait_for_line / finish behave exactly as on a real child — no subprocess involved.

fn output_string<'life0, 'life1, 'async_trait>( &'life0 self, command: &'life1 Command, ) -> Pin<Box<dyn Future<Output = Result<ProcessResult<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Run command to completion, capturing stdout/stderr and the exit code. A non-zero exit is reported in the result, not raised.

fn output_bytes<'life0, 'life1, 'async_trait>( &'life0 self, command: &'life1 Command, ) -> Pin<Box<dyn Future<Output = Result<ProcessResult<Vec<u8>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Run command to completion, capturing stdout as raw bytes (output_string captures it as lossy-UTF-8 text); stderr is still text. For binary tools — git cat-file, tar -c, an image transcoder — whose stdout is not UTF-8.