How can I properly inject my mock into real app to be used in integration test?

[Veeksi]

I am trying to make integration test by mocking my email module or its function and injecting it into app. The idea is to test my endpoint via integration test by mocking the email module since obviously I don't want to spam emails during testing. Somehow I cannot get this mocking done correctly and my AppState struct returns this kind of error and I cannot compile the project / run tests:

mismatched types
expected `EmailService`, found `MockEmailService`

Here I have my mock implementation:

#[async_trait]
pub trait SendEmail {
    async fn send_multipart_email(
        &self,
        user: models::EmailToUser,
        state: startup::AppState,
        email_type: models::EmailType,
    ) -> Result<(), CustomAppError>;
}

#[derive(Clone, Default)]
pub struct EmailService {}

#[async_trait]
impl SendEmail for EmailService {
    async fn send_multipart_email(
        &self,
        user: models::EmailToUser,
        state: startup::AppState,
        email_type: models::EmailType,
    ) -> Result<(), CustomAppError> {
        let subject = email_type.subject().to_string();
        let text = email_type.plain_text();
        let html_text = email_type.generate_html_text(&state).await?;

        match send_email(user, subject, html_text, text).await {
            Ok(_) => Ok(()),
            Err(e) => Err(e),
        }
    }
}

mock! {
    pub EmailService {}

    impl Clone for EmailService {
        fn clone(&self) -> Self;
    }

    #[async_trait]
    impl SendEmail for EmailService {
        async fn send_multipart_email(
            &self,
            user: models::EmailToUser,
            state: startup::AppState,
            email_type: models::EmailType,
        ) -> Result<(), CustomAppError> {
        let subject = email_type.subject().to_string();
            let text = email_type.plain_text();
            let html_text = email_type.generate_html_text(&state).await?;

            match send_email(user, subject, html_text, text).await {
                Ok(_) => Ok(()),
                Err(e) => Err(e),
            }
        }
    }
}

And here is my setup_test_app() function that gives me above error when instantiating AppState:

#[double]
use backend::utils::EmailService;

pub async fn setup_test_app() -> Router {
    dotenvy::from_filename(".env.test").ok();

    let mut env = minijinja::Environment::new();
    env.set_loader(minijinja::path_loader("templates"));

    let db_pool = configure_database().await;
    let redis_store = configure_redis().await;
    let mut email_service = EmailService::default();

    email_service
        .expect_send_multipart_email()
        .returning(|_, _, _| Ok(()));

    let config = Config::init();

    let app_state = AppState {
        db_store: Store { pool: db_pool },
        config,
        env,
        redis_store,
        email_service, // THIS LINE GIVES ME ERROR
    };

    startup::configure_router(app_state)
}

My AppState is structured like this:

#[double]
use crate::utils::EmailService;

#[derive(Clone)]
pub struct AppState {
    pub db_store: store::Store,
    pub config: config::Config,
    pub redis_store: bb8_redis::bb8::Pool<bb8_redis::RedisConnectionManager>,
    pub env: minijinja::Environment<'static>,
    pub email_service: EmailService,
}

My app structure is like this:

src/
  startup.rs (contains AppState struct)
  utils/
    email.rs (contains EmailService and mocks)
tests/
  helpers/
    core.rs (contains setup_test_app method)
  integration_tests.rs 

Any ideas what is going wrong here? I have tried to find examples where people inject their mocks to real app but can't find similar ones.

[Veeksi]

Is it possible to test like this or should I stub that email function differently? As you can see I am quite new to rust world so help is appreciated.

[asomers]

Is backend a separate crate? That could cause the problem. When you build a crate in test mode, its dependencies still get built in non-test mode. So you're probably building AppState in non-test mode, where it expects the real EmailService, but setup_test_app provides a MockEmailService.

[Veeksi]

But looks like the reference is lost somehow on that line because clone_expectation size is 1 and send_multipart_expectation size is 0?

@asomers
How does that work like I debugged the app and looks like the reference to that expectation is lost when register_user route handler is called (basically after I curl /api/register endpoint). But I can clearly see that it is still there when user routes are instantiated.

Here:

[asomers]

At this point you've got Mockall properly integrated into your application, but your problem is with your application itself. I can't help you there, because there's real work that I need to be doing. You need to debug your application yourself.
But since I know that you're cloning mock objects, I'm guessing that you're setting your expectation on the wrong object. Remember, cloning a mock object does not clone its expectations.

[Veeksi]

Yeah I think the problem is that on every request the AppState is cloned and the reference to that expectation is lost since you mentioned again that clone doesn't clone expectations :/

tokio-rs/axum#1911 (comment)

So yeah I have to figure out a way to remake expectation somehow or do something dunno but yea at least I get it this time

[Veeksi]

Okay looks like I got it by separating that email sending even more by using those cfg(test) annotations

pub async fn register_user(
    State(state): State<AppState>,
    CustomAppJson(new_user): CustomAppJson<NewUserParams>,
) -> Result<impl IntoResponse, CustomAppError> {
    ...
    send_email(&state, &email_to_user, &email_type).await?;
    ...
}

#[cfg(test)]
pub async fn send_email(
    state: &AppState,
    email_to_user: &EmailToUser,
    email_type: &EmailType,
) -> Result<(), CustomAppError> {
    use crate::utils::MockEmailService;

    let mut email_service = MockEmailService::default();

    email_service
        .expect_send_multipart_email()
        .returning(move |_, _, _| Ok(()));

    email_service
        .send_multipart_email(email_to_user, state, email_type)
        .await
        .map_err(|e| {
            CustomAppError::InternalError("Failed to send activation email".to_string(), e.into())
        })
}

#[cfg(not(test))]
pub async fn send_email(
    state: &AppState,
    email_to_user: &EmailToUser,
    email_type: &EmailType,
) -> Result<(), CustomAppError> {
    state
        .email_service
        .send_multipart_email(email_to_user, state, email_type)
        .await
        .map_err(|e| {
            CustomAppError::InternalError("Failed to send activation email".to_string(), e.into())
        })
}

Now the expectation is added there and cloning before doesn't matter anymore. Thanks asomers for help! Take a whole day to figure out how this works but now I think I got it and gonna use it even more :) 👍

[Veeksi]

Or actually even better to modify the recursion for clone mock to instantiate that other mock aswell!

#[cfg(test)]
fn create_mock_email_service() -> EmailService {
    let mut mock = EmailService::new();

    mock.expect_clone()
        .returning(create_mock_email_service);

    mock.expect_send_multipart_email()
        .returning(|_, _, _| Ok(()));

    mock
}

#[cfg(test)]
pub async fn setup_test_app() -> Router {
    ...
    let email_service = create_mock_email_service();
   ...
}