macltok

use matrix_sdk::{

    Room,

    ruma::{

        UInt,

        api::client::push::get_notifications::v3,

        event_id,

        events::{AnySyncTimelineEvent, Mentions},

        owned_user_id,

        push::{Action, EventMatchConditionData, NewConditionalPushRule, PushCondition, Ruleset},

        room_id,

        serde::Raw,

    },

    test_utils::mocks::MatrixMockServer,

};

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

use serde_json::json;

use std::time::Duration;

use wiremock::{

    Mock, ResponseTemplate,

    matchers::{method, path, query_param},

};

fn explicit_mention(

    room_id: &matrix_sdk::ruma::RoomId,

    event_id: &matrix_sdk::ruma::EventId,

    sender: &matrix_sdk::ruma::UserId,

    mentioned: &matrix_sdk::ruma::UserId,

) -> Raw<AnySyncTimelineEvent> {

    EventFactory::new()

        .room(room_id)

        .text_msg("hello")

        .mentions(Mentions::with_user_ids([mentioned.to_owned()]))

        .event_id(event_id)

        .sender(sender)

        .into_raw_sync()

}

fn assert_mention_actions(actions: &[Action]) {

    assert!(

        actions

            .iter()

            .any(|action| matches!(action, Action::Notify))

    );

    assert!(actions.iter().any(Action::is_highlight));

}

async fn sync_room_with_mention(

    server: &MatrixMockServer,

    client: &matrix_sdk::Client,

    room_id: &matrix_sdk::ruma::RoomId,

    event_id: &matrix_sdk::ruma::EventId,

) {

    let user_id = client.user_id().unwrap();

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

    let sender = owned_user_id!("@alice:localhost");

    let event = explicit_mention(room_id, event_id, &sender, user_id);

    let rules = Ruleset::server_default(user_id);

    server

        .mock_sync()

        .ok_and_run(client, |builder| {

            builder.add_global_account_data(factory.push_rules(rules));

            builder.add_joined_room(

                JoinedRoomBuilder::new(room_id)

                    .add_state_event(factory.member(user_id))

                    .add_timeline_event(event),

            );

        })

        .await;

}

async fn actions_for(room: &Room, event: &Raw<AnySyncTimelineEvent>) -> Option<Vec<Action>> {

    room.event_push_actions(event).await.unwrap()

}

#[tokio::test]

async fn joined_room_update_exposes_mention_actions_without_opening_a_ui_timeline() {

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

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

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

    let event_id = event_id!("$mention:localhost");

    let mut updates = client.subscribe_to_all_room_updates();

    sync_room_with_mention(&server, &client, room_id, event_id).await;

    let room_updates = tokio::time::timeout(Duration::from_secs(2), updates.recv())

        .await

        .unwrap()

        .unwrap();

    let joined = room_updates

        .joined

        .get(room_id)

        .expect("the joined room update was absent");

    let event = joined

        .timeline

        .events

        .iter()

        .find(|event| event.event_id().as_deref().map(|id| id.as_str()) == Some(event_id.as_str()))

        .expect("the explicit mention was absent from the room update");

    let event_json: serde_json::Value =

        serde_json::from_str(event.kind.raw().json().get()).unwrap();

    assert_eq!(

        event_json["content"]["m.mentions"]["user_ids"],

        json!([client.user_id().unwrap().as_str()])

    );

    assert_mention_actions(

        event

            .push_actions()

            .expect("push actions were not computed"),

    );

}

#[tokio::test]

