macltok

mod support;

use std::time::Duration;

use macltok::{

    ClientHandle, Command, Engine, EngineConfig, EngineError, ErrorKind, Event, EventStream,

    MessageContent, MessageEditContent, RichText, RoomCommand, TimelineCommand,

};

use matrix_sdk::{

    ruma::{RoomId, api::client::sync::sync_events::v5, event_id, room_id},

    test_utils::mocks::MatrixMockServer,

};

use support::shut_down;

use tokio::task::JoinHandle;

#[tokio::test]

async fn empty_message_bodies_fail_with_empty_body() {

    let room_id = room_id!("!empty-bodies:localhost");

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

    open_room(&handle, &mut events, room_id).await;

    let commands = [

        TimelineCommand::Send {

            timeline_id: room_id.to_owned().into(),

            content: MessageContent::text(String::new()),

        },

        TimelineCommand::Send {

            timeline_id: room_id.to_owned().into(),

            content: MessageContent::emote(RichText::plain("   "), Default::default()),

        },

        TimelineCommand::Send {

            timeline_id: room_id.to_owned().into(),

            content: MessageContent::reply(

                event_id!("$reply:localhost").to_owned(),

                RichText::plain("\n"),

                Default::default(),

            ),

        },

        TimelineCommand::Edit {

            timeline_id: room_id.to_owned().into(),

            target: event_id!("$edit:localhost").to_owned().into(),

            content: MessageEditContent::text("\t"),

        },

    ];

    for command in commands {

        let error = handle

            .execute(Command::Timeline(command))

            .await

            .expect_err("empty body command unexpectedly succeeded");

        assert_eq!(error.kind, ErrorKind::EmptyBody);

    }

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

    drop(server);

}

#[tokio::test]

async fn open_resets_the_timeline_before_succeeding() {

    let room_id = room_id!("!open-order:localhost");

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

    open_room(&handle, &mut events, room_id).await;

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

    drop(server);

}

#[tokio::test]

async fn same_room_sends_complete_in_submission_order() {

    let room_id = room_id!("!send-order:localhost");

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

    open_room(&handle, &mut events, room_id).await;

    server

        .mock_room_send()

        .ok(event_id!("$sent:localhost"))

        .expect(2)

        .mount()

        .await;

    let first = handle

        .try_send(Command::Timeline(TimelineCommand::Send {

            timeline_id: room_id.to_owned().into(),

            content: MessageContent::text("first"),

        }))

        .unwrap();

    let second = handle

        .try_send(Command::Timeline(TimelineCommand::Send {

            timeline_id: room_id.to_owned().into(),

            content: MessageContent::text("second"),

        }))

        .unwrap();

    // both answers land almost together, so racing them can't show which was

    // processed first, only the order the sends actually reached the homeserver can

    let (first_result, second_result) = tokio::join!(first, second);

    first_result.expect("first send failed");

    second_result.expect("second send failed");

    tokio::time::timeout(Duration::from_secs(2), async {

        loop {

            let bodies: Vec<String> = server

                .received_requests()

                .await

                .unwrap()

                .iter()

                .filter(|request| request.url.path().contains("/send/m.room.message/"))

                .filter_map(|request| {

                    serde_json::from_slice::<serde_json::Value>(&request.body).ok()

                })

                .filter_map(|body| body["body"].as_str().map(str::to_owned))

                .collect();

            if bodies.len() >= 2 {

                assert_eq!(bodies, ["first", "second"]);

                break;

            }

            tokio::task::yield_now().await;

        }

    })

    .await

    .expect("both sends did not reach the homeserver in submission order");

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

    drop(server);

}

async fn start_engine(

    room_id: &RoomId,

) -> (

    MatrixMockServer,

    ClientHandle,

    EventStream,

    JoinHandle<Result<(), EngineError>>,

) {

    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.sync_joined_room(&client, room_id).await;

    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());

    (server, handle, events, running)

}

/// opens `room_id` and confirms its `TimelineReset` was already on the

/// stream by the time the open command answered

async fn open_room(handle: &ClientHandle, events: &mut EventStream, room_id: &RoomId) {

    let mut pending = handle

        .send(Command::Room(RoomCommand::Open(room_id.to_owned())))

        .await

        .unwrap();

    let mut reset_received = false;

    tokio::time::timeout(Duration::from_secs(2), async {

        loop {

            tokio::select! {

                biased;

                event = events.recv() => {

                    if let Event::TimelineReset { timeline_id, .. } = event.expect("event stream closed")

                        && timeline_id.room_id() == room_id

                    {

                        reset_received = true;

                    }

                }

                result = &mut pending => {

                    result.expect("opening room failed");

                    break;

                }

            }

        }

    })

    .await

    .expect("room did not open");

    assert!(reset_received, "open completed before its reset");

}