Struct mimicry::Mut

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

A lightweight wrapper around the state (essentially, a RefCell) allowing to easily mutate it in mock code.

Besides access to the state, Mut implements CallReal, thus allowing partial mocks / spies.

Examples

#[mock(using = "CounterMock")]
fn answer() -> usize { 42 }

#[derive(Default, Mock)]
#[mock(mut)] // indicates to use `Mut`
struct CounterMock(usize);

impl CounterMock {
    fn answer(this: &Mut<Self>) -> usize {
        // Note a custom "receiver" instead of `&self`
        this.borrow().0 += 1;
        this.borrow().0
    }
}

let guard = CounterMock::default().set_as_mock();
assert_eq!(answer(), 1);
assert_eq!(answer(), 2);
assert_eq!(answer(), 3);
assert_eq!(guard.into_inner().0, 3);

Implementations

impl<T> Mut<T>

pub fn borrow(&self) -> impl DerefMut<Target = T> + '_

Returns an exclusive reference to the underlying mock.

Beware that while the reference is alive, further calls to functions in the same mock (including indirect ones, e.g., performed from the tested program code) will not be able to retrieve the state via this method; this will result in a panic. To deal with this, you can create short lived state refs a la this.borrow().do_something(), or enclose the reference into an additional scope.

Panics

Panics if a reference to the same mock state is alive, as described above.

Trait Implementations

impl<T> CallReal for Mut<T>

fn call_real(&self) -> RealCallGuard<'_, Self>

Delegates all calls to the mocked functions / methods to the real implementation until the returned RealCallGuard is dropped.

fn call_real_once(&self) -> RealCallGuard<'_, Self>

Delegates the first call to the mocked functions / methods to the real implementation until the returned RealCallGuard is dropped. Further calls will be directed to the mock.

impl<T: Debug> Debug for Mut<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Mut<T>

fn default() -> Mut<T>

Returns the “default value” for a type.

impl<T> From<T> for Mut<T>

fn from(inner: T) -> Self

Converts to this type from the input type.