mockall and zbus, problem of lifetime

[fmartinsons]

Hello there,

I'm starting to learn rust and I have a use case where I need to make dbus call, for this , I use zbus. And for unit test , I chose to use mockall (awesome crate by the way).
For example , let's say that I have the following Trait (which abstract dbus proxy):

use zbus::dbus_proxy;

#[dbus_proxy(
    interface = "com.Service.Hello",
    default_service = "com.Service.Hello",
    default_path = "/com/Service/Hello",
    assume_defaults = false
)]
trait Hello {
    /// hello method
    #[dbus_proxy(name = "hello")]
    fn hello(&self, msg: &str) -> zbus::Result<()>;
}

I cannot use automock because of the proc macro dbus_proxy (if you know how, please tell me), the compiler throw me this error when I put #[mockall::automock] above dbus proxy:

custom attributes cannot be applied to statements
see issue #54727 <https://github.com/rust-lang/rust/issues/54727> for more information

Nevertheless, I manage to have something working by the use of mock macro like that:

    mock! {
        pub Connection {
            pub async fn system() -> zbus::Result<Self>;
        }
    }
    mock! {
        pub HelloProxy {
            pub async fn new(conn: &MockConnection) -> zbus::Result<Self>;
            pub async fn hello(&self, msg: &str) -> zbus::Result<()>;
        }
    }

And my unit test work well (providing limitations that are stated in https://docs.rs/mockall/latest/mockall/#static-methods) and I can mock the various dbus methods to return error or tested value by using different import in test :

use zbus::Result;

cfg_if::cfg_if! {
    if #[cfg(not(test))] {
        use zbus::Connection;
        use hello::HelloProxy;
    } else {
        use hello::mock::MockConnection as Connection;
        use hello::mock::MockHelloProxy as HelloProxy;
    }
}

#[tokio::main]
pub async fn start() -> Result<()> {
    let connection = Connection::system().await?;
    let hello_proxy = HelloProxy::new(&connection).await?;

    hello_proxy.hello("World").await?;

    Ok(())
}

But my application is going more complex and I need to put the proxy type inside a struct and this require adding a lifetime parameter (I choose static for simplicity):

struct MyStruct {
    proxy: HelloProxy<'static>
}

But doing that says my mock doesn't have a lifetime parameter and when I didn't manage to add one in mock definition:

    mock! {
        pub HelloProxy<'static> {
            pub async fn new(conn: &MockConnection) -> zbus::Result<Self>;
            pub async fn hello(&self, msg: &str) -> zbus::Result<()>;
        }
    }

Doing that raises:

invalid lifetime parameter name: `'static`
'static is a reserved lifetime namerustcClick for full compiler diagnostic
cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
for more information, see issue #42868 <https://github.com/rust-lang/rust/issues/42868>
`#[warn(late_bound_lifetime_arguments)]` on by defaultrustcClick for full compiler diagnostic

And using another lifetime name like <'a> throw me:

use of undeclared lifetime name `'a`
undeclared lifetimerustcClick for full compiler diagnostic
lib.rs(134, 24): lifetime `'a` is missing in item created through this procedural macro
lib.rs(133, 13): consider introducing lifetime `'a` here: `<'a>`
cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
for more information, see issue #42868 <https://github.com/rust-lang/rust/issues/42868>
`#[warn(late_bound_lifetime_arguments)]` on by defaultrustcClick for full compiler diagnostic
hello.rs(23, 5): the late bound lifetime parameter is introduced here

I looked at #293 and #348 but it didn't help me to understand how can I achieve what I want.

Any advices on how I can mange to mock the zbus proxy when it requires a lifetime parameter ?

[asomers]

This is a limitation of Mockall. It can't currently mock constructor methods for structs with a lifetime parameter. It might be possible to relax this limitation by always returning 'static values, like this for example. Would this work for your use case?

mock! {
    pub HelloProxy<'static> {
        pub async fn new(conn: &MockConnection) -> zbus::Result<Self<'static>>;
    }
}

[asomers]

The difference between what I'm proposing and what "perfect" would be is that in my proposal, the mock object must be 'static, whereas in the "perfect" situation the caller would get to choose its lifetime. 'static can easily be downcast to any other lifetime, so the real question for you is whether it's possible to create a 'static MockHelloProxy?

