chore: Tested duplicated subscription

Author: Utilitycoder

Cargo.lock

@@ -17,7 +17,7 @@ actix-web = "4"
 tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
 serde = {version = "1.0.163", features = ["derive"]}
 serde-aux = "4.2.0" 
-config = "0.11"
+config = {version = "0.13", default-features = false, features = ["yaml"] }
 uuid = { version = "1.3.3", features = ["v4"] }
 chrono = "0.4.15"
 tracing = { version = "0.1", features = ["log"] }
@@ -26,7 +26,7 @@ tracing-bunyan-formatter = "0.3.3"
 tracing-log = "0.1"
 secrecy = { version = "0.8", features = ["serde"] }
 tracing-actix-web = "0.5"
-sqlx = { version = "0.5.7", default-features = false, features = ["offline", "runtime-actix-rustls", "macros", "postgres", "uuid", "chrono", "migrate"] }
+sqlx = { version = "0.6", default-features = false, features = ["runtime-actix-rustls", "macros", "postgres", "uuid", "chrono", "migrate", "offline"] }
 unicode-segmentation = "1"
 validator = "0.16.0"
 reqwest = { version = "0.11.18", default-features = false, features = ["json", "rustls-tls"] }

Cargo.toml

@@ -65,4 +65,4 @@ databases:
   num_nodes: 1
   size: db-s-dev-database
   # Postgres version - using the latest here
-  version: "12"
+  version: "14"

spec.yaml

@@ -1,18 +1,3 @@
 {
-  "db": "PostgreSQL",
-  "bcfcfebc6f5e8ffbf97d97c5a209be78b46d703924482cf8b43842705fcb7714": {
-    "describe": {
-      "columns": [],
-      "nullable": [],
-      "parameters": {
-        "Left": [
-          "Uuid",
-          "Text",
-          "Text",
-          "Timestamptz"
-        ]
-      }
-    },
-    "query": "\n        INSERT INTO subscriptions (id, email, name, subscribed_at)\n        VALUES ($1, $2, $3, $4)\n        "
-  }
+  "db": "PostgreSQL"
 }

sqlx-data.json

@@ -3,6 +3,7 @@ use secrecy::{ExposeSecret, Secret};
 use serde_aux::field_attributes::deserialize_number_from_string;
 use sqlx::postgres::{PgConnectOptions, PgSslMode};
 use sqlx::ConnectOptions;
+use std::convert::{TryFrom, TryInto};
 use tracing_log::log;
 
 #[derive(serde::Deserialize, Clone)]
