Struct Runcmd

pub struct Runcmd { /* private fields */ }

The Runcmd context gives a step function access to the ability to run subprocesses as part of a scenario. These subprocesses are run with various environment variables set, and we record the stdout/stderr of the most recent-to-run command for testing purposes.

Implementations

impl Runcmd

pub fn prepend_to_path<S: Into<OsString>>(&mut self, element: S)

Prepend the given location to the run path

pub fn stdout_as_string(&self) -> String

Retrieve the last run command’s stdout as a string.

This does a lossy conversion from utf8 so should always succeed.

pub fn stderr_as_string(&self) -> String

Retrieve the last run command’s stderr as a string.

This does a lossy conversion from utf8 so should always succeed.

pub fn setenv<K: Into<OsString>, V: Into<OsString>>(&mut self, key: K, value: V)

Set an env var in the Runcmd context

This sets an environment variable into the Runcmd context for use during execution

pub fn getenv<K: AsRef<OsStr>>(&self, key: K) -> Option<&OsStr>

Get an env var from the Runcmd context

This retrieves a set environment variable from the Runcmd context

pub fn unsetenv<K: AsRef<OsStr>>(&mut self, key: K) -> bool

Unset an env var in the Runcmd context

This removes an environment variable (if set) from the Runcmd context and returns whether or not it was removed.

pub fn join_paths(&self) -> Result<OsString, JoinPathsError>

Join the PATH environment variable and the paths attribute together properly.

This prepends the paths (in reverse order) to the PATH environment variable and then returns it.

If there is no PATH in the stored environment then the resultant path will be entirely made up of the pushed path elements

let mut rc = Runcmd::default();

assert_eq!(rc.join_paths().unwrap(), "");

rc.setenv("PATH", "one");
assert_eq!(rc.join_paths().unwrap(), "one");

rc.prepend_to_path("two");
assert_eq!(rc.join_paths().unwrap(), "two:one");

rc.unsetenv("PATH");
assert_eq!(rc.join_paths().unwrap(), "two");

rc.prepend_to_path("three");
assert_eq!(rc.join_paths().unwrap(), "three:two");

rc.setenv("PATH", "one");
assert_eq!(rc.join_paths().unwrap(), "three:two:one");

pub fn with_forklock<F, R>(&mut self, func: F) -> Result<R, StepError>

where F: FnOnce() -> Result<R, StepError>,

Perform an operation with the fork-lock held.

In order to prevent races where one scenario creates a file which is related to executables, and another forks, defeating the sequencing of creation and cleanup, the runcmd core will hold the fork lock while creating subprocesses.

The implied contract therefore is that any step involved in the creation of an executable in-process must hold the fork-lock for the duration of the any code involved in the creation of it which has file descriptors open. For example, the writing out of a script file

Trait Implementations

impl ContextElement for Runcmd

fn scenario_starts(&mut self) -> StepResult

Scenario starts

fn created(&mut self, scenario: &Scenario)

A new context element was created.

fn scenario_stops(&mut self) -> StepResult

Scenario stops

fn step_starts(&mut self, step_title: &str) -> StepResult

Entry to a step function

fn step_stops(&mut self) -> StepResult

Exit from a step function

impl Debug for Runcmd

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

Formats the value using the given formatter.

impl Default for Runcmd

fn default() -> Runcmd

Returns the “default value” for a type.