[fmartinsons]

I'm afraid I cannot clearly answer your question :(
For that, I need to know more about lifetime in rust (and I'm planning to do so, of course), below is a minimal working code that demonstrate what I would like to achieve (I commented out the unit tests part for obvious reasons):

main.rs

use futures::executor::block_on;
use zbus::Result;

//cfg_if::cfg_if! {
//    if #[cfg(not(test))] {
//        use zbus::Connection;
//        use hello::HelloProxy;
//    } else {
//        use hello::mock::MockConnection as Connection;
//        use hello::mock::MockHelloProxy as HelloProxy;
//    }
//}
use hello::HelloProxy;
use zbus::Connection;

mod hello;

struct MyStruct {
    proxy: HelloProxy<'static>,
}

impl MyStruct {
    async fn create_mode_proxy() -> Result<HelloProxy<'static>> {
        let connection = Connection::system().await?;
        let hello_proxy = HelloProxy::new(&connection).await?;
        Ok(hello_proxy)
    }

    pub fn new() -> Self {
        let proxy = block_on(Self::create_mode_proxy()).unwrap();
        Self { proxy }
    }
    pub async fn call(&self) -> Result<()> {
        self.proxy.hello("World").await?;
        Ok(())
    }
}

#[tokio::main]
pub async fn run() -> Result<()> {
    let m: MyStruct = MyStruct::new();
    block_on(m.call())
}

fn main() {
    match run() {
        Ok(()) => {
            println!("Successfully call hello dbus method");
        }
        Err(e) => {
            println!("Unable to call hello dbus method: {e}");
        }
    }
}

//#[cfg(test)]
//mod tests {
//    use super::*;
//    use hello::mock::{MockConnection, MockHelloProxy};
//    use zbus::Error::Failure;
//    use lazy_static::lazy_static;
//    use std::sync::{Mutex, MutexGuard};
//
//    lazy_static! {
//        pub static ref MTX: Mutex<()> = Mutex::new(());
//    }
//    pub fn get_lock(m: &'static Mutex<()>) -> MutexGuard<'static, ()> {
//        match m.lock() {
//            Ok(guard) => guard,
//            Err(poisoned) => poisoned.into_inner(),
//        }
//    }
//    #[test]
//    fn test_hello() {
//        let _m = get_lock(&MTX);
//        let ctx_conn = MockConnection::system_context();
//        ctx_conn
//            .expect()
//            .returning(|| Ok(MockConnection::default()));
//
//        let ctx_hello = MockHelloProxy::new_context();
//        ctx_hello.expect().returning(|_| {
//            let mut mock = MockHelloProxy::default();
//            mock.expect_hello().times(1).returning(|msg| {
//                assert_eq!(msg, "World");
//                Ok(())
//            });
//            Ok(mock)
//        });
//
//        run().unwrap();
//    }
//
//    #[test]
//    fn test_hello_error() {
//        let _m = get_lock(&MTX);
//        let ctx_conn = MockConnection::system_context();
//        ctx_conn
//            .expect()
//            .returning(|| Ok(MockConnection::default()));
//
//        let ctx_hello = MockHelloProxy::new_context();
//        ctx_hello.expect().returning(|_| {
//            let mut mock = MockHelloProxy::default();
//            mock.expect_hello().times(1).returning(|msg| {
//                assert_eq!(msg, "World");
//                Err(Failure("DBUS ERROR".to_string()))
//            });
//            Ok(mock)
//        });
//
//        if let Err(e) = run() {
//            assert_eq!(format!("{e}"), "DBUS ERROR");
//        } else {
//            !unreachable!();
//        }
//    }
//}

hello.rs:

use zbus::dbus_proxy;

#[dbus_proxy(
    interface = "com.Service.Hello",
    default_service = "com.Service.Hello",
    default_path = "/com/Service/Hello",
    assume_defaults = false
)]
trait Hello {
    /// hello method
    #[dbus_proxy(name = "hello")]
    fn hello(&self, msg: &str) -> zbus::Result<()>;
}

pub mod mock {
    use mockall::*;

