async_trait mock times N

[ymwjbxxq]

Hello,

I am wondering if you can help me with the #[async_trait]

The concrete code:

pub struct AppClient {
    pub my_query: Option<MyObj>,
}

#[async_trait]
pub trait MyTrait {
    async fn execute(&self, something: &str) -> Result<Option<MyObj>, Error>;
}

#[async_trait]
impl MyTrait for AppClient {
    async fn execute(&self, something: &str) -> Result<Option<MyObj>, Error>;
        let result =  self.my_query.clone().unwrap().execute(&something).await?;
        Ok(result)
    }
}

I want to test a part of the code like this:

let response = app_client.execute(&something).await?;
 if let Some(my_obj) = response {
    ....
 } else {
    ...
    let response = app_client.execute(&something_else).await?;
}

As you can see, I call app_client.execute twice.

I cannot find the syntax to say return twice with the unit tests.

#[cfg(test)]
mod tests {
       #[automock]
       #[async_trait]
        pub trait MyTrait {
            async fn execute(&self, something: &str) -> Result<Option<MyObj>, Error>;
        }

    #[tokio::test]
    async fn my_test_case() -> Result<(), ApplicationError> {
        mock! {
            pub AppClient {}
            #[async_trait]
            impl MyTrait for AppClient {
                async fn execute(&self, something: &str) -> Result<Option<MyObj>, Error>;
                    Ok(None)
                }
            }
        }

   // here I would like to do something similar
   let mut mock = MockAppClient::default();
    mock.expect_execute().times(2).returning(|_| Ok(None));
}

Sadly I cannot find the syntax, and also, if I could execute once, it does not mock it the first call. Is it possible, or I am in the wrong direction? If there is an option, I would also like to know if I can return different things each time.

Thanks
Dan

[asomers]

.times(2) is exactly the correct syntax to use if want to expect that a function gets called twice. And if you want to return something different each time, you can use a Sequence, like this:

let mut seq = Sequence::new();
let mut mock = MockAppClient::default();
mock.expect_execute()
    .once()
    .in_sequence(&mut seq)
    .returning(|| something);
mock.expect_execute()
    .once()
    .in_sequence(&mut seq)
    .returning(|| something_else);

[ymwjbxxq]

Thanks for the quick answer and the syntax.

I think I do something wrong because it does not mock it.

#[cfg(test)]
mod tests {
       #[automock]
       #[async_trait]
        pub trait MyTrait {
            async fn execute(&self, something: &str) -> Result<Option<MyObj>, Error>;
        }

    #[tokio::test]
    async fn my_test_case() -> Result<(), ApplicationError> {
        // ARRANGE
        mock! {
            pub AppClient {}
            #[async_trait]
            impl MyTrait for AppClient {
                async fn execute(&self, something: &str) -> Result<Option<MyObj>, Error>;
                    Ok(None)
                }
            }
        }

      // here I would like to do something similar
      let mut mock = MockAppClient::default();
      mock.expect_execute().times(2).returning(|_| Ok(None));
      
      let app_client = get_app_client().await?; -> TYPE of AppClient like the mock
      
     // ACT
    let result = execute(&app_client, request).await?;
}

I try to mock AppClient, but to the method, I do not pass the mock version under test, and I think this is the problem.

I should pass like MockAppClient.same_type_but_fake

And when I reach this point, it executes the method and finds my_query as None.

#[async_trait]
impl MyTrait for AppClient {
    async fn execute(&self, something: &str) -> Result<Option<MyObj>, Error>;
        if let Some(query) = &self. my_query {
            let result = query.execute(&something).await?;
            return Ok(result);
        }
        Ok(None)
    }
}

Not sure if I use MockAll correctly or Rust at this point, but the idea of mocking is to mock the method (in this case, execute) and avoid the implementation with a fake.

Do you mind telling me what to watch?

If I remove all the mocks inside the test area by doing this:
file my_trait.rs

#[cfg(test)]
use mockall::{automock, predicate::*};

#[cfg_attr(test, automock)]
#[async_trait]
pub trait MyTrait: Send + Sync {
    async fn execute(
        &self,
        something: &str,
    ) -> Result<Option<MyObj>, Error>;
}

