Struct mimicry::MockRef

pub struct MockRef<T: Mock> { /* private fields */ }

Reference to a mock state used when mocking async functions / methods.

A separate reference type is required because it would be unsound to spill a direct state reference or a reference to Mut across await boundaries. (Internally, such a reference is produced using interior mutability primitives like RefCell.) Instead, MockRef provides access to the state using with() or with_mut() methods that do not overly restrict the lifetime of the state reference.

Examples

Mock with immutable state

#[mock(using = "CountingMock")]
async fn answer() -> u32 { 42 }

#[derive(Default, Mock)]
struct CountingMock(AtomicU32);

impl CheckRealCall for CountingMock {}

impl CountingMock {
    async fn answer(r: MockRef<Self>) -> u32 {
        r.with(|this| this.0.fetch_add(1, Ordering::Relaxed))
    }
}

Mock with mutable state

Also demonstrates spying logic.

#[mock(using = "CountingMock")]
async fn answer() -> u32 { 42 }

#[derive(Default, Mock)]
#[mock(mut)]
struct CountingMock {
    captured_value: Option<u32>,
}

impl CountingMock {
    #[async_recursion] // workaround for `async fn` recursion
    async fn answer(r: MockRef<Self>) -> u32 {
        let captured = r.with_mut(|this| this.captured_value);
        if let Some(captured) = captured {
            captured
        } else {
            let value = r.call_real().async_scope(answer()).await;
            r.with_mut(|this| this.captured_value = Some(value));
            value
        }
    }
}

let guard = CountingMock::default().set_as_mock();
assert_eq!(answer().await, 42);
let captured = guard.into_inner().captured_value;
assert_eq!(captured, Some(42));

Implementations

impl<T: Mock<Base = T>> MockRef<T>

pub fn with<R>(&self, action: impl FnOnce(&T) -> R) -> R

Accesses the underlying mock state.

Panics

Panics if the mock state has gone missing. This is a sign that test code is ill-constructed (e.g., the mock is removed before all mocked calls are made).

impl<T: Mock<Base = Mut<T>>> MockRef<T>

pub fn with_mut<R>(&self, action: impl FnOnce(&mut T) -> R) -> R

Accesses the underlying Mutable mock state.

Panics

Panics if the mock state has gone missing. This is a sign that test code is ill-constructed (e.g., the mock is removed before all mocked calls are made).

Trait Implementations

impl<T> CallReal for MockRef<T>where
    T: Mock,
    T::Base: CallReal,

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: Mock> Clone for MockRef<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Mock> Debug for MockRef<T>where
    T::Shared: Debug,

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

Formats the value using the given formatter.

impl<T: Mock> Copy for MockRef<T>