macltok

mod support;

use macltok::{

    ClientHandle, CreateRoomOptions, Engine, EngineConfig, EngineError, ErrorKind, EventStream,

    RoomPreset, RoomVisibility,

};

use matrix_sdk::{

    ruma::{

        api::client::sync::sync_events::v5,

        events::{GlobalAccountDataEventType, RoomAccountDataEventType},

        room_id,

        serde::Raw,

        server_name, user_id,

    },

    test_utils::mocks::MatrixMockServer,

};

use matrix_sdk_test::{InvitedRoomBuilder, JoinedRoomBuilder};

use serde_json::json;

use tokio::task::JoinHandle;

use wiremock::{

    Mock, ResponseTemplate,

    matchers::{body_partial_json, method, path, path_regex, query_param},

};

#[tokio::test]

async fn joining_by_room_id_forwards_via_servers() {

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

    let (server, handle, mut events, running) = start_engine().await;

    Mock::given(method("POST"))

        .and(path(format!("/_matrix/client/v3/join/{room_id}")))

        .and(query_param("via", "relay.example"))

        .respond_with(ResponseTemplate::new(200).set_body_json(json!({ "room_id": room_id })))

        .expect(1)

        .mount(server.server())

        .await;

    let joined_room = handle

        .join_room(

            room_id.to_owned().into(),

            vec![server_name!("relay.example").to_owned()],

        )

        .await

        .unwrap();

    assert_eq!(joined_room, room_id);

    support::shut_down(&handle, &mut events, running).await;

}

#[tokio::test]

async fn leaving_then_forgetting_a_room_hits_the_expected_endpoints() {

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

    let (server, client) = configured_client().await;

    server.sync_joined_room(&client, room_id).await;

    server.mock_room_leave().ok(room_id).expect(1).mount().await;

    server.mock_room_forget().ok().expect(1).mount().await;

    let (handle, mut events, running) = run_client(client).await;

    handle.leave_room(room_id.to_owned()).await.unwrap();

    handle.forget_room(room_id.to_owned()).await.unwrap();

    support::shut_down(&handle, &mut events, running).await;

    drop(server);

}

#[tokio::test]

async fn accepting_and_rejecting_invites_use_the_expected_endpoints() {

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

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

    let (server, client) = configured_client().await;

    server

        .sync_room(&client, InvitedRoomBuilder::new(accepted))

        .await;

    server

        .sync_room(&client, InvitedRoomBuilder::new(rejected))

        .await;

    server.mock_room_join(accepted).ok().expect(1).mount().await;

    server

        .mock_room_leave()

        .ok(rejected)

        .expect(1)

        .mount()

        .await;

    let (handle, mut events, running) = run_client(client).await;

    handle.accept_invite(accepted.to_owned()).await.unwrap();

    handle.reject_invite(rejected.to_owned()).await.unwrap();

    support::shut_down(&handle, &mut events, running).await;

}

#[tokio::test]

async fn creating_a_room_forwards_options() {

    let (server, handle, mut events, running) = start_engine().await;

    Mock::given(method("POST"))

        .and(path("/_matrix/client/v3/createRoom"))

        .and(body_partial_json(json!({

            "name": "Planning",

            "topic": "Next release",

            "room_alias_name": "planning",

            "invite": ["@partner:localhost"],

            "visibility": "public",

            "preset": "public_chat"

        })))

        .respond_with(

            ResponseTemplate::new(200).set_body_json(json!({ "room_id": "!created:localhost" })),

        )

        .expect(1)

        .mount(server.server())

        .await;

    let created_room = handle

        .create_room(

            CreateRoomOptions::default()

                .with_name("Planning")

                .with_topic("Next release")

                .with_alias_localpart("planning")

                .with_invite(vec![user_id!("@partner:localhost").to_owned()])

                .with_visibility(RoomVisibility::Public)

                .with_preset(RoomPreset::PublicChat),

        )

        .await

        .unwrap();

    assert_eq!(created_room, room_id!("!created:localhost").to_owned());

    support::shut_down(&handle, &mut events, running).await;

}

#[tokio::test]

async fn creating_a_direct_room_invites_the_other_user() {

    let (server, handle, mut events, running) = start_engine().await;

    Mock::given(method("POST"))

        .and(path("/_matrix/client/v3/createRoom"))

        .and(body_partial_json(json!({

            "invite": ["@partner:localhost"],

            "is_direct": true,

            "preset": "trusted_private_chat"

        })))

        .respond_with(

            ResponseTemplate::new(200).set_body_json(json!({ "room_id": "!direct:localhost" })),

        )

        .expect(1)

        .mount(server.server())

        .await;

    Mock::given(method("GET"))

        .and(path_regex(

            r"^/_matrix/client/v3/user/.*/account_data/m\.direct$",

        ))

        .respond_with(ResponseTemplate::new(200).set_body_json(json!({})))

        .expect(1)

        .mount(server.server())

        .await;

    Mock::given(method("PUT"))

        .and(path_regex(

            r"^/_matrix/client/v3/user/.*/account_data/m\.direct$",

        ))

        .respond_with(ResponseTemplate::new(200).set_body_json(json!({})))

        .expect(1)

        .mount(server.server())

        .await;

    let direct_room = handle

        .create_direct(user_id!("@partner:localhost").to_owned())

        .await

        .unwrap();

    assert_eq!(direct_room, room_id!("!direct:localhost").to_owned());

    support::shut_down(&handle, &mut events, running).await;

}

