Allow mocking non-'static structs

[asomers]

Mockall currently can't mock a struct or trait with a lifetime parameter. So something like this doesn't work:

#[allow(unused)]
struct GenericStruct<'a, T, V> {
    t: T,
    v: &'a V
}
#[automock]
impl<'a, T, V> GenericStruct<'a, T, V> {
    #[allow(unused)]
    fn foo(&self, _x: u32) -> i64 {
        42
    }
}

#[test]
fn returning() {
    let mut mock = MockGenericStruct::<'static, u8, i8>::new();
    mock.expect_foo()
        .returning(|x| i64::from(x) + 1);
    assert_eq!(5, mock.foo(4));
}

[michaelmarconi]

I think I've just run into this:

        fn create_foo<'insert>(&self, foo: &'insert NewFoo<'insert>) {
            diesel::insert_into(foo::table)
                .values(foo)
                .execute(self.connection.as_ref().unwrap())
                .expect("Failed to insert new foo");
        }

Yields: help: message: Mockall does not yet support this argument type in this position. More information may be available when mockall is built with the "nightly" feature.

I'm not using nightly.

I'm using the Diesel ORM, so require the lifetimes to cope with string insertion on a struct like this:

#[derive(Insertable)]
#[table_name = "foos"]
pub struct NewFoo<'insert> {
    pub reference: &'insert str,
}

I've got a RepositoryTrait that I'm using to create an interface to the database and for mocking with automock, with the create_foo method on it.

Can you suggest a workaround in this situation?

[asomers]

Actually, you're running into a different problem. This issue concerns structs with lifetime parameters. Your problem is with a method with a lifetime parameter. A full solution would be different than for the struct case.

Situations like this can usually be dealt with eliminating the lifetimes when compiling in test mode. You can try something like this:

#[automock]
trait RepositoryTrait {
    #[cfg(not(test))]
    fn create_foo<'insert>(&self, foo: &'insert NewFoo<'insert>);
    #[cfg(test)]
    fn create_foo(&self, foo: &'static NewFoo<'static>);
}

Of course, that obviously imposes a new restriction on how you write your tests. Another possible workaround would be to redefine NewFoo in test mode to eliminate the lifetime parameter.

[michaelmarconi]

Thanks @asomers, that's done the trick for me!