Can mockall be used to mock a fn of an external crate

[zephod77]

Say I have this code:

use zmq::*; 

pub struct S {
   zmq_ctx: zmq::Context,
}
impl S {
    pub fn init(&mut self) -> bool {
        let pub_skt = match self.zmq_ctx.socket(zmq::PUB) {
            Ok(skt) => skt, 
            Err(e) => {println!("Error creating socket: {}", e); return false;},
        };
        true
    }
}

and I want to test the error case where socket creation fails.

#[cfg(test)]
mod the_test {
    use super::*;
    use mockall::*;
    use mockall::predicate::*;

    #[automock]
    pub trait MockSocket {
    }
    pub trait MockZmqContext {
        fn socket (&self, t: i32) -> Result<MockSocket>;
    }

    #[test]
    fn init_test() {
        let mut ctx_mock = MockZmqContext::new();
        let mut pub_skt_mock = MockSocket::new();

        ctx_mock.expect_socket()
            .with(predicate::eq(zmq::PUB))
            .returning(Err("Error"));

        let mut test_obj = S { zmq_ctx: &mut ctx_mock };
        assert!(!test_obj.init());
    }
}

The problem, or at least one problem, is with the definition of the traits and the mock objects. Another is with my understanding of how mockall works. Does

    #[automock]
    pub trait MockSocket {
    }

automatically create a mock of the zmq::Socket stuct? The error I am getting is with the declaration of the socket function in MockZmqContext. The compiler is telling me that I have to put 'dyn' in front of MockSocket because MockSocket is a trait object but that leads to other errors and I think the problem is more fundamental than that.
Can anyone point me to the correct path?

[asomers]

Is zmq::Socket a struct or a trait? Because what you wrote assumes that it's a trait. And if you fix that , then what it will create is a struct with the same API as the real struct, but it can't be passed to functions expecting the real struct. So you need to make the substitution at compile time. First fix your trait/struct confusion and then the next step will be more obvious.

[zephod77]

That what I was trying to do, and obviously failing, by making the socket call return pub_skt_mock instead of MockSocket::new().

[zephod77]

So, @asomers, do you have any other suggestions for this? I can post the full code if you would like.

[asomers]

Like I said, you need to set the expectation on the MockSocket that you return from socket. Do it like this:

ctx_mock.expect_socket()
.with(predicate::eq(zmq::PUB))
.returning(|_| {
    let mut pub_skt_mock = MockSocket::new();
    pub_skt_mock.expect_bind()
    .with(predicate::eq(PUB_ADDR)
    .returning(|_| Ok(()));
    Ok(pub_skt_mock));
});

[zephod77]

Thanks, I would not have come up with that one my own!
The scope of pub_skt_mock is limited to the enclosure but what if my code were to have another external call that I wanted to mock that took both pub_skt and sub_skt, extern_fn(pub_skt, sub_skt);? How would you write the expectation for that?

[asomers]

What do you mean by "the enclosure"? And expeting that other function is easy:

ctx.expect_extern_fn()
    .withf(|pub_skt, sub_skt| /* validate them, if you care to */ true)
    .return_const(())