Struct snapbox::cmd::OutputAssert

pub struct OutputAssert { /* private fields */ }

Assert the state of a Command’s Output.

Create an OutputAssert through the Command::assert.

Implementations

impl OutputAssert

pub fn new(output: Output) -> Self

Create an Assert for a given Output.

pub fn with_assert(self, config: Assert) -> Self

Customize the assertion behavior

pub fn get_output(&self) -> &Output

Access the contained Output.

pub fn success(self) -> Self

Ensure the command succeeded.

use snapbox::cmd::Command;
use snapbox::cmd::cargo_bin;

let assert = Command::new(cargo_bin("snap-fixture"))
    .assert()
    .success();

pub fn failure(self) -> Self

Ensure the command failed.

use snapbox::cmd::Command;
use snapbox::cmd::cargo_bin;

let assert = Command::new(cargo_bin("snap-fixture"))
    .env("exit", "1")
    .assert()
    .failure();

pub fn interrupted(self) -> Self

Ensure the command aborted before returning a code.

pub fn code(self, expected: i32) -> Self

Ensure the command returned the expected code.

use snapbox::cmd::Command;
use snapbox::cmd::cargo_bin;

let assert = Command::new(cargo_bin("snap-fixture"))
    .env("exit", "42")
    .assert()
    .code(42);

pub fn stdout_eq(self, expected: impl Into<Data>) -> Self

Ensure the command wrote the expected data to stdout.

use snapbox::cmd::Command;
use snapbox::cmd::cargo_bin;

let assert = Command::new(cargo_bin("snap-fixture"))
    .env("stdout", "hello")
    .env("stderr", "world")
    .assert()
    .stdout_eq("hello");

pub fn stdout_eq_path(self, expected_path: impl AsRef<Path>) -> Self

Ensure the command wrote the expected data to stdout.

use snapbox::cmd::Command;
use snapbox::cmd::cargo_bin;

let assert = Command::new(cargo_bin("snap-fixture"))
    .env("stdout", "hello")
    .env("stderr", "world")
    .assert()
    .stdout_eq_path("tests/snapshots/output.txt");

pub fn stdout_matches(self, expected: impl Into<Data>) -> Self

Ensure the command wrote the expected data to stdout.

use snapbox::cmd::Command;
use snapbox::cmd::cargo_bin;

let assert = Command::new(cargo_bin("snap-fixture"))
    .env("stdout", "hello")
    .env("stderr", "world")
    .assert()
    .stdout_matches("he[..]o");

pub fn stdout_matches_path(self, expected_path: impl AsRef<Path>) -> Self

Ensure the command wrote the expected data to stdout.

use snapbox::cmd::Command;
use snapbox::cmd::cargo_bin;

let assert = Command::new(cargo_bin("snap-fixture"))
    .env("stdout", "hello")
    .env("stderr", "world")
    .assert()
    .stdout_matches_path("tests/snapshots/output.txt");

pub fn stderr_eq(self, expected: impl Into<Data>) -> Self

Ensure the command wrote the expected data to stderr.

use snapbox::cmd::Command;
use snapbox::cmd::cargo_bin;

let assert = Command::new(cargo_bin("snap-fixture"))
    .env("stdout", "hello")
    .env("stderr", "world")
    .assert()
    .stderr_eq("world");

pub fn stderr_eq_path(self, expected_path: impl AsRef<Path>) -> Self

Ensure the command wrote the expected data to stderr.

use snapbox::cmd::Command;
use snapbox::cmd::cargo_bin;

let assert = Command::new(cargo_bin("snap-fixture"))
    .env("stdout", "hello")
    .env("stderr", "world")
    .assert()
    .stderr_eq_path("tests/snapshots/err.txt");

pub fn stderr_matches(self, expected: impl Into<Data>) -> Self

Ensure the command wrote the expected data to stderr.

use snapbox::cmd::Command;
use snapbox::cmd::cargo_bin;

let assert = Command::new(cargo_bin("snap-fixture"))
    .env("stdout", "hello")
    .env("stderr", "world")
    .assert()
    .stderr_matches("wo[..]d");

pub fn stderr_matches_path(self, expected_path: impl AsRef<Path>) -> Self

Ensure the command wrote the expected data to stderr.

use snapbox::cmd::Command;
use snapbox::cmd::cargo_bin;

let assert = Command::new(cargo_bin("snap-fixture"))
    .env("stdout", "hello")
    .env("stderr", "world")
    .assert()
    .stderr_matches_path("tests/snapshots/err.txt");