Mocking 3rd party trait with generic parameter

[zwilcox]

I'm learning rust. I'm attempting to mock write_frame with mockall.
It has the following signature:
fn write_frame<F>(&self, frame: &F) -> io::Result<()>

I've set up my mock with the following:

mockall::mock! {
    pub MockableSocket {}
    impl socketcan::Socket for MockableSocket {
       type FrameType = socketcan::CanAnyFrame;
       fn write_frame<F>(&self, frame: &F) -> std::io::Result<()>
        where
            F: Into<socketcan::CanAnyFrame> + AsPtr;
    }

    impl std::os::unix::io::AsRawFd for MockableSocket {
        fn as_raw_fd(&self) -> std::os::unix::io::RawFd;
    }
}

I'm getting the following error:
error[E0310]: the parameter type F may not live long enough

Which appears to be coming from:

/mockall-0.11.4/src/lib.rs:1354:29
pub trait AnyExpectations : Any + Send + Sync {}
                            ^^^

I've attempted to add static in a few places but that seems to break the trait by implementing stricter requirements.

For example changing the following:

F: Into<socketcan::CanAnyFrame> + AsPtr  + 'static;

Results in

Error[E0276]: impl has stricter requirements than trait
   |
12 |             F: Into<socketcan::CanAnyFrame> + AsPtr + 'static;
   |                                                       ^^^^^^^ impl has extra requirement `F: 'static`

I get similar errors when adding static to the generic type in the signature.

Could some one help me out here?

[zwilcox]

I did search the forum. I think there are similar cases but I'm not sure since I'm still learning rust.

[asomers]

This is a perennial problem. Due to limitations in the language, Mockall has very limited ability to mock functions with non-'static generic arguments. Your best options are either:

• Redefine the trait to add 'static' to F, like you tried. You'll have to change the trait as well as the mock.
• Use Mockall's still-experimental #[concretize] feature. You'll have to use the latest git master branch of Mockall. When using this attribute, the arguments will be turned into trait objects before being passed to matchers and returners. Use mock! as you normally would, but put #[concretize] just above the method that you want to change.

[zwilcox]

It appears Into requires Self: Sized and thus cannot be turned into an object

[asomers]

Ahh yes. That's the fundamental limitation of concretize. Not everything can be a trait object.

[zwilcox]

Dang. So it sounds like there isn't a path forward?

[asomers]

You'll have to do the mocking at least partially manually. For instance, you could use mockall for inherent methods, and inner methods, and then manually impl the trait. If you're sure the lifetimes are safe, you can even transmute them , like this:

mockall::mock! {
    pub Socket {
       fn _write_frame<F>(&self, frame: &F) -> std::io::Result<()>
           where F:  std::convert::Into<Self::FrameType> + socketcan::frame::AsPtr + 'static;
    }
}

}
impl socketcan::Socket for MockSocket {
    type FrameType = socketcan::CanAnyFrame;
     fn write_frame<F>(&self, frame: &F) -> std::io::Result<()>
    where
        F:  std::convert::Into<Self::FrameType> + socketcan::frame::AsPtr;
    {
         let sframe: mem::transmute(something something something frame);
         self._write_frame(sframe)
    }
}

[zwilcox]

Awesome. I think this is the solution I was looking.

Thanks for your help.