macltok

use macltok::{Engine, EngineConfig, ErrorKind, MemberFilter, MemberMembership};

use matrix_sdk::{

    ruma::{

        api::client::sync::sync_events::v5, events::room::member::MembershipState, room_id, user_id,

    },

    test_utils::mocks::MatrixMockServer,

};

use matrix_sdk_test::{ALICE, JoinedRoomBuilder, event_factory::EventFactory};

#[tokio::test]

async fn members_filters_and_normalises_synced_room_members() {

    let server = MatrixMockServer::new().await;

    server

        .mock_sliding_sync()

        .ok(v5::Response::new("1".to_owned()))

        .mount()

        .await;

    let client = server.client_builder().build().await;

    let room_id = room_id!("!members:localhost");

    server.mock_room_state_encryption().plain().mount().await;

    let factory = EventFactory::new().room(room_id);

    let own = factory

        .member(user_id!("@example:localhost"))

        .display_name("Example")

        .into_raw_sync_state();

    let joined = factory

        .member(user_id!("@bob:localhost"))

        .display_name("Bobby")

        .into_raw_sync_state();

    let invited = factory

        .member(user_id!("@carol:localhost"))

        .membership(MembershipState::Invite)

        .sender(&ALICE)

        .state_key(user_id!("@carol:localhost"))

        .display_name("Carol")

        .into_raw_sync_state();

    let own_member = factory

        .member(user_id!("@example:localhost"))

        .display_name("Example")

        .into_raw();

    let joined_member = factory

        .member(user_id!("@bob:localhost"))

        .display_name("Bobby")

        .into_raw();

    let invited_member = factory

        .member(user_id!("@carol:localhost"))

        .membership(MembershipState::Invite)

        .sender(&ALICE)

        .state_key(user_id!("@carol:localhost"))

        .display_name("Carol")

        .into_raw();

    server

        .sync_room(

            &client,

            JoinedRoomBuilder::new(room_id)

                .add_state_event(own.clone())

                .add_state_event(joined.clone())

                .add_state_event(invited.clone()),

        )

        .await;

    server

        .mock_get_members()

        .ok(vec![own_member, joined_member, invited_member])

        .mock_once()

        .mount()

        .await;

    let (engine, handle, _events) = Engine::from_client(client, EngineConfig::default())

        .await

        .unwrap();

    let joined_members = handle.members(room_id, MemberFilter::Joined).await.unwrap();

    assert_eq!(joined_members.len(), 2);

    let own_member = joined_members

        .iter()

        .find(|member| member.own)

        .expect("own member missing");

    assert_eq!(own_member.user_id, user_id!("@example:localhost"));

    assert_eq!(own_member.name, "Example");

    assert_eq!(own_member.display_name.as_deref(), Some("Example"));

    assert_eq!(own_member.membership, MemberMembership::Joined);

    assert!(own_member.own);

    let bob = joined_members

        .iter()

        .find(|member| member.user_id == user_id!("@bob:localhost"))

        .expect("joined member missing");

    assert_eq!(bob.name, "Bobby");

    assert_eq!(bob.display_name.as_deref(), Some("Bobby"));

    assert_eq!(bob.membership, MemberMembership::Joined);

    assert!(!bob.own);

    let invited_members = handle

        .members(room_id, MemberFilter::Invited)

        .await

        .unwrap();

    assert_eq!(invited_members.len(), 1);

    let carol = &invited_members[0];

    assert_eq!(carol.user_id, user_id!("@carol:localhost"));

    assert_eq!(carol.name, "Carol");

    assert_eq!(carol.display_name.as_deref(), Some("Carol"));

    assert_eq!(carol.membership, MemberMembership::Invited);

    assert!(!carol.own);

    drop(engine);

}

#[tokio::test]

async fn members_all_includes_custom_membership_states() {

    let server = MatrixMockServer::new().await;

    server

        .mock_sliding_sync()

        .ok(v5::Response::new("1".to_owned()))

        .mount()

        .await;

    let client = server.client_builder().build().await;

    let room_id = room_id!("!members-custom:localhost");

    server.mock_room_state_encryption().plain().mount().await;

    let factory = EventFactory::new().room(room_id);

    let joined = factory

        .member(user_id!("@bob:localhost"))

        .display_name("Bobby")

        .into_raw_sync_state();

    let custom = factory

        .member(user_id!("@dave:localhost"))

        .membership(MembershipState::from("flying"))

        .sender(user_id!("@bob:localhost"))

        .state_key(user_id!("@dave:localhost"))

        .display_name("Dave")

        .into_raw_sync_state();

    let joined_member = factory

        .member(user_id!("@bob:localhost"))

        .display_name("Bobby")

        .into_raw();

    let custom_member = factory

        .member(user_id!("@dave:localhost"))

        .membership(MembershipState::from("flying"))

        .sender(user_id!("@bob:localhost"))

        .state_key(user_id!("@dave:localhost"))

        .display_name("Dave")

        .into_raw();

    server

        .sync_room(

            &client,

            JoinedRoomBuilder::new(room_id)

                .add_state_event(joined)

                .add_state_event(custom),

        )

        .await;

    server

        .mock_get_members()

        .ok(vec![joined_member, custom_member])

        .mock_once()

        .mount()

        .await;

    let (engine, handle, _events) = Engine::from_client(client, EngineConfig::default())

        .await

        .unwrap();

    // `All` maps to the SDK's unfiltered empty mask, so custom states are included.

    let all_members = handle.members(room_id, MemberFilter::All).await.unwrap();

    assert_eq!(all_members.len(), 2);

    let dave = all_members

        .iter()

        .find(|member| member.user_id == user_id!("@dave:localhost"))

        .expect("custom member missing");

    assert!(

        matches!(&dave.membership, MemberMembership::Custom(state) if state == "flying"),

        "unexpected membership: {:?}",

        dave.membership

    );

    // Narrow filters still exclude the custom state.

    let joined_members = handle.members(room_id, MemberFilter::Joined).await.unwrap();

    assert_eq!(joined_members.len(), 1);

    assert_eq!(joined_members[0].user_id, user_id!("@bob:localhost"));

    drop(engine);

}

#[tokio::test]

async fn members_rejects_unknown_room() {

    let server = MatrixMockServer::new().await;

    let client = server.client_builder().build().await;

    let (engine, handle, _events) = Engine::from_client(client, EngineConfig::default())

        .await

        .unwrap();

    let room_id = room_id!("!missing:localhost");

    assert_eq!(

        handle

            .members(room_id, MemberFilter::All)

            .await

            .unwrap_err()

            .kind,

        ErrorKind::RoomUnknown

    );

    drop(engine);

}