Mocking Clone

[flounders]

I have a trait that requires Clone, but I'm having trouble getting it working. I'm not sure what I'm missing, but this is a reduced example I came up with:

pub struct Thing;

pub trait Db: Clone {
    fn get_things(&self) -> Thing;
}

#[cfg(test)]
mod tests {
    use super::*;
    use mockall::mock;

    #[derive(Clone)]
    struct MyDb;

    mock! {
        MyDb {}

        impl Clone for MyDb {
            fn clone(&self) -> Self;
        }

        impl Db for MyDb {
            fn get_things(&self) -> Thing;
        }
    }

    #[test]
    fn clone_test() {
        let db = MockMyDb::new();
        db.clone();
    }
}

With that code when I run cargo test, I get the following:

running 1 test
test tests::clone_test ... FAILED

failures:

---- tests::clone_test stdout ----
thread 'tests::clone_test' panicked at 'MockMyDb::clone(): No matching expectation found', src\lib.rs:15:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::clone_test

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--lib`

I apologize if I missed something in the documentation or didn't find a relevant discussion, but I haven't been able to find anything in my searches and reading.

[asomers]

You did everything correctly, but never wrote any expectations. BTW, you might want to look at https://github.com/asomers/mockall/blob/master/mockall/tests/mock_clone.rs .

[flounders]

Thank you, that worked and now the error makes more sense.

[HaoYang670]

But does the cloned one always have the same behavior as the original one in the example https://github.com/asomers/mockall/blob/master/mockall/tests/mock_clone.rs?

For example, what if I do

#[test]
fn returning() {
    let mut mock0 = MockA::new();
    mock0.expect_clone()
        .returning(MockA::new);
    let _mock1 = mock0.clone()?.clone()?;
}

[asomers]

The cloned mock object is an independent object. It doesn't share any state with the original, and doesn't inherit the original's expectations.