type driven development, checks for email + name

src/domain/mod.rs

@@ -0,0 +1,7 @@
+mod subscriber_name;
+mod subscriber_email;
+mod new_subscriber;
+
+pub use subscriber_name::SubscriberName;
+pub use subscriber_email::SubscriberEmail;
+pub use new_subscriber::NewSubscriber;

src/domain/new_subscriber.rs

@@ -0,0 +1,7 @@
+use crate::domain::SubscriberName;
+use crate::domain::SubscriberEmail;
+
+pub struct NewSubscriber {
+	pub email: SubscriberEmail,
+	pub name: SubscriberName,
+}

src/domain/subscriber_email.rs

@@ -0,0 +1,65 @@
+use validator::validate_email;
+
+#[derive(Debug)]
+pub struct SubscriberEmail(String);
+
+impl SubscriberEmail {
+	pub fn parse(s: String) -> Result<SubscriberEmail, String> {
+		if validate_email(&s) {
+			Ok(Self(s))
+		} else {
+			Err(format!("{} is not a valid subscriber email.", s))
+		}
+	}
+}
+
+impl AsRef<str> for SubscriberEmail {
+	fn as_ref(&self) -> &str {
+		&self.0
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::SubscriberEmail;
+	use claim::assert_err;
+	use fake::faker::internet::en::SafeEmail;
+	use fake::Fake;
+	use rand::rngs::StdRng;
+	use rand::SeedableRng;
+
+	#[test]
+	fn empty_string_is_rejected() {
+		let email = "".to_string();
+		assert_err!(SubscriberEmail::parse(email));
+	}
+	
+	#[test]
+	fn email_missing_at_symbol_is_rejected() {
+		let email = "ursuladomain.com".to_string();
+		assert_err!(SubscriberEmail::parse(email));
+	}
+	
+	#[test]
+	fn email_missing_subject_is_rejected() {
+		let email = "@domain.com".to_string();
+		assert_err!(SubscriberEmail::parse(email));
+	}
+
+	#[derive(Debug, Clone)]
+	struct ValidEmailFixture(pub String);
+
+	impl quickcheck::Arbitrary for ValidEmailFixture {
+		fn arbitrary(g: &mut quickcheck::Gen) -> Self {
+			let mut rng = StdRng::seed_from_u64(u64::arbitrary(g));
+			let email = SafeEmail().fake_with_rng(&mut rng);
+			Self(email)
+		}
+	}
+
+	#[quickcheck_macros::quickcheck]
+	fn valid_emails_are_parsed_successfully(valid_email: ValidEmailFixture) -> bool {
+		dbg!(&valid_email.0);
+		SubscriberEmail::parse(valid_email.0).is_ok()
+	}
+}

src/domain/subscriber_name.rs

@@ -0,0 +1,59 @@
+use unicode_segmentation::UnicodeSegmentation;
+
+#[derive(Debug)]
+pub struct SubscriberName(String);
+
+impl SubscriberName {
+	pub fn parse(s: String) -> Result<SubscriberName, String> {
+		let is_empty_or_whitespace = s.trim().is_empty();
+		let is_too_long = s.graphemes(true).count() > 2048;
+		let forbidden_characters = [';', ':', '!', '?', '*', '(', ')', '&', '$', '@', '#', '<', '>', '[', ']', '{', '}', '/', '\\'];
+		let contains_forbidden_characters = s.chars().any(|c| forbidden_characters.contains(&c));
+
+		if is_empty_or_whitespace || is_too_long || contains_forbidden_characters
+		{
+			Err(format!("{} is not a valid subscriber name.", s))
+		} else {
+			Ok(Self(s))
+		}
+	}
+}
+
+impl AsRef<str> for SubscriberName {
+	fn as_ref(&self) -> &str {
+		&self.0
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use crate::domain::SubscriberName;
+	use claim::{assert_err, assert_ok};
+
+	#[test]
+	fn a_very_long_name_is_rejected() {
+		let too_long_name = "a".repeat(2049);
+		assert_err!(SubscriberName::parse(too_long_name));
+	}
+
+	#[test]
+	fn a_name_with_forbidden_characters_is_rejected() {
+		let forbidden_characters = vec![';', ':', '!', '?', '*', '(', ')', '&', '$', '@', '#', '<', '>', '[', ']', '{', '}', '/', '\\'];
+		for forbidden_character in forbidden_characters {
+			let name_with_forbidden_character = format!("name{}", forbidden_character);
+			assert_err!(SubscriberName::parse(name_with_forbidden_character));
+		}
+	}
+
+	#[test]
+	fn a_name_with_allowed_characters_is_accepted() {
+		let name = "name".to_string();
+		assert_ok!(SubscriberName::parse(name));
+	}
+
+	#[test]
+	fn empty_string_is_rejected() {
+		let name = "".to_string();
+		assert_err!(SubscriberName::parse(name));
+	}
+}

src/email_client.rs

@@ -0,0 +1,17 @@
+use crate::domain::SubscriberEmail;
+
+pub struct EmailClient {
+	sender: SubscriberEmail,
+}
+
+impl EmailClient {
+	pub async fn send_email(
+		&self,
+		recipient: SubscriberEmail,
+		subject: &str,
+		html_content: &str,
+		text_content: &str,
+	) -> Result<(), String> {
+		todo!("send_email not implemented")
+	}
+}

src/lib.rs

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

src/routes/subscriptions.rs

@@ -4,6 +4,8 @@ use chrono::Utc;
 use uuid::Uuid;
 use sqlx::{query, Pool, Postgres};
 
+use crate::domain::{NewSubscriber, SubscriberEmail, SubscriberName};
+
 #[derive(Deserialize)]
 pub struct FormData {
     pub email: String,
@@ -19,26 +21,39 @@ pub struct FormData {
 	)
 )]
 pub async fn subscribe(form: web::Form<FormData>, connection_pool: web::Data<Pool<Postgres>>) -> HttpResponse {
-	match insert_subscriber(&form, &connection_pool).await
-	{
+	let new_subscriber = match form.0.try_into() {
+		Ok(subscriber) => subscriber,
+		Err(_) => return HttpResponse::BadRequest().finish(),
+	};
+	match insert_subscriber(&new_subscriber, &connection_pool).await {
 		Ok(_) => HttpResponse::Ok().finish(),
 		Err(_) => HttpResponse::InternalServerError().finish(),
 	}
 }
 
+impl TryFrom<FormData> for NewSubscriber {
+	type Error = String;
+
+	fn try_from(form: FormData) -> Result<NewSubscriber, Self::Error> {
+		let name = SubscriberName::parse(form.name)?;
+		let email = SubscriberEmail::parse(form.email)?;
+		Ok(NewSubscriber { email, name })
+	}
+}
+
 #[tracing::instrument(
 	name = "Saving new subscriber details in the database",
-	skip(form, connection_pool)
+	skip(new_subscriber, connection_pool)
 )]
-async fn insert_subscriber(form: &FormData, connection_pool: &Pool<Postgres>) -> Result<(), sqlx::Error> {
+async fn insert_subscriber(new_subscriber: &NewSubscriber, connection_pool: &Pool<Postgres>) -> Result<(), sqlx::Error> {
 	query!(
 		r#"
 		INSERT INTO subscriptions (id, email, name, subscribed_at)
 		VALUES ($1, $2, $3, $4)
 		"#,
 		Uuid::new_v4(),
-		form.email,
-		form.name,
+		new_subscriber.email.as_ref(),
+		new_subscriber.name.as_ref(),
 		Utc::now()
 	)
 	.execute(connection_pool)