mogimail 0.1.0

Embedded SMTP server
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! SMTP response handling

/// Represents an SMTP response that can be sent to a client
#[derive(Debug, Clone)]
pub struct SmtpResponse {
    /// The SMTP response code (e.g., "250", "354", "500")
    pub code: String,
    /// The human-readable message
    pub message: String,
}

impl SmtpResponse {
    /// Create a new SMTP response
    pub fn new(code: &str, message: &str) -> Self {
        Self {
            code: code.to_string(),
            message: message.to_string(),
        }
    }

    /// Create a success response (250 OK)
    pub fn ok() -> Self {
        Self::new("250", "OK")
    }

    /// Create a greeting response (220)
    pub fn greeting() -> Self {
        Self::new("220", "Welcome to MogiMail")
    }

    /// Create a HELO response (250)
    pub fn helo(hostname: &str, client_domain: &str) -> Self {
        Self::new("250", &format!("{hostname} Hello {client_domain}"))
    }

    /// Create a DATA intermediate response (354)
    pub fn data_start() -> Self {
        Self::new("354", "End data with <CR><LF>.<CR><LF>")
    }

    /// Create a QUIT response (221)
    pub fn quit() -> Self {
        Self::new("221", "Bye")
    }

    /// Create an error response from an error
    pub fn error(code: &str, message: &str) -> Self {
        Self::new(code, message)
    }

    /// Format the response for sending over the wire
    pub fn format(&self) -> String {
        format!("{} {}\r\n", self.code, self.message)
    }

    /// Check if this is a success response (2xx)
    pub fn is_success(&self) -> bool {
        self.code.starts_with('2')
    }

    /// Check if this is an error response (4xx or 5xx)
    pub fn is_error(&self) -> bool {
        self.code.starts_with('4') || self.code.starts_with('5')
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_response_creation() {
        let response = SmtpResponse::new("250", "OK");
        assert_eq!(response.code, "250");
        assert_eq!(response.message, "OK");
    }

    #[test]
    fn test_ok_response() {
        let response = SmtpResponse::ok();
        assert_eq!(response.code, "250");
        assert_eq!(response.message, "OK");
    }

    #[test]
    fn test_greeting_response() {
        let response = SmtpResponse::greeting();
        assert_eq!(response.code, "220");
        assert_eq!(response.message, "Welcome to MogiMail");
    }

    #[test]
    fn test_helo_response() {
        let response = SmtpResponse::helo("server.local", "client.local");
        assert_eq!(response.code, "250");
        assert_eq!(response.message, "server.local Hello client.local");
    }

    #[test]
    fn test_data_start_response() {
        let response = SmtpResponse::data_start();
        assert_eq!(response.code, "354");
        assert_eq!(response.message, "End data with <CR><LF>.<CR><LF>");
    }

    #[test]
    fn test_quit_response() {
        let response = SmtpResponse::quit();
        assert_eq!(response.code, "221");
        assert_eq!(response.message, "Bye");
    }

    #[test]
    fn test_error_response() {
        let response = SmtpResponse::error("500", "Syntax error");
        assert_eq!(response.code, "500");
        assert_eq!(response.message, "Syntax error");
    }

    #[test]
    fn test_format() {
        let response = SmtpResponse::new("250", "OK");
        assert_eq!(response.format(), "250 OK\r\n");
    }

    #[test]
    fn test_is_success() {
        let success_response = SmtpResponse::new("250", "OK");
        assert!(success_response.is_success());

        let error_response = SmtpResponse::new("500", "Error");
        assert!(!error_response.is_success());
    }

    #[test]
    fn test_is_error() {
        let error_response = SmtpResponse::new("500", "Error");
        assert!(error_response.is_error());

        let client_error_response = SmtpResponse::new("421", "Service not available");
        assert!(client_error_response.is_error());

        let success_response = SmtpResponse::new("250", "OK");
        assert!(!success_response.is_error());
    }
}