    mock! {
        pub Connection {
            pub async fn system() -> zbus::Result<Self>;
        }
    }
    mock! {
        pub HelloProxy {
            pub async fn new(conn: &MockConnection) -> zbus::Result<Self>;
            pub async fn hello(&self, msg: &str) -> zbus::Result<()>;
        }
    }
}

Cargo.toml

[package]
name = "zbus_mock"
version = "0.1.0"
edition = "2021"

[dependencies]
cfg-if = "1.0"
futures = "0.3.28"
tokio = { version = "1.28.2", features = ["macros", "rt-multi-thread", "time"] }
zbus = { version = "3", default-features = false, features = ["tokio"] }
mockall = "0.11.4"
lazy_static = "1.4.0"

Does this help to answer your question about 'static MockHelloProxy creation ?

[fmartinsons]

Hello @asomers , is my previous answer helpful ?

Can I help in some way to provide what you described about making mock having a 'static lifetime ?

[asomers]

But it needs to have a lifetime parameter, right? So you'll need to add one in the mock! definition. And then, according to my proposal, MockHelloProxy::new will return a HelloProxy<'static>. But I need to know if that would work for you, or if for some other reason a MockHelloProxy<'static> would be impossible. For example, if that struct needs to contain a pointer with a lesser lifetime, perhaps in the closure for one of its other methods' returning statements.

[fmartinsons]

For the moment, I don't need to have a pointer with a lesser lifetime than static and no method in it has to return a thing like that. So if you can easily release a a mockall version which allow me to define a 'static mock, I think it will be ok for me.

[fmartinsons]

Hello @asomers

have you made any progress about the suggestion you made on return a static lifetime mock ?
is our discussion related to #85 and #134 ?

Thank you for your work on mockall !

[asomers]

No, I haven't done any work on it.

[fmartinsons]

Ok , have you some guidance which would help me to do this by myself ?

I'll look at that and possibly make a merge request if I manage to do so but I'd need some helping hands. Please tell me if you think
it is not doable by a rookie too.

Thanks again

[asomers]

Honestly, everything in mockall_derive is difficult for a rookie. Writing proc macros is harder than writing normal Rust code. So my advice would be that you don't wait for me. Instead, work around this limitation by yourself. You can do it by manually implementing the new method. Like this, for example:

pub mod mock {
    use mockall::*;

    mock! {
        pub Connection {
            pub async fn system() -> zbus::Result<Self>;
        }
    }
    mock! {
        pub HelloProxy {
            pub async fn hello(&self, msg: &str) -> zbus::Result<()>;
        }
    }
    impl MockHelloProxy {
        pub async fn new(_conn: &MockConnection) -> zbus::Result<Self> {
            Ok(MockConnection::default)
        )
    }
}

[fmartinsons]

Thank you very much for the tip.

I'll try that in the coming days and come back to you if it was successful.

[fmartinsons]

Hello, the workaround is not possible because mock! already create a new method

error[E0592]: duplicate definitions with name `new`
  --> src/hello.rs:22:5
   |
22 | /     mock! {
23 | |         pub HelloProxy {
24 | |             pub async fn hello(&self, msg: &str) -> zbus::Result<()>;
25 | |         }
26 | |     }
   | |_____^ duplicate definitions for `new`
27 |       impl MockHelloProxy {
28 |           pub async fn new(_conn: &MockConnection) -> zbus::Result<Self> {
   |           -------------------------------------------------------------- other definition for `new`

I think I'll restructure my mocking strategy, maybe by doing something like that:

cfg_if::cfg_if! {
    if #[cfg(not(test))] {
        use zbus::Connection;
        use hello::HelloProxy;
    } else {
        use hello::mock::MockConnection as Connection;
        use std::marker::PhantomData;

        struct HelloProxy<'a> {
            phantom: PhantomData<&'a ()>
        }
        impl<'a> HelloProxy<'a> {
            pub async fn new(_conn: &Connection) -> zbus::Result<HelloProxy<'a>> {
                Ok(HelloProxy { phantom: PhantomData })
            }
            pub async fn hello(&self, msg: &str) -> zbus::Result<()> {
                println!("{msg}");
                Ok(())
            }
        }
    }
}