Struct unimock::Unimock

pub struct Unimock { /* private fields */ }

A type whose purpose is to provide mocked behaviour for the traits that it implements.

All traits implemented by Unimock can be considered mock implementations, except marker traits, Clone and Drop.

The mock configuration is specified up front, as a constructor argument in the form of a simple or compound Clause. After instantiation, the unimock configuration is immutable.

Unimock implements Send and Sync, and is therefore thread safe.

Unimock is meant to be used as a testing utility. Using it for other purposes is not recommended.

Clone semantics

Calling clone on unimock creates a derived object which shares internal state with the original.

Unimock runs post-test verifications automatically upon drop (it is a RAII utility). Interaction verifications should be performed only after all expected interactions have completed. Because of this, only the original instance will run any verifications upon being dropped, and when dropping the original instance, it is an error if there are derived objects still alive. In a typical testing context, this scenario usually means that a spawned thread (that owns a derived Unimock) has escaped the test. Unimock will panic with an appropriate message if this is detected.

This detection is usually reliable. Unimock will also induce a panic if the original instance gets dropped in a thread that does not equal the creator thread. Therefore, Unimock should always be cloned before sending off to another thread.

Implementations

impl Unimock

pub fn new(setup: impl Clause) -> Self

Construct a unimock instance which strictly adheres to the description in the passed Clause.

Every call hitting the instance must be declared in advance as a clause, or else panic will ensue.

Example

#[unimock(api=TraitMock)]
trait Trait {
    fn foo(&self) -> &'static str;
}

let mocked = Unimock::new(TraitMock::foo.some_call(matching!()).returns("mocked"));

assert_eq!("mocked", mocked.foo());

pub fn new_partial(setup: impl Clause) -> Self

Construct a unimock instance using partial mocking.

In a partially mocked environment, every clause acts as an override over the default behaviour, which is to hit “real world” code. Trait methods which support the unmock feature get this behaviour automatically in a partial mock, unless explicitly overridden in the passed Clause.

Methods that cannot be unmocked still need to be explicitly mocked with a clause.

Example

#[unimock(api=TraitMock, unmock_with=[real_foo])]
trait Trait {
    fn foo(&self) -> &'static str;
}

fn real_foo(_: &impl std::any::Any) -> &'static str {
    "real thing"
}

// A partial mock with no overrides:
assert_eq!("real thing", Unimock::new_partial(()).foo());

// A partial mock that overrides the behaviour of `Trait::foo`:
let clause = TraitMock::foo.next_call(matching!()).returns("mocked");
assert_eq!("mocked", Unimock::new_partial(clause).foo());

Trait Implementations

impl Clone for Unimock

fn clone(&self) -> Unimock

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Drop for Unimock

fn drop(&mut self)

Executes the destructor for this type.