feat: email sends expected request

Author: Utilitycoder

Cargo.lock

@@ -29,15 +29,17 @@ tracing-actix-web = "0.5"
 sqlx = { version = "0.5.7", default-features = false, features = ["offline", "runtime-actix-rustls", "macros", "postgres", "uuid", "chrono", "migrate"] }
 unicode-segmentation = "1"
 validator = "0.16.0"
-fake = "2.6.1"
+reqwest = { version = "0.11.18", default-features = false, features = ["json", "rustls-tls"] }
 
 [dev-dependencies]
-reqwest = "0.11.18"
 once_cell = "1"
 claim = "0.5"
 quickcheck = "1.0.3"
 quickcheck_macros = "1.0.0"
 rand = "0.8.5"
+fake = "2.6.1"
+wiremock = "0.5.19"
+serde_json = "1"
 
 [profile.release]
 strip = true

Cargo.toml

@@ -4,4 +4,4 @@ database:
   require_ssl: true
 email_client:
   base_url: "https://api.postmarkapp.com"
-  sender_email: "something@gmail.com"
+  sender_email: "lawal@rowship.com"

configuration/production.yml

@@ -1,3 +1,4 @@
+use crate::domain::SubscriberEmail;
 use secrecy::{ExposeSecret, Secret};
 use serde_aux::field_attributes::deserialize_number_from_string;
 use sqlx::postgres::{PgConnectOptions, PgSslMode};
@@ -8,6 +9,7 @@ use tracing_log::log;
 pub struct Settings {
     pub database: DatabaseSettings,
     pub application: ApplicationSettings,
+    pub email_client: EmailClientSettings,
 }
 
 #[derive(serde::Deserialize)]
@@ -17,6 +19,19 @@ pub struct ApplicationSettings {
     pub host: String,
 }
 
