Adds configuration for email server by provider

configuration/production.yaml

···
   require_ssl: true
 email_client:
   base_url: "https://api.postmarkapp.com"
+  server: "postmark"

configuration/test.yaml

···
   id: "12345abcdef"
 database:
   port: 54321
+email_client:
+  base_url: http://localhost:8025
+  server: mailpit
 s3_client:
   access_key: S3SecretKeyx123456789
   endpoint: http://127.0.0.1:9002
   region: global
   secret_key: S3AccessKey
+hosts:
+  client: "http://127.0.0.1:5173"
 redis_uri: "redis://127.0.0.1:63791"

src/configuration.rs

···
 use crate::clients::cloudinary_client::CloudinaryClient;
 use crate::clients::s3_client::S3Client;
 use crate::domain::SubscriberEmail;
-use crate::email_client::EmailClient;
+use crate::email_client::{EmailClient, EmailServer, deserialize_email_server_from_string};
 use secrecy::{ExposeSecret, Secret};
 use serde::Deserialize;
 use serde_aux::field_attributes::deserialize_number_from_string;
···
     pub authorization_token: Secret<String>,
     #[serde(deserialize_with = "deserialize_number_from_string")]
     pub timeout_milliseconds: u64,
+    #[serde(deserialize_with = "deserialize_email_server_from_string")]
+    pub server: EmailServer,
 }
 
 impl EmailClientSettings {
···
             sender_email,
             self.authorization_token,
             timeout,
+            self.server,
         )
     }
 

src/email_client.rs

···
 use crate::domain::SubscriberEmail;
 use reqwest::Client;
 use secrecy::{ExposeSecret, Secret};
+use serde::{Deserialize, Deserializer, Serialize};
 
 pub struct EmailClient {
     http_client: Client,
     base_url: String,
     sender: SubscriberEmail,
     authorization_token: Secret<String>,
+    pub server: EmailServer,
 }
 
 impl EmailClient {
···
         sender: SubscriberEmail,
         authorization_token: Secret<String>,
         timeout: std::time::Duration,
+        server: EmailServer,
     ) -> Self {
         let http_client = Client::builder().timeout(timeout).build().unwrap();
         Self {
···
             base_url,
             sender,
             authorization_token,
+            server,
         }
     }
 
···
         html_content: &str,
         text_content: &str,
     ) -> Result<(), reqwest::Error> {
-        let url = format!("{}/email", self.base_url);
+        let url: String = self.server.url(&self.base_url);
         let request_body = SendEmailRequest {
             from: self.sender.as_ref(),
             to: recipient.as_ref(),
···
             html_body: html_content,
             text_body: text_content,
         };
-        self.http_client
-            .post(&url)
-            .header(
-                "X-Postmark-Server-Token",
-                self.authorization_token.expose_secret(),
-            )
-            .json(&request_body)
-            .send()
-            .await?
-            .error_for_status()?;
+        let builder = self.http_client.post(&url).header(
+            "X-Postmark-Server-Token",
+            self.authorization_token.expose_secret(),
+        );
+
+        match self.server {
+            EmailServer::Mailpit => builder.json(&MailpitSendEmailRequest::from(request_body)),
+            EmailServer::Postmark => builder.json(&request_body),
+        }
+        .send()
+        .await?
+        .error_for_status()?;
+
         Ok(())
     }
 }
···
     text_body: &'a str,
 }
 
