murf 0.2.0

A mocking and unit test framework for rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

//! The [`action`](self) module contains difference pre-defined actions that may
//! be executed for a call-expectation of a mocked type.

mod invoke;
mod returns;

pub use invoke::{invoke, Invoke};
pub use returns::{return_, return_pointee, return_ref, Return, ReturnPointee, ReturnRef};

/// Trait that defines an action that can only be executed once.
///
/// This is similar to [`FnOnce`] of the standard library.
///
/// The arguments passed to the action are either
/// - a unit `()` for no arguments
/// - a single type `T` for one argument
/// - or a tuple `(T1, T2, ...)` of many arguments
pub trait Action<T, R> {
    /// Execute the action with the passed arguments.
    fn exec(self, args: T) -> R;
}

impl<X, T, R> Action<T, R> for X
where
    X: FnOnce(T) -> R,
{
    fn exec(self, args: T) -> R {
        self(args)
    }
}

/// Like [`Action`] but this action may be called repeatedly.
///
/// This is similar to [`FnMut`] of the standard library.
pub trait RepeatableAction<T, R> {
    /// Execute the action with the passed arguments.
    fn exec(&mut self, args: T) -> R;
}

impl<X, T, R> RepeatableAction<T, R> for X
where
    X: FnMut(T) -> R,
{
    fn exec(&mut self, args: T) -> R {
        self(args)
    }
}

/// Helper type to implement [`RepeatableAction`] for a action that can only be
/// called once. Any further call will panic!
#[derive(Debug)]
pub struct OnetimeAction<X>(Option<X>);

impl<X> OnetimeAction<X> {
    /// Create a new [`OnetimeAction`] instance.
    pub fn new(inner: X) -> Self {
        Self(Some(inner))
    }
}

impl<T, R, X> RepeatableAction<T, R> for OnetimeAction<X>
where
    X: Action<T, R>,
{
    fn exec(&mut self, args: T) -> R {
        self.0
            .take()
            .expect("Action was already executed")
            .exec(args)
    }
}

/// Helper type to implement [`RepeatableAction`] for any action that implements
/// [`Action`] and [`Clone`].
#[derive(Debug)]
pub struct RepeatedAction<X>(X);

impl<X> RepeatedAction<X> {
    /// Create a new [`RepeatedAction`] instance.
    pub fn new(inner: X) -> Self {
        Self(inner)
    }
}

impl<X, T, R> RepeatableAction<T, R> for RepeatedAction<X>
where
    X: Action<T, R> + Clone,
{
    fn exec(&mut self, args: T) -> R {
        self.0.clone().exec(args)
    }
}