Refactor

Author: v1adhope

src/main.rs

@@ -1,36 +1,16 @@
-use sqlx::postgres::PgPoolOptions;
-use std::net::TcpListener;
 use zero2prod::config::get_config;
-use zero2prod::email_client::EmailClient;
-use zero2prod::startup::run;
+use zero2prod::startup::App;
 use zero2prod::telemetry::{get_subscriber, init_subscriber};
 
 #[tokio::main]
-async fn main() -> std::io::Result<()> {
+async fn main() -> Result<(), std::io::Error> {
     let subscriber = get_subscriber("zero2prod".into(), "info".into(), std::io::stdout);
     init_subscriber(subscriber);
 
     let cfg = get_config().expect("failed to read config");
-    let sender = cfg
-        .email_client
-        .sender()
-        .expect("invalid sender email address");
-    let timeout = cfg.email_client.timeout();
 
-    let listener = TcpListener::bind(cfg.service.host).expect("failed to bind random port");
+    let app = App::build(cfg).await?;
+    app.run_until_stopped().await?;
 
-    let database = PgPoolOptions::new()
-        .max_connections(5)
-        .connect_with(cfg.database.with_db())
-        .await
-        .expect("failed to connect to Postgres");
-
-    let email_client = EmailClient::new(
-        cfg.email_client.base_url,
-        sender,
-        cfg.email_client.auth_token,
-        timeout,
-    );
-
-    run(listener, database, email_client)?.await
+    Ok(())
 }

src/startup.rs

@@ -1,21 +1,63 @@
 use crate::{
+    config::Settings,
     email_client::EmailClient,
     routes::{healthz, subscribe},
 };
-use actix_web::{App, HttpServer, dev::Server, web};
-use sqlx::PgPool;
+use actix_web::{HttpServer, dev::Server, web};
+use sqlx::{PgPool, postgres::PgPoolOptions};
 use std::{net::TcpListener, time::Duration};
 use tracing_actix_web::TracingLogger;
 
-pub fn run(
+pub struct App {
+    port: u16,
+    server: Server,
+}
+
+impl App {
+    pub async fn build(cfg: Settings) -> Result<Self, std::io::Error> {
+        let pg_pool = PgPoolOptions::new()
+            .max_connections(5)
+            .connect_with(cfg.database.with_db())
+            .await
+            .expect("failed to connect to Postgres");
+
+        let sender = cfg
+            .email_client
+            .sender()
+            .expect("invalid sender email address");
+        let timeout = cfg.email_client.timeout();
+        let email_client = EmailClient::new(
+            cfg.email_client.base_url,
+            sender,
+            cfg.email_client.auth_token,
+            timeout,
+        );
+
+        let listener = TcpListener::bind(cfg.service.host).expect("failed to bind port");
+        let port = listener.local_addr().unwrap().port();
+        let server = run(listener, pg_pool, email_client)?;
+
+        Ok(Self { port, server })
+    }
+
+    pub fn port(&self) -> u16 {
+        self.port
+    }
+
+    pub async fn run_until_stopped(self) -> Result<(), std::io::Error> {
+        self.server.await
+    }
+}
+
+fn run(
     listener: TcpListener,
-    database: PgPool,
+    pg_pool: PgPool,
     email_client: EmailClient,
 ) -> std::io::Result<Server> {
-    let database = web::Data::new(database);
+    let database = web::Data::new(pg_pool);
 
     let srv = HttpServer::new(move || {
-        App::new()
+        actix_web::App::new()
             .wrap(TracingLogger::default())
             .route("/healthz", web::get().to(healthz))
             .route("/subscriptions", web::post().to(subscribe))

tests/api/healthz.rs

@@ -0,0 +1,16 @@
+use crate::helpers::spawn_app;
+
+#[tokio::test]
+async fn healthz_works() {
+    let app = spawn_app().await;
+    let client = reqwest::Client::new();
+
+    let resp = client
+        .get(&format!("{}/healthz", &app.host))
+        .send()
+        .await
+        .expect("failed to execute request");
+
+    assert!(resp.status().is_success());
+    assert_eq!(Some(0), resp.content_length());
+}

tests/api/helpers.rs

@@ -0,0 +1,58 @@
+use once_cell::sync::Lazy;
+use sqlx::{Connection, Executor, PgConnection, PgPool};
+use uuid::Uuid;
+use zero2prod::{
+    config::{Database, get_config},
+    startup::App,
+    telemetry::{get_subscriber, init_subscriber},
+};
+
+static TRACING: Lazy<()> = Lazy::new(|| {
+    if std::env::var("TEST_LOG").is_ok() {
+        let subscriber = get_subscriber("test".into(), "debug".into(), std::io::stdout);
+        init_subscriber(subscriber);
+    } else {
+        let subscriber = get_subscriber("test".into(), "debug".into(), std::io::sink);
+        init_subscriber(subscriber);
+    };
+});
+
+pub struct TestApp {
+    pub host: String,
+    pub pg_pool: PgPool,
+}
+
+pub async fn spawn_app() -> TestApp {
+    Lazy::force(&TRACING);
+
+    let mut cfg = get_config().expect("failed to read config");
+
+    cfg.database.database_name = Uuid::now_v7().to_string();
+    let pg_pool = configure_database(&cfg.database).await;
+
+    cfg.service.host = "127.0.0.1:0".to_string();
+    let app = App::build(cfg).await.expect("failed to build app");
+    let host = format!("http://127.0.0.1:{}", app.port());
+    let _ = tokio::spawn(app.run_until_stopped());
+
+    TestApp { host, pg_pool }
+}
+
+async fn configure_database(cfg: &Database) -> PgPool {
+    let mut conn = PgConnection::connect_with(&cfg.without_db())
+        .await
+        .expect("failed to connect to Postgres");
+    conn.execute(format!(r#"create database "{}""#, cfg.database_name).as_str())
+        .await
+        .expect("failed to create database");
+
+    let pool = PgPool::connect_with(cfg.with_db())
+        .await
+        .expect("failed to connect to Postgres");
+    sqlx::migrate!()
+        .run(&pool)
+        .await
+        .expect("failed to migrate the database");
+
+    pool
+}

tests/api/main.rs

@@ -0,0 +1,3 @@
+mod healthz;
+mod helpers;
+mod subscriptions;

tests/api/subscriptions.rs

@@ -0,0 +1,99 @@
+use reqwest::StatusCode;
+use serde::Serialize;
+
+use crate::helpers::spawn_app;
+
+#[derive(Serialize)]
+struct Subscription {
+    name: Option<String>,
+    email: Option<String>,
+}
+
+#[tokio::test]
+async fn subscribe_returns_a_200_for_valid_form_data() {
+    let app = spawn_app().await;
+    let client = reqwest::Client::new();
+
+    let sub = Subscription {
+        name: Some("vla".to_string()),
+        email: Some("vla@example.com".to_string()),
+    };
+
+    let resp = client
+        .post(&format!("{}/subscriptions", &app.host))
+        .form(&sub)
+        .send()
+        .await
+        .expect("failed to execute request");
+
+    assert_eq!(StatusCode::OK, resp.status());
+
+    let saved = sqlx::query!("select email, name from subscriptions")
+        .fetch_one(&app.pg_pool)
+        .await
+        .expect("failed to fetch saved subscription");
+
+    assert_eq!(saved.name, sub.name);
+    assert_eq!(saved.email, sub.email);
+}
+
+#[tokio::test]
+async fn subscribe_returns_a_400() {
+    let app = spawn_app().await;
+    let client = reqwest::Client::new();
+    let test_cases = vec![
+        (
+            "Missing email",
+            Subscription {
+                name: Some("vla".to_string()),
+                email: None,
+            },
+        ),
+        (
+            "Missing name",
+            Subscription {
+                name: None,
+                email: Some("vla@example.com".to_string()),
+            },
+        ),
+        (
+            "Missing whole data",
+            Subscription {
+                name: None,
+                email: None,
+            },
+        ),
+        (
+            "Empty email",
+            Subscription {
+                name: Some("vla".to_string()),
+                email: Some("".to_string()),
+            },
+        ),
+        (
+            "Empty name",
+            Subscription {
+                name: Some("".to_string()),
+                email: Some("vla@example.com".to_string()),
+            },
+        ),
+        (
+            "Invalid email",
+            Subscription {
+                name: Some("vla".to_string()),
+                email: Some("vla-example.com".to_string()),
+            },
+        ),
+    ];
+
+    for (name, input) in test_cases {
+        let resp = client
+            .post(&format!("{}/subscriptions", &app.host))
+            .form(&input)
+            .send()
+            .await
+            .expect("failed to execute request");
+
+        assert_eq!(StatusCode::BAD_REQUEST, resp.status(), "case name {}", name);
+    }
+}