refactor: extract inline test modules to separate files

crates/adapters/postgres/src/activitypub/mod.rs

@@ -334,73 +334,4 @@ impl ActivityPubRepository for PgActivityPubRepository {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use activitypub_base::ActivityPubRepository;
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn intern_remote_actor_is_idempotent(pool: sqlx::PgPool) {
-        let repo = PgActivityPubRepository::new(pool);
-        let url = "https://mastodon.social/users/alice";
-        let id1 = repo.intern_remote_actor(url).await.unwrap();
-        let id2 = repo.intern_remote_actor(url).await.unwrap();
-        assert_eq!(id1, id2);
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn accept_and_retract_note(pool: sqlx::PgPool) {
-        let repo = PgActivityPubRepository::new(pool);
-        let actor_url = "https://remote.example/users/bob";
-        let ap_id = "https://remote.example/notes/1";
-        let author = repo.intern_remote_actor(actor_url).await.unwrap();
-        repo.accept_note(
-            ap_id,
-            &author,
-            "hello from remote",
-            chrono::Utc::now(),
-            false,
-            None,
-            "public",
-            None,
-        )
-        .await
-        .unwrap();
-        repo.retract_note(ap_id).await.unwrap();
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn count_local_notes_excludes_remote(pool: sqlx::PgPool) {
-        let repo = PgActivityPubRepository::new(pool);
-        assert_eq!(repo.count_local_notes().await.unwrap(), 0);
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn accept_note_returns_thought_id(pool: sqlx::PgPool) {
-        let repo = PgActivityPubRepository::new(pool.clone());
-        let actor_user_id = repo
-            .intern_remote_actor("https://remote.example/users/alice")
-            .await
-            .unwrap();
-
-        let thought_id = repo
-            .accept_note(
-                "https://remote.example/notes/1",
-                &actor_user_id,
-                "Hello #rust world",
-                chrono::Utc::now(),
-                false,
-                None,
-                "public",
-                None,
-            )
-            .await
-            .unwrap();
-
-        let row: (uuid::Uuid,) = sqlx::query_as("SELECT id FROM thoughts WHERE ap_id=$1")
-            .bind("https://remote.example/notes/1")
-            .fetch_one(&pool)
-            .await
-            .unwrap();
-        assert_eq!(thought_id.as_uuid(), row.0);
-    }
-}
+mod tests;

crates/adapters/postgres/src/activitypub/tests.rs

@@ -0,0 +1,68 @@
+    use super::*;
+    use activitypub_base::ActivityPubRepository;
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn intern_remote_actor_is_idempotent(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool);
+        let url = "https://mastodon.social/users/alice";
+        let id1 = repo.intern_remote_actor(url).await.unwrap();
+        let id2 = repo.intern_remote_actor(url).await.unwrap();
+        assert_eq!(id1, id2);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn accept_and_retract_note(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool);
+        let actor_url = "https://remote.example/users/bob";
+        let ap_id = "https://remote.example/notes/1";
+        let author = repo.intern_remote_actor(actor_url).await.unwrap();
+        repo.accept_note(
+            ap_id,
+            &author,
+            "hello from remote",
+            chrono::Utc::now(),
+            false,
+            None,
+            "public",
+            None,
+        )
+        .await
+        .unwrap();
+        repo.retract_note(ap_id).await.unwrap();
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn count_local_notes_excludes_remote(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool);
+        assert_eq!(repo.count_local_notes().await.unwrap(), 0);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn accept_note_returns_thought_id(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool.clone());
+        let actor_user_id = repo
+            .intern_remote_actor("https://remote.example/users/alice")
+            .await
+            .unwrap();
+
+        let thought_id = repo
+            .accept_note(
+                "https://remote.example/notes/1",
+                &actor_user_id,
+                "Hello #rust world",
+                chrono::Utc::now(),
+                false,
+                None,
+                "public",
+                None,
+            )
+            .await
+            .unwrap();
+
+        let row: (uuid::Uuid,) = sqlx::query_as("SELECT id FROM thoughts WHERE ap_id=$1")
+            .bind("https://remote.example/notes/1")
+            .fetch_one(&pool)
+            .await
+            .unwrap();
+        assert_eq!(thought_id.as_uuid(), row.0);
+    }

crates/adapters/postgres/src/api_key/mod.rs

@@ -89,54 +89,4 @@ impl ApiKeyRepository for PgApiKeyRepository {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::user::PgUserRepository;
-    use chrono::Utc;
-    use domain::ports::UserWriter;
-    use domain::{models::user::User, value_objects::*};
-
-    async fn seed_user(pool: &sqlx::PgPool) -> User {
-        let repo = PgUserRepository::new(pool.clone());
-        let u = User::new_local(
-            UserId::new(),
-            Username::new("alice").unwrap(),
-            Email::new("alice@ex.com").unwrap(),
-            PasswordHash("h".into()),
-        );
-        repo.save(&u).await.unwrap();
-        u
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn save_and_find_by_hash(pool: sqlx::PgPool) {
-        let user = seed_user(&pool).await;
-        let repo = PgApiKeyRepository::new(pool);
-        let key = ApiKey {
-            id: ApiKeyId::new(),
-            user_id: user.id.clone(),
-            key_hash: "abc123".into(),
-            name: "test".into(),
-            created_at: Utc::now(),
-        };
-        repo.save(&key).await.unwrap();
-        let found = repo.find_by_hash("abc123").await.unwrap().unwrap();
-        assert_eq!(found.name, "test");
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn delete_key(pool: sqlx::PgPool) {
-        let user = seed_user(&pool).await;
-        let repo = PgApiKeyRepository::new(pool);
-        let key = ApiKey {
-            id: ApiKeyId::new(),
-            user_id: user.id.clone(),
-            key_hash: "def456".into(),
-            name: "key2".into(),
-            created_at: Utc::now(),
-        };
-        repo.save(&key).await.unwrap();
-        repo.delete(&key.id, &user.id).await.unwrap();
-        assert!(repo.find_by_hash("def456").await.unwrap().is_none());
-    }
-}
+mod tests;

crates/adapters/postgres/src/api_key/tests.rs

@@ -0,0 +1,49 @@
+    use super::*;
+    use crate::user::PgUserRepository;
+    use chrono::Utc;
+    use domain::ports::UserWriter;
+    use domain::{models::user::User, value_objects::*};
+
+    async fn seed_user(pool: &sqlx::PgPool) -> User {
+        let repo = PgUserRepository::new(pool.clone());
+        let u = User::new_local(
+            UserId::new(),
+            Username::new("alice").unwrap(),
+            Email::new("alice@ex.com").unwrap(),
+            PasswordHash("h".into()),
+        );
+        repo.save(&u).await.unwrap();
+        u
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn save_and_find_by_hash(pool: sqlx::PgPool) {
+        let user = seed_user(&pool).await;
+        let repo = PgApiKeyRepository::new(pool);
+        let key = ApiKey {
+            id: ApiKeyId::new(),
+            user_id: user.id.clone(),
+            key_hash: "abc123".into(),
+            name: "test".into(),
+            created_at: Utc::now(),
+        };
+        repo.save(&key).await.unwrap();
+        let found = repo.find_by_hash("abc123").await.unwrap().unwrap();
+        assert_eq!(found.name, "test");
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn delete_key(pool: sqlx::PgPool) {
+        let user = seed_user(&pool).await;
+        let repo = PgApiKeyRepository::new(pool);
+        let key = ApiKey {
+            id: ApiKeyId::new(),
+            user_id: user.id.clone(),
+            key_hash: "def456".into(),
+            name: "key2".into(),
+            created_at: Utc::now(),
+        };
+        repo.save(&key).await.unwrap();
+        repo.delete(&key.id, &user.id).await.unwrap();
+        assert!(repo.find_by_hash("def456").await.unwrap().is_none());
+    }

crates/adapters/postgres/src/block/mod.rs

@@ -52,39 +52,4 @@ impl BlockRepository for PgBlockRepository {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_helpers::seed_user;
-    use chrono::Utc;
-    use domain::value_objects::*;
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn block_exists(pool: sqlx::PgPool) {
-        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
-        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
-        let repo = PgBlockRepository::new(pool);
-        let block = Block {
-            blocker_id: alice.id.clone(),
-            blocked_id: bob.id.clone(),
-            created_at: Utc::now(),
-        };
-        repo.save(&block).await.unwrap();
-        assert!(repo.exists(&alice.id, &bob.id).await.unwrap());
-        assert!(!repo.exists(&bob.id, &alice.id).await.unwrap());
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn unblock(pool: sqlx::PgPool) {
-        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
-        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
-        let repo = PgBlockRepository::new(pool);
-        let block = Block {
-            blocker_id: alice.id.clone(),
-            blocked_id: bob.id.clone(),
-            created_at: Utc::now(),
-        };
-        repo.save(&block).await.unwrap();
-        repo.delete(&alice.id, &bob.id).await.unwrap();
-        assert!(!repo.exists(&alice.id, &bob.id).await.unwrap());
-    }
-}
+mod tests;

crates/adapters/postgres/src/block/tests.rs

@@ -0,0 +1,34 @@
+    use super::*;
+    use crate::test_helpers::seed_user;
+    use chrono::Utc;
+    use domain::value_objects::*;
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn block_exists(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
+        let repo = PgBlockRepository::new(pool);
+        let block = Block {
+            blocker_id: alice.id.clone(),
+            blocked_id: bob.id.clone(),
+            created_at: Utc::now(),
+        };
+        repo.save(&block).await.unwrap();
+        assert!(repo.exists(&alice.id, &bob.id).await.unwrap());
+        assert!(!repo.exists(&bob.id, &alice.id).await.unwrap());
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn unblock(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
+        let repo = PgBlockRepository::new(pool);
+        let block = Block {
+            blocker_id: alice.id.clone(),
+            blocked_id: bob.id.clone(),
+            created_at: Utc::now(),
+        };
+        repo.save(&block).await.unwrap();
+        repo.delete(&alice.id, &bob.id).await.unwrap();
+        assert!(!repo.exists(&alice.id, &bob.id).await.unwrap());
+    }

crates/adapters/postgres/src/boost/mod.rs

@@ -71,40 +71,4 @@ impl BoostRepository for PgBoostRepository {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_helpers::seed_user_and_thought;
-    use chrono::Utc;
-    use domain::value_objects::*;
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn boost_and_count(pool: sqlx::PgPool) {
-        let (user, thought) = seed_user_and_thought(&pool).await;
-        let repo = PgBoostRepository::new(pool);
-        let boost = Boost {
-            id: BoostId::new(),
-            user_id: user.id.clone(),
-            thought_id: thought.id.clone(),
-            ap_id: None,
-            created_at: Utc::now(),
-        };
-        repo.save(&boost).await.unwrap();
-        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 1);
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn unboost(pool: sqlx::PgPool) {
-        let (user, thought) = seed_user_and_thought(&pool).await;
-        let repo = PgBoostRepository::new(pool);
-        let boost = Boost {
-            id: BoostId::new(),
-            user_id: user.id.clone(),
-            thought_id: thought.id.clone(),
-            ap_id: None,
-            created_at: Utc::now(),
-        };
-        repo.save(&boost).await.unwrap();
-        repo.delete(&user.id, &thought.id).await.unwrap();
-        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 0);
-    }
-}
+mod tests;

crates/adapters/postgres/src/boost/tests.rs

@@ -0,0 +1,35 @@
+    use super::*;
+    use crate::test_helpers::seed_user_and_thought;
+    use chrono::Utc;
+    use domain::value_objects::*;
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn boost_and_count(pool: sqlx::PgPool) {
+        let (user, thought) = seed_user_and_thought(&pool).await;
+        let repo = PgBoostRepository::new(pool);
+        let boost = Boost {
+            id: BoostId::new(),
+            user_id: user.id.clone(),
+            thought_id: thought.id.clone(),
+            ap_id: None,
+            created_at: Utc::now(),
+        };
+        repo.save(&boost).await.unwrap();
+        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 1);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn unboost(pool: sqlx::PgPool) {
+        let (user, thought) = seed_user_and_thought(&pool).await;
+        let repo = PgBoostRepository::new(pool);
+        let boost = Boost {
+            id: BoostId::new(),
+            user_id: user.id.clone(),
+            thought_id: thought.id.clone(),
+            ap_id: None,
+            created_at: Utc::now(),
+        };
+        repo.save(&boost).await.unwrap();
+        repo.delete(&user.id, &thought.id).await.unwrap();
+        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 0);
+    }

crates/adapters/postgres/src/feed/mod.rs

@@ -326,74 +326,4 @@ impl FeedRepository for PgFeedRepository {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{thought::PgThoughtRepository, user::PgUserRepository};
-    use domain::{
-        models::{
-            feed::PageParams,
-            thought::{Thought, Visibility},
-            user::User,
-        },
-        ports::{FeedQuery, ThoughtRepository, UserWriter},
-        value_objects::*,
-    };
-
-    async fn seed(pool: &sqlx::PgPool, username: &str, content: &str) -> (User, Thought) {
-        let urepo = PgUserRepository::new(pool.clone());
-        let trepo = PgThoughtRepository::new(pool.clone());
-        let u = User::new_local(
-            UserId::new(),
-            Username::new(username).unwrap(),
-            Email::new(format!("{username}@ex.com")).unwrap(),
-            PasswordHash("h".into()),
-        );
-        urepo.save(&u).await.unwrap();
-        let t = Thought::new_local(
-            ThoughtId::new(),
-            u.id.clone(),
-            Content::new_local(content).unwrap(),
-            None,
-            Visibility::Public,
-            None,
-            false,
-        );
-        trepo.save(&t).await.unwrap();
-        (u, t)
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn public_feed_returns_local_thoughts(pool: sqlx::PgPool) {
-        let (_, _) = seed(&pool, "alice", "hello").await;
-        let repo = PgFeedRepository::new(pool);
-        let result = repo
-            .query(&FeedQuery::public(
-                PageParams { page: 1, per_page: 20 },
-                None,
-            ))
-            .await
-            .unwrap();
-        assert_eq!(result.total, 1);
-        assert_eq!(result.items[0].thought.content.as_str(), "hello");
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn search_returns_matching_thoughts(pool: sqlx::PgPool) {
-        let (_, _) = seed(&pool, "alice", "hello world").await;
-        let (_, _) = seed(&pool, "bob", "goodbye world").await;
-        let repo = PgFeedRepository::new(pool);
-        let result = repo
-            .query(&FeedQuery::search(
-                "hello world",
-                PageParams { page: 1, per_page: 20 },
-                None,
-            ))
-            .await
-            .unwrap();
-        assert!(result.total >= 1);
-        assert!(result
-            .items
-            .iter()
-            .any(|e| e.thought.content.as_str() == "hello world"));
-    }
-}
+mod tests;

crates/adapters/postgres/src/feed/tests.rs

@@ -0,0 +1,69 @@
+    use super::*;
+    use crate::{thought::PgThoughtRepository, user::PgUserRepository};
+    use domain::{
+        models::{
+            feed::PageParams,
+            thought::{Thought, Visibility},
+            user::User,
+        },
+        ports::{FeedQuery, ThoughtRepository, UserWriter},
+        value_objects::*,
+    };
+
+    async fn seed(pool: &sqlx::PgPool, username: &str, content: &str) -> (User, Thought) {
+        let urepo = PgUserRepository::new(pool.clone());
+        let trepo = PgThoughtRepository::new(pool.clone());
+        let u = User::new_local(
+            UserId::new(),
+            Username::new(username).unwrap(),
+            Email::new(format!("{username}@ex.com")).unwrap(),
+            PasswordHash("h".into()),
+        );
+        urepo.save(&u).await.unwrap();
+        let t = Thought::new_local(
+            ThoughtId::new(),
+            u.id.clone(),
+            Content::new_local(content).unwrap(),
+            None,
+            Visibility::Public,
+            None,
+            false,
+        );
+        trepo.save(&t).await.unwrap();
+        (u, t)
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn public_feed_returns_local_thoughts(pool: sqlx::PgPool) {
+        let (_, _) = seed(&pool, "alice", "hello").await;
+        let repo = PgFeedRepository::new(pool);
+        let result = repo
+            .query(&FeedQuery::public(
+                PageParams { page: 1, per_page: 20 },
+                None,
+            ))
+            .await
+            .unwrap();
+        assert_eq!(result.total, 1);
+        assert_eq!(result.items[0].thought.content.as_str(), "hello");
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn search_returns_matching_thoughts(pool: sqlx::PgPool) {
+        let (_, _) = seed(&pool, "alice", "hello world").await;
+        let (_, _) = seed(&pool, "bob", "goodbye world").await;
+        let repo = PgFeedRepository::new(pool);
+        let result = repo
+            .query(&FeedQuery::search(
+                "hello world",
+                PageParams { page: 1, per_page: 20 },
+                None,
+            ))
+            .await
+            .unwrap();
+        assert!(result.total >= 1);
+        assert!(result
+            .items
+            .iter()
+            .any(|e| e.thought.content.as_str() == "hello world"));
+    }

crates/adapters/postgres/src/follow/mod.rs

@@ -190,63 +190,4 @@ impl FollowRepository for PgFollowRepository {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_helpers::seed_user;
-    use chrono::Utc;
-    use domain::value_objects::*;
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn save_and_find_follow(pool: sqlx::PgPool) {
-        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
-        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
-        let repo = PgFollowRepository::new(pool);
-        let follow = Follow {
-            follower_id: alice.id.clone(),
-            following_id: bob.id.clone(),
-            state: FollowState::Accepted,
-            ap_id: None,
-            created_at: Utc::now(),
-        };
-        repo.save(&follow).await.unwrap();
-        let found = repo.find(&alice.id, &bob.id).await.unwrap().unwrap();
-        assert_eq!(found.state, FollowState::Accepted);
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn update_state(pool: sqlx::PgPool) {
-        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
-        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
-        let repo = PgFollowRepository::new(pool);
-        let follow = Follow {
-            follower_id: alice.id.clone(),
-            following_id: bob.id.clone(),
-            state: FollowState::Pending,
-            ap_id: None,
-            created_at: Utc::now(),
-        };
-        repo.save(&follow).await.unwrap();
-        repo.update_state(&alice.id, &bob.id, &FollowState::Accepted)
-            .await
-            .unwrap();
-        let found = repo.find(&alice.id, &bob.id).await.unwrap().unwrap();
-        assert_eq!(found.state, FollowState::Accepted);
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn get_accepted_following_ids(pool: sqlx::PgPool) {
-        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
-        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
-        let repo = PgFollowRepository::new(pool);
-        let follow = Follow {
-            follower_id: alice.id.clone(),
-            following_id: bob.id.clone(),
-            state: FollowState::Accepted,
-            ap_id: None,
-            created_at: Utc::now(),
-        };
-        repo.save(&follow).await.unwrap();
-        let ids = repo.get_accepted_following_ids(&alice.id).await.unwrap();
-        assert_eq!(ids, vec![bob.id]);
-    }
-}
+mod tests;

crates/adapters/postgres/src/follow/tests.rs

@@ -0,0 +1,58 @@
+    use super::*;
+    use crate::test_helpers::seed_user;
+    use chrono::Utc;
+    use domain::value_objects::*;
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn save_and_find_follow(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
+        let repo = PgFollowRepository::new(pool);
+        let follow = Follow {
+            follower_id: alice.id.clone(),
+            following_id: bob.id.clone(),
+            state: FollowState::Accepted,
+            ap_id: None,
+            created_at: Utc::now(),
+        };
+        repo.save(&follow).await.unwrap();
+        let found = repo.find(&alice.id, &bob.id).await.unwrap().unwrap();
+        assert_eq!(found.state, FollowState::Accepted);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn update_state(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
+        let repo = PgFollowRepository::new(pool);
+        let follow = Follow {
+            follower_id: alice.id.clone(),
+            following_id: bob.id.clone(),
+            state: FollowState::Pending,
+            ap_id: None,
+            created_at: Utc::now(),
+        };
+        repo.save(&follow).await.unwrap();
+        repo.update_state(&alice.id, &bob.id, &FollowState::Accepted)
+            .await
+            .unwrap();
+        let found = repo.find(&alice.id, &bob.id).await.unwrap().unwrap();
+        assert_eq!(found.state, FollowState::Accepted);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn get_accepted_following_ids(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
+        let repo = PgFollowRepository::new(pool);
+        let follow = Follow {
+            follower_id: alice.id.clone(),
+            following_id: bob.id.clone(),
+            state: FollowState::Accepted,
+            ap_id: None,
+            created_at: Utc::now(),
+        };
+        repo.save(&follow).await.unwrap();
+        let ids = repo.get_accepted_following_ids(&alice.id).await.unwrap();
+        assert_eq!(ids, vec![bob.id]);
+    }

crates/adapters/postgres/src/like/mod.rs

@@ -71,40 +71,4 @@ impl LikeRepository for PgLikeRepository {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_helpers::seed_user_and_thought;
-    use chrono::Utc;
-    use domain::value_objects::*;
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn like_and_count(pool: sqlx::PgPool) {
-        let (user, thought) = seed_user_and_thought(&pool).await;
-        let repo = PgLikeRepository::new(pool);
-        let like = Like {
-            id: LikeId::new(),
-            user_id: user.id.clone(),
-            thought_id: thought.id.clone(),
-            ap_id: None,
-            created_at: Utc::now(),
-        };
-        repo.save(&like).await.unwrap();
-        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 1);
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn unlike(pool: sqlx::PgPool) {
-        let (user, thought) = seed_user_and_thought(&pool).await;
-        let repo = PgLikeRepository::new(pool);
-        let like = Like {
-            id: LikeId::new(),
-            user_id: user.id.clone(),
-            thought_id: thought.id.clone(),
-            ap_id: None,
-            created_at: Utc::now(),
-        };
-        repo.save(&like).await.unwrap();
-        repo.delete(&user.id, &thought.id).await.unwrap();
-        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 0);
-    }
-}
+mod tests;

crates/adapters/postgres/src/like/tests.rs

@@ -0,0 +1,35 @@
+    use super::*;
+    use crate::test_helpers::seed_user_and_thought;
+    use chrono::Utc;
+    use domain::value_objects::*;
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn like_and_count(pool: sqlx::PgPool) {
+        let (user, thought) = seed_user_and_thought(&pool).await;
+        let repo = PgLikeRepository::new(pool);
+        let like = Like {
+            id: LikeId::new(),
+            user_id: user.id.clone(),
+            thought_id: thought.id.clone(),
+            ap_id: None,
+            created_at: Utc::now(),
+        };
+        repo.save(&like).await.unwrap();
+        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 1);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn unlike(pool: sqlx::PgPool) {
+        let (user, thought) = seed_user_and_thought(&pool).await;
+        let repo = PgLikeRepository::new(pool);
+        let like = Like {
+            id: LikeId::new(),
+            user_id: user.id.clone(),
+            thought_id: thought.id.clone(),
+            ap_id: None,
+            created_at: Utc::now(),
+        };
+        repo.save(&like).await.unwrap();
+        repo.delete(&user.id, &thought.id).await.unwrap();
+        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 0);
+    }

crates/adapters/postgres/src/notification/mod.rs

@@ -159,72 +159,4 @@ impl NotificationRepository for PgNotificationRepository {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_helpers;
-    use chrono::Utc;
-    use domain::{
-        models::{notification::NotificationKind, user::User},
-        value_objects::*,
-    };
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn save_and_list(pool: sqlx::PgPool) {
-        let user = test_helpers::seed_user(&pool, "alice", "alice@ex.com").await;
-        let from_user = test_helpers::seed_user(&pool, "bob", "bob@ex.com").await;
-        let repo = PgNotificationRepository::new(pool);
-        use domain::models::feed::PageParams;
-        let n = Notification {
-            id: NotificationId::new(),
-            user_id: user.id.clone(),
-            kind: NotificationKind::Follow {
-                from_user_id: from_user.id.clone(),
-            },
-            read: false,
-            created_at: Utc::now(),
-        };
-        repo.save(&n).await.unwrap();
-        let page = repo
-            .list_for_user(
-                &user.id,
-                &PageParams {
-                    page: 1,
-                    per_page: 20,
-                },
-            )
-            .await
-            .unwrap();
-        assert_eq!(page.total, 1);
-        assert!(!page.items[0].read);
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn mark_all_read(pool: sqlx::PgPool) {
-        let user = test_helpers::seed_user(&pool, "alice", "alice@ex.com").await;
-        let from_user = test_helpers::seed_user(&pool, "bob", "bob@ex.com").await;
-        let repo = PgNotificationRepository::new(pool);
-        use domain::models::feed::PageParams;
-        let n = Notification {
-            id: NotificationId::new(),
-            user_id: user.id.clone(),
-            kind: NotificationKind::Follow {
-                from_user_id: from_user.id.clone(),
-            },
-            read: false,
-            created_at: Utc::now(),
-        };
-        repo.save(&n).await.unwrap();
-        repo.mark_all_read(&user.id).await.unwrap();
-        let page = repo
-            .list_for_user(
-                &user.id,
-                &PageParams {
-                    page: 1,
-                    per_page: 20,
-                },
-            )
-            .await
-            .unwrap();
-        assert!(page.items[0].read);
-    }
-}
+mod tests;

crates/adapters/postgres/src/notification/tests.rs

@@ -0,0 +1,67 @@
+    use super::*;
+    use crate::test_helpers;
+    use chrono::Utc;
+    use domain::{
+        models::{notification::NotificationKind, user::User},
+        value_objects::*,
+    };
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn save_and_list(pool: sqlx::PgPool) {
+        let user = test_helpers::seed_user(&pool, "alice", "alice@ex.com").await;
+        let from_user = test_helpers::seed_user(&pool, "bob", "bob@ex.com").await;
+        let repo = PgNotificationRepository::new(pool);
+        use domain::models::feed::PageParams;
+        let n = Notification {
+            id: NotificationId::new(),
+            user_id: user.id.clone(),
+            kind: NotificationKind::Follow {
+                from_user_id: from_user.id.clone(),
+            },
+            read: false,
+            created_at: Utc::now(),
+        };
+        repo.save(&n).await.unwrap();
+        let page = repo
+            .list_for_user(
+                &user.id,
+                &PageParams {
+                    page: 1,
+                    per_page: 20,
+                },
+            )
+            .await
+            .unwrap();
+        assert_eq!(page.total, 1);
+        assert!(!page.items[0].read);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn mark_all_read(pool: sqlx::PgPool) {
+        let user = test_helpers::seed_user(&pool, "alice", "alice@ex.com").await;
+        let from_user = test_helpers::seed_user(&pool, "bob", "bob@ex.com").await;
+        let repo = PgNotificationRepository::new(pool);
+        use domain::models::feed::PageParams;
+        let n = Notification {
+            id: NotificationId::new(),
+            user_id: user.id.clone(),
+            kind: NotificationKind::Follow {
+                from_user_id: from_user.id.clone(),
+            },
+            read: false,
+            created_at: Utc::now(),
+        };
+        repo.save(&n).await.unwrap();
+        repo.mark_all_read(&user.id).await.unwrap();
+        let page = repo
+            .list_for_user(
+                &user.id,
+                &PageParams {
+                    page: 1,
+                    per_page: 20,
+                },
+            )
+            .await
+            .unwrap();
+        assert!(page.items[0].read);
+    }

crates/adapters/postgres/src/tag/mod.rs

@@ -132,53 +132,4 @@ impl TagRepository for PgTagRepository {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{thought::PgThoughtRepository, user::PgUserRepository};
-    use domain::ports::{ThoughtRepository, UserWriter};
-    use domain::{
-        models::{
-            thought::{Thought, Visibility},
-            user::User,
-        },
-        value_objects::*,
-    };
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn find_or_create_tag(pool: sqlx::PgPool) {
-        let repo = PgTagRepository::new(pool);
-        let t1 = repo.find_or_create("rust").await.unwrap();
-        let t2 = repo.find_or_create("rust").await.unwrap();
-        assert_eq!(t1.id, t2.id);
-        assert_eq!(t1.name, "rust");
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn attach_and_list(pool: sqlx::PgPool) {
-        let urepo = PgUserRepository::new(pool.clone());
-        let trepo = PgThoughtRepository::new(pool.clone());
-        let u = User::new_local(
-            UserId::new(),
-            Username::new("alice").unwrap(),
-            Email::new("alice@ex.com").unwrap(),
-            PasswordHash("h".into()),
-        );
-        urepo.save(&u).await.unwrap();
-        let t = Thought::new_local(
-            ThoughtId::new(),
-            u.id.clone(),
-            Content::new_local("hi").unwrap(),
-            None,
-            Visibility::Public,
-            None,
-            false,
-        );
-        trepo.save(&t).await.unwrap();
-        let repo = PgTagRepository::new(pool);
-        let tag = repo.find_or_create("greetings").await.unwrap();
-        repo.attach_to_thought(&t.id, tag.id).await.unwrap();
-        let tags = repo.list_for_thought(&t.id).await.unwrap();
-        assert_eq!(tags.len(), 1);
-        assert_eq!(tags[0].name, "greetings");
-    }
-}
+mod tests;

crates/adapters/postgres/src/tag/tests.rs

@@ -0,0 +1,48 @@
+    use super::*;
+    use crate::{thought::PgThoughtRepository, user::PgUserRepository};
+    use domain::ports::{ThoughtRepository, UserWriter};
+    use domain::{
+        models::{
+            thought::{Thought, Visibility},
+            user::User,
+        },
+        value_objects::*,
+    };
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn find_or_create_tag(pool: sqlx::PgPool) {
+        let repo = PgTagRepository::new(pool);
+        let t1 = repo.find_or_create("rust").await.unwrap();
+        let t2 = repo.find_or_create("rust").await.unwrap();
+        assert_eq!(t1.id, t2.id);
+        assert_eq!(t1.name, "rust");
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn attach_and_list(pool: sqlx::PgPool) {
+        let urepo = PgUserRepository::new(pool.clone());
+        let trepo = PgThoughtRepository::new(pool.clone());
+        let u = User::new_local(
+            UserId::new(),
+            Username::new("alice").unwrap(),
+            Email::new("alice@ex.com").unwrap(),
+            PasswordHash("h".into()),
+        );
+        urepo.save(&u).await.unwrap();
+        let t = Thought::new_local(
+            ThoughtId::new(),
+            u.id.clone(),
+            Content::new_local("hi").unwrap(),
+            None,
+            Visibility::Public,
+            None,
+            false,
+        );
+        trepo.save(&t).await.unwrap();
+        let repo = PgTagRepository::new(pool);
+        let tag = repo.find_or_create("greetings").await.unwrap();
+        repo.attach_to_thought(&t.id, tag.id).await.unwrap();
+        let tags = repo.list_for_thought(&t.id).await.unwrap();
+        assert_eq!(tags.len(), 1);
+        assert_eq!(tags[0].name, "greetings");
+    }

crates/adapters/postgres/src/thought/mod.rs

@@ -168,95 +168,4 @@ impl ThoughtRepository for PgThoughtRepository {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_helpers::seed_user;
-    use domain::{
-        models::thought::{Thought, Visibility},
-        value_objects::*,
-    };
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn save_and_find_thought(pool: sqlx::PgPool) {
-        let user = seed_user(&pool, "alice", "alice@ex.com").await;
-        let repo = PgThoughtRepository::new(pool);
-        let t = Thought::new_local(
-            ThoughtId::new(),
-            user.id.clone(),
-            Content::new_local("hello world").unwrap(),
-            None,
-            Visibility::Public,
-            None,
-            false,
-        );
-        repo.save(&t).await.unwrap();
-        let found = repo.find_by_id(&t.id).await.unwrap().unwrap();
-        assert_eq!(found.content.as_str(), "hello world");
-        assert!(found.local);
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn delete_thought(pool: sqlx::PgPool) {
-        let user = seed_user(&pool, "bob", "bob@ex.com").await;
-        let repo = PgThoughtRepository::new(pool);
-        let t = Thought::new_local(
-            ThoughtId::new(),
-            user.id.clone(),
-            Content::new_local("bye").unwrap(),
-            None,
-            Visibility::Public,
-            None,
-            false,
-        );
-        repo.save(&t).await.unwrap();
-        repo.delete(&t.id, &user.id).await.unwrap();
-        assert!(repo.find_by_id(&t.id).await.unwrap().is_none());
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn delete_wrong_owner_returns_not_found(pool: sqlx::PgPool) {
-        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
-        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
-        let repo = PgThoughtRepository::new(pool);
-        let t = Thought::new_local(
-            ThoughtId::new(),
-            alice.id.clone(),
-            Content::new_local("secret").unwrap(),
-            None,
-            Visibility::Public,
-            None,
-            false,
-        );
-        repo.save(&t).await.unwrap();
-        let err = repo.delete(&t.id, &bob.id).await.unwrap_err();
-        assert!(matches!(err, DomainError::NotFound));
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn get_thread_returns_root_and_replies(pool: sqlx::PgPool) {
-        let user = seed_user(&pool, "charlie", "charlie@ex.com").await;
-        let repo = PgThoughtRepository::new(pool);
-        let root = Thought::new_local(
-            ThoughtId::new(),
-            user.id.clone(),
-            Content::new_local("root").unwrap(),
-            None,
-            Visibility::Public,
-            None,
-            false,
-        );
-        let reply = Thought::new_local(
-            ThoughtId::new(),
-            user.id.clone(),
-            Content::new_local("reply").unwrap(),
-            Some(root.id.clone()),
-            Visibility::Public,
-            None,
-            false,
-        );
-        repo.save(&root).await.unwrap();
-        repo.save(&reply).await.unwrap();
-        let thread = repo.get_thread(&root.id).await.unwrap();
-        assert_eq!(thread.len(), 2);
-    }
-}
+mod tests;

crates/adapters/postgres/src/thought/tests.rs

@@ -0,0 +1,90 @@
+    use super::*;
+    use crate::test_helpers::seed_user;
+    use domain::{
+        models::thought::{Thought, Visibility},
+        value_objects::*,
+    };
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn save_and_find_thought(pool: sqlx::PgPool) {
+        let user = seed_user(&pool, "alice", "alice@ex.com").await;
+        let repo = PgThoughtRepository::new(pool);
+        let t = Thought::new_local(
+            ThoughtId::new(),
+            user.id.clone(),
+            Content::new_local("hello world").unwrap(),
+            None,
+            Visibility::Public,
+            None,
+            false,
+        );
+        repo.save(&t).await.unwrap();
+        let found = repo.find_by_id(&t.id).await.unwrap().unwrap();
+        assert_eq!(found.content.as_str(), "hello world");
+        assert!(found.local);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn delete_thought(pool: sqlx::PgPool) {
+        let user = seed_user(&pool, "bob", "bob@ex.com").await;
+        let repo = PgThoughtRepository::new(pool);
+        let t = Thought::new_local(
+            ThoughtId::new(),
+            user.id.clone(),
+            Content::new_local("bye").unwrap(),
+            None,
+            Visibility::Public,
+            None,
+            false,
+        );
+        repo.save(&t).await.unwrap();
+        repo.delete(&t.id, &user.id).await.unwrap();
+        assert!(repo.find_by_id(&t.id).await.unwrap().is_none());
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn delete_wrong_owner_returns_not_found(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
+        let repo = PgThoughtRepository::new(pool);
+        let t = Thought::new_local(
+            ThoughtId::new(),
+            alice.id.clone(),
+            Content::new_local("secret").unwrap(),
+            None,
+            Visibility::Public,
+            None,
+            false,
+        );
+        repo.save(&t).await.unwrap();
+        let err = repo.delete(&t.id, &bob.id).await.unwrap_err();
+        assert!(matches!(err, DomainError::NotFound));
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn get_thread_returns_root_and_replies(pool: sqlx::PgPool) {
+        let user = seed_user(&pool, "charlie", "charlie@ex.com").await;
+        let repo = PgThoughtRepository::new(pool);
+        let root = Thought::new_local(
+            ThoughtId::new(),
+            user.id.clone(),
+            Content::new_local("root").unwrap(),
+            None,
+            Visibility::Public,
+            None,
+            false,
+        );
+        let reply = Thought::new_local(
+            ThoughtId::new(),
+            user.id.clone(),
+            Content::new_local("reply").unwrap(),
+            Some(root.id.clone()),
+            Visibility::Public,
+            None,
+            false,
+        );
+        repo.save(&root).await.unwrap();
+        repo.save(&reply).await.unwrap();
+        let thread = repo.get_thread(&root.id).await.unwrap();
+        assert_eq!(thread.len(), 2);
+    }

crates/adapters/postgres/src/top_friend/mod.rs

@@ -104,52 +104,4 @@ impl TopFriendRepository for PgTopFriendRepository {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::user::PgUserRepository;
-    use domain::ports::UserWriter;
-    use domain::{models::user::User, value_objects::*};
-
-    async fn seed_user(pool: &sqlx::PgPool, username: &str, email: &str) -> User {
-        let repo = PgUserRepository::new(pool.clone());
-        let u = User::new_local(
-            UserId::new(),
-            Username::new(username).unwrap(),
-            Email::new(email).unwrap(),
-            PasswordHash("h".into()),
-        );
-        repo.save(&u).await.unwrap();
-        u
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn set_and_list_top_friends(pool: sqlx::PgPool) {
-        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
-        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
-        let repo = PgTopFriendRepository::new(pool);
-        repo.set_top_friends(&alice.id, vec![(bob.id.clone(), 1)])
-            .await
-            .unwrap();
-        let friends = repo.list_for_user(&alice.id).await.unwrap();
-        assert_eq!(friends.len(), 1);
-        assert_eq!(friends[0].0.position, 1);
-        assert_eq!(friends[0].1.username.as_str(), "bob");
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn replace_top_friends(pool: sqlx::PgPool) {
-        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
-        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
-        let carol = seed_user(&pool, "carol", "carol@ex.com").await;
-        let repo = PgTopFriendRepository::new(pool);
-        repo.set_top_friends(&alice.id, vec![(bob.id.clone(), 1)])
-            .await
-            .unwrap();
-        repo.set_top_friends(&alice.id, vec![(carol.id.clone(), 1)])
-            .await
-            .unwrap();
-        let friends = repo.list_for_user(&alice.id).await.unwrap();
-        assert_eq!(friends.len(), 1);
-        assert_eq!(friends[0].1.username.as_str(), "carol");
-    }
-}
+mod tests;

crates/adapters/postgres/src/top_friend/tests.rs

@@ -0,0 +1,47 @@
+    use super::*;
+    use crate::user::PgUserRepository;
+    use domain::ports::UserWriter;
+    use domain::{models::user::User, value_objects::*};
+
+    async fn seed_user(pool: &sqlx::PgPool, username: &str, email: &str) -> User {
+        let repo = PgUserRepository::new(pool.clone());
+        let u = User::new_local(
+            UserId::new(),
+            Username::new(username).unwrap(),
+            Email::new(email).unwrap(),
+            PasswordHash("h".into()),
+        );
+        repo.save(&u).await.unwrap();
+        u
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn set_and_list_top_friends(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
+        let repo = PgTopFriendRepository::new(pool);
+        repo.set_top_friends(&alice.id, vec![(bob.id.clone(), 1)])
+            .await
+            .unwrap();
+        let friends = repo.list_for_user(&alice.id).await.unwrap();
+        assert_eq!(friends.len(), 1);
+        assert_eq!(friends[0].0.position, 1);
+        assert_eq!(friends[0].1.username.as_str(), "bob");
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn replace_top_friends(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
+        let carol = seed_user(&pool, "carol", "carol@ex.com").await;
+        let repo = PgTopFriendRepository::new(pool);
+        repo.set_top_friends(&alice.id, vec![(bob.id.clone(), 1)])
+            .await
+            .unwrap();
+        repo.set_top_friends(&alice.id, vec![(carol.id.clone(), 1)])
+            .await
+            .unwrap();
+        let friends = repo.list_for_user(&alice.id).await.unwrap();
+        assert_eq!(friends.len(), 1);
+        assert_eq!(friends[0].1.username.as_str(), "carol");
+    }

crates/adapters/postgres/src/user/mod.rs

@@ -279,74 +279,4 @@ impl UserWriter for PgUserRepository {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use domain::{models::user::User, value_objects::*};
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn save_and_find_by_id(pool: sqlx::PgPool) {
-        let repo = PgUserRepository::new(pool);
-        let user = User::new_local(
-            UserId::new(),
-            Username::new("alice").unwrap(),
-            Email::new("alice@ex.com").unwrap(),
-            PasswordHash("hash".into()),
-        );
-        repo.save(&user).await.unwrap();
-        let found = repo.find_by_id(&user.id).await.unwrap().unwrap();
-        assert_eq!(found.username.as_str(), "alice");
-        assert_eq!(found.email.as_str(), "alice@ex.com");
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn find_by_username_returns_none_when_missing(pool: sqlx::PgPool) {
-        let repo = PgUserRepository::new(pool);
-        let result = repo
-            .find_by_username(&Username::new("ghost").unwrap())
-            .await
-            .unwrap();
-        assert!(result.is_none());
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn find_by_email(pool: sqlx::PgPool) {
-        let repo = PgUserRepository::new(pool);
-        let user = User::new_local(
-            UserId::new(),
-            Username::new("bob").unwrap(),
-            Email::new("bob@ex.com").unwrap(),
-            PasswordHash("hash".into()),
-        );
-        repo.save(&user).await.unwrap();
-        let found = repo
-            .find_by_email(&Email::new("bob@ex.com").unwrap())
-            .await
-            .unwrap();
-        assert!(found.is_some());
-    }
-
-    #[sqlx::test(migrations = "./migrations")]
-    async fn update_profile_changes_fields(pool: sqlx::PgPool) {
-        let repo = PgUserRepository::new(pool);
-        let user = User::new_local(
-            UserId::new(),
-            Username::new("charlie").unwrap(),
-            Email::new("charlie@ex.com").unwrap(),
-            PasswordHash("hash".into()),
-        );
-        repo.save(&user).await.unwrap();
-        repo.update_profile(
-            &user.id,
-            Some("Charlie".into()),
-            Some("bio".into()),
-            None,
-            None,
-            None,
-        )
-        .await
-        .unwrap();
-        let found = repo.find_by_id(&user.id).await.unwrap().unwrap();
-        assert_eq!(found.display_name.as_deref(), Some("Charlie"));
-        assert_eq!(found.bio.as_deref(), Some("bio"));
-    }
-}
+mod tests;

crates/adapters/postgres/src/user/tests.rs

@@ -0,0 +1,69 @@
+    use super::*;
+    use domain::{models::user::User, value_objects::*};
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn save_and_find_by_id(pool: sqlx::PgPool) {
+        let repo = PgUserRepository::new(pool);
+        let user = User::new_local(
+            UserId::new(),
+            Username::new("alice").unwrap(),
+            Email::new("alice@ex.com").unwrap(),
+            PasswordHash("hash".into()),
+        );
+        repo.save(&user).await.unwrap();
+        let found = repo.find_by_id(&user.id).await.unwrap().unwrap();
+        assert_eq!(found.username.as_str(), "alice");
+        assert_eq!(found.email.as_str(), "alice@ex.com");
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn find_by_username_returns_none_when_missing(pool: sqlx::PgPool) {
+        let repo = PgUserRepository::new(pool);
+        let result = repo
+            .find_by_username(&Username::new("ghost").unwrap())
+            .await
+            .unwrap();
+        assert!(result.is_none());
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn find_by_email(pool: sqlx::PgPool) {
+        let repo = PgUserRepository::new(pool);
+        let user = User::new_local(
+            UserId::new(),
+            Username::new("bob").unwrap(),
+            Email::new("bob@ex.com").unwrap(),
+            PasswordHash("hash".into()),
+        );
+        repo.save(&user).await.unwrap();
+        let found = repo
+            .find_by_email(&Email::new("bob@ex.com").unwrap())
+            .await
+            .unwrap();
+        assert!(found.is_some());
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn update_profile_changes_fields(pool: sqlx::PgPool) {
+        let repo = PgUserRepository::new(pool);
+        let user = User::new_local(
+            UserId::new(),
+            Username::new("charlie").unwrap(),
+            Email::new("charlie@ex.com").unwrap(),
+            PasswordHash("hash".into()),
+        );
+        repo.save(&user).await.unwrap();
+        repo.update_profile(
+            &user.id,
+            Some("Charlie".into()),
+            Some("bio".into()),
+            None,
+            None,
+            None,
+        )
+        .await
+        .unwrap();
+        let found = repo.find_by_id(&user.id).await.unwrap().unwrap();
+        assert_eq!(found.display_name.as_deref(), Some("Charlie"));
+        assert_eq!(found.bio.as_deref(), Some("bio"));
+    }