Feature Request: use real implementation in some struct methods

[alordash]

Hi!
First of all - thank you for your crate, really helpful and easy to use.

I want the ability to write tests like this:

struct Foo;
impl Foo {
    pub fn work(&self) { self.extra_work(); }
    fn extra_work(&self) {}
}

#[cfg(test)]
mod tests {
    fn work_calls_extra_work() {
        // Arrange
        let foo = FooMock::new();

        // Act
        foo.work();

        // Assert
        foo.expect_extra_work.times(1);
    }
}

However this will not currently work because foo.work() would call mock's implementation that does nothing. To fix it I imagine we'd need something like this:

fn work_calls_extra_work() {
    // Arrange
    let foo = FooMock::new();
    foo.work().call_impl(); // tell mockall that this method must call real method's implementation

    // Act
    foo.work();

    // Assert
    foo.expect_extra_work.times(1);
}

Is it possible to add something like that? I would gladly help to implement it if you think that it can be done.

I imagine it would require storing _impl: Option<Foo> in FooMock and also adding some way to pass Foos constructor arguments to FooMock::new().

This is analog to CallBase() method from C#'s mocking framework Moq. (https://stackoverflow.com/a/31968342)

[asomers]

No, Mockall will never add a feature like that. It's much too hard to make it work. You've already realized the necessity to store a Option<Foo> within the FooMock. That's hard enough. But there are extra complications. What if Foo doesn't have a new method, but is instead constructed in some other way? What if Foo::work itself calls a method that you want to be mocked? What about recursion? What if Foo doesn't implement Default? Then MockFoo won't be able to.

Instead, when you find yourself in a situation like this, you should take it as a clue that your code is structured wrong. Instead of half-mocking a structure, you should split your code up into more clearly defined layers, where a real outer structure is tested by means of a mock inner structure. In your case, that might look like this:

mod inner {
    #[automock]
    pub struct Inner {
        pub fn extra_work(&self) {...}
    }
}

#[mockall_double::double]
use inner::Inner;

struct Foo(Inner);
impl Foo {
    pub fn work(&self) { self.0.extra_work(); }
}

Hope that suggestion helps.

[alordash]

I understand, I expected it to be a hard feature to implement.

Instead of half-mocking a structure, you should split your code up into more clearly defined layers

Yes, I know that, but I just don't want to create separate layer for each time when struct's function calls another function of this struct and when all these internal functions aren't planned to be used anywhere else except in this half-mocked struct. I'm basically doing opposite - group together a lot of different layers to keep everything related to particular functionality close to each other.

Anyway, thanks for answer and suggestion!

[alordash]

By the way, perhaps you know another library that is capable of doing half-mocks?

[alordash]

Looks like this crate offers functionality that I want with mock.set_fallback function: https://crates.io/crates/mock_derive

[asomers]

BTW, if you're interested in other Rust mocking libraries, I wrote this article a while back comparing them. But be advised: I haven't updated it for several years.
https://asomers.github.io/mock_shootout/