movies-diary/crates/application/tests/users/request_account_deletion_test.rs

use std::sync::Arc;

use domain::{
    errors::DomainError,
    events::DomainEvent,
    models::UserRole,
    ports::UserRepository,
    testing::InMemoryStore,
    value_objects::{Email, UserId},
};

use application::{
    auth::{deps::RegisterDeps, register},
    users::{deps::RequestAccountDeletionDeps, request_account_deletion},
};

use crate::support::{TestContextBuilder, register_command};

const PASSWORD: &str = "password123";

struct Fixture {
    store: Arc<InMemoryStore>,
    deps: RequestAccountDeletionDeps,
    register: RegisterDeps,
}

fn fixture() -> Fixture {
    let store = InMemoryStore::new();
    let b = TestContextBuilder::new().with_users(Arc::clone(&store) as _);
    Fixture {
        deps: RequestAccountDeletionDeps {
            user: b.user_repo.clone(),
            password_hasher: b.password_hasher.clone(),
        },
        register: RegisterDeps {
            user: b.user_repo.clone(),
            password_hasher: b.password_hasher.clone(),
            config: b.config.clone(),
        },
        store,
    }
}

impl Fixture {
    async fn user(&self, name: &str, role: UserRole) -> UserId {
        let email = format!("{name}@example.com");
        let mut cmd = register_command(email.clone(), name);
        cmd.role = role;
        register::execute(&self.register, cmd).await.unwrap();
        self.store
            .find_by_email(&Email::new(email).unwrap())
            .await
            .unwrap()
            .unwrap()
            .id()
            .clone()
    }

    async fn is_live(&self, id: &UserId) -> bool {
        self.store.find_by_id(id).await.unwrap().is_some()
    }
}

#[tokio::test]
async fn a_user_deletes_their_own_account_with_the_right_password() {
    let f = fixture();
    let alice = f.user("alice", UserRole::Standard).await;

    request_account_deletion::execute(&f.deps, alice.clone(), alice.clone(), PASSWORD)
        .await
        .unwrap();

    assert!(!f.is_live(&alice).await);
    assert!(
        matches!(
            f.store.recorded_events().as_slice(),
            [DomainEvent::UserDeleted { user_id }] if *user_id == alice
        ),
        "events: {:?}",
        f.store.recorded_events()
    );
}

#[tokio::test]
async fn a_wrong_password_is_unauthorized_and_changes_nothing() {
    let f = fixture();
    let alice = f.user("alice", UserRole::Standard).await;

    let err = request_account_deletion::execute(&f.deps, alice.clone(), alice.clone(), "nope")
        .await
        .unwrap_err();

    assert!(matches!(err, DomainError::Unauthorized(_)), "got {err:?}");
    assert!(f.is_live(&alice).await);
    assert!(f.store.recorded_events().is_empty());
}

#[tokio::test]
async fn a_non_admin_cannot_delete_someone_else() {
    let f = fixture();
    let alice = f.user("alice", UserRole::Standard).await;
    let bob = f.user("bob", UserRole::Standard).await;

    let err = request_account_deletion::execute(&f.deps, alice, bob.clone(), PASSWORD)
        .await
        .unwrap_err();

    assert!(matches!(err, DomainError::Forbidden(_)), "got {err:?}");
    assert!(f.is_live(&bob).await);
}

#[tokio::test]
async fn an_admin_deletes_another_user_with_their_own_password() {
    let f = fixture();
    let admin = f.user("root", UserRole::Admin).await;
    let bob = f.user("bob", UserRole::Standard).await;

    let err = request_account_deletion::execute(&f.deps, admin.clone(), bob.clone(), "bobs-pw")
        .await
        .unwrap_err();
    assert!(matches!(err, DomainError::Unauthorized(_)), "got {err:?}");
    assert!(f.is_live(&bob).await);

    request_account_deletion::execute(&f.deps, admin.clone(), bob.clone(), PASSWORD)
        .await
        .unwrap();

    assert!(!f.is_live(&bob).await);
    assert!(f.is_live(&admin).await);
}

#[tokio::test]
async fn the_last_active_admin_cannot_delete_themselves() {
    let f = fixture();
    let admin = f.user("root", UserRole::Admin).await;

    let err = request_account_deletion::execute(&f.deps, admin.clone(), admin.clone(), PASSWORD)
        .await
        .unwrap_err();

    assert!(matches!(err, DomainError::Conflict(_)), "got {err:?}");
    assert!(f.is_live(&admin).await);
    assert!(f.store.recorded_events().is_empty());
}

#[tokio::test]
async fn an_admin_can_delete_themselves_when_another_admin_remains() {
    let f = fixture();
    let first = f.user("root", UserRole::Admin).await;
    let _second = f.user("root2", UserRole::Admin).await;

    request_account_deletion::execute(&f.deps, first.clone(), first.clone(), PASSWORD)
        .await
        .unwrap();

    assert!(!f.is_live(&first).await);
}

#[tokio::test]
async fn an_unknown_target_is_not_found() {
    let f = fixture();
    let admin = f.user("root", UserRole::Admin).await;

    let err = request_account_deletion::execute(&f.deps, admin, UserId::generate(), PASSWORD)
        .await
        .unwrap_err();

    assert!(matches!(err, DomainError::NotFound(_)), "got {err:?}");
}

#[tokio::test]
async fn an_already_deleted_target_is_not_found() {
    let f = fixture();
    let admin = f.user("root", UserRole::Admin).await;
    let bob = f.user("bob", UserRole::Standard).await;
    request_account_deletion::execute(&f.deps, admin.clone(), bob.clone(), PASSWORD)
        .await
        .unwrap();

    let err = request_account_deletion::execute(&f.deps, admin, bob, PASSWORD)
        .await
        .unwrap_err();

    assert!(matches!(err, DomainError::NotFound(_)), "got {err:?}");
}