+impl From<SendEmailRequest<'_>> for MailpitSendEmailRequest {
+    fn from(email_request: SendEmailRequest) -> Self {
+        MailpitSendEmailRequest {
+            from: MailpitContact {
+                email: email_request.from.to_string(),
+                name: Some("".to_string()),
+            },
+            to: vec![MailpitContact {
+                email: email_request.to.to_string(),
+                name: Some("".to_string()),
+            }],
+            subject: email_request.subject.to_string(),
+            text: email_request.text_body.to_string(),
+            html: email_request.html_body.to_string(),
+        }
+    }
+}
+
+#[derive(Serialize, Debug)]
+#[serde(rename_all = "PascalCase")]
+pub struct MailpitContact {
+    pub email: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+
+#[derive(Serialize, Debug)]
+#[serde(rename_all = "PascalCase")]
+pub struct MailpitSendEmailRequest {
+    pub from: MailpitContact,
+    pub to: Vec<MailpitContact>,
+    pub subject: String,
+    pub text: String,
+    pub html: String,
+}
+
+/// The possible email services for our application.
+#[derive(Clone)]
+pub enum EmailServer {
+    Postmark,
+    Mailpit,
+}
+
+impl EmailServer {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            EmailServer::Postmark => "postmark",
+            EmailServer::Mailpit => "mailpit",
+        }
+    }
+
+    pub fn url(&self, base_url: &str) -> String {
+        match self {
+            EmailServer::Postmark => format!("{}/email", base_url),
+            EmailServer::Mailpit => format!("{}/api/v1/send", base_url),
+        }
+    }
+}
+
+impl TryFrom<String> for EmailServer {
+    type Error = String;
+
+    fn try_from(s: String) -> Result<Self, Self::Error> {
+        match s.to_lowercase().as_str() {
+            "postmark" => Ok(Self::Postmark),
+            "mailpit" => Ok(Self::Mailpit),
+            other => Err(format!(
+                "{} is not a supported email server. Use either `postmark` or `mailpit`.",
+                other
+            )),
+        }
+    }
+}
+
+pub fn deserialize_email_server_from_string<'de, D>(
+    deserializer: D,
+) -> Result<EmailServer, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let email_server: String = Deserialize::deserialize(deserializer)?;
+
+    EmailServer::try_from(email_server).map_err(serde::de::Error::custom)
+}
+
 #[cfg(test)]
 mod tests {
     use crate::domain::SubscriberEmail;
-    use crate::email_client::EmailClient;
+    use crate::email_client::{EmailClient, EmailServer};
     use claims::{assert_err, assert_ok};
     use fake::faker::internet::en::SafeEmail;
     use fake::faker::lorem::en::{Paragraph, Sentence};
···
             email(),
             Secret::new(Faker.fake()),
             std::time::Duration::from_millis(200),
+            EmailServer::Postmark,
         )
     }
 

tests/api/admin/newsletters/detail/publish.rs

···
         .await;
     assert_eq!(201, response.status().as_u16());
 
-    Mock::given(path("/email"))
+    Mock::given(path("/api/v1/send"))
         .and(method("POST"))
         .respond_with(ResponseTemplate::new(200))
         .expect(1)
···
         .await;
     assert_eq!(201, response.status().as_u16());
 
-    Mock::given(path("/email"))
+    Mock::given(path("/api/v1/send"))
         .and(method("POST"))
         .respond_with(ResponseTemplate::new(200))
         .expect(1)
···
     }))
     .await;
 
-    Mock::given(path("/email"))
+    Mock::given(path("/api/v1/send"))
         .and(method("POST"))
         // Setting a long delay to ensure that the second request
         // arrives before the first one completes

tests/api/helpers.rs

···
 use fake::faker::name::en::Name;
 use newsletter_api::clients::cloudinary_client::CloudinaryClient;
 use newsletter_api::configuration::{DatabaseSettings, get_configuration};
-use newsletter_api::email_client::EmailClient;
+use newsletter_api::email_client::{EmailClient, EmailServer};
 use newsletter_api::issue_delivery_worker::{ExecutionOutcome, try_execute_task};
 use newsletter_api::models::{NewUser, NewUserData, UserProfile};
 use newsletter_api::startup::{Application, get_connection_pool};
···
             "user_id": user_id
         });
 
-        let _mock_guard = Mock::given(path("/email"))
+        let _mock_guard = Mock::given(path("/api/v1/send"))
             .and(method("POST"))
             .respond_with(ResponseTemplate::new(200))
             .named("Create unconfirmed subscriber")
···
             confirmation_link
         };
 
-        let html = get_link(body["HtmlBody"].as_str().unwrap());
-        let plain_text = get_link(body["TextBody"].as_str().unwrap());
+        let html = match self.email_client.server {
+            EmailServer::Mailpit => get_link(body["Html"].as_str().unwrap()),
+            EmailServer::Postmark => get_link(body["HtmlBody"].as_str().unwrap()),
+        };
+        let plain_text = match self.email_client.server {
+            EmailServer::Mailpit => get_link(body["Text"].as_str().unwrap()),
+            EmailServer::Postmark => get_link(body["TextBody"].as_str().unwrap()),
+        };
+
         ConfirmationLinks { html, plain_text }
     }
 }

tests/api/subscriptions.rs

···
     // Arrange
     let app = spawn_app().await;
 
-    Mock::given(path("/email"))
+    Mock::given(path("/api/v1/send"))
         .and(method("POST"))
         .respond_with(ResponseTemplate::new(200))
         .mount(&app.email_server)
···
     // Arrange
     let app = spawn_app().await;
 
-    Mock::given(path("/email"))
+    Mock::given(path("/api/v1/send"))
         .and(method("POST"))
         .respond_with(ResponseTemplate::new(200))
         .expect(1)
···
     // Arrange
     let app = spawn_app().await;
 
-    Mock::given(path("/email"))
+    Mock::given(path("/api/v1/send"))
         .and(method("POST"))
         .respond_with(ResponseTemplate::new(200))
         .mount(&app.email_server)