macltok

mod support;

use std::time::Duration;

use macltok::{

    ConnectionState, Engine, EngineConfig, EngineError, Event, PackUsage, Retain, RoomMembership,

    Termination,

};

use matrix_sdk::{

    ruma::{api::client::sync::sync_events::v5, events::AnySyncStateEvent, room_id, serde::Raw},

    test_utils::mocks::MatrixMockServer,

};

use matrix_sdk_test::JoinedRoomBuilder;

use serde_json::json;

use tokio::sync::watch;

#[tokio::test]

async fn rooms_changed_invalidates_room_summaries() {

    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!("!state:localhost");

    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, mut events) = Engine::from_client(client, config).await.unwrap();

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

    support::receive_until(&mut events, |event| matches!(event, Event::RoomsChanged)).await;

    let rooms = handle.rooms().await;

    let summary = rooms

        .iter()

        .find(|summary| summary.room_id == room_id)

        .expect("synced room was absent from the room summaries");

    assert_eq!(summary.membership, RoomMembership::Joined);

    assert!(!summary.name.is_empty());

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

}

#[tokio::test]

async fn connection_watch_tracks_the_engine_lifecycle() {

    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 config = EngineConfig::default().with_initial_history_limit(0);

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

    let mut connection = handle.connection_state();

    let connection_peer = connection.clone();

    assert_eq!(*connection.borrow(), ConnectionState::Idle);

    assert_eq!(*connection_peer.borrow(), ConnectionState::Idle);

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

    support::receive_until(&mut events, |event| {

        matches!(event, Event::ConnectionChanged(ConnectionState::Connecting))

    })

    .await;

    assert_ne!(*connection.borrow(), ConnectionState::Idle);

    support::receive_until(&mut events, |event| {

        matches!(event, Event::ConnectionChanged(ConnectionState::Online))

    })

    .await;

    wait_for_connection(&mut connection, ConnectionState::Online).await;

    assert_eq!(*connection_peer.borrow(), ConnectionState::Online);

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

    wait_for_connection(&mut connection, ConnectionState::Stopped).await;

    assert_eq!(*connection_peer.borrow(), ConnectionState::Stopped);

}

#[tokio::test]

async fn soft_logout_says_so_and_stops_the_engine() {

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

    server

        .mock_sliding_sync()

        .error_unknown_token(true)

        .mount()

        .await;

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

    let (engine, _handle, mut events) = Engine::from_client(

        client,

        EngineConfig::default().with_initial_history_limit(0),

    )

    .await

    .unwrap();

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

    support::receive_until(&mut events, |event| {

        matches!(

            event,

            Event::SessionAccessRejected {

                soft_logout: Some(_)

            }

        )

    })

    .await;

    support::receive_until(&mut events, |event| matches!(event, Event::Stopped)).await;

    let termination = running.await.unwrap().unwrap();

    assert!(matches!(termination, Termination::SoftLoggedOut { .. }));

    assert_eq!(termination.retain(), Retain::Store);

}

#[tokio::test]

async fn closing_the_event_stream_stops_an_idle_engine() {

    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 (engine, handle, mut events) = Engine::from_client(

        client,

        EngineConfig::default().with_initial_history_limit(0),

    )

    .await

    .unwrap();

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

    support::receive_until(&mut events, |event| {

        matches!(event, Event::ConnectionChanged(ConnectionState::Online))

    })

    .await;

    drop(events);

    let result = tokio::time::timeout(Duration::from_secs(2), running)

        .await

        .expect("engine did not stop after its event receiver closed")

        .unwrap();

    assert!(matches!(result, Err(EngineError::EventReceiverClosed)));

    drop(handle);

}

async fn wait_for_connection(

    connection: &mut watch::Receiver<ConnectionState>,

    expected: ConnectionState,

) {

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

        loop {

            if *connection.borrow_and_update() == expected {

                return;

            }

            connection

                .changed()

                .await

                .expect("connection watch closed before the expected state");

        }

    })

    .await

    .expect("expected connection state did not arrive");

}

#[tokio::test]

async fn image_packs_follow_room_state_and_account_data() {

    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!("!packs:localhost");

    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, mut events) = Engine::from_client(client.clone(), config).await.unwrap();

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

    let pack: Raw<AnySyncStateEvent> = serde_json::from_value(json!({

        "type": "im.ponies.room_emotes",

        "state_key": "cats",

        "event_id": "$pack",

        "sender": "@example:localhost",

        "origin_server_ts": 1,

        "content": {

            "pack": { "display_name": "cats", "usage": ["emoticon"] },

            "images": {

                "blep": { "url": "mxc://localhost/blep" },

                "broken": { "url": "not an mxc" },

                "sticker": { "url": "mxc://localhost/sticker", "usage": ["sticker"] },

            },

        },

    }))

    .unwrap();

    server

        .mock_sync()

        .ok_and_run(&client, |builder| {

            builder.add_joined_room(JoinedRoomBuilder::new(room_id).add_state_event(pack));

            builder.add_custom_global_account_data(json!({

                "type": "im.ponies.emote_rooms",

                "content": { "rooms": { "!packs:localhost": { "cats": {} } } },

            }));

        })

        .await;

    support::receive_until(&mut events, |event| {

        matches!(event, Event::ImagePacksChanged)

    })

    .await;

    let packs = handle.image_packs().await.unwrap();

    let offered = packs.for_room(Some(room_id));

    assert_eq!(offered.len(), 1, "an enabled room's pack was offered twice");

    let pack = offered[0];

    assert_eq!(pack.id, "room:!packs:localhost:cats");

    assert_eq!(packs.global, vec![pack.clone()]);

    let images: Vec<_> = pack

        .images

        .iter()

        .map(|image| {

            (

                image.shortcode.as_str(),

                image.reaction_key.as_str(),

                image.usage.clone(),

            )

        })

        .collect();

    assert_eq!(

        images,

        [

            ("blep", "mxc://localhost/blep", vec![PackUsage::Emoticon]),

            (

                "sticker",

                "mxc://localhost/sticker",

                vec![PackUsage::Sticker]

            ),

        ]

    );

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

}