Mocking custom function that uses lettre rust create

[Sirneij]

I have a handler function in Actix web. This function looks like this:

pub async fn sample_handler(pool: actix_web::web::Data<sqlx::postgres::PgPool>) -> actix_web::HttpResponse {
    ...
    crate::utils::send_multipart_email(...)
    ...
}

send_multipart_email has something like the following:

pub async fn send_multipart_email(...) -> Result<(), String> {
    tokio::spawn(send_email(...));
    Ok(())
}

Then, send_email, which really does the sending:

pub async fn send_email(...) -> Result<(), String> {
    let email = lettre::Message::builder()
        .from(
            format!(
                "{} <{}>",
                "Some title",
                if sender_email.is_some() {
                    sender_email.unwrap()
                } else {
                    settings.email.host_user.clone()
                }
            )
            .parse()
            .unwrap(),
        )
        .to(format!(
            "{} <{}>",
            [recipient_first_name, recipient_last_name].join(" "),
            recipient_email
        )
        .parse()
        .unwrap())
        .subject(subject)
        .multipart(
            lettre::message::MultiPart::alternative()
                .singlepart(
                    lettre::message::SinglePart::builder()
                        .header(lettre::message::header::ContentType::TEXT_PLAIN)
                        .body(text_content.into()),
                )
                .singlepart(
                    lettre::message::SinglePart::builder()
                        .header(lettre::message::header::ContentType::TEXT_HTML)
                        .body(html_content.into()),
                ),
        )
        .unwrap();

    let creds = lettre::transport::smtp::authentication::Credentials::new(
        settings.email.host_user,
        settings.email.host_user_password,
    );

    // Open a remote connection to gmail
    let mailer: lettre::AsyncSmtpTransport<lettre::Tokio1Executor> =
        lettre::AsyncSmtpTransport::<lettre::Tokio1Executor>::relay(&settings.email.host)
            .unwrap()
            .credentials(creds)
            .build();

    // Send the email
    match mailer.send(email).await {
        Ok(_) => {
            Ok(())
        }
        Err(e) => {
            Err(format!("Could not send email: {:#?}", e))
        }
    }
}

While doing integration testing in Python and using the mock library, I could do something like this:

with patch('path/to/where/send_email/was/used'):
    response = requests...

How can I do something equivalent with Mockall? I need to mock the send_email used in the handler which is being tested using rust's reqwest library.

[asomers]

You can certainly mock send_email. But unlike in Python, you can't select between the real implementation and the mock implementation at runtime. You must do it at compile time. You can do it by creating a module for your mock functions:

#[automock]
mod mymod {
    pub async fn send_email(...) {unimplemented!()}
}

and then in whatever file send_multipart_email is defined, you can select at compile time whether to use the mock:

#[cfg(test)]
use crate::mock_mymod::send_email;
#[cfg(not(test)]
use some_other_module::send_email;

that's basically what #[double] does, except it makes stronger assumptions about the module naming convention.

[Sirneij]

@asomers Thanks for the prompt response.

Do I need to write the custom implementation for send_email in:

#[automock]
mod mymod {
    pub async fn send_email(...) {unimplemented!()}
}

Or this, pub async fn send_email(...) {unimplemented!()}, is enough?

[asomers]

There must be some implementation there or it won't be syntactially valid. However, if you're never going to call the real function, perhaps because it's defined in a different crate, then unimplemented!() is a perfectly valid implementation.

[Sirneij]

Okay. Thank you

[Sirneij]

@asomers What if send_email and send_multipart_email are in the same file?

and then in whatever file send_multipart_email is defined, you can select at compile time whether to use the mock:

[asomers]

Then you must put send_email's definition into a submodule. And if you do that, you can also use #[double], exactly as described at https://docs.rs/mockall/latest/mockall/#modules .