Mock a concrete struct within async_trait

[ymwjbxxq]

Hello Alan,

I am trying to mock a concrete struct without success.

I have an Add struct that references RandomGenerator and both of them are using async_trait

add.rs

#[async_trait]
pub trait AddQuery {
    async fn execute(&self, item: &Request) -> Result<(), ApplicationError>;
}

#[derive(Debug, Clone, Builder)]
pub struct Add {
    #[builder(default, setter(strip_option))]
    pub dynamo_db_client: Option<aws_sdk_dynamodb::Client>,

    #[builder(setter(into))]
    random_generator: RandomGenerator,
}

#[async_trait]
impl AddQuery for Add {
    async fn execute(&self, item: &Request) -> Result<(), ApplicationError> {
        let shortener = self.random_generator.generate(&request).await?;
        self.dynamo_db_client
            .....
            .send()
            .await?;

        Ok(())
    }
}

random_generator.rs

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

#[cfg_attr(test, automock)]
#[async_trait]
pub trait Generator {
    async fn generate(&self, request: &Request) -> Result<String, ApplicationError>;
}

#[derive(Debug, Clone, Builder)]
pub struct RandomGenerator {
   #[builder(setter(into))]
    query: AnotherQuery,
}

#[async_trait]
impl Generator for RandomGenerator {
    async fn generate(&self, request: &Request) -> Result<String, ApplicationError> {
        // check if exists
        let result = self.query.execute(&request.brand).await?;

        //generate the next with the result
        .....
        Ok(Something)
    }

The unit test inside add.rs is something like this

#[tokio::test]
async fn add_with_random_generate() -> Result<(), ApplicationError> {
        // ARRANGE
       ....

         // and mock!
        mock! {
            pub RandomGenerator {}
            #[async_trait]
            impl Generator for RandomGenerator {
                async fn generate(&self, request: &Request) -> Result<String, ApplicationError>;
            }
        }

        let mut mock = MockRandomGenerator::default();
        mock.expect_generate().times(0).returning(|_| Ok("xxxx".to_string()));

        let query = Add::builder()
            .dynamo_db_client(dynamo_db_client.clone())
            .random_generator(mock) // **HERE THE PROBLEM**
            .build();


        // ACT
        query.execute(&request).await?;

        // ASSERT
        ...
        Ok(())
    }
  }

This code does not compile:

        let query = Add::builder()
            .dynamo_db_client(dynamo_db_client.clone())
            .random_generator(mock) // **HERE THE PROBLEM**
            .build();

the trait bound `generator::RandomGenerator: From<MockRandomGeneratorr>` is not satisfied
required because of the requirements on the impl of `Into<generator::RandomGeneratorr>` for `MockRandomGenerator

My question is:

Is there any secret command to cast the MockRandomGeneratorr mock to the struct concrete?

[asomers]

Sorry I didn't notice this discussion when you first opened it. But if you haven't figured it out already, here is the problem:
Your random_generator function is defined to take a RandomGenerator argument. However, in your unit test you create a different struct named MockRandomGenerator. Those are different structs. In order to use the mock object with the real random_generator function, you need to ensure that, in test mode, random_generator is defined to take a MockRandomGenerator. The best way to do that would be to put your mock! item inside of random_generator.rs, and then import it into add.rs with mockall_double::double.

[ymwjbxxq]

I have refactored everything to make it work, but I guess I need to try it to mockall_double::double because I never used it.

Thanks for the answer.