11.11

Author: timonviola

src/configuration.rs

@@ -1,11 +1,27 @@
 use crate::domain::SubscriberEmail;
+use crate::email_client::EmailClient;
 use secrecy::ExposeSecret;
 use secrecy::Secret;
 use sqlx::postgres::{PgConnectOptions, PgSslMode};
 
 use serde_aux::field_attributes::deserialize_number_from_string;
 use std::convert::{TryFrom, TryInto};
 
+
+impl EmailClientSettings {
+    pub fn client(self) -> EmailClient {
+        let sender_email = self.sender().expect("Invalid sender email address.");
+        let timeout = self.timeout();
+        EmailClient::new(
+            self.base_url,
+            sender_email,
+            self.authorization_token,
+            timeout,
+        )
+    }
+
+}
+
 #[derive(serde::Deserialize, Clone)]
 pub struct Settings {
     pub database: DatabaseSettings,

src/issue_delivery_worker.rs

@@ -7,7 +7,7 @@ use sqlx::{Executor, PgPool, Postgres, Transaction};
 use tracing::{field::display, Span};
 use uuid::Uuid;
 
-enum ExecutionOutcome {
+pub enum ExecutionOutcome {
     TaskCompleted,
     EmptyQueue,
 }
@@ -20,7 +20,7 @@ enum ExecutionOutcome {
     ),
     err
 )]
