Struct Assert 

pub struct Assert<T> { /* private fields */ }

Entry point for the Assert DSL.

Assert provides a fluent API for assertions. An Assert holds the actual value that can be used in assertion statements.

Assert::that(3).is(3);

It takes ownership of self and returns ownership back so that assertions can be chained in fluent manner.

Like in the following example:

Assert::that("foo")
    .is("foo")
    .is_not("bar");

Implementations

impl<T> Assert<T>

where T: Debug,

pub fn is<R>(self, expected: R) -> Self

where T: PartialEq<R>, R: Debug,

Assert that self is equal to the expected value.

Assert::that(2).is(2);
Assert::that(String::from("2")).is(String::from("2"));
Assert::that(String::from("2")).is("2");

Assert::that(2).is(3);

pub fn is_not<R>(self, other: R) -> Self

where T: PartialEq<R>, R: Debug,

Assert that self is not equal to the other value.

Assert::that(2).is_not(3);

Assert::that(2).is_not(2);

pub fn is_gt<R>(self, other: R) -> Self

where T: PartialOrd<R>, R: Debug,

Assert that self is greater than the other value.

Assert::that(3).is_gt(2);

Assert::that(3).is_gt(3);

Assert::that(3).is_gt(4);

pub fn is_ge<R>(self, other: R) -> Self

where T: PartialOrd<R>, R: Debug,

Assert that self is greater than or equal to the other value.

Assert::that(3).is_ge(3);
Assert::that(3).is_ge(2);

Assert::that(3).is_ge(4);

pub fn is_lt<R>(self, other: R) -> Self

where T: PartialOrd<R>, R: Debug,

Assert that self is less than the other value.

Assert::that(3).is_lt(4);

Assert::that(3).is_lt(2);

Assert::that(3).is_lt(3);

pub fn is_le<R>(self, other: R) -> Self

where T: PartialOrd<R>, R: Debug,

Assert that self is less than or equal to the other value.

Assert::that(3).is_le(3);
Assert::that(3).is_le(4);

Assert::that(3).is_le(2);

pub fn satisfies(self, predicate: impl FnOnce(&T) -> bool) -> Self

Assert that the actual value satisfies the given predicate.

Assert::that(4).satisfies(|v| v % 2 == 0);

Assert::that(3).satisfies(|v| v % 2 == 0);

impl<T> Assert<Option<T>>

where T: PartialEq + Debug,

pub fn is_some(self, expected: T) -> Self

Assert that actual is equal to Some expected value.

Assert::that(Some(2)).is_some(2);

Assert::that(None::<i32>).is_some(2);

pub fn is_none(self) -> Self

Assert that actual is equal to None.

Assert::that(None::<i32>).is_none();

Assert::that(Some(2)).is_none();

pub fn unwrap(self) -> Assert<T>

Unwrap the Option value, panic for None.

Assert::that(Some(2)).unwrap().is(2);

Assert::that(None::<i32>).unwrap();

impl<T, E> Assert<Result<T, E>>

where T: Debug, E: Debug,

pub fn is_ok(self) -> Self

Assert that actual is Ok.

let result: Result<i32, i32> = Ok(2);
Assert::that(result).is_ok();

let result: Result<i32, i32> = Err(2);
Assert::that(result).is_ok();

pub fn is_err(self) -> Self

Assert that actual is Err.

let result: Result<i32, i32> = Err(2);
Assert::that(result).is_err();

let result: Result<i32, i32> = Ok(2);
Assert::that(result).is_err();

pub fn unwrap(self) -> Assert<T>

Unwrap the Ok value, panic for Err.

let result: Result<i32, i32> = Ok(2);
Assert::that(result).unwrap().is(2);

let result: Result<i32, i32> = Err(2);
Assert::that(result).unwrap();

pub fn unwrap_err(self) -> Assert<E>

Unwrap the Err value, panic for Ok.

let result: Result<i32, i32> = Err(2);
Assert::that(result).unwrap_err().is(2);

let result: Result<i32, i32> = Ok(2);
Assert::that(result).unwrap_err();

impl Assert<String>

DSL for String.

pub fn starts_with(self, prefix: &str) -> Self

Assert that the actual string starts with the given prefix.

Assert::that(String::from("hello world")).starts_with("hello");

Assert::that(String::from("hello world")).starts_with("world");

pub fn ends_with(self, suffix: &str) -> Self

Assert that the actual string ends with the given suffix.

Assert::that(String::from("hello world")).ends_with("world");

Assert::that(String::from("hello world")).ends_with("hello");

pub fn contains(self, pattern: &str) -> Self

Assert that the actual string contains the given pattern.

Assert::that(String::from("hello world")).contains("lo wo");

Assert::that(String::from("hello world")).contains("xyz");

impl<T> Assert<Vec<T>>

where T: PartialEq + Debug,

DSL for Vec.

pub fn contains(self, expected: &T) -> Self

Assert that the actual vector contains a specific expected value.

Assert::that(vec![1, 2, 3]).contains(&2);

pub fn get(self, index: usize) -> Assert<Option<T>>

Returns an Assert for a value from the Vec.

Assert::that(vec!['a', 'b', 'c']).get(1).is_some('b');
Assert::that(vec!['a', 'b', 'c']).get(5).is_none();

pub fn is_empty(self) -> Self

Assert that the actual vector is empty.

Assert::that(Vec::<i32>::new()).is_empty();

Assert::that(vec![1, 2, 3]).is_empty();

pub fn has_length(self, expected: usize) -> Self

Assert that the actual vector has the given length.

Assert::that(vec![1, 2, 3]).has_length(3);

Assert::that(vec![1, 2, 3]).has_length(2);

impl<T> Assert<T>

pub fn that(actual: T) -> Self

Create an Assert instance for the actual value.

All assertions start with Assert::that(actual).

pub fn map<R>(self, f: impl FnOnce(T) -> R) -> Assert<R>

Maps the actual value using lambda f.

This method is intended to map the actual value in order to apply further assertions.

Assert::that("3")
    .map(|v| v.parse::<i32>().unwrap())
    .is(3);

Assert::that(2).map(|v| v + 2).is(3);