#[tokio::test]

async fn unknown_rooms_fail_membership_commands_with_room_unknown() {

    let (server, handle, mut events, running) = start_engine().await;

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

    assert_eq!(

        handle

            .leave_room(unknown.to_owned())

            .await

            .unwrap_err()

            .kind,

        ErrorKind::RoomUnknown

    );

    assert_eq!(

        handle

            .forget_room(unknown.to_owned())

            .await

            .unwrap_err()

            .kind,

        ErrorKind::RoomUnknown

    );

    assert_eq!(

        handle

            .accept_invite(unknown.to_owned())

            .await

            .unwrap_err()

            .kind,

        ErrorKind::RoomUnknown

    );

    assert_eq!(

        handle

            .reject_invite(unknown.to_owned())

            .await

            .unwrap_err()

            .kind,

        ErrorKind::RoomUnknown

    );

    support::shut_down(&handle, &mut events, running).await;

    drop(server);

}

#[tokio::test]

async fn account_data_reads_synced_values_and_writes_raw_content() {

    let room_id = room_id!("!account-data:localhost");

    let (server, client) = configured_client().await;

    server

        .sync_room(

            &client,

            JoinedRoomBuilder::new(room_id).add_account_data(

                Raw::new(&json!({ "type": "m.fully_read", "content": { "event_id": "$seen:localhost" } }))

                    .unwrap()

                    .cast_unchecked(),

            ),

        )

        .await;

    server

        .mock_sync()

        .ok_and_run(&client, |builder| {

            builder.add_custom_global_account_data(json!({

                "type": "com.example.preferences",

                "content": { "theme": "dark" }

            }));

        })

        .await;

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

        .await

        .unwrap();

    let running = tokio::spawn(engine.run());

    let global_type = GlobalAccountDataEventType::from("com.example.preferences".to_owned());

    let room_type = RoomAccountDataEventType::FullyRead;

    let global = handle

        .global_account_data(global_type.clone())

        .await

        .unwrap()

        .unwrap();

    assert_eq!(

        global.deserialize_as::<serde_json::Value>().unwrap()["theme"],

        "dark"

    );

    let room = handle

        .room_account_data(room_id, room_type.clone())

        .await

        .unwrap()

        .unwrap();

    assert_eq!(

        room.deserialize_as::<serde_json::Value>().unwrap()["content"]["event_id"],

        "$seen:localhost"

    );

    assert_eq!(

        handle

            .room_account_data(room_id!("!missing:localhost"), room_type.clone())

            .await

            .unwrap_err()

            .kind,

        ErrorKind::RoomUnknown

    );

    Mock::given(method("PUT"))

        .and(path(

            "/_matrix/client/v3/user/@example:localhost/account_data/com.example.preferences",

        ))

        .and(body_partial_json(json!({ "theme": "light" })))

        .respond_with(ResponseTemplate::new(200).set_body_json(json!({})))

        .expect(1)

        .mount(server.server())

        .await;

    server

        .mock_set_room_account_data(room_type.clone())

        .ok()

        .expect(1)

        .mount()

        .await;

    handle

        .set_global_account_data(

            global_type,

            Raw::new(&json!({ "theme": "light" }))

                .unwrap()

                .cast_unchecked(),

        )

        .await

        .unwrap();

    handle

        .set_room_account_data(

            room_id.to_owned(),

            room_type,

            Raw::new(&json!({ "event_id": "$later:localhost" }))

                .unwrap()

                .cast_unchecked(),

        )

        .await

        .unwrap();

    assert_eq!(

        handle

            .set_room_account_data(

                room_id!("!missing:localhost").to_owned(),

                RoomAccountDataEventType::FullyRead,

                Raw::new(&json!({ "event_id": "$later:localhost" }))

                    .unwrap()

                    .cast_unchecked()

            )

            .await

            .unwrap_err()

            .kind,

        ErrorKind::RoomUnknown

    );

    support::shut_down(&handle, &mut events, running).await;

}

async fn configured_client() -> (MatrixMockServer, matrix_sdk::Client) {

    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;

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

    (server, client)

}

async fn start_engine() -> (

    MatrixMockServer,

    ClientHandle,

    EventStream,

    JoinHandle<Result<(), EngineError>>,

) {

    let (server, client) = configured_client().await;

    let (handle, events, running) = run_client(client).await;

    (server, handle, events, running)

}

async fn run_client(

    client: matrix_sdk::Client,

) -> (

    ClientHandle,

    EventStream,

    JoinHandle<Result<(), EngineError>>,

) {

    let config = EngineConfig::default().with_initial_history_limit(0);

    let (engine, handle, events) = Engine::from_client(client, config).await.unwrap();

    let running = tokio::spawn(engine.run());

    (handle, events, running)

}