refactor: drop postgres leftovers, narrow bootstrap api

crates/application/tests/diary/edit_review_test.rs

@@ -131,7 +131,7 @@ async fn edit_sets_watch_medium() {
 }
 
 #[tokio::test]
-async fn editing_a_review_fails_when_the_store_refuses() {
+async fn editing_a_review_fails_when_the_store_refuses_to_load_it() {
     let (_, events, review_id, user_id) = setup().await;
     let deps = EditReviewDeps {
         review: Arc::new(domain::testing::RefusingReviewRepository),

crates/application/tests/users.rs

@@ -2,6 +2,8 @@ mod support;
 
 #[path = "users/authorize_admin_test.rs"]
 mod authorize_admin_test;
+#[path = "users/delete_account_test.rs"]
+mod delete_account_test;
 #[path = "users/get_current_profile_test.rs"]
 mod get_current_profile_test;
 #[path = "users/get_federated_profile_stats_test.rs"]

crates/application/tests/users/delete_account_test.rs

@@ -0,0 +1,87 @@
+use crate::support::{TestContextBuilder, register_command};
+use std::sync::Arc;
+
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    ports::UserRepository,
+    testing::{InMemoryStore, NoopEventPublisher, RefusingEventPublisher},
+    value_objects::{Email, UserId},
+};
+use uuid::Uuid;
+
+use application::{
+    auth::{deps::RegisterDeps, register},
+    users::{delete_account, deps::DeleteAccountDeps},
+};
+
+async fn register_user(b: &TestContextBuilder, users: &Arc<InMemoryStore>) -> Uuid {
+    let reg_deps = RegisterDeps {
+        user: b.user_repo.clone(),
+        password_hasher: b.password_hasher.clone(),
+        config: b.config.clone(),
+    };
+    register::execute(&reg_deps, register_command("alice@example.com", "alice"))
+        .await
+        .unwrap();
+    users
+        .find_by_email(&Email::new("alice@example.com".into()).unwrap())
+        .await
+        .unwrap()
+        .unwrap()
+        .id()
+        .value()
+}
+
+#[tokio::test]
+async fn deleting_an_unknown_user_is_not_found() {
+    let events = NoopEventPublisher::new();
+    let b = TestContextBuilder::new();
+    let deps = DeleteAccountDeps {
+        user: b.user_repo.clone(),
+        event_publisher: Arc::clone(&events) as _,
+    };
+
+    let err = delete_account::execute(&deps, Uuid::new_v4())
+        .await
+        .unwrap_err();
+
+    assert!(matches!(err, DomainError::NotFound(_)));
+    assert!(events.published().is_empty());
+}
+
+#[tokio::test]
+async fn deleting_an_existing_user_publishes_user_deleted() {
+    let users = InMemoryStore::new();
+    let events = NoopEventPublisher::new();
+    let b = TestContextBuilder::new().with_users(Arc::clone(&users) as _);
+    let deps = DeleteAccountDeps {
+        user: b.user_repo.clone(),
+        event_publisher: Arc::clone(&events) as _,
+    };
+    let uid = register_user(&b, &users).await;
+
+    delete_account::execute(&deps, uid).await.unwrap();
+
+    let published = events.published();
+    assert!(
+        matches!(
+            published.as_slice(),
+            [DomainEvent::UserDeleted { user_id }] if *user_id == UserId::from_uuid(uid)
+        ),
+        "published: {published:?}"
+    );
+}
+
+#[tokio::test]
+async fn deleting_fails_when_the_publisher_refuses() {
+    let users = InMemoryStore::new();
+    let b = TestContextBuilder::new().with_users(Arc::clone(&users) as _);
+    let deps = DeleteAccountDeps {
+        user: b.user_repo.clone(),
+        event_publisher: Arc::new(RefusingEventPublisher),
+    };
+    let uid = register_user(&b, &users).await;
+
+    assert!(delete_account::execute(&deps, uid).await.is_err());
+}