structural refactor and codebase improvements

crates/application/src/users/tests/authorize_admin.rs

@@ -0,0 +1,92 @@
+use std::sync::Arc;
+
+use domain::models::UserRole;
+use domain::testing::InMemoryUserRepository;
+
+use crate::{
+    auth::{commands::RegisterCommand, deps::RegisterDeps, register},
+    test_helpers::TestContextBuilder,
+    users::{authorize_admin, deps::AuthorizeAdminDeps},
+};
+
+async fn register_user(
+    b: &TestContextBuilder,
+    email: &str,
+    username: &str,
+    role: UserRole,
+) -> domain::models::User {
+    let reg_deps = RegisterDeps {
+        user: b.user_repo.clone(),
+        password_hasher: b.password_hasher.clone(),
+        config: b.config.clone(),
+    };
+    register::execute(
+        &reg_deps,
+        RegisterCommand {
+            email: email.into(),
+            username: username.into(),
+            password: "password123".into(),
+            role,
+        },
+    )
+    .await
+    .unwrap();
+
+    b.user_repo
+        .find_by_email(&domain::value_objects::Email::new(email.into()).unwrap())
+        .await
+        .unwrap()
+        .unwrap()
+}
+
+#[tokio::test]
+async fn authorize_admin_is_true_for_an_admin_user() {
+    let users = InMemoryUserRepository::new();
+    let b = TestContextBuilder::new().with_users(Arc::clone(&users) as _);
+    let user = register_user(&b, "admin@example.com", "admin_user", UserRole::Admin).await;
+
+    let deps = AuthorizeAdminDeps {
+        user: b.user_repo.clone(),
+    };
+    let result = authorize_admin::execute(&deps, user.id().value())
+        .await
+        .unwrap();
+
+    assert_eq!(result, Some(true));
+}
+
+#[tokio::test]
+async fn authorize_admin_is_false_for_a_regular_user() {
+    let users = InMemoryUserRepository::new();
+    let b = TestContextBuilder::new().with_users(Arc::clone(&users) as _);
+    let user = register_user(
+        &b,
+        "standard@example.com",
+        "standard_user",
+        UserRole::Standard,
+    )
+    .await;
+
+    let deps = AuthorizeAdminDeps {
+        user: b.user_repo.clone(),
+    };
+    let result = authorize_admin::execute(&deps, user.id().value())
+        .await
+        .unwrap();
+
+    assert_eq!(result, Some(false));
+}
+
+#[tokio::test]
+async fn authorize_admin_is_not_found_for_unknown_user() {
+    let b = TestContextBuilder::new();
+
+    let deps = AuthorizeAdminDeps {
+        user: b.user_repo.clone(),
+    };
+    let result = authorize_admin::execute(&deps, uuid::Uuid::new_v4())
+        .await
+        .unwrap();
+
+    assert_eq!(result, None);
+}

crates/application/src/users/tests/get_current_profile.rs

@@ -9,7 +9,7 @@ use uuid::Uuid;
 use crate::{
     auth::{commands::RegisterCommand, deps::RegisterDeps, register},
     test_helpers::TestContextBuilder,
-    users::{get_current_profile, queries::GetCurrentProfileQuery},
+    users::{deps::GetCurrentProfileDeps, get_current_profile, queries::GetCurrentProfileQuery},
 };
 
 #[tokio::test]
