feat: sends a comfirmation email

Author: Utilitycoder

migrations/20230619105403_add_status_to_subscriptions.sql

@@ -0,0 +1,2 @@
+-- Add migration script here
+ALTER TABLE subscriptions ADD COLUMN status TEXT NULL;

migrations/20230619112026_make_status_not_null_in_subscriptions.sql

@@ -0,0 +1,12 @@
+-- We wrap the whole migration in a transaction to make sure
+-- it succeeds or fails atomically. We will discuss SQL transactions
+-- in more details towards the end of this chapter!
+-- `sqlx` does not do it automatically for us.
+BEGIN;
+-- Backfill `status` for historical entries
+UPDATE subscriptions
+SET status = 'confirmed'
+WHERE status IS NULL;
+-- Make `status` mandatory
+ALTER TABLE subscriptions ALTER COLUMN status SET NOT NULL;
+COMMIT;

migrations/20230619112501_create_subscription_tokens_table.sql

@@ -0,0 +1,7 @@
+-- Create Subscription Tokens Table
+CREATE TABLE subscription_tokens(
+    subscription_token TEXT NOT NULL,
+    subscriber_id uuid NOT NULL
+        REFERENCES subscriptions (id),
+    PRIMARY KEY (subscription_token)
+);

src/routes/subscriptions.rs

@@ -1,4 +1,5 @@
 use crate::domain::{NewSubscriber, SubscriberEmail, SubscriberName};
+use crate::email_client::EmailClient;
 use actix_web::{web, HttpResponse};
 use chrono::Utc;
 use sqlx::types::Uuid;
@@ -13,25 +14,40 @@ pub struct FormData {
 
 #[tracing::instrument(
     name = "Adding a new subscriber",
-    skip(form, pool),
+    skip(form, pool, email_client),
     fields(
         email = %form.email,
         name = %form.name
     )
 )]