file main.rs:

pub async fn execute(app_client: &dyn MyTrait, event: Request) -> Result<impl IntoResponse, Error> {
    let response = app_client.execute(&something).await?;
    if let Some(my_obj) = response {
    ....
    } else {
    ...
    let response = app_client.execute(&something_else).await?;
   }
}


#[cfg(test)]
mod tests {
    #[tokio::test]
    async fn my_test_case() -> Result<(), Error> {
        // ARRANGE
      let mut mock = MockMyTrait::new();
      mock.expect_execute().times(2).returning(|_| Ok(None));
      
     // ACT
    let result = execute(&mock, request).await?;
}

this syntax fails with:
failed to resolve: use of undeclared type MockMyTrait use of undeclared type MockMyTrait

It seems because it is in a different file. If I put it all in one file, it is okay.

[asomers]

So is everything working now?

[ymwjbxxq]

no I cannot mock anything :(

[asomers]

What's the problem? You said "If I put it all in one file, it is okay". Does that just mean that you are forgetting to import the mock symbols with use? They're regular symbols just like anything else. If you want to use a symbol defined in a different file, you must import it. Like `#[cfg(test)] use my_module:MockMyStruct;' There's a macro designed to make that a little bit easier. It's the "mockall-double" crate.

[asomers]

Nothing defines MockAppClient. There is no #[automock] nor any mock!. Did you forget that part?

[ymwjbxxq]

Maybe this is the problem that I am missing.

I have set just the #[cfg_attr(test, automock)] on top of the trait

I have this structure as in the previous code

#[derive(Debug, Clone, Builder)]  //Builder is typed-builder
pub struct AppClient {
    #[builder(default, setter(strip_option))]
    pub my_query: Option<MyObj>,
}

How can I define MockAppClient?

Could you please write pseudocode on what I should add?

[asomers]

Putting #[automock] on the trait defines a MockMyTrait. It doesn't have anything to do with AppClient. If you want to mock a struct that implements it, see https://docs.rs/mockall/latest/mockall/#multiple-and-inherited-traits .

[ymwjbxxq]

All your hints help me I just made it

Inside the test I have the mock!

#[tokio::test]
    async fn slug_found() -> Result<(), ApplicationError> {
        // ARRANGE
...stuff
        mock! {
            pub AppClient {}
            #[async_trait]
            impl MyTrait for AppClient {
                async fn execute(&self, something: &st) -> Result<Option<MyObj>, ApplicationError> {
                    Ok(None)
                }
            }
        }
        ...stuff
        let mut seq = Sequence::new();
        let mut mock = MockAppClient::default();
        //mock.expect_execute().times(2).returning(|_, _| Ok(None));
        mock.expect_execute()
            .once()
            .in_sequence(&mut seq)
            .returning(|_, _| Ok(None));
        mock.expect_execute_slug_query()
            .once()
            .in_sequence(&mut seq)
            .returning(move |_, _| Ok(Some(my_obj.clone())));

[goodgoodwish]

Thanks for the post. "Send + Sync" , solved my problem of async_trait async fn:

error[E0277]: `dyn BookStore` cannot be shared between threads safely
  --> arvr/projects/orion/devtools/test_runner/src/tra.rs:49:22
   |
49 |         let handle = store.put(content).await?;
   |                      ^^^^^ --- required by a bound introduced by this call
   |                      |
   |                      `dyn BookStore` cannot be shared between threads safely
   |
   = help: the trait `Sync` is not implemented for `dyn tra::BookStore`

My mocking trait:

#[automock]
#[async_trait]
pub trait BookStore: Send + Sync {
    async fn put(&self, _content: String) -> Result<String> {
        let handle = "".to_owned();
        Ok(handle)
    }
}

Caller:

#[async_trait]
impl DbaOps for SomeStruct {
    async fn add_log(&mut self, store: &dyn BookStore) -> Result<()> {
        let handle = "".to_owned();
        let handle = store.put(content).await?;
        Ok(())
   }
}