feat: added faster timeout for client

Author: Utilitycoder

configuration/base.yml

@@ -11,4 +11,5 @@ database:
 email_client:
   base_url: "localhost"
   sender_email: "[email protected]"
-  authorization_token: "my-secret-token"
+  authorization_token: "my-secret-token"
+  timeout_milliseconds: 10000

src/configuration.rs

@@ -24,12 +24,17 @@ pub struct EmailClientSettings {
     pub base_url: String,
     pub sender_email: String,
     pub authorization_token: Secret<String>,
+    pub timeout_ms: u64,
 }
 
 impl EmailClientSettings {
     pub fn sender(&self) -> Result<SubscriberEmail, String> {
         SubscriberEmail::parse(self.sender_email.clone())
     }
+
+    pub fn timeout(&self) -> std::time::Duration {
+        std::time::Duration::from_millis(self.timeout_ms)
+    }
 }
 
 #[derive(serde::Deserialize)]

src/email_client.rs

@@ -15,9 +15,14 @@ impl EmailClient {
         base_url: String,
         sender: SubscriberEmail,
         authorization_token: Secret<String>,
+        timeout: std::time::Duration,
     ) -> Self {
+        let http_client = Client::builder()
+            .timeout(timeout)
+            .build()
+            .unwrap();
         Self {
-            http_client: Client::new(),
+            http_client,
             base_url,
             sender,
             authorization_token,
@@ -51,14 +56,15 @@ impl EmailClient {
             )
             .json(&request_body)
             .send()
-            .await?;
+            .await?
+            .error_for_status()?;
         Ok(())
     }
 }
 
 #[derive(serde::Serialize)]
 #[serde(rename_all = "PascalCase")]
-pub struct SendEmailRequest <'a> {
+pub struct SendEmailRequest<'a> {
     pub from: &'a str,
     pub to: &'a str,
     pub subject: &'a str,
@@ -69,14 +75,15 @@ pub struct SendEmailRequest <'a> {
 #[cfg(test)]
 mod tests {
     use crate::{domain::SubscriberEmail, email_client::EmailClient};
+    use claim::{assert_err, assert_ok};
     use fake::{
         faker::internet::en::SafeEmail,
         faker::lorem::en::{Paragraph, Sentence},
         Fake, Faker,
     };
     use secrecy::Secret;
     use wiremock::{
-        matchers::{header, header_exists, method, path},
+        matchers::{any, header, header_exists, method, path},
         Mock, MockServer, Request, ResponseTemplate,
     };
 
@@ -98,11 +105,31 @@ mod tests {
         }
     }
 
+    fn generate_subject() -> String {
+        Sentence(1..2).fake()
+    }
+
+    fn generate_content() -> String {
+        Paragraph(1..10).fake()
+    }
+
+    fn get_email_client(base_url: String) -> EmailClient {
+        EmailClient::new(
+            base_url,
+            SubscriberEmail::parse(SafeEmail().fake()).unwrap(),
+            Secret::new(Faker.fake()),
+            std::time::Duration::from_millis(200),
+        )
+    }
+
+    fn get_email() -> SubscriberEmail {
+        SubscriberEmail::parse(SafeEmail().fake()).unwrap()
+    }
+
     #[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()));
+        let email_client = get_email_client(mock_server.uri());
 
         Mock::given(header_exists("X-Postmark-Server-Token"))
             .and(header("Content-Type", "application/json"))
@@ -114,12 +141,92 @@ mod tests {
             .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 recipient = get_email();
 
         let _ = email_client
-            .send_email(recipient, &subject, &content, &content)
+            .send_email(
+                recipient,
+                &generate_subject(),
+                &generate_content(),
+                &generate_content(),
+            )
+            .await;
+    }
+
+    #[tokio::test]
+    async fn send_email_succeeds_if_server_returns_200() {
+        let mock_server = MockServer::start().await;
+        let email_client = get_email_client(mock_server.uri());
+
+        let subscriber_email = get_email();
+
+        Mock::given(any())
+            .respond_with(ResponseTemplate::new(200))
+            .expect(1)
+            .mount(&mock_server)
             .await;
+
+        let outcome = email_client
+            .send_email(
+                subscriber_email,
+                &generate_subject(),
+                &generate_content(),
+                &generate_content(),
+            )
+            .await;
+
+        assert_ok!(outcome);
+    }
+
+    #[tokio::test]
+    async fn send_email_fails_if_server_returns_500() {
+        let mock_server = MockServer::start().await;
+        let email_client = get_email_client(mock_server.uri());
+
+        let subscriber_email = get_email();
+
+        Mock::given(any())
+            .respond_with(ResponseTemplate::new(500))
+            .expect(1)
+            .mount(&mock_server)
+            .await;
+
+        let outcome = email_client
+            .send_email(
+                subscriber_email,
+                &generate_subject(),
+                &generate_content(),
+                &generate_content(),
+            )
+            .await;
+
+        assert_err!(outcome);
+    }
+
+    #[tokio::test]
+    async fn send_email_times_out_if_server_takes_too_long() {
+        let mock_server = MockServer::start().await;
+        let email_client = get_email_client(mock_server.uri());
+
+        let subscriber_email = get_email();
+
+        let response = ResponseTemplate::new(200).set_delay(std::time::Duration::from_secs(180));
+
+        Mock::given(any())
+            .respond_with(response)
+            .expect(1)
+            .mount(&mock_server)
+            .await;
+
+        let outcome = email_client
+            .send_email(
+                subscriber_email,
+                &generate_subject(),
+                &generate_content(),
+                &generate_content(),
+            )
+            .await;
+
+        assert_err!(outcome);
     }
 }

src/main.rs

@@ -23,10 +23,12 @@ async fn main() -> std::io::Result<()> {
         .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 listener = TcpListener::bind(address).expect("Failed to bind random port");

tests/health_check.rs

@@ -50,10 +50,14 @@ async fn spawn_app() -> TestApp {
         .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,
     );
 
     // Launch our application as a background task