+#[derive(serde::Deserialize)]
+pub struct EmailClientSettings {
+    pub base_url: String,
+    pub sender_email: String,
+    pub authorization_token: Secret<String>,
+}
+
+impl EmailClientSettings {
+    pub fn sender(&self) -> Result<SubscriberEmail, String> {
+        SubscriberEmail::parse(self.sender_email.clone())
+    }
+}
+
 #[derive(serde::Deserialize)]
 pub struct DatabaseSettings {
     pub username: String,

src/configuration.rs

@@ -1,5 +1,6 @@
+use crate::domain::subscriber_email::SubscriberEmail;
 use crate::domain::subscriber_name::SubscriberName;
 pub struct NewSubscriber {
-    pub email: String,
+    pub email: SubscriberEmail,
     pub name: SubscriberName,
 }

src/domain/new_subscriber.rs

@@ -1,6 +1,6 @@
 use validator::validate_email;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct SubscriberEmail(String);
 
 impl SubscriberEmail {

src/domain/subscriber_email.rs

@@ -0,0 +1,125 @@
+use crate::domain::SubscriberEmail;
+use reqwest::Client;
+use secrecy::{ExposeSecret, Secret};
+
+#[derive(Clone)]
+pub struct EmailClient {
+    http_client: Client,
+    base_url: String,
+    sender: SubscriberEmail,
+    authorization_token: Secret<String>,
+}
+
+impl EmailClient {
+    pub fn new(
+        base_url: String,
+        sender: SubscriberEmail,
+        authorization_token: Secret<String>,
+    ) -> Self {
+        Self {
+            http_client: Client::new(),
+            base_url,
+            sender,
+            authorization_token,
+        }
+    }
+}
+
+impl EmailClient {
+    pub async fn send_email(
+        &self,
+        recipient: SubscriberEmail,
+        subject: &str,
+        html_content: &str,
+        text_content: &str,
+    ) -> Result<(), reqwest::Error> {
+        let url = format!("{}/email", self.base_url);
+        let request_body = SendEmailRequest {
+            from: self.sender.as_ref(),
+            to: recipient.as_ref(),
+            subject,
+            html_body: html_content,
+            text_body: text_content,
+        };
+
+        let _builder = self
+            .http_client
+            .post(url)
+            .header(
+                "X-Postmark-Server-Token",
+                self.authorization_token.expose_secret(),
+            )
+            .json(&request_body)
+            .send()
+            .await?;
+        Ok(())
+    }
+}
+
+#[derive(serde::Serialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct SendEmailRequest <'a> {
+    pub from: &'a str,
+    pub to: &'a str,
+    pub subject: &'a str,
+    pub html_body: &'a str,
+    pub text_body: &'a str,
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{domain::SubscriberEmail, email_client::EmailClient};
+    use fake::{
+        faker::internet::en::SafeEmail,
+        faker::lorem::en::{Paragraph, Sentence},
+        Fake, Faker,
+    };
+    use secrecy::Secret;
+    use wiremock::{
+        matchers::{header, header_exists, method, path},
+        Mock, MockServer, Request, ResponseTemplate,
+    };
+
+    struct SendEmailBodyMatcher;
+
+    impl wiremock::Match for SendEmailBodyMatcher {
+        fn matches(&self, request: &Request) -> bool {
+            let result: Result<serde_json::Value, _> = serde_json::from_slice(&request.body);
+
+            if let Ok(body) = result {
+                body.get("From").is_some()
+                    && body.get("To").is_some()
+                    && body.get("Subject").is_some()
+                    && body.get("HtmlBody").is_some()
+                    && body.get("TextBody").is_some()
+            } else {
+                false
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn send_email_sends_the_expected_request() {
+        let mock_server = MockServer::start().await;
+        let sender = SubscriberEmail::parse(SafeEmail().fake()).unwrap();
+        let email_client = EmailClient::new(mock_server.uri(), sender, Secret::new(Faker.fake()));
+
+        Mock::given(header_exists("X-Postmark-Server-Token"))
+            .and(header("Content-Type", "application/json"))
+            .and(method("POST"))
+            .and(path("/email"))
+            .and(SendEmailBodyMatcher)
+            .respond_with(ResponseTemplate::new(200))
+            .expect(1)
+            .mount(&mock_server)
+            .await;
+
+        let recipient = SubscriberEmail::parse(SafeEmail().fake()).unwrap();
+        let subject: String = Sentence(1..2).fake();
+        let content: String = Paragraph(1..10).fake();
+
+        let _ = email_client
+            .send_email(recipient, &subject, &content, &content)
+            .await;
+    }
+}

src/email_client.rs

@@ -1,5 +1,6 @@
 pub mod configuration;
 pub mod domain;
+pub mod email_client;
 pub mod routes;
 pub mod startup;
 pub mod telemetry;

src/lib.rs

@@ -1,6 +1,7 @@
-use robust_rust::configuration::get_configuration;
-use robust_rust::startup::run;
-use robust_rust::telemetry::{get_subscriber, init_subscriber};
+use robust_rust::{
+    configuration::get_configuration, email_client::EmailClient, startup::run,
+    telemetry::get_subscriber, telemetry::init_subscriber,
+};
 use sqlx::postgres::PgPoolOptions;
 use std::net::TcpListener;
 
@@ -16,7 +17,19 @@ async fn main() -> std::io::Result<()> {
         "{}:{}",
         configuration.application.host, configuration.application.port
     );
+
+    let sender_email = configuration
+        .email_client
+        .sender()
+        .expect("Invalid sender email address.");
+
+    let email_client = EmailClient::new(
+        configuration.email_client.base_url,
+        sender_email,
+        configuration.email_client.authorization_token,
+    );
+
     let listener = TcpListener::bind(address).expect("Failed to bind random port");
-    run(listener, connection_pool)?.await?;
+    run(listener, connection_pool, email_client)?.await?;
     Ok(())
 }

src/main.rs

@@ -1,4 +1,4 @@
-use crate::domain::{NewSubscriber, SubscriberName};
+use crate::domain::{NewSubscriber, SubscriberEmail, SubscriberName};
 use actix_web::{web, HttpResponse};
 use chrono::Utc;
 use sqlx::types::Uuid;
@@ -19,16 +19,10 @@ pub struct FormData {
         name = %form.name
     )
 )]
-
 pub async fn subscribe(form: web::Form<FormData>, pool: web::Data<PgPool>) -> HttpResponse {
-    let subscriber_name = match SubscriberName::parse(form.0.name) {
-        Ok(name) => name,
-        Err(_) => return HttpResponse::BadRequest().finish(),
-    };
-
-    let new_subscriber = NewSubscriber {
-        email: form.0.email,
-        name: subscriber_name,
+    let new_subscriber = match form.0.try_into() {
+        Ok(subscriber) => subscriber,
+        Err(e) => return HttpResponse::BadRequest().body(e),
     };
 
     match insert_subscriber(&new_subscriber, &pool).await {
@@ -40,6 +34,16 @@ pub async fn subscribe(form: web::Form<FormData>, pool: web::Data<PgPool>) -> Ht
     }
 }
 
+impl TryFrom<FormData> for NewSubscriber {
+    type Error = String;
+
+    fn try_from(value: FormData) -> Result<Self, Self::Error> {
+        let name = SubscriberName::parse(value.name)?;
+        let email = SubscriberEmail::parse(value.email)?;
+        Ok(Self { name, email })
+    }
+}
+
 #[tracing::instrument(
     name = "Saving a new subscriber details in the database",
     skip(new_subscriber, pool)
@@ -55,7 +59,7 @@ async fn insert_subscriber(
         VALUES ($1, $2, $3, $4)
         "#,
         subscribe_id,
-        new_subscriber.email,
+        new_subscriber.email.as_ref(),
         new_subscriber.name.as_ref(),
         Utc::now()
     )