mailcrab 1.6.5

Email test server for development, written in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use std::net::IpAddr;
use tokio::sync::broadcast::Receiver;
use tokio_util::sync::CancellationToken;

mod error;
mod smtp;
mod types;

/// retrieve the version from Cargo.toml, note that this will yield an error
/// when compiling without cargo
pub const VERSION: &str = env!("CARGO_PKG_VERSION");

pub use error::{Error, Result};
pub use smtp::mail_server;
pub use types::{Action, Address, Attachment, MailMessage, MailMessageMetadata, MessageId};

pub struct TestMailServerHandle {
    pub token: CancellationToken,
    pub rx: Receiver<MailMessage>,
}

/// Start a test mail server, returns a channel on which messages can be received
/// and a token to stop the server
/// This server is NOT intended for production use, it is a development tool
pub async fn development_mail_server(
    smtp_host: impl Into<IpAddr>,
    smtp_port: u16,
) -> TestMailServerHandle {
    let (tx, rx) = tokio::sync::broadcast::channel::<MailMessage>(128);
    let token = CancellationToken::new();

    tokio::spawn(mail_server(
        smtp_host.into(),
        smtp_port,
        tx,
        false,
        token.clone(),
    ));

    TestMailServerHandle { token, rx }
}

#[cfg(test)]
mod tests {
    use std::time::Duration;

    use fake::{
        Fake,
        faker::{company::en::CatchPhrase, internet::en::SafeEmail},
    };
    use lettre::{
        AsyncSmtpTransport, AsyncTransport, Message, Tokio1Executor,
        message::{SinglePart, header},
    };
    use rand::Rng;

    #[tokio::test]
    async fn test_mail_server() {
        let mut rng = rand::rng();
        let port = rng.random_range(10_000..30_000);

        let mut handle = crate::development_mail_server([127, 0, 0, 1], port).await;

        let mailer: AsyncSmtpTransport<Tokio1Executor> =
            AsyncSmtpTransport::<Tokio1Executor>::builder_dangerous("127.0.0.1".to_string())
                .port(port)
                .build();

        let email = Message::builder()
            .from(SafeEmail().fake::<String>().parse().unwrap())
            .to(SafeEmail().fake::<String>().parse().unwrap())
            .subject(CatchPhrase().fake::<String>())
            .singlepart(
                SinglePart::builder()
                    .header(header::ContentType::TEXT_PLAIN)
                    .body(CatchPhrase().fake::<String>()),
            )
            .expect("failed to build email");

        // try sending message
        for i in 0..=10 {
            match mailer.send(email.clone()).await {
                Ok(_) => break,
                Err(e) => {
                    tokio::time::sleep(Duration::from_millis(100)).await;

                    if i == 10 {
                        panic!("failed to send email: {e}");
                    }
                }
            }
        }

        let received = handle.rx.recv().await.expect("failed to receive email");

        // assert uuid length
        assert_eq!(received.id.to_string().len(), 36);

        handle.token.cancel();
    }
}