Mockall with Any: How to use "self" in returning

[richardzone]

Apologies for bother again, but here's the thing I'd like to achieve:

use std::any::Any;

use mockall::{automock, mock, predicate::*};

#[automock]
pub trait Task {
    fn execute(&self) -> Result<(), Box<dyn std::error::Error>>;
    fn as_any(&self) -> &dyn Any;
}

mock!{
    pub OtherTask{}
    impl Task for OtherTask {
        fn execute(&self) -> Result<(), Box<dyn std::error::Error>>;
    }
}

impl Task for MockOtherTask {
    fn as_any(&self) -> &dyn Any {
        self
    }
}

struct RealTask;
impl Task for RealTask {
    fn execute(&self) -> Result<(), Box<dyn std::error::Error>> {
        Ok(())
    }
    fn as_any(&self) -> &dyn Any {
        self
    }
}

pub fn get_task<T: Task + Any>(tasks: &[Box<dyn Task>]) -> Option<&T> {
    tasks
        .iter()
        .find_map(|task| task.as_any().downcast_ref::<T>())
}

#[test]
fn test() {
    let task = MockTask::new();
    let other_task = MockOtherTask::new();
    let tasks: Vec<Box<dyn Task>> = vec![Box::new(task), Box::new(other_task)];

    // How do I return self like in RealTask?
    task.expect_as_any().return_var(task);

    // Test whether get_task can get the correct item of Task from tasks
    assert_eq!(get_task::<MockTask>(&tasks).type_id(), Some(&task).unwrap().type_id());
}

I have trouble trying to get above to compile. The error is pretty weird, as it seems like it cannot find returning_st or return_once:

error[E0599]: no method named `return_once` found for mutable reference `&mut __mock_MockTask_Task::__as_any::Expectation` in the current scope
  --> src/main.rs:36:26
   |
36 |     task.expect_as_any().return_once(|| task);
   |                          ^^^^^^^^^^^ help: there is an associated function with a similar name: `return_const`

[asomers]

The return_once method does not exist for methods that return a non-static reference. Instead, they only have return_const, and the expectation must own the referent. That makes your use case pretty hard. I've never tried to mock a method that needs to return &self. But the following should definitely work:

task.expect_as_any().return_const(MockTask::new());

For unusual requirements, it's often best to manually implement the tricky method, like this for example:

mock!{
    pub OtherTask{
        fn as_any_priv(&self);
    }
}
impl Task for MockOtherTask {
    fn as_any(&self) -> &dyn Any {
        self.as_any_priv();
        self
    }
}

The as_any_priv method only exists so you can still set expectations for stuff like call counts. You can leave it out if you don't need it.

[richardzone]

Hmm I tried manually implement as_any, but got:

error[E0119]: conflicting implementations of trait `Task` for type `MockOtherTask`
  --> src/main.rs:11:1
   |
11 | mock!{
   | ^^^^^ conflicting implementation for `MockOtherTask`
...
18 | impl Task for MockOtherTask {
   | --------------------------- first implementation here
   |
   = note: this error originates in the macro `mock` (in Nightly builds, run with -Z macro-backtrace for more info)

I think this is because trait Task actually have more than 1 method - I have updated the code in original post to reflect this. My understanding is I cannot have a mock! block for a Trait (which has several methods) and just manually implement one of these methods. Am I correct?

[asomers]

Correct. You can't have an impl Trait for block anywhere that doesn't have all of the trait's methods. So you'll have to remove it from the mock! and implement it manually. Or, you can create a default implementation of as_any, if you don't care about verifying call counts.

[richardzone]

I can't use default implementation of as_any on trait Task either because of object safety (I won't be able to make Task as trait objects).

Thanks for the help!