How do I mock a trait with functions that have a trait bound in its argument?

[chitoku-k]

Let's say I want to mock Service::get_by_ids() in the following and test Application::run():

struct Foo;
struct FooId(u32);

#[cfg_attr(test, mockall::automock)]
trait Service: Send + Sync + 'static {
    fn get_by_ids<T>(&self, ids: T) -> Vec<Foo>
    where
        T: IntoIterator<Item = FooId> + Send + Sync + 'static;
}

struct Application<T> {
    service: T,
}

impl<T> Application<T>
where
    T: Service,
{
    fn new(service: T) -> Self {
        Self { service }
    }

    fn run(&self, ids: Vec<u32>) {
        let ids = ids.into_iter().map(|id| FooId(id));
        self.service.get_by_ids(ids);
    }
}

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

    #[test]
    fn run() {
        let mut mock_service = MockService::new();
        mock_service
            .expect_get_by_ids::</* no idea what could be written here */>()
            .returning(|_| Vec::new());

        let application = Application::new(mock_service);
        application.run(vec![1, 2, 3, 4]);
    }
}

I'd like to test this while get_by_ids() being mocked, but neither of the following does not work:

• std::iter::Map<std::vec::IntoIter<u32>, fn(u32) -> FooId>
  • ends up with No matching expectation found
• core::iter::adapters::map::Map<alloc::vec::into_iter::IntoIter<u32>, fn(u32) -> FooId>
  • This is extracted from the output of std::any::type_name() but it doesn't compile as core::iter::adapters is a private module

How do I mock this, hopefully without writing a concrete type name that represents implementation? Thanks!

mockall: 0.11.1
rustc: 1.62.0 (a8314ef7d 2022-06-27)
Rust edition: 2021

[asomers]

On Mon, Jul 4, 2022 at 6:02 AM Chitoku ***@***.***> wrote: Let's say I want to mock Service::get_by_ids() in the following and test Application::run(): struct Foo;struct FooId(u32); #[cfg_attr(test, mockall::automock)]trait Service: Send + Sync + 'static { fn get_by_ids<T>(&self, ids: T) -> Vec<Foo> where T: IntoIterator<Item = FooId> + Send + Sync + 'static; } struct Application<T> { service: T, } impl<T> Application<T>where T: Service, { fn new(service: T) -> Self { Self { service } } fn run(&self, ids: &[u32]) { let ids = ids.into_iter().map(|id| FooId(id)); self.service.get_by_ids(ids); } } #[cfg(test)]mod tests { use super::*; #[test] fn run() { let mut mock_service = MockService::new(); mock_service .expect_get_by_ids::</* no idea what could be written here */>() .returning(|_| Vec::new()); let application = Application::new(mock_service); application.run(&[1, 2, 3, 4]); } } I'd like to test this while get_by_ids() being mocked, but neither of the following does not work: - std::iter::Map<std::vec::IntoIter<u32>, fn(u32) -> FooId> - ends up with No matching expectation found - core::iter::adapters::map::Map<alloc::vec::into_iter::IntoIter<u32>, fn(u32) -> FooId> - This is extracted from the output of std::any::type_name() but it doesn't compile as core::iter::adapters is a private module How do I mock this, hopefully without writing a concrete type name that represents implementation. Thanks! mockall: 0.11.1 rustc: 1.62.0 (a8314ef7d 2022-06-27) Rust edition: 2021 Message ID: ***@***.***>

Try this: ```rust let ids: i32 = ids.into_iter().map(|id| FooId(id)); self.service.get_by_ids(ids); ``` The compiler's error message should show you what the correct type name is. And if it includes something like `core::iter` that won't compile, try replacing it with `std::iter`.

[chitoku-k]

Thank you for the quick answer!

As I tested further based on your suggestion, the culprit seems to be how a closure is interpreted. As an experiment I changed the implementation not to use .map() but instead .rev() to find out the root cause:

        let ids = ids.into_iter().rev();

and the annotation becomes std::iter::Rev<std::vec::IntoIter<FooId>>

        mock_service
            .expect_get_by_ids::<std::iter::Rev<std::vec::IntoIter<FooId>>>()
            .returning(|_| Vec::new());

then the mocking succeeds; however, once I use a closure or even a function, the compiler emits an error message in a way that a programmer cannot directly embed in Rust code:

   = note: expected type `i32`
            found struct `std::iter::Map<std::vec::IntoIter<u32>, [closure@src/main.rs:58:42: 58:54]>`

   = note: expected type `i32`
            found struct `std::iter::Map<std::vec::IntoIter<u32>, fn(u32) -> FooId {convert_u32_to_foo_id_func}>`

[asomers]

On Mon, Jul 4, 2022 at 8:18 AM Chitoku ***@***.***> wrote: Thank you for the quick answer! As I tested further based on your suggestion, the culprit seems to be how a closure is interpreted. As an experiment I changed the implementation not to use .map() but instead .rev() to find out the root cause: let ids = ids.into_iter().rev(); and the annotation becomes std::iter::Rev<std::vec::IntoIter<FooId>> mock_service .expect_get_by_ids::<std::iter::Rev<std::vec::IntoIter<FooId>>>() .returning(|_| Vec::new()); then the mocking succeeds; however, once I use a closure or even a function, the compiler emits an error message in a way that a programmer cannot directly embed in Rust code: = note: expected type `i32` found struct `std::iter::Map<std::vec::IntoIter<u32>, ***@***.***/main.rs:58:42: 58:54]>` = note: expected type `i32` found struct `std::iter::Map<std::vec::IntoIter<u32>, fn(u32) -> FooId {convert_u32_to_foo_id_func}>` — Reply to this email directly, view it on GitHub <#391 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AAA7VOJQIJH6RNEW4GKS4LLVSLXCXANCNFSM52S6XQWA> . You are receiving this because you commented.

Ahh yes. Closures can never be named. Therefore you can't set a Mockall expectation for a call with a closure. The generic workaround is to turn the closure into a named function. Or, you can Box the `ids` argument and turn it into a trait object: `Box<dyn IntoIterator<...>>`. But there's an easier alternative for this specific case, because you don't even need a closure. You can just turn `map(|id| FooId(id)` into `map(FooId)`.

…

Message ID: ***@***.*** com>

[chitoku-k]

Thanks again for your response.

I tried (1) turning it to a named function, (2) boxing ids argument to a trait object, and (3) turning into map(FooId), but none of them seemed to work. For (1) turning to a named function and (3) turning into map(FooId), I cannot find any valid ways which expresses a specific function as a concrete type that compiles other than fn(u32) -> FooId as I might be too ignorant in how Rust function are expressed. Unfortunately (2) boxing does not work either as compiler complains that it requires its associated type IntoIter be explicitly specified to be a valid trait object, which ends up with the same thing (the concrete type for IntoIter seems to be required there unless boxing IntoIter too).

Is there no way so far to mock this kind of functions?

[chitoku-k]

As a workaround, I manually implemented every function for a trait that firstly collects ids to Vec<_> then delegates to an automock.

#[cfg(test)]
struct MockServiceWrapper(MockService);

#[cfg(test)]
impl MockServiceWrapper {
    fn new() -> Self {
        Self(MockService::new())
    }
}

#[cfg(test)]
impl Service for MockServiceWrapper {
    fn get_by_ids<T>(&self, ids: T) -> Vec<Foo>
    where
        T: IntoIterator<Item = FooId> + Send + Sync + 'static,
    {
        let ids: Vec<_> = ids.into_iter().collect();
        self.0.get_by_ids(ids).collect()
    }
}

// Implement Deref and DerefMut for MockServiceWrapper too.
// ...

This isn't pretty much ideal but at least it works and does not rely on the exact type that caller specified. Any other solution would be still welcomed but I think I could've made this to work.

[asomers]

Option 1) + 3) works for me:

