refactor db & add database test

src/db.rs

@@ -1,16 +1,18 @@
 use crate::config::AppConfig;
+use derive_more::{Display, Error};
 use log::info;
 use sqlx::postgres::PgPoolOptions;
 use sqlx::{Pool, Postgres};
 use std::io;
 
 #[derive(Clone)]
-pub struct AppDB {
-    pub pool: Pool<Postgres>,
+pub enum AppDB {
+    Postgres(Pool<Postgres>),
+    Mock,
 }
 
 impl AppDB {
-    pub async fn new(config: &AppConfig) -> io::Result<Self> {
+    pub async fn postgres(config: &AppConfig) -> io::Result<Self> {
         let db_url = format!(
             "postgres://{}:{}@{}/{}",
             config.db_user, config.db_password, config.db_host, config.db_database
@@ -26,10 +28,44 @@ impl AppDB {
                 "connected to database {} at {}",
                 config.db_database, config.db_host
             );
-            Ok(AppDB { pool })
+            Ok(Self::Postgres(pool))
         } else {
             let msg = format!("failed to connect to database, config {:?}", config);
             Err(io::Error::other(msg))
         }
     }
+    pub fn mock() -> Self {
+        Self::Mock
+    }
+}
+
+impl AppDB {
+    pub async fn test_db(&self) -> DBResult<()> {
+        match self {
+            Self::Postgres(pool) => {
+                let row: (i64,) = sqlx::query_as("SELECT $1")
+                    .bind(150_i64)
+                    .fetch_one(pool)
+                    .await?;
+
+                assert_eq!(row.0, 150);
+                Ok(())
+            }
+            _ => Err(DBError::Unimplemented),
+        }
+    }
+}
+
+pub type DBResult<T> = std::result::Result<T, DBError>;
+
+#[derive(Debug, Error, Display)]
+pub enum DBError {
+    SqlxError(sqlx::Error),
+    Unimplemented,
+}
+
+impl From<sqlx::Error> for DBError {
+    fn from(err: sqlx::Error) -> Self {
+        Self::SqlxError(err)
+    }
 }

src/main.rs

@@ -21,7 +21,7 @@ pub struct AppState {
 
 impl AppState {
     pub async fn new(config: &AppConfig) -> std::io::Result<AppState> {
-        let db = AppDB::new(&config).await?;
+        let db = AppDB::postgres(&config).await?;
         Ok(AppState { db })
     }
 }

src/misc.rs

@@ -45,11 +45,6 @@ pub async fn test_invalid() -> AppResult<()> {
 
 #[get("/db")]
 pub async fn test_db(data: web::Data<AppState>) -> AppResult<&'static str> {
-    let row: (i64,) = sqlx::query_as("SELECT $1")
-        .bind(150_i64)
-        .fetch_one(&data.db.pool)
-        .await?;
-
-    assert_eq!(row.0, 150);
-    AppResponse::Success("success").response()
+    data.db.test_db().await?;
+    AppResponse::Success("Test for db is success").response()
 }

src/response.rs

@@ -7,6 +7,8 @@ use derive_more::{Display, Error};
 use log::warn;
 use serde::Serialize;
 
+use crate::db::DBError;
+
 /// Result type returned by handler functions.
 pub type AppResult<T> = actix_web::Result<web::Json<OkModel<T>>, AppError>;
 
@@ -64,6 +66,13 @@ impl From<sqlx::Error> for AppError {
     }
 }
 
+impl From<DBError> for AppError {
+    fn from(err: DBError) -> Self {
+        warn!("{}", err);
+        Self::InternalError
+    }
+}
+
 /// App response types
 ///
 /// # Examples

src/tests/database.rs

@@ -0,0 +1,16 @@
+use crate::db::{AppDB, DBError};
+
+#[actix_rt::test]
+async fn test_db() {
+    let db = AppDB::mock();
+    let res = db.test_db().await;
+    if let Err(e) = res {
+        if let DBError::Unimplemented = e {
+            // test success
+        } else {
+            panic!("Error should be `Unimplemented`, got {}", e)
+        }
+    } else {
+        panic!("`db.test_db().await` should be `Err(Unimplemented)`, not `Ok()`.")
+    }
+}

src/tests/mod.rs

@@ -1 +1,2 @@
+mod database;
 mod response;