-async fn try_execute_task(pool: &PgPool, email_client: &EmailClient) -> Result<ExecutionOutcome, anyhow::Error> {
+pub async fn try_execute_task(pool: &PgPool, email_client: &EmailClient) -> Result<ExecutionOutcome, anyhow::Error> {
     let task = dequeue_task(pool).await?;
     if task.is_none() {
         return Ok(ExecutionOutcome::EmptyQueue)
@@ -155,17 +155,6 @@ pub async fn run_worker_until_stopped(
     configuration: Settings
 ) -> Result<(), anyhow::Error> {
     let connection_pool = get_connection_pool(&configuration.database);
-
-    let sender_email = configuration
-        .email_client
-        .sender()
-        .expect("Invalid sender email address.");
-    let timeout = configuration.email_client.timeout();
-    let email_client = EmailClient::new(
-        configuration.email_client.base_url, 
-        sender_email,
-        configuration.email_client.authorization_token,
-        timeout
-    );
+    let email_client = configuration.email_client.client();
     worker_loop(connection_pool, email_client).await
 }

src/startup.rs

@@ -1,6 +1,7 @@
 use crate::authentication::reject_anonymous_users;
 use crate::configuration::DatabaseSettings;
 use crate::configuration::Settings;
+use crate::email_client;
 use crate::email_client::EmailClient;
 use crate::routes::admin_dashboard;
 use crate::routes::{change_password, change_password_form};
@@ -36,19 +37,7 @@ impl Application {
     pub async fn build(configuration: Settings) -> Result<Self, std::io::Error> {
         let connection_pool = get_connection_pool(&configuration.database);
 
-        let sender_email = configuration
-            .email_client
-            .sender()
-            .expect("Invalid sender email address.");
-
-        let timeout = configuration.email_client.timeout();
-
-        let email_client = EmailClient::new(
-            configuration.email_client.base_url,
-            sender_email,
-            configuration.email_client.authorization_token,
-            timeout,
-        );
+        let email_client = configuration.email_client.client();
         let address = format!(
             "{}:{}",
             configuration.application.host, configuration.application.port

tests/api/helpers.rs

@@ -10,6 +10,8 @@ use wiremock::MockServer;
 use zero2prod::configuration::{get_configuration, DatabaseSettings};
 use zero2prod::startup::{get_connection_pool, Application};
 use zero2prod::telemetry::{get_subscriber, init_subscriber};
+use zero2prod::email_client::EmailClient;
+use zero2prod::issue_delivery_worker::{try_execute_task, ExecutionOutcome};
 
 static TRACING: LazyLock<()> = LazyLock::new(|| {
     let _default_filter_level = "info".to_string();
@@ -76,6 +78,7 @@ pub struct TestApp {
     pub port: u16,
     pub test_user: TestUser,
     pub api_client: reqwest::Client,
+    pub email_client: EmailClient,
 }
 
 pub struct ConfirmationLinks {
@@ -84,6 +87,17 @@ pub struct ConfirmationLinks {
 }
 
 impl TestApp {
+    pub async fn dispatch_all_pending_emails(&self) {
+        loop {
+            if let ExecutionOutcome::EmptyQueue = try_execute_task(&self.db_pool, &self.email_client)
+                .await
+                .unwrap()
+            {
+                break;
+            }
+        }
+    }
+
     pub async fn post_logout(&self) -> reqwest::Response {
         self.api_client
             .post(&format!("{}/admin/logout", &self.address))
@@ -259,6 +273,7 @@ pub async fn spawn_app() -> TestApp {
         email_server,
         test_user: TestUser::generate(),
         api_client: client,
+        email_client: configuration.email_client.client(),
     };
     test_app.test_user.store(&test_app.db_pool).await;
     test_app

tests/api/newsletter.rs

@@ -34,7 +34,9 @@ async fn concurrent_form_submissions_handled_gracefully() {
     assert_eq!(
         response1.text().await.unwrap(),
         response2.text().await.unwrap()
-    )
+    );
+
+    app.dispatch_all_pending_emails().await;
 }
 
 #[tokio::test]
@@ -132,7 +134,11 @@ async fn newsletters_are_delivered_to_confirmed_subscribers() {
         .await;
     assert_is_redirect_to(&response, "/admin/newsletters");
     let html_page = app.get_submit_newsletters_html().await;
-    assert!(html_page.contains("<p><i>The newsletter issue has been published!</i></p>"));
+    assert!(html_page.contains(
+        "The newsletter issue has been accepted - \
+        email will go out shortly."
+    ));
+    app.dispatch_all_pending_emails().await;
     // Mock verifies on Drop that we have sent the newsletter email
 }
 
@@ -160,8 +166,12 @@ async fn newsletters_are_not_delivered_to_unconfirmed_subscribers() {
     let response = app.post_newsletters(&newsletter_request_body).await;
     assert_is_redirect_to(&response, "/admin/newsletters");
     let html_page = app.get_submit_newsletters_html().await;
+    assert!(html_page.contains(
+        "The newsletter issue has been accepted - \
+        email will go out shortly."
+    ));
+    app.dispatch_all_pending_emails().await;
     // assert on injected FlashMessage content
-    assert!(html_page.contains("<p><i>The newsletter issue has been published!</i></p>"));
     // Mock verifies on Drop that we haven't sent the newsletter email
 }
 
@@ -237,47 +247,43 @@ async fn create_confirmed_subscriber(app: &TestApp) {
         .error_for_status()
         .unwrap();
 }
-
-fn when_sending_an_email() -> MockBuilder {
-    Mock::given(path("/email")).and(method("POST"))
-}
-
 #[tokio::test]
-async fn transient_errors_do_nost_cause_duplicate_deliveries_on_retries() {
+async fn newsletter_creation_is_idempotent() {
+    // Arrange
     let app = spawn_app().await;
-    let newsletter_request_body = serde_json::json!({
-      "title": "Newsletter title",
-      "text_content": "Newsletter body as plain text",
-      "html_content": "<p>Newsletter body as HTML</p>",
-      "idempotency_key": uuid::Uuid::new_v4().to_string(),
-    });
-    create_confirmed_subscriber(&app).await;
     create_confirmed_subscriber(&app).await;
     app.test_user.login(&app).await;
-    when_sending_an_email()
+
+    Mock::given(path("/email"))
+        .and(method("POST"))
         .respond_with(ResponseTemplate::new(200))
-        .up_to_n_times(1)
-        .expect(1)
-        .mount(&app.email_server)
-        .await;
-    // second delivery should fail
-    when_sending_an_email()
-        .respond_with(ResponseTemplate::new(500))
-        .up_to_n_times(1)
         .expect(1)
         .mount(&app.email_server)
         .await;
 
+    let newsletter_request_body = serde_json::json!({
+        "title": "Newsletter title",
+        "text_content": "Newsletter body as plain text",
+        "html_content": "<p>Newsletter body as HTML</p>",
+        "idempotency_key": uuid::Uuid::new_v4().to_string()
+    });
     let response = app.post_newsletters(&newsletter_request_body).await;
+    assert_is_redirect_to(&response, "/admin/newsletters");
 
-    assert_eq!(response.status().as_u16(), 500);
-    when_sending_an_email()
-        .respond_with(ResponseTemplate::new(200))
-        .expect(1)
-        .named("Delivery retry")
-        .mount(&app.email_server)
-        .await;
+    let html_page = app.get_submit_newsletters_html().await;
+    assert!(html_page.contains(
+        "<p><i>The newsletter issue has been accepted - \
+        emails will go out shortly.</i></p>"
+    ));
 
     let response = app.post_newsletters(&newsletter_request_body).await;
-    assert_eq!(response.status().as_u16(), 303);
+    assert_is_redirect_to(&response, "/admin/newsletters");
+
+    let html_page = app.get_submit_newsletters_html().await;
+    assert!(html_page.contains(
+        "The newsletter issue has been accepted - \
+        email will go out shortly."
+    ));
+    app.dispatch_all_pending_emails().await;
 }
+