let ids: std::iter::Map<std::vec::IntoIter<u32>, fn(u32) -> FooId> = ids.into_iter().map(FooId);
        self.service.get_by_ids(ids);
...
mock_service
            .expect_get_by_ids::<std::iter::Map<std::vec::IntoIter<u32>, fn(u32) -> FooId>>()
            .returning(|_| Vec::new());

Option 2) works for me too:

let ids = Box::new(ids.into_iter().map(FooId)) as Box<dyn Iterator<Item=FooId>+ Send + Sync>;
...
        mock_service
            .expect_get_by_ids::<Box<dyn Iterator<Item=FooId>+ Send + Sync>>()

[chitoku-k]

Thanks! Wow, I didn't expect that the extra annotation is necessary to get this working.

Option 1) + 3) works if and only if type annotation is there:

Working 👍

let ids: std::iter::Map<std::vec::IntoIter<u32>, fn(u32) -> FooId> = ids.into_iter().map(FooId);
self.service.get_by_ids(ids);
...
mock_service
    .expect_get_by_ids::<std::iter::Map<std::vec::IntoIter<u32>, fn(u32) -> FooId>>()
    .returning(|_| Vec::new());

Working even if it's a closure 👍

let ids: std::iter::Map<std::vec::IntoIter<u32>, fn(u32) -> FooId> = ids.into_iter().map(|id| FooId(id));
self.service.get_by_ids(ids);
...
mock_service
    .expect_get_by_ids::<std::iter::Map<std::vec::IntoIter<u32>, fn(u32) -> FooId>>()
    .returning(|_| Vec::new());

Not working 👎

let ids = ids.into_iter().map(FooId);
self.service.get_by_ids(ids);
...
mock_service
    .expect_get_by_ids::<std::iter::Map<std::vec::IntoIter<u32>, fn(u32) -> FooId>>()
    .returning(|_| Vec::new());

I don't know what are the exact reasons behind this but this could be pretty helpful if documented!

[asomers]

Yeah, I don't know either. Probably some subtle type inference thing.

[chitoku-k]

OK. Marked your reply as an answer. Thanks again for taking your time to dig into this.