-pub async fn subscribe(form: web::Form<FormData>, pool: web::Data<PgPool>) -> HttpResponse {
+pub async fn subscribe(
+    form: web::Form<FormData>,
+    pool: web::Data<PgPool>,
+    email_client: web::Data<EmailClient>,
+) -> HttpResponse {
     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 {
-        Ok(_) => HttpResponse::Ok().finish(),
-        Err(e) => {
-            tracing::error!("Failed to execute query: {:?}", e);
-            HttpResponse::InternalServerError().finish()
-        }
+    if insert_subscriber(&new_subscriber, &pool).await.is_err() {
+        return HttpResponse::InternalServerError().finish();
     }
+
+    if email_client
+        .send_email(
+            new_subscriber.email,
+            "Welcome!",
+            "Welcome to our newsletter!",
+            "Welcome to our newsletter!",
+        )
+        .await
+        .is_err()
+    {
+        return HttpResponse::InternalServerError().finish();
+    }
+
+    HttpResponse::Ok().finish()
 }
 
 impl TryFrom<FormData> for NewSubscriber {
@@ -55,8 +71,8 @@ async fn insert_subscriber(
     let subscribe_id = Uuid::new_v4();
     sqlx::query!(
         r#"
-        INSERT INTO subscriptions (id, email, name, subscribed_at)
-        VALUES ($1, $2, $3, $4)
+        INSERT INTO subscriptions (id, email, name, subscribed_at, status)
+        VALUES ($1, $2, $3, $4, 'confirmed')
         "#,
         subscribe_id,
         new_subscriber.email.as_ref(),

src/startup.rs

@@ -38,7 +38,6 @@ impl Application {
 
         let listener = TcpListener::bind(address)?;
         let port = listener.local_addr().unwrap().port();
-        println!("Port {}", port);
         let server = run(listener, connection_pool, email_client)?;
         Ok(Self { port, server })
     }
@@ -48,7 +47,6 @@ impl Application {
     }
 
     pub async fn run_until_stopped(self) -> Result<(), std::io::Error> {
-        println!("Server running on port {}", self.port);
         self.server.await
     }
 }

tests/api/helpers.rs

@@ -6,6 +6,7 @@ use robust_rust::{
 };
 use sqlx::{Connection, Executor, PgConnection, PgPool};
 use uuid::Uuid;
+use wiremock::MockServer;
 
 // Ensure that the `tracing` stack is only initialized once using `Lazy`.
 static TRACING: Lazy<()> = Lazy::new(|| {
@@ -24,12 +25,27 @@ static TRACING: Lazy<()> = Lazy::new(|| {
 pub struct TestApp {
     pub address: String,
     pub db_pool: PgPool,
+    pub mock_server: MockServer,
+}
+
+impl TestApp {
+    pub async fn post_subscriptions(&self, body: String) -> reqwest::Response {
+        reqwest::Client::new()
+            .post(&format!("{}/subscriptions", &self.address))
+            .header("Content-Type", "application/x-www-form-urlencoded")
+            .body(body)
+            .send()
+            .await
+            .expect("Failed to execute request.")
+    }
 }
 
 #[allow(clippy::let_underscore_future)]
 pub async fn spawn_app() -> TestApp {
     Lazy::force(&TRACING);
 
+    let mock_server = MockServer::start().await;
+
     let configuration = {
         let mut c = get_configuration().expect("Failed to read configuration.");
         c.database.database_name = Uuid::new_v4().to_string();
@@ -53,6 +69,7 @@ pub async fn spawn_app() -> TestApp {
     TestApp {
         address,
         db_pool: get_connection_pool(&configuration.database),
+        mock_server,
     }
 }
 

tests/api/subscriptions.rs

@@ -1,29 +1,40 @@
 use crate::helpers::spawn_app;
+use wiremock::matchers::{method, path};
+use wiremock::{Mock, ResponseTemplate};
+
+#[tokio::test]
+async fn subscribe_sends_a_confirmation_email_for_valid_data() {
+    let app = spawn_app().await;
+    let body = "name=le%20guin&email=ursula_le_guin%40gmail.com";
+
+    Mock::given(path("/email"))
+        .and(method("POST"))
+        .respond_with(ResponseTemplate::new(200))
+        .expect(1)
+        .mount(&app.mock_server)
+        .await;
+
+    let response = app.post_subscriptions(body.into()).await;
+    assert_eq!(200, response.status().as_u16());
+}
 
 #[tokio::test]
 async fn subscribe_returns_a_200_for_valid_form_data() {
     // Arrange
     let app_details = spawn_app().await;
     let connection = &app_details.db_pool;
-    let client = reqwest::Client::new();
 
     // Act
     let body = "name=le%20guid&email=ursula_le_guin%40gmail.com";
-    let response = client
-        .post(&format!("{}/subscriptions", &app_details.address))
-        .header("Content-Type", "application/x-www-form-urlencoded")
-        .body(body)
-        .send()
-        .await
-        .expect("Failed to execute request.");
+    let response = app_details.post_subscriptions(body.into()).await;
     // Assert
     assert_eq!(200, response.status().as_u16());
 
     let saved = sqlx::query!("SELECT email, name FROM subscriptions",)
         .fetch_one(connection)
         .await
         .expect("Failed to fetch saved subscription.");
-    println!("saved: {:?}", saved);
+
     assert_eq!(saved.email, "[email protected]");
     assert_eq!(saved.name, "le guid");
 }
@@ -32,21 +43,14 @@ async fn subscribe_returns_a_200_for_valid_form_data() {
 async fn subscribe_returns_a_400_when_data_is_missing() {
     // Arrange
     let app_details = spawn_app().await;
-    let client = reqwest::Client::new();
     let test_cases = vec![
         ("name=le%20guin", "missing the email"),
         ("email=ursula_le_guin%40gmail.com", "missing the name"),
         ("", "missing both name and email"),
     ];
     for (invalid_body, error_message) in test_cases {
         // Act
-        let response = client
-            .post(&format!("{}/subscriptions", &app_details.address))
-            .header("Content-Type", "application/x-www-form-urlencoded")
-            .body(invalid_body)
-            .send()
-            .await
-            .expect("Failed to execute request.");
+        let response = app_details.post_subscriptions(invalid_body.into()).await;
         // Assert
         assert_eq!(
             400,
@@ -62,7 +66,6 @@ async fn subscribe_returns_a_400_when_data_is_missing() {
 async fn subscribe_returns_a_400_when_fields_are_present_but_empty() {
     // Arrange
     let app_details = spawn_app().await;
-    let client = reqwest::Client::new();
     let test_cases = vec![
         ("name=&email=ursula_le_guin%40gmail.com", "empty name"),
         ("name=le%20guin&email=", "empty email"),
@@ -73,13 +76,7 @@ async fn subscribe_returns_a_400_when_fields_are_present_but_empty() {
     ];
     for (invalid_body, error_message) in test_cases {
         // Act
-        let response = client
-            .post(&format!("{}/subscriptions", &app_details.address))
-            .header("Content-Type", "application/x-www-form-urlencoded")
-            .body(invalid_body)
-            .send()
-            .await
-            .expect("Failed to execute request.");
+        let response = app_details.post_subscriptions(invalid_body.into()).await;
         // Assert
         assert_eq!(
             400,