async fn event_cache_generic_update_finds_the_mention_without_opening_a_ui_timeline() {

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

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

    let room_id = room_id!("!cached-mentions:localhost");

    let event_id = event_id!("$cached-mention:localhost");

    client.event_cache().subscribe().unwrap();

    let mut updates = client.event_cache().subscribe_to_room_generic_updates();

    sync_room_with_mention(&server, &client, room_id, event_id).await;

    let update = tokio::time::timeout(Duration::from_secs(2), updates.recv())

        .await

        .unwrap()

        .unwrap();

    assert_eq!(update.room_id, room_id);

    let room = client.get_room(room_id).unwrap();

    let (event_cache, _drop_handles) = room.event_cache().await.unwrap();

    let event = event_cache.find_event(event_id).await.unwrap().unwrap();

    assert_eq!(

        event.event_id().as_deref().map(|id| id.as_str()),

        Some(event_id.as_str())

    );

    assert_mention_actions(

        event

            .push_actions()

            .expect("cached push actions were absent"),

    );

}

#[tokio::test]

async fn ignored_sender_and_muted_room_actions_remain_sdk_push_rule_results() {

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

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

    let ignored_room_id = room_id!("!ignored-sender:localhost");

    let muted_room_id = room_id!("!muted-room:localhost");

    let ignored_sender = owned_user_id!("@ignored:localhost");

    let own_user = client.user_id().unwrap();

    let factory = EventFactory::new();

    let ignored_event_id = event_id!("$ignored-mention:localhost");

    let muted_event_id = event_id!("$muted-message:localhost");

    let ignored_event =

        explicit_mention(ignored_room_id, ignored_event_id, &ignored_sender, own_user);

    let sender = owned_user_id!("@alice:localhost");

    let muted_event = explicit_mention(muted_room_id, muted_event_id, &sender, own_user);

    let mut rules = Ruleset::server_default(own_user);

    rules.override_.shift_insert(

        1,

        NewConditionalPushRule::new(

            "mute-room".to_owned(),

            vec![PushCondition::EventMatch(EventMatchConditionData::new(

                "room_id".to_owned(),

                muted_room_id.to_string(),

            ))],

            Vec::new(),

        )

        .into(),

    );

    server

        .mock_sync()

        .ok_and_run(&client, |builder| {

            builder.add_global_account_data(factory.ignored_user_list([ignored_sender.clone()]));

            builder.add_global_account_data(factory.push_rules(rules));

            builder.add_joined_room(

                JoinedRoomBuilder::new(ignored_room_id)

                    .add_state_event(EventFactory::new().room(ignored_room_id).member(own_user))

                    .add_timeline_event(ignored_event.clone()),

            );

            builder.add_joined_room(

                JoinedRoomBuilder::new(muted_room_id)

                    .add_state_event(EventFactory::new().room(muted_room_id).member(own_user))

                    .add_timeline_event(muted_event.clone()),

            );

        })

        .await;

    assert!(client.is_user_ignored(&ignored_sender).await);

    let ignored_room = client.get_room(ignored_room_id).unwrap();

    let ignored_actions = actions_for(&ignored_room, &ignored_event)

        .await

        .expect("the ignored sender's push actions could not be computed");

    assert_mention_actions(&ignored_actions);

    let muted_room = client.get_room(muted_room_id).unwrap();

    let muted_actions = actions_for(&muted_room, &muted_event)

        .await

        .expect("the muted room's push actions could not be computed");

    assert!(muted_actions.is_empty());

}

#[tokio::test]

async fn notifications_v3_request_round_trips_opaque_pagination() {

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

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

    let cursor = "opaque / cursor?x=1&y=2";

    let next_cursor = "next / cursor?x=3&y=4";

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

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

        .and(query_param("from", cursor))

        .and(query_param("limit", "8"))

        .and(query_param("only", "highlight"))

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

            "next_token": next_cursor,

            "notifications": [],

        })))

        .expect(1)

        .mount(server.server())

        .await;

    let mut request = v3::Request::new();

    request.from = Some(cursor.to_owned());

    request.limit = Some(UInt::new(8).unwrap());

    request.only = Some("highlight".to_owned());

    let response = client.send(request).await.unwrap();

    assert_eq!(response.next_token.as_deref(), Some(next_cursor));

}