@@ -73,28 +74,27 @@ impl DatabaseSettings {
 
 pub fn get_configuration() -> Result<Settings, config::ConfigError> {
     // Initialize our configuration reader
-    let mut settings = config::Config::default();
     let base_path = std::env::current_dir().expect("Failed to determine the current directory");
     let configuration_directory = base_path.join("configuration");
 
-    // Read the "default" configuration file
-    settings.merge(config::File::from(configuration_directory.join("base")).required(true))?;
-
     // Detect the running environment
     // Default to 'local' if unspecified
     let environment: Environment = std::env::var("APP_ENVIRONMENT")
         .unwrap_or_else(|_| "local".into())
         .try_into()
         .expect("APP_ENVIRONMENT must be 'local' or 'production'");
 
-    // Layer on environment specific values
-    settings.merge(
-        config::File::from(configuration_directory.join(environment.as_str())).required(true),
-    )?;
+    let environment_filename = format!("{}.yml", environment.as_str());
 
-    settings.merge(config::Environment::with_prefix("app").separator("__"))?;
+    let settings = config::Config::builder().add_source(
+        config::File::from(configuration_directory.join("base"),
+    )).add_source(
+        config::File::from(configuration_directory.join(environment_filename)),
+    ).add_source(
+        config::Environment::with_prefix("app").prefix_separator("_").separator("__"),
+    ).build()?;
 
-    settings.try_into()
+    settings.try_deserialize::<Settings>()
 }
 
 // The possible runtime environment for our application
@@ -105,7 +105,7 @@ pub enum Environment {
 }
 
 impl Environment {
-    pub fn as_str(&self) -> &str {
+    pub fn as_str(&self) -> &'static str {
         match self {
             Environment::Local => "local",
             Environment::Production => "production",

src/configuration.rs

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

src/domain/subscriber_email.rs

@@ -44,9 +44,9 @@ impl EmailClient {
             text_body: text_content,
         };
 
-        let _builder = self
+        self
             .http_client
-            .post(url)
+            .post(&url)
             .header(
                 "X-Postmark-Server-Token",
                 self.authorization_token.expose_secret(),
@@ -62,11 +62,11 @@ impl EmailClient {
 #[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,
+    from: &'a str,
+    to: &'a str,
+    subject: &'a str,
+    html_body: &'a str,
+    text_body: &'a str,
 }
 
 #[cfg(test)]

src/email_client.rs

@@ -1,5 +1,5 @@
 use actix_web::HttpResponse;
 
 pub async fn health_check() -> HttpResponse {
-    HttpResponse::Ok().into()
+    HttpResponse::Ok().finish()
 }

src/routes/health_check.rs

@@ -6,9 +6,9 @@ use crate::{
 use actix_web::{web, HttpResponse};
 use chrono::Utc;
 use rand::{distributions::Alphanumeric, thread_rng, Rng};
-
-use sqlx::types::Uuid;
 use sqlx::{PgPool, Postgres, Transaction};
+use std::convert::{TryInto, TryFrom};
+use uuid::Uuid;
 
 #[allow(dead_code)]
 #[derive(serde::Deserialize)]
@@ -27,12 +27,13 @@ impl TryFrom<FormData> for NewSubscriber {
     }
 }
 
+#[allow(clippy::async_yields_async)]
 #[tracing::instrument(
     name = "Adding a new subscriber",
     skip(form, pool, email_client, base_url),
     fields(
-        email = %form.email,
-        name = %form.name
+        subscriber_email = %form.email,
+        subscriber_name = %form.name
     )
 )]
 pub async fn subscribe(
@@ -43,22 +44,30 @@ pub async fn subscribe(
 ) -> HttpResponse {
     let new_subscriber = match form.0.try_into() {
         Ok(subscriber) => subscriber,
-        Err(e) => return HttpResponse::BadRequest().body(e),
+        Err(_) => return HttpResponse::BadRequest().finish(),
     };
 
     let mut transaction = match pool.begin().await {
         Ok(t) => t,
         Err(_) => return HttpResponse::InternalServerError().finish(),
     };
 
+    if search_for_existing_subscription(&new_subscriber, &mut transaction).await.is_err() {
+        return HttpResponse::InternalServerError().finish();
+    }
+
     let subscriber_id = match insert_subscriber(&new_subscriber, &mut transaction).await {
         Ok(id) => id,
         Err(_) => return HttpResponse::InternalServerError().finish(),
     };
 
     let subscription_token = generate_subscription_token();
 
-    if store_token(subscriber_id, &subscription_token, &pool).await.is_err() {
+    if store_token(subscriber_id, &subscription_token, &mut transaction).await.is_err() {
+        return HttpResponse::InternalServerError().finish();
+    }
+
+    if transaction.commit().await.is_err() {
         return HttpResponse::InternalServerError().finish();
     }
 
@@ -69,10 +78,6 @@ pub async fn subscribe(
         return HttpResponse::InternalServerError().finish();
     }
 
-    if transaction.commit().await.is_err() {
-        return HttpResponse::InternalServerError().finish();
-    }
-
     HttpResponse::Ok().finish()
 }
 
@@ -142,12 +147,12 @@ async fn insert_subscriber(
 /// Store subscription token in the database
 #[tracing::instrument(
     name = "Saving subscription token in the database",
-    skip(subscriber_id, subscription_token, pool)
+    skip(subscriber_id, subscription_token, transaction)
 )]
 async fn store_token(
     subscriber_id: Uuid,
     subscription_token: &str,
-    pool: &PgPool,
+    transaction: &mut Transaction <'_ , Postgres>
 ) -> Result<(), sqlx::Error> {
     sqlx::query!(
         r#"
@@ -157,7 +162,7 @@ async fn store_token(
         subscription_token,
         subscriber_id,
     )
-    .execute(pool)
+    .execute(transaction)
     .await
     .map_err(|e| {
         tracing::error!("Failed to execute query: {:?}", e);
@@ -173,4 +178,26 @@ fn generate_subscription_token() -> String {
         .map(char::from)
         .take(25)
         .collect()
+}
+
+async fn search_for_existing_subscription(
+    new_subscriber: &NewSubscriber,
+    transaction: &mut Transaction<'_, Postgres>
+) -> Result<(), sqlx::Error> {
+    sqlx::query!(
+        r#"
+        SELECT email, name
+        FROM subscriptions
+        WHERE email = $1 AND name = $2
+        "#,
+        new_subscriber.email.as_ref(),
+        new_subscriber.name.as_ref(),
+    )
+    .fetch_optional(transaction)
+    .await
+    .map_err(|e| {
+        tracing::error!("Failed to execute query: {:?}", e);
+        e
+    })?;
+    Ok(())
 }

src/routes/subscriptions.rs

@@ -1,5 +1,6 @@
 use actix_web::{web, HttpResponse};
-use sqlx::{PgPool, types::Uuid};
+use sqlx::PgPool;
+use uuid::Uuid;
 
 #[derive(serde::Deserialize)]
 pub struct Parameters {
@@ -10,7 +11,7 @@ pub struct Parameters {
 pub async fn confirm(parameters: web::Query<Parameters>, pool: web::Data<PgPool>) -> HttpResponse {
     let id = match get_subscriber_id_from_token(&parameters.subscription_token, &pool).await {
         Ok(id) => id,
-        Err(_) => return HttpResponse::BadRequest().finish(),
+        Err(_) => return HttpResponse::InternalServerError().finish(),
     };
 
     match id {