diff --git a/Cargo.lock b/Cargo.lock
index c66f6c6..675f91b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -568,9 +568,9 @@ checksum = "a12916984aab3fa6e39d655a33e09c0071eb36d6ab3aea5c2d78551f1df6d952"
 
 [[package]]
 name = "cc"
-version = "1.1.5"
+version = "1.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "324c74f2155653c90b04f25b2a47a8a631360cb908f92a772695f430c7e31052"
+checksum = "2aba8f4e9906c7ce3c73463f62a7f0c65183ada1a2d47e397cc8810827f9694f"
 
 [[package]]
 name = "cfg-if"
diff --git a/README.md b/README.md
index 633cb29..19a8f27 100644
--- a/README.md
+++ b/README.md
@@ -4,6 +4,8 @@ Axum scaffold with clean architecture.
 
 You probably don't need [Rust on Rails](https://github.com/loco-rs/loco).
 
+Refer to this post for more details on background: <https://kigawas.me/posts/rustacean-clean-architecture-approach/>.
+
 ## Features
 
 - [Axum](https://github.com/tokio-rs/axum) framework
diff --git a/tests/api/mod.rs b/tests/api/mod.rs
index ef0545d..7505b4c 100644
--- a/tests/api/mod.rs
+++ b/tests/api/mod.rs
@@ -1,41 +1,29 @@
-use axum::{http::StatusCode, Router};
-use http_body_util::BodyExt;
-
 use api::setup_router;
-use utils::testing::{make_get_request, make_post_request, setup_test_db};
+use utils::testing::setup_test_db;
+
+mod root;
+mod user;
+use root::*;
+use user::*;
 
 #[tokio::test]
-async fn main() {
-    let db = setup_test_db("sqlite::memory:")
+async fn root_main() {
+    let db = setup_test_db("sqlite::root?mode=memory&cache=shared")
         .await
         .expect("Set up db failed!");
 
     let app = setup_router(db);
-    test_root(app.clone()).await;
-    test_post_users(app.clone()).await;
-    test_get_users(app).await;
-}
-
-async fn test_root(app: Router) {
-    let response = make_get_request(app, "/").await;
-    assert_eq!(response.status(), StatusCode::OK);
-
-    let body = response.into_body().collect().await.unwrap().to_bytes();
-    assert_eq!(&body[..], b"Hello, World from DB!");
-}
-
-async fn test_post_users(app: Router) {
-    let response = make_post_request(app, "/users", r#"{"username": "test"}"#.to_owned()).await;
-    assert_eq!(response.status(), StatusCode::CREATED);
-
-    let body = response.into_body().collect().await.unwrap().to_bytes();
-    assert_eq!(&body[..], br#"{"id":1,"username":"test"}"#);
+    test_root(app).await;
 }
 
-async fn test_get_users(app: Router) {
-    let response = make_get_request(app, "/users").await;
-    assert_eq!(response.status(), StatusCode::OK);
+#[tokio::test]
+async fn user_main() {
+    let db = setup_test_db("sqlite::user?mode=memory&cache=shared")
+        .await
+        .expect("Set up db failed!");
 
-    let body = response.into_body().collect().await.unwrap().to_bytes();
-    assert_eq!(&body[..], br#"{"users":[{"id":1,"username":"test"}]}"#);
+    let app = setup_router(db);
+    test_post_users(app.clone()).await;
+    test_post_users_error(app.clone()).await;
+    test_get_users(app).await;
 }
diff --git a/tests/api/root.rs b/tests/api/root.rs
new file mode 100644
index 0000000..7eb3313
--- /dev/null
+++ b/tests/api/root.rs
@@ -0,0 +1,12 @@
+use axum::{http::StatusCode, Router};
+use http_body_util::BodyExt;
+
+use utils::testing::make_get_request;
+
+pub(super) async fn test_root(app: Router) {
+    let response = make_get_request(app, "/").await;
+    assert_eq!(response.status(), StatusCode::OK);
+
+    let body = response.into_body().collect().await.unwrap().to_bytes();
+    assert_eq!(&body[..], b"Hello, World from DB!");
+}
diff --git a/tests/api/user.rs b/tests/api/user.rs
new file mode 100644
index 0000000..6d7afbd
--- /dev/null
+++ b/tests/api/user.rs
@@ -0,0 +1,36 @@
+use axum::{http::StatusCode, Router};
+use http_body_util::BodyExt;
+use serde_json::Value;
+
+use utils::testing::{make_get_request, make_post_request};
+
+pub(super) async fn test_post_users(app: Router) {
+    let response = make_post_request(app, "/users", r#"{"username": "test"}"#.to_owned()).await;
+    assert_eq!(response.status(), StatusCode::CREATED);
+
+    let body = response.into_body().collect().await.unwrap().to_bytes();
+    assert_eq!(&body[..], br#"{"id":1,"username":"test"}"#);
+}
+
+pub(super) async fn test_post_users_error(app: Router) {
+    let response = make_post_request(app, "/users", r#"{"username": "1"}"#.to_owned()).await;
+    assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
+
+    let body = response.into_body().collect().await.unwrap().to_bytes();
+    let result: Value = serde_json::from_slice(&body).unwrap();
+    assert_eq!(result["message"], "Validation error");
+    assert_eq!(result["details"]["username"][0]["code"], "length");
+    assert_eq!(result["details"]["username"][0]["message"], Value::Null);
+    assert_eq!(
+        result["details"]["username"][0]["params"]["min"],
+        Value::Number(2.into())
+    )
+}
+
+pub(super) async fn test_get_users(app: Router) {
+    let response = make_get_request(app, "/users").await;
+    assert_eq!(response.status(), StatusCode::OK);
+
+    let body = response.into_body().collect().await.unwrap().to_bytes();
+    assert_eq!(&body[..], br#"{"users":[{"id":1,"username":"test"}]}"#);
+}
diff --git a/tests/app/mod.rs b/tests/app/mod.rs
index 7bf7cda..35d60ea 100644
--- a/tests/app/mod.rs
+++ b/tests/app/mod.rs
@@ -1,27 +1,13 @@
-use sea_orm::{DatabaseConnection, DbErr, Unchanged};
-
-use app::services::user::create_user;
-use models::domains::user;
-use models::params::user::CreateUserParams;
 use utils::testing::setup_test_db;
 
-#[tokio::test]
-async fn main() -> Result<(), DbErr> {
-    let db = setup_test_db("sqlite::memory:").await?;
-    test_user(&db).await?;
-    Ok(())
-}
+mod user;
+use user::test_user;
 
-async fn test_user(db: &DatabaseConnection) -> Result<(), DbErr> {
-    let params = CreateUserParams {
-        username: "test".to_string(),
-    };
+#[tokio::test]
+async fn main() {
+    let db = setup_test_db("sqlite::memory:")
+        .await
+        .expect("Set up db failed!");
 
-    let user = create_user(db, params).await?;
-    let expected = user::ActiveModel {
-        id: Unchanged(1),
-        username: Unchanged("test".to_owned()),
-    };
-    assert_eq!(user, expected);
-    Ok(())
+    test_user(&db).await;
 }
diff --git a/tests/app/user.rs b/tests/app/user.rs
new file mode 100644
index 0000000..79bda6e
--- /dev/null
+++ b/tests/app/user.rs
@@ -0,0 +1,18 @@
+use sea_orm::{DatabaseConnection, Unchanged};
+
+use app::services::user::create_user;
+use models::domains::user;
+use models::params::user::CreateUserParams;
+
+pub(super) async fn test_user(db: &DatabaseConnection) {
+    let params = CreateUserParams {
+        username: "test".to_string(),
+    };
+
+    let user = create_user(db, params).await.expect("Create user failed!");
+    let expected = user::ActiveModel {
+        id: Unchanged(1),
+        username: Unchanged("test".to_owned()),
+    };
+    assert_eq!(user, expected);
+}