@@ -41,8 +41,9 @@ async fn returns_profile_for_existing_user() {
         .unwrap()
         .unwrap();
 
+    let deps = GetCurrentProfileDeps { user: user_repo };
     let profile = get_current_profile::execute(
-        user_repo,
+        &deps,
         GetCurrentProfileQuery {
             user_id: user.id().value(),
         },
@@ -58,8 +59,9 @@ async fn fails_for_nonexistent_user() {
     let b = TestContextBuilder::new();
     let user_repo = b.user_repo.clone();
 
+    let deps = GetCurrentProfileDeps { user: user_repo };
     let result = get_current_profile::execute(
-        user_repo,
+        &deps,
         GetCurrentProfileQuery {
             user_id: Uuid::new_v4(),
         },
@@ -97,8 +99,9 @@ async fn returns_profile_with_avatar_banner_and_fields() {
     let b = TestContextBuilder::new().with_users(Arc::clone(&users) as _);
     let user_repo = b.user_repo.clone();
 
+    let deps = GetCurrentProfileDeps { user: user_repo };
     let profile = get_current_profile::execute(
-        user_repo,
+        &deps,
         GetCurrentProfileQuery {
             user_id: uid.value(),
         },

crates/application/src/users/tests/get_federated_profile.rs

@@ -0,0 +1,115 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use domain::{errors::DomainError, models::FederatedProfile, ports::FederatedProfileQuery};
+
+use crate::users::deps::GetFederatedProfileDeps;
+use crate::users::get_federated_profile;
+
+fn a_profile() -> FederatedProfile {
+    FederatedProfile {
+        actor_url: "https://remote.example/users/alice".into(),
+        handle: "alice@remote.example".into(),
+        display_name: Some("Alice".into()),
+        bio: None,
+        avatar_url: None,
+        banner_url: None,
+    }
+}
+
+struct FoundFederatedProfileQuery;
+
+#[async_trait]
+impl FederatedProfileQuery for FoundFederatedProfileQuery {
+    async fn get_federated_profile(
+        &self,
+        _synthetic_user_id: uuid::Uuid,
+    ) -> Result<Option<FederatedProfile>, DomainError> {
+        Ok(Some(a_profile()))
+    }
+}
+
+struct EmptyFederatedProfileQuery;
+
+#[async_trait]
+impl FederatedProfileQuery for EmptyFederatedProfileQuery {
+    async fn get_federated_profile(
+        &self,
+        _synthetic_user_id: uuid::Uuid,
+    ) -> Result<Option<FederatedProfile>, DomainError> {
+        Ok(None)
+    }
+}
+
+struct FailingFederatedProfileQuery;
+
+#[async_trait]
+impl FederatedProfileQuery for FailingFederatedProfileQuery {
+    async fn get_federated_profile(
+        &self,
+        _synthetic_user_id: uuid::Uuid,
+    ) -> Result<Option<FederatedProfile>, DomainError> {
+        Err(DomainError::InfrastructureError(
+            "remote lookup failed".into(),
+        ))
+    }
+}
+
+#[tokio::test]
+async fn returns_the_profile_when_the_port_finds_one() {
+    let deps = GetFederatedProfileDeps {
+        federated_profile: Some(Arc::new(FoundFederatedProfileQuery)),
+    };
+
+    let result = get_federated_profile::execute(&deps, uuid::Uuid::new_v4())
+        .await
+        .unwrap();
+
+    assert_eq!(
+        result.map(|p| p.handle),
+        Some("alice@remote.example".to_string())
+    );
+}
+
+#[tokio::test]
+async fn returns_ok_none_when_the_port_finds_nothing() {
+    let deps = GetFederatedProfileDeps {
+        federated_profile: Some(Arc::new(EmptyFederatedProfileQuery)),
+    };
+
+    let result = get_federated_profile::execute(&deps, uuid::Uuid::new_v4())
+        .await
+        .unwrap();
+
+    assert!(result.is_none());
+}
+
+#[tokio::test]
+async fn returns_ok_none_when_federation_is_disabled() {
+    let deps = GetFederatedProfileDeps {
+        federated_profile: None,
+    };
+
+    let result = get_federated_profile::execute(&deps, uuid::Uuid::new_v4())
+        .await
+        .unwrap();
+
+    assert!(
+        result.is_none(),
+        "an absent port must collapse to Ok(None), the same as an empty lookup — \
+         the handler cannot and must not tell the two apart"
+    );
+}
+
+#[tokio::test]
+async fn propagates_an_error_from_the_port_unchanged() {
+    let deps = GetFederatedProfileDeps {
+        federated_profile: Some(Arc::new(FailingFederatedProfileQuery)),
+    };
+
+    let err = get_federated_profile::execute(&deps, uuid::Uuid::new_v4())
+        .await
+        .expect_err("a repository error must not be swallowed inside the use case");
+
+    assert!(matches!(err, DomainError::InfrastructureError(_)));
+}

crates/application/src/users/tests/get_federated_profile_stats.rs

@@ -0,0 +1,45 @@
+use crate::test_helpers::TestContextBuilder;
+use crate::users::deps::GetFederatedProfileStatsDeps;
+use crate::users::get_federated_profile_stats;
+use crate::users::queries::{GetUserProfileQuery, ProfileView};
+
+/// Mirrors exactly how `build_federated_profile_response`
+/// (`crates/presentation/src/handlers/users.rs`) calls `execute`: a `user_id` that
+/// has no row in the local `users` table (a federated/remote profile uses a
+/// synthetic id — see `FederatedProfileQuery`), `is_own_profile: false`,
+/// `include_remote: true`. Before ADR-0004's split this was the tolerant branch of
+/// the unified `get_profile`; now it's simply this function's only behavior — it
+/// never looks at the local `users` table at all, so there is nothing to be
+/// tolerant about.
+#[tokio::test]
+async fn succeeds_for_a_user_id_with_no_local_row() {
+    let b = TestContextBuilder::new();
+    let deps = GetFederatedProfileStatsDeps {
+        stats: b.stats_repo.clone(),
+        diary: b.diary_repo.clone(),
+        social_query: b.social_query_unified.clone(),
+    };
+
+    let synthetic_user_id = uuid::Uuid::new_v4();
+
+    let result = get_federated_profile_stats::execute(
+        &deps,
+        GetUserProfileQuery {
+            user_id: synthetic_user_id,
+            view: ProfileView::Recent,
+            limit: None,
+            offset: None,
+            sort_by: domain::models::FeedSortBy::Date,
+            search: None,
+            is_own_profile: false,
+            include_remote: true,
+        },
+    )
+    .await;
+
+    assert!(
+        result.is_ok(),
+        "execute must not hard-fail for a user_id absent from the local `users` table \
+         (the federated-profile call shape) — got Err"
+    );
+}

crates/application/src/users/tests/get_local_profile.rs

@@ -1,3 +1,4 @@
+use domain::errors::DomainError;
 use domain::models::UserRole;
 use domain::value_objects::Email;
 
@@ -5,9 +6,11 @@ use crate::auth::commands::RegisterCommand;
 use crate::auth::deps::RegisterDeps;
 use crate::auth::register;
 use crate::test_helpers::TestContextBuilder;
-use crate::users::deps::GetProfileDeps;
-use crate::users::get_profile;
+use crate::users::commands::UpdateProfileCommand;
+use crate::users::deps::{GetLocalProfileDeps, UpdateProfileDeps};
+use crate::users::get_local_profile;
 use crate::users::queries::{GetUserProfileQuery, ProfileView};
+use crate::users::update_profile;
 
 async fn setup_user(b: &TestContextBuilder, email: &str, username: &str) {
     let deps = RegisterDeps {
@@ -28,15 +31,51 @@ async fn setup_user(b: &TestContextBuilder, email: &str, username: &str) {
     .unwrap();
 }
 
+fn deps(b: &TestContextBuilder) -> GetLocalProfileDeps {
+    GetLocalProfileDeps {
+        stats: b.stats_repo.clone(),
+        diary: b.diary_repo.clone(),
+        social_query: b.social_query_unified.clone(),
+        user: b.user_repo.clone(),
+        instance: domain::value_objects::InstanceIdentity::new(b.config.base_url.clone()),
+    }
+}
+
+fn unknown_query(user_id: uuid::Uuid) -> GetUserProfileQuery {
+    GetUserProfileQuery {
+        user_id,
+        view: ProfileView::Recent,
+        limit: None,
+        offset: None,
+        sort_by: domain::models::FeedSortBy::Date,
+        search: None,
+        is_own_profile: false,
+        include_remote: false,
+    }
+}
+
+/// `get_local_profile` is the local-only half of the former `get_profile` split
+/// (ADR-0004's closed wart). Unlike the old tolerant behavior, a user id with no
+/// local row must be `NotFound` here — the empty-string identity sentinel this
+/// replaces cannot be represented in `LocalProfileData` at all.
+#[tokio::test]
+async fn get_local_profile_is_not_found_for_unknown_user() {
+    let b = TestContextBuilder::new();
+    let d = deps(&b);
+
+    let unknown_id = uuid::Uuid::new_v4();
+    let err = match get_local_profile::execute(&d, unknown_query(unknown_id)).await {
+        Err(e) => e,
+        Ok(_) => panic!("expected Err(NotFound) for an unknown user id, got Ok"),
+    };
+    assert!(matches!(err, DomainError::NotFound(_)), "got {err:?}");
+}
+
 #[tokio::test]
 async fn returns_profile_with_empty_stats() {
     let b = TestContextBuilder::new();
     let user_repo = b.user_repo.clone();
-    let deps = GetProfileDeps {
-        stats: b.stats_repo.clone(),
-        diary: b.diary_repo.clone(),
-        social_query: b.social_query_unified.clone(),
-    };
+    let d = deps(&b);
 
     setup_user(&b, "profile@test.com", "profuser").await;
 
@@ -44,8 +83,8 @@ async fn returns_profile_with_empty_stats() {
     let user = user_repo.find_by_email(&email).await.unwrap().unwrap();
     let uid = user.id().value();
 
-    let result = get_profile::execute(
-        &deps,
+    let result = get_local_profile::execute(
+        &d,
         GetUserProfileQuery {
             user_id: uid,
             view: ProfileView::Recent,
@@ -67,11 +106,7 @@ async fn returns_profile_with_empty_stats() {
 async fn returns_history_view() {
     let b = TestContextBuilder::new();
     let user_repo = b.user_repo.clone();
-    let deps = GetProfileDeps {
-        stats: b.stats_repo.clone(),
-        diary: b.diary_repo.clone(),
-        social_query: b.social_query_unified.clone(),
-    };
+    let d = deps(&b);
 
     setup_user(&b, "hist@test.com", "histuser").await;
 
@@ -79,8 +114,8 @@ async fn returns_history_view() {
     let user = user_repo.find_by_email(&email).await.unwrap().unwrap();
     let uid = user.id().value();
 
-    let result = get_profile::execute(
-        &deps,
+    let result = get_local_profile::execute(
+        &d,
         GetUserProfileQuery {
             user_id: uid,
             view: ProfileView::History,
@@ -104,11 +139,7 @@ async fn returns_history_view() {
 async fn returns_trends_view() {
     let b = TestContextBuilder::new();
     let user_repo = b.user_repo.clone();
-    let deps = GetProfileDeps {
-        stats: b.stats_repo.clone(),
-        diary: b.diary_repo.clone(),
-        social_query: b.social_query_unified.clone(),
-    };
+    let d = deps(&b);
 
     setup_user(&b, "trends@test.com", "trendsuser").await;
 
@@ -116,8 +147,8 @@ async fn returns_trends_view() {
     let user = user_repo.find_by_email(&email).await.unwrap().unwrap();
     let uid = user.id().value();
 
-    let result = get_profile::execute(
-        &deps,
+    let result = get_local_profile::execute(
+        &d,
         GetUserProfileQuery {
             user_id: uid,
             view: ProfileView::Trends,
@@ -141,11 +172,7 @@ async fn returns_trends_view() {
 async fn returns_ratings_view() {
     let b = TestContextBuilder::new();
     let user_repo = b.user_repo.clone();
-    let deps = GetProfileDeps {
-        stats: b.stats_repo.clone(),
-        diary: b.diary_repo.clone(),
-        social_query: b.social_query_unified.clone(),
-    };
+    let d = deps(&b);
 
     setup_user(&b, "ratings@test.com", "ratingsuser").await;
 
@@ -153,8 +180,8 @@ async fn returns_ratings_view() {
     let user = user_repo.find_by_email(&email).await.unwrap().unwrap();
     let uid = user.id().value();
 
-    let result = get_profile::execute(
-        &deps,
+    let result = get_local_profile::execute(
+        &d,
         GetUserProfileQuery {
             user_id: uid,
             view: ProfileView::Ratings,
@@ -176,11 +203,7 @@ async fn returns_ratings_view() {
 async fn returns_recent_with_search() {
     let b = TestContextBuilder::new();
     let user_repo = b.user_repo.clone();
-    let deps = GetProfileDeps {
-        stats: b.stats_repo.clone(),
-        diary: b.diary_repo.clone(),
-        social_query: b.social_query_unified.clone(),
-    };
+    let d = deps(&b);
 
     setup_user(&b, "search@test.com", "searchuser").await;
 
@@ -188,8 +211,8 @@ async fn returns_recent_with_search() {
     let user = user_repo.find_by_email(&email).await.unwrap().unwrap();
     let uid = user.id().value();
 
-    let result = get_profile::execute(
-        &deps,
+    let result = get_local_profile::execute(
+        &d,
         GetUserProfileQuery {
             user_id: uid,
             view: ProfileView::Recent,
@@ -211,11 +234,7 @@ async fn returns_recent_with_search() {
 async fn non_own_profile_skips_pending_followers() {
     let b = TestContextBuilder::new();
     let user_repo = b.user_repo.clone();
-    let deps = GetProfileDeps {
-        stats: b.stats_repo.clone(),
-        diary: b.diary_repo.clone(),
-        social_query: b.social_query_unified.clone(),
-    };
+    let d = deps(&b);
 
     setup_user(&b, "other@test.com", "otheruser").await;
 
@@ -223,8 +242,8 @@ async fn non_own_profile_skips_pending_followers() {
     let user = user_repo.find_by_email(&email).await.unwrap().unwrap();
     let uid = user.id().value();
 
-    let result = get_profile::execute(
-        &deps,
+    let result = get_local_profile::execute(
+        &d,
         GetUserProfileQuery {
             user_id: uid,
             view: ProfileView::Recent,
@@ -241,3 +260,96 @@ async fn non_own_profile_skips_pending_followers() {
 
     assert!(result.pending_followers.is_empty());
 }
+
+#[tokio::test]
+async fn populates_handle_and_actor_url_for_a_local_user() {
+    let b = TestContextBuilder::new();
+    let user_repo = b.user_repo.clone();
+    let d = deps(&b);
+
+    setup_user(&b, "handle@test.com", "gabriel").await;
+    let email = Email::new("handle@test.com".into()).unwrap();
+    let user = user_repo.find_by_email(&email).await.unwrap().unwrap();
+    let uid = user.id().value();
+
+    // `InMemoryUserRepository::update_profile` now actually persists (previously a
+    // no-op stub) — use it to give this test a real display_name/bio to assert,
+    // rather than asserting `None` for a mapping that could just as easily be
+    // wrong, inverted, or hardcoded.
+    let update_deps = UpdateProfileDeps {
+        user: user_repo.clone(),
+        object_storage: b.object_storage.clone(),
+        event_publisher: b.event_publisher.clone(),
+    };
+    update_profile::execute(
+        &update_deps,
+        UpdateProfileCommand {
+            user_id: uid,
+            display_name: Some("Gabriel K".into()),
+            bio: Some("Movies and diaries.".into()),
+            avatar_bytes: None,
+            avatar_content_type: None,
+            banner_bytes: None,
+            banner_content_type: None,
+            also_known_as: None,
+        },
+    )
+    .await
+    .unwrap();
+
+    let result = get_local_profile::execute(
+        &d,
+        GetUserProfileQuery {
+            user_id: uid,
+            view: ProfileView::Recent,
+            limit: None,
+            offset: None,
+            sort_by: domain::models::FeedSortBy::Date,
+            search: None,
+            is_own_profile: true,
+            include_remote: false,
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.identity.username, "gabriel");
+    assert_eq!(result.identity.handle, "@gabriel@localhost:3000");
+    assert_eq!(
+        result.identity.actor_url,
+        format!("http://localhost:3000/users/{}", uid)
+    );
+    assert_eq!(result.identity.display_name, Some("Gabriel K".to_string()));
+    assert_eq!(result.identity.bio, Some("Movies and diaries.".to_string()));
+}
+
+#[tokio::test]
+async fn identity_display_name_and_bio_are_none_when_unset() {
+    let b = TestContextBuilder::new();
+    let user_repo = b.user_repo.clone();
+    let d = deps(&b);
+
+    setup_user(&b, "unset@test.com", "unsetuser").await;
+    let email = Email::new("unset@test.com".into()).unwrap();
+    let user = user_repo.find_by_email(&email).await.unwrap().unwrap();
+    let uid = user.id().value();
+
+    let result = get_local_profile::execute(
+        &d,
+        GetUserProfileQuery {
+            user_id: uid,
+            view: ProfileView::Recent,
+            limit: None,
+            offset: None,
+            sort_by: domain::models::FeedSortBy::Date,
+            search: None,
+            is_own_profile: true,
+            include_remote: false,
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.identity.display_name, None);
+    assert_eq!(result.identity.bio, None);
+}

crates/application/src/users/tests/get_page_viewer.rs

@@ -0,0 +1,66 @@
+use domain::models::UserRole;
+use domain::value_objects::{Email, FollowTarget, SocialIdentity, UserId};
+
+use crate::auth::commands::RegisterCommand;
+use crate::auth::deps::RegisterDeps;
+use crate::auth::register;
+use crate::test_helpers::TestContextBuilder;
+use crate::users::deps::GetPageViewerDeps;
+use crate::users::get_page_viewer;
+
+async fn setup_user(b: &TestContextBuilder, email: &str, username: &str) -> uuid::Uuid {
+    let deps = RegisterDeps {
+        user: b.user_repo.clone(),
+        password_hasher: b.password_hasher.clone(),
+        config: b.config.clone(),
+    };
+    register::execute(
+        &deps,
+        RegisterCommand {
+            email: email.into(),
+            username: username.into(),
+            password: "password123".into(),
+            role: UserRole::Standard,
+        },
+    )
+    .await
+    .unwrap();
+    let user = b
+        .user_repo
+        .find_by_email(&Email::new(email.into()).unwrap())
+        .await
+        .unwrap()
+        .unwrap();
+    user.id().value()
+}
+
+/// `get_page_viewer` absorbs `helpers.rs::build_page_context`'s inline pending-count
+/// computation. It must reuse `FollowGraphQuery::count_pending_followers` rather than
+/// re-deriving the count from raw follow rows.
+#[tokio::test]
+async fn get_page_viewer_reports_pending_follower_count() {
+    let b = TestContextBuilder::new();
+    let owner_uuid = setup_user(&b, "owner@test.com", "pageowner").await;
+    let follower1 = setup_user(&b, "follower1@test.com", "pagefollower1").await;
+    let follower2 = setup_user(&b, "follower2@test.com", "pagefollower2").await;
+
+    let owner_id = UserId::from_uuid(owner_uuid);
+    let target = FollowTarget::Identity(SocialIdentity::Local(owner_id.clone()));
+    b.social_command
+        .follow(&UserId::from_uuid(follower1), &target)
+        .await
+        .unwrap();
+    b.social_command
+        .follow(&UserId::from_uuid(follower2), &target)
+        .await
+        .unwrap();
+
+    let deps = GetPageViewerDeps {
+        user: b.user_repo.clone(),
+        follow_graph: b.social_query_unified.clone(),
+    };
+
+    let v = get_page_viewer::execute(&deps, owner_uuid).await.unwrap();
+    assert_eq!(v.pending_follow_count, 2);
+    assert!(!v.is_admin);
+}

crates/application/src/users/tests/get_profile_settings.rs

@@ -0,0 +1,64 @@
+use domain::models::{ProfileField, UserRole};
+use domain::value_objects::{Email, UserId};
+
+use crate::auth::commands::RegisterCommand;
+use crate::auth::deps::RegisterDeps;
+use crate::auth::register;
+use crate::test_helpers::TestContextBuilder;
+use crate::users::deps::GetProfileSettingsDeps;
+use crate::users::get_profile_settings;
+
+/// `get_profile_settings` absorbs BOTH of the handler's calls: the user lookup
+/// (`repos.user.find_by_id`) and the profile_fields join
+/// (`repos.profile_fields.get_fields`). This proves the join actually moved in,
+/// not just the user lookup.
+#[tokio::test]
+async fn get_profile_settings_includes_profile_fields() {
+    let b = TestContextBuilder::new();
+    let register_deps = RegisterDeps {
+        user: b.user_repo.clone(),
+        password_hasher: b.password_hasher.clone(),
+        config: b.config.clone(),
+    };
+    register::execute(
+        &register_deps,
+        RegisterCommand {
+            email: "settings@test.com".into(),
+            username: "settingsuser".into(),
+            password: "password123".into(),
+            role: UserRole::Standard,
+        },
+    )
+    .await
+    .unwrap();
+    let user = b
+        .user_repo
+        .find_by_email(&Email::new("settings@test.com".into()).unwrap())
+        .await
+        .unwrap()
+        .unwrap();
+    let uid = user.id().value();
+
+    b.profile_fields_repo
+        .set_fields(
+            &UserId::from_uuid(uid),
+            vec![ProfileField {
+                name: "pronouns".into(),
+                value: "they/them".into(),
+            }],
+        )
+        .await
+        .unwrap();
+
+    let deps = GetProfileSettingsDeps {
+        user: b.user_repo.clone(),
+        profile_fields: b.profile_fields_repo.clone(),
+        instance: domain::value_objects::InstanceIdentity::new(b.config.base_url.clone()),
+    };
+
+    let s = get_profile_settings::execute(&deps, uid).await.unwrap();
+    assert_eq!(
+        s.fields,
+        vec![("pronouns".to_string(), "they/them".to_string())]
+    );
+}

crates/application/src/users/tests/get_settings.rs

@@ -1,15 +1,18 @@
 use uuid::Uuid;
 
-use crate::{test_helpers::TestContextBuilder, users::get_settings};
+use crate::{
+    test_helpers::TestContextBuilder,
+    users::{deps::GetSettingsDeps, get_settings},
+};
 
 #[tokio::test]
 async fn returns_default_settings() {
     let b = TestContextBuilder::new();
-    let user_settings = b.user_settings_repo.clone();
+    let deps = GetSettingsDeps {
+        user_settings: b.user_settings_repo.clone(),
+    };
 
-    let settings = get_settings::execute(user_settings, Uuid::nil())
-        .await
-        .unwrap();
+    let settings = get_settings::execute(&deps, Uuid::nil()).await.unwrap();
 
     assert!(settings.federate_goals());
     assert!(settings.federate_reviews());

crates/application/src/users/tests/resolve_username_to_id.rs

@@ -0,0 +1,23 @@
+use domain::value_objects::Username;
+
+use crate::test_helpers::TestContextBuilder;
+use crate::users::deps::ResolveUsernameDeps;
+use crate::users::resolve_username_to_id;
+
+/// `resolve_username_to_id` absorbs `handlers/users.rs::get_user_by_username`'s
+/// `repos.user.find_by_username()` call. Unknown usernames must resolve to `None`,
+/// not an error — the handler turns `None` into a 404, same as today.
+#[tokio::test]
+async fn resolve_username_to_id_returns_none_for_unknown() {
+    let b = TestContextBuilder::new();
+    let deps = ResolveUsernameDeps {
+        user: b.user_repo.clone(),
+    };
+    let unknown = Username::new("nosuchuser".into()).unwrap();
+    assert!(
+        resolve_username_to_id::execute(&deps, &unknown)
+            .await
+            .unwrap()
+            .is_none()
+    );
+}

crates/application/src/users/tests/update_profile_fields.rs

@@ -7,7 +7,9 @@ use uuid::Uuid;
 
 use crate::{
     test_helpers::TestContextBuilder,
-    users::{commands::UpdateProfileFieldsCommand, update_profile_fields},
+    users::{
+        commands::UpdateProfileFieldsCommand, deps::UpdateProfileFieldsDeps, update_profile_fields,
+    },
 };
 
 #[tokio::test]
@@ -17,12 +19,13 @@ async fn saves_profile_fields() {
     let b = TestContextBuilder::new()
         .with_profile_fields(Arc::clone(&fields_repo) as _)
         .with_event_publisher(Arc::clone(&events) as _);
-    let profile_fields = b.profile_fields_repo.clone();
-    let event_publisher = b.event_publisher.clone();
+    let deps = UpdateProfileFieldsDeps {
+        profile_fields: b.profile_fields_repo.clone(),
+        event_publisher: b.event_publisher.clone(),
+    };
 
     update_profile_fields::execute(
-        profile_fields,
-        event_publisher,
+        &deps,
         UpdateProfileFieldsCommand {
             user_id: Uuid::nil(),
             fields: vec![
@@ -51,8 +54,10 @@ async fn saves_profile_fields() {
 #[tokio::test]
 async fn rejects_more_than_four_fields() {
     let b = TestContextBuilder::new();
-    let profile_fields = b.profile_fields_repo.clone();
-    let event_publisher = b.event_publisher.clone();
+    let deps = UpdateProfileFieldsDeps {
+        profile_fields: b.profile_fields_repo.clone(),
+        event_publisher: b.event_publisher.clone(),
+    };
 
     let fields: Vec<ProfileField> = (0..5)
         .map(|i| ProfileField {
@@ -62,8 +67,7 @@ async fn rejects_more_than_four_fields() {
         .collect();
 
     let result = update_profile_fields::execute(
-        profile_fields,
-        event_publisher,
+        &deps,
         UpdateProfileFieldsCommand {
             user_id: Uuid::nil(),
             fields,

crates/application/src/users/tests/update_settings.rs

@@ -5,7 +5,11 @@ use uuid::Uuid;
 
 use crate::{
     test_helpers::TestContextBuilder,
-    users::{get_settings, update_settings::UpdateUserSettingsCommand},
+    users::{
+        deps::{GetSettingsDeps, UpdateSettingsDeps},
+        get_settings,
+        update_settings::UpdateUserSettingsCommand,
+    },
 };
 
 #[tokio::test]
@@ -16,7 +20,9 @@ async fn updates_federate_goals() {
     let uid = Uuid::nil();
 
     crate::users::update_settings::execute(
-        user_settings.clone(),
+        &UpdateSettingsDeps {
+            user_settings: user_settings.clone(),
+        },
         UpdateUserSettingsCommand {
             user_id: uid,
             federate_goals: false,
@@ -27,7 +33,9 @@ async fn updates_federate_goals() {
     .await
     .unwrap();
 
-    let settings = get_settings::execute(user_settings, uid).await.unwrap();
+    let settings = get_settings::execute(&GetSettingsDeps { user_settings }, uid)
+        .await
+        .unwrap();
     assert!(!settings.federate_goals());
     assert!(settings.federate_reviews());
     assert!(settings.federate_watchlist());
@@ -41,7 +49,9 @@ async fn updates_federate_reviews() {
     let uid = Uuid::nil();
 
     crate::users::update_settings::execute(
-        user_settings.clone(),
+        &UpdateSettingsDeps {
+            user_settings: user_settings.clone(),
+        },
         UpdateUserSettingsCommand {
             user_id: uid,
             federate_goals: true,
@@ -52,7 +62,9 @@ async fn updates_federate_reviews() {
     .await
     .unwrap();
 
-    let settings = get_settings::execute(user_settings, uid).await.unwrap();
+    let settings = get_settings::execute(&GetSettingsDeps { user_settings }, uid)
+        .await
+        .unwrap();
     assert!(settings.federate_goals());
     assert!(!settings.federate_reviews());
     assert!(settings.federate_watchlist());
@@ -66,7 +78,9 @@ async fn updates_federate_watchlist() {
     let uid = Uuid::nil();
 
     crate::users::update_settings::execute(
-        user_settings.clone(),
+        &UpdateSettingsDeps {
+            user_settings: user_settings.clone(),
+        },
         UpdateUserSettingsCommand {
             user_id: uid,
             federate_goals: true,
@@ -77,7 +91,9 @@ async fn updates_federate_watchlist() {
     .await
     .unwrap();
 
-    let settings = get_settings::execute(user_settings, uid).await.unwrap();
+    let settings = get_settings::execute(&GetSettingsDeps { user_settings }, uid)
+        .await
+        .unwrap();
     assert!(settings.federate_goals());
     assert!(settings.federate_reviews());
     assert!(!settings.federate_watchlist());