Dima/matrix-rust-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: update the code in pinned_events integration tests

Browse Source 
This is done so the tests there use the new APIs based on `MatrixMockServer`.
This commit is contained in:
Jorge Martín
2025-01-20 15:56:20 +01:00
committed by Jorge Martin Espinosa
parent d078ef6155
commit dad3e6839f
2 changed files with 174 additions and 205 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/matrix-sdk-ui/tests/integration/main.rs
-16
View File
@@ -82,22 +82,6 @@ async fn mock_context(
.await;
}
/// Mocks the /event endpoint
#[allow(clippy::too_many_arguments)] // clippy you've got such a fixed mindset
async fn mock_event(
server: &MockServer,
room_id: &RoomId,
event_id: &EventId,
event: TimelineEvent,
) {
Mock::given(method("GET"))
.and(path(format!("/_matrix/client/r0/rooms/{room_id}/event/{event_id}")))
.and(header("authorization", "Bearer 1234"))
.respond_with(ResponseTemplate::new(200).set_body_json(event.into_raw().json()))
.mount(server)
.await;
}
/// Mocks the /messages endpoint.
///
/// Note: pass `chunk` in the correct order: topological for forward pagination,
crates/matrix-sdk-ui/tests/integration/timeline/pinned_event.rs
+174 -189
View File
@@ -6,8 +6,10 @@ use matrix_sdk::{
assert_next_matches_with_timeout,
config::SyncSettings,
event_cache::{BackPaginationOutcome, TimelineHasBeenResetWhilePaginating},
sync::SyncResponse,
test_utils::logged_in_client_with_server,
test_utils::{
logged_in_client_with_server,
mocks::{MatrixMockServer, RoomMessagesResponseTemplate},
},
Client,
};
use matrix_sdk_base::deserialized_responses::TimelineEvent;
@@ -20,7 +22,7 @@ use matrix_sdk_ui::{
Timeline,
};
use ruma::{
event_id,
assign, event_id,
events::{
room::{
encrypted::{
@@ -39,10 +41,10 @@ use stream_assert::assert_pending;
use tokio::time::sleep;
use wiremock::{
matchers::{header, method, path_regex},
Mock, MockServer, ResponseTemplate,
Mock, ResponseTemplate,
};
use crate::{mock_event, mock_sync};
use crate::mock_sync;
#[async_test]
async fn test_new_pinned_events_are_added_on_sync() {
@@ -50,8 +52,7 @@ async fn test_new_pinned_events_are_added_on_sync() {
let room_id = test_helper.room_id.clone();
// Join the room
let _ = test_helper.setup_initial_sync_response().await;
test_helper.server.reset().await;
let _ = test_helper.do_initial_sync().await;
let f = EventFactory::new().room(&room_id).sender(*BOB);
let event_1 = f
@@ -60,14 +61,16 @@ async fn test_new_pinned_events_are_added_on_sync() {
.server_ts(MilliSecondsSinceUnixEpoch::now())
.into_timeline();
// Load initial timeline items: a text message and a `m.room.pinned_events` with
// events $1 and $2 pinned
let _ = test_helper.setup_sync_response(vec![(event_1, false)], Some(vec!["$1", "$2"])).await;
// Mock /event endpoint for a timeline event
test_helper.mock_events(vec![event_1.clone()]).await;
// Load initial timeline items: a `m.room.pinned_events` with events $1 and $2
// pinned
test_helper.sync_once(Vec::new(), Some(vec!["$1", "$2"])).await.expect("Sync failed");
let room = test_helper.client.get_room(&room_id).unwrap();
let timeline =
Timeline::builder(&room).with_focus(pinned_events_focus(100)).build().await.unwrap();
test_helper.server.reset().await;
assert!(
timeline.live_back_pagination_status().await.is_none(),
@@ -81,7 +84,6 @@ async fn test_new_pinned_events_are_added_on_sync() {
assert!(items[0].is_date_divider());
assert_eq!(items[1].as_event().unwrap().content().as_message().unwrap().body(), "in the end");
assert_pending!(timeline_stream);
test_helper.server.reset().await;
// Load new pinned event contents from sync, $2 was pinned but wasn't available
// before
@@ -95,7 +97,8 @@ async fn test_new_pinned_events_are_added_on_sync() {
.event_id(event_id!("$3"))
.server_ts(MilliSecondsSinceUnixEpoch::now())
.into_timeline();
let _ = test_helper.setup_sync_response(vec![(event_2, true), (event_3, true)], None).await;
test_helper.mock_events(vec![event_2.clone(), event_3.clone()]).await;
test_helper.sync_once(vec![event_2, event_3], None).await.expect("Sync failed");
// The item is added automatically
assert_next_matches_with_timeout!(timeline_stream, VectorDiff::PushBack { value } => {
@@ -113,7 +116,6 @@ async fn test_new_pinned_events_are_added_on_sync() {
assert_next_matches_with_timeout!(timeline_stream, VectorDiff::PushFront { value } => {
assert!(value.is_date_divider());
});
test_helper.server.reset().await;
}
#[async_test]
@@ -122,8 +124,7 @@ async fn test_new_pinned_event_ids_reload_the_timeline() {
let room_id = test_helper.room_id.clone();
// Join the room
let _ = test_helper.setup_initial_sync_response().await;
test_helper.server.reset().await;
test_helper.do_initial_sync().await;
let f = EventFactory::new().room(&room_id).sender(*BOB);
let event_1 = f
@@ -139,12 +140,8 @@ async fn test_new_pinned_event_ids_reload_the_timeline() {
// Load initial timeline items: 2 text messages and a `m.room.pinned_events`
// with event $1 and $2 pinned
let _ = test_helper
.setup_sync_response(
vec![(event_1.clone(), false), (event_2.clone(), true)],
Some(vec!["$1"]),
)
.await;
test_helper.mock_events(vec![event_1.clone(), event_2.clone()]).await;
let _ = test_helper.sync_once(vec![event_2.clone()], Some(vec!["$1"])).await;
let room = test_helper.client.get_room(&room_id).unwrap();
let timeline =
@@ -161,15 +158,10 @@ async fn test_new_pinned_event_ids_reload_the_timeline() {
assert!(items[0].is_date_divider());
assert_eq!(items[1].as_event().unwrap().content().as_message().unwrap().body(), "in the end");
assert_pending!(timeline_stream);
test_helper.server.reset().await;
// Reload timeline with new pinned event ids
let _ = test_helper
.setup_sync_response(
vec![(event_1.clone(), false), (event_2.clone(), false)],
Some(vec!["$1", "$2"]),
)
.await;
test_helper.mock_events(vec![event_1.clone(), event_2.clone()]).await;
test_helper.sync_once(Vec::new(), Some(vec!["$1", "$2"])).await.expect("Sync failed");
assert_next_matches_with_timeout!(timeline_stream, VectorDiff::Clear);
assert_next_matches_with_timeout!(timeline_stream, VectorDiff::PushBack { value } => {
@@ -182,16 +174,13 @@ async fn test_new_pinned_event_ids_reload_the_timeline() {
assert!(value.is_date_divider());
});
assert_pending!(timeline_stream);
test_helper.server.reset().await;
// Reload timeline with no pinned event ids
let _ = test_helper
.setup_sync_response(vec![(event_1, false), (event_2, false)], Some(Vec::new()))
.await;
// Reload timeline with no pinned event
test_helper.mock_events(vec![event_1.clone(), event_2.clone()]).await;
let _ = test_helper.sync_once(Vec::new(), Some(Vec::new())).await;
assert_next_matches_with_timeout!(timeline_stream, VectorDiff::Clear);
assert_pending!(timeline_stream);
test_helper.server.reset().await;
}
#[async_test]
@@ -200,8 +189,7 @@ async fn test_max_events_to_load_is_honored() {
let room_id = test_helper.room_id.clone();
// Join the room
let _ = test_helper.setup_initial_sync_response().await;
test_helper.server.reset().await;
let _ = test_helper.do_initial_sync().await;
let f = EventFactory::new().room(&room_id).sender(*BOB);
let pinned_event = f
@@ -212,8 +200,8 @@ async fn test_max_events_to_load_is_honored() {
// Load initial timeline items: a text message and a `m.room.pinned_events`
// with event $1 and $2 pinned
let _ =
test_helper.setup_sync_response(vec![(pinned_event, false)], Some(vec!["$1", "$2"])).await;
test_helper.mock_events(vec![pinned_event]).await;
test_helper.sync_once(Vec::new(), Some(vec!["$1", "$2"])).await.expect("Sync failed");
let room = test_helper.client.get_room(&room_id).unwrap();
let ret = Timeline::builder(&room).with_focus(pinned_events_focus(1)).build().await;
@@ -221,8 +209,6 @@ async fn test_max_events_to_load_is_honored() {
// We're only taking the last event id, `$2`, and it's not available so the
// timeline fails to initialise.
assert!(ret.is_err());
test_helper.server.reset().await;
}
#[async_test]
@@ -235,8 +221,7 @@ async fn test_cached_events_are_kept_for_different_room_instances() {
let room_id = test_helper.room_id.clone();
// Join the room
let _ = test_helper.setup_initial_sync_response().await;
test_helper.server.reset().await;
test_helper.do_initial_sync().await;
let f = EventFactory::new().room(&room_id).sender(*BOB);
let pinned_event = f
@@ -245,10 +230,12 @@ async fn test_cached_events_are_kept_for_different_room_instances() {
.server_ts(MilliSecondsSinceUnixEpoch::now())
.into_timeline();
// Load initial timeline items: a text message and a `m.room.pinned_events`
// with event $1 and $2 pinned
let _ =
test_helper.setup_sync_response(vec![(pinned_event, false)], Some(vec!["$1", "$2"])).await;
// Mock /event for some timeline events
test_helper.mock_events(vec![pinned_event]).await;
// Load initial timeline items: a `m.room.pinned_events` with event $1 and $2
// pinned
test_helper.sync_once(Vec::new(), Some(vec!["$1", "$2"])).await.expect("Sync failed");
let room = test_helper.client.get_room(&room_id).unwrap();
let (room_cache, _drop_handles) = room.event_cache().await.unwrap();
@@ -268,14 +255,13 @@ async fn test_cached_events_are_kept_for_different_room_instances() {
assert!(room_cache.event(event_id!("$1")).await.is_some());
// Drop the existing room and timeline instances
test_helper.server.reset().await;
drop(timeline_stream);
drop(timeline);
drop(room);
// Set up a sync response with only the pinned event ids and no events, so if
// they exist later we know they come from the cache
let _ = test_helper.setup_sync_response(Vec::new(), Some(vec!["$1", "$2"])).await;
test_helper.sync_once(Vec::new(), Some(vec!["$1", "$2"])).await.expect("Sync failed");
// Get a new room instance
let room = test_helper.client.get_room(&room_id).unwrap();
@@ -289,14 +275,14 @@ async fn test_cached_events_are_kept_for_different_room_instances() {
assert!(room_cache.event(event_id!("$1")).await.is_some());
// Drop the existing room and timeline instances
test_helper.server.reset().await;
test_helper.server.server().reset().await;
drop(timeline);
drop(room);
// Now remove the pinned events from the cache and try again
test_helper.client.event_cache().empty_immutable_cache().await;
let _ = test_helper.setup_sync_response(Vec::new(), Some(vec!["$1", "$2"])).await;
test_helper.sync_once(Vec::new(), Some(vec!["$1", "$2"])).await.expect("Sync failed");
// Get a new room instance
let room = test_helper.client.get_room(&room_id).unwrap();
@@ -307,8 +293,6 @@ async fn test_cached_events_are_kept_for_different_room_instances() {
// Since the events are no longer in the cache the timeline couldn't load them
// and can't be initialised.
assert!(ret.is_err());
test_helper.server.reset().await;
}
#[async_test]
@@ -317,20 +301,17 @@ async fn test_pinned_timeline_with_pinned_event_ids_and_empty_result_fails() {
let room_id = test_helper.room_id.clone();
// Join the room
let _ = test_helper.setup_initial_sync_response().await;
test_helper.server.reset().await;
test_helper.do_initial_sync().await;
// Load initial timeline items: a `m.room.pinned_events` with event $1 and $2
// pinned, but they're not available neither in the cache nor in the HS
let _ = test_helper.setup_sync_response(Vec::new(), Some(vec!["$1", "$2"])).await;
test_helper.sync_once(Vec::new(), Some(vec!["$1", "$2"])).await.expect("Sync failed");
let room = test_helper.client.get_room(&room_id).unwrap();
let ret = Timeline::builder(&room).with_focus(pinned_events_focus(1)).build().await;
// The timeline couldn't load any events so it fails to initialise
assert!(ret.is_err());
test_helper.server.reset().await;
}
#[async_test]
@@ -339,11 +320,10 @@ async fn test_pinned_timeline_with_no_pinned_event_ids_is_just_empty() {
let room_id = test_helper.room_id.clone();
// Join the room
let _ = test_helper.setup_initial_sync_response().await;
test_helper.server.reset().await;
test_helper.do_initial_sync().await;
// Load initial timeline items: an empty `m.room.pinned_events` event
let _ = test_helper.setup_sync_response(Vec::new(), Some(Vec::new())).await;
test_helper.sync_once(Vec::new(), Some(Vec::new())).await.expect("Sync failed");
let room = test_helper.client.get_room(&room_id).unwrap();
let timeline =
@@ -353,12 +333,10 @@ async fn test_pinned_timeline_with_no_pinned_event_ids_is_just_empty() {
// returns an empty list
let (items, _) = timeline.subscribe().await;
assert!(items.is_empty());
test_helper.server.reset().await;
}
#[async_test]
async fn test_pinned_timeline_with_no_pinned_events_and_an_utd_is_just_empty() {
async fn test_pinned_timeline_with_no_pinned_events_and_an_utd_on_sync_is_just_empty() {
let mut test_helper = TestHelper::new().await;
let room_id = test_helper.room_id.clone();
let event_id = event_id!("$1:morpheus.localhost");
@@ -370,22 +348,26 @@ async fn test_pinned_timeline_with_no_pinned_events_and_an_utd_is_just_empty() {
.add_state_event(StateTestEvent::Encryption);
// Sync the joined room
let json_response =
SyncResponseBuilder::new().add_joined_room(joined_room_builder).build_json_sync_response();
mock_sync(&test_helper.server, json_response, None).await;
test_helper
.client
.sync_once(test_helper.sync_settings.clone())
.await
.expect("Sync should work");
test_helper.server.reset().await;
.server
.mock_sync()
.ok_and_run(&test_helper.client, move |sync_builder| {
sync_builder.add_joined_room(joined_room_builder);
})
.await;
// Load initial timeline items: an empty `m.room.pinned_events` event
let _ = test_helper.setup_sync_response(Vec::new(), Some(Vec::new())).await;
test_helper.sync_once(Vec::new(), Some(Vec::new())).await.expect("Sync failed");
// Mock encrypted event for which we have now keys (an UTD)
// Mock encrypted event for which we don't have keys (an UTD)
let utd_event = create_utd(&room_id, &sender_id, event_id);
mock_event(&test_helper.server, &room_id, event_id, TimelineEvent::new(utd_event)).await;
test_helper
.server
.mock_room_event()
.match_event_id()
.ok(TimelineEvent::new(utd_event))
.mount()
.await;
let room = test_helper.client.get_room(&room_id).unwrap();
let timeline =
@@ -395,8 +377,6 @@ async fn test_pinned_timeline_with_no_pinned_events_and_an_utd_is_just_empty() {
// returns an empty list
let (items, _) = timeline.subscribe().await;
assert!(items.is_empty());
test_helper.server.reset().await;
}
#[async_test]
@@ -407,17 +387,32 @@ async fn test_pinned_timeline_with_no_pinned_events_on_pagination_is_just_empty(
let sender_id = owned_user_id!("@example:localhost");
// Join the room
let _ = test_helper.setup_initial_sync_response().await;
test_helper.server.reset().await;
let joined_room_builder = JoinedRoomBuilder::new(&room_id)
// Set up encryption
.add_state_event(StateTestEvent::Encryption);
// Sync the joined room
test_helper
.server
.mock_sync()
.ok_and_run(&test_helper.client, move |sync_builder| {
sync_builder.add_joined_room(joined_room_builder);
})
.await;
// Load initial timeline items: an empty `m.room.pinned_events` event
test_helper.setup_sync_response(Vec::new(), Some(Vec::new())).await.expect("Sync failed");
test_helper.sync_once(Vec::new(), Some(Vec::new())).await.expect("Sync failed");
let room = test_helper.client.get_room(&room_id).unwrap();
let pinned_timeline =
Timeline::builder(&room).with_focus(pinned_events_focus(1)).build().await.unwrap();
// Create a non-pinned event
// The timeline couldn't load any events, but it expected none, so it just
// returns an empty list
let (pinned_items, mut pinned_events_stream) = pinned_timeline.subscribe().await;
assert!(pinned_items.is_empty());
// Create a non-pinned event to return in the pagination
let not_pinned_event = EventFactory::new()
.room(&room_id)
.sender(&sender_id)
@@ -425,29 +420,14 @@ async fn test_pinned_timeline_with_no_pinned_events_on_pagination_is_just_empty(
.event_id(event_id)
.into_raw_timeline();
mock_event(
&test_helper.server,
&room_id,
event_id,
TimelineEvent::new(not_pinned_event.clone()),
)
.await;
// The timeline couldn't load any events, but it expected none, so it just
// returns an empty list
let (pinned_items, mut pinned_events_stream) = pinned_timeline.subscribe().await;
assert!(pinned_items.is_empty());
// Mock the /messages endpoint with the not pinned event
Mock::given(method("GET"))
.and(path_regex(r"^/_matrix/client/r0/rooms/.*/messages$"))
.and(header("authorization", "Bearer 1234"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"start": "prev1",
"chunk": vec![not_pinned_event],
})))
.expect(1)
.mount(&test_helper.server)
test_helper
.server
.mock_room_messages()
.ok(assign!(RoomMessagesResponseTemplate::default(), {
chunk: vec![not_pinned_event]
}))
.mock_once()
.mount()
.await;
let (event_cache, _) = room.event_cache().await.expect("Event cache should be accessible");
@@ -475,7 +455,7 @@ async fn test_pinned_timeline_with_no_pinned_events_on_pagination_is_just_empty(
}
#[async_test]
async fn test_pinned_timeline_with_pinned_utd_contains_it() {
async fn test_pinned_timeline_with_pinned_utd_on_sync_contains_it() {
let test_helper = TestHelper::new().await;
let room_id = test_helper.room_id.clone();
let event_id = event_id!("$1:morpheus.localhost");
@@ -503,19 +483,24 @@ async fn test_pinned_timeline_with_pinned_utd_contains_it() {
)));
// Sync the joined room
let json_response =
SyncResponseBuilder::new().add_joined_room(joined_room_builder).build_json_sync_response();
mock_sync(&test_helper.server, json_response, None).await;
test_helper
.client
.sync_once(test_helper.sync_settings.clone())
.await
.expect("Sync should work");
test_helper.server.reset().await;
.server
.mock_sync()
.ok_and_run(&test_helper.client, move |sync_builder| {
sync_builder.add_joined_room(joined_room_builder);
})
.await;
// Mock encrypted pinned event for which we have now keys (an UTD)
// Mock encrypted pinned event for which we don't have keys (an UTD)
let utd_event = create_utd(&room_id, &sender_id, event_id);
mock_event(&test_helper.server, &room_id, event_id, TimelineEvent::new(utd_event)).await;
test_helper
.server
.mock_room_event()
.match_event_id()
.ok(TimelineEvent::new(utd_event))
.mock_once()
.mount()
.await;
let room = test_helper.client.get_room(&room_id).unwrap();
let timeline =
@@ -526,8 +511,6 @@ async fn test_pinned_timeline_with_pinned_utd_contains_it() {
assert_eq!(items.len(), 2);
let pinned_utd_event = items.last().unwrap().as_event().unwrap();
assert_eq!(pinned_utd_event.event_id().unwrap(), event_id);
test_helper.server.reset().await;
}
#[async_test]
@@ -536,8 +519,7 @@ async fn test_edited_events_are_reflected_in_sync() {
let room_id = test_helper.room_id.clone();
// Join the room
let _ = test_helper.setup_initial_sync_response().await;
test_helper.server.reset().await;
test_helper.do_initial_sync().await;
let f = EventFactory::new().room(&room_id).sender(*BOB);
let pinned_event = f
@@ -546,14 +528,16 @@ async fn test_edited_events_are_reflected_in_sync() {
.server_ts(MilliSecondsSinceUnixEpoch::now())
.into_timeline();
// Mock /event for some timeline events
test_helper.mock_events(vec![pinned_event]).await;
// Load initial timeline items: a text message and a `m.room.pinned_events` with
// event $1
let _ = test_helper.setup_sync_response(vec![(pinned_event, false)], Some(vec!["$1"])).await;
test_helper.sync_once(Vec::new(), Some(vec!["$1"])).await.expect("Sync failed");
let room = test_helper.client.get_room(&room_id).unwrap();
let timeline =
Timeline::builder(&room).with_focus(pinned_events_focus(100)).build().await.unwrap();
test_helper.server.reset().await;
assert!(
timeline.live_back_pagination_status().await.is_none(),
@@ -567,7 +551,6 @@ async fn test_edited_events_are_reflected_in_sync() {
assert!(items[0].is_date_divider());
assert_eq!(items[1].as_event().unwrap().content().as_message().unwrap().body(), "in the end");
assert_pending!(timeline_stream);
test_helper.server.reset().await;
let edited_event = f
.text_msg("edited message!")
@@ -579,8 +562,11 @@ async fn test_edited_events_are_reflected_in_sync() {
.server_ts(MilliSecondsSinceUnixEpoch::now())
.into_timeline();
// Mock /event for some timeline events
test_helper.mock_events(vec![edited_event.clone()]).await;
// Load new pinned event contents from sync, where $2 is and edit on $1
let _ = test_helper.setup_sync_response(vec![(edited_event, true)], None).await;
test_helper.sync_once(vec![edited_event], None).await.expect("Sync failed");
// The list is reloaded, so it's reset
assert_next_matches_with_timeout!(timeline_stream, VectorDiff::Clear);
@@ -603,7 +589,6 @@ async fn test_edited_events_are_reflected_in_sync() {
}
});
assert_pending!(timeline_stream);
test_helper.server.reset().await;
}
#[async_test]
@@ -612,8 +597,7 @@ async fn test_redacted_events_are_reflected_in_sync() {
let room_id = test_helper.room_id.clone();
// Join the room
let _ = test_helper.setup_initial_sync_response().await;
test_helper.server.reset().await;
test_helper.do_initial_sync().await;
let f = EventFactory::new().room(&room_id).sender(*BOB);
let pinned_event = f
@@ -622,14 +606,16 @@ async fn test_redacted_events_are_reflected_in_sync() {
.server_ts(MilliSecondsSinceUnixEpoch::now())
.into_timeline();
// Mock /event for some timeline events
test_helper.mock_events(vec![pinned_event]).await;
// Load initial timeline items: a text message and a `m.room.pinned_events` with
// event $1
let _ = test_helper.setup_sync_response(vec![(pinned_event, false)], Some(vec!["$1"])).await;
test_helper.sync_once(Vec::new(), Some(vec!["$1"])).await.expect("Sync failed");
let room = test_helper.client.get_room(&room_id).unwrap();
let timeline =
Timeline::builder(&room).with_focus(pinned_events_focus(100)).build().await.unwrap();
test_helper.server.reset().await;
assert!(
timeline.live_back_pagination_status().await.is_none(),
@@ -643,7 +629,6 @@ async fn test_redacted_events_are_reflected_in_sync() {
assert!(items[0].is_date_divider());
assert_eq!(items[1].as_event().unwrap().content().as_message().unwrap().body(), "in the end");
assert_pending!(timeline_stream);
test_helper.server.reset().await;
let redaction_event = f
.redaction(event_id!("$1"))
@@ -651,8 +636,11 @@ async fn test_redacted_events_are_reflected_in_sync() {
.server_ts(MilliSecondsSinceUnixEpoch::now())
.into_timeline();
// Mock /event for some timeline events
test_helper.mock_events(vec![redaction_event.clone()]).await;
// Load new pinned event contents from sync, where $1 is now redacted
let _ = test_helper.setup_sync_response(vec![(redaction_event, true)], None).await;
let _ = test_helper.sync_once(vec![redaction_event], None).await;
// The list is reloaded, so it's reset
assert_next_matches_with_timeout!(timeline_stream, VectorDiff::Clear);
@@ -670,7 +658,6 @@ async fn test_redacted_events_are_reflected_in_sync() {
assert_matches!(value.as_event().unwrap().content(), TimelineItemContent::RedactedMessage);
});
assert_pending!(timeline_stream);
test_helper.server.reset().await;
}
#[async_test]
@@ -679,8 +666,7 @@ async fn test_edited_events_survive_pinned_event_ids_change() {
let room_id = test_helper.room_id.clone();
// Join the room
let _ = test_helper.setup_initial_sync_response().await;
test_helper.server.reset().await;
test_helper.do_initial_sync().await;
let f = EventFactory::new().room(&room_id).sender(*BOB);
let pinned_event = f
@@ -689,14 +675,15 @@ async fn test_edited_events_survive_pinned_event_ids_change() {
.server_ts(MilliSecondsSinceUnixEpoch::now())
.into_timeline();
// Load initial timeline items: a text message and a `m.room.pinned_events` with
// event $1
let _ = test_helper.setup_sync_response(vec![(pinned_event, false)], Some(vec!["$1"])).await;
// Mock /event for some timeline events
test_helper.mock_events(vec![pinned_event]).await;
// Load initial timeline items: a `m.room.pinned_events` with event $1 pinned
test_helper.sync_once(Vec::new(), Some(vec!["$1"])).await.expect("Sync failed");
let room = test_helper.client.get_room(&room_id).unwrap();
let timeline =
Timeline::builder(&room).with_focus(pinned_events_focus(100)).build().await.unwrap();
test_helper.server.reset().await;
assert!(
timeline.live_back_pagination_status().await.is_none(),
@@ -710,7 +697,6 @@ async fn test_edited_events_survive_pinned_event_ids_change() {
assert!(items[0].is_date_divider());
assert_eq!(items[1].as_event().unwrap().content().as_message().unwrap().body(), "in the end");
assert_pending!(timeline_stream);
test_helper.server.reset().await;
let edited_pinned_event = f
.text_msg("* edited message!")
@@ -722,10 +708,12 @@ async fn test_edited_events_survive_pinned_event_ids_change() {
.server_ts(MilliSecondsSinceUnixEpoch::now())
.into_timeline();
// Mock /event for some timeline events
test_helper.mock_events(vec![edited_pinned_event.clone()]).await;
// Load new pinned event contents from sync, $2 was pinned but wasn't available
// before
let _ = test_helper.setup_sync_response(vec![(edited_pinned_event, true)], None).await;
test_helper.server.reset().await;
test_helper.sync_once(vec![edited_pinned_event], None).await.expect("Sync failed");
// The list is reloaded, so it's reset
assert_next_matches_with_timeout!(timeline_stream, VectorDiff::Clear);
@@ -755,11 +743,14 @@ async fn test_edited_events_survive_pinned_event_ids_change() {
.server_ts(MilliSecondsSinceUnixEpoch::now())
.into_timeline();
// Mock /event for some timeline events
test_helper.mock_events(vec![new_pinned_event.clone()]).await;
// Load new pinned event contents from sync: $3
let _ = test_helper
.setup_sync_response(vec![(new_pinned_event, true)], Some(vec!["$1", "$3"]))
.await;
test_helper.server.reset().await;
test_helper
.sync_once(vec![new_pinned_event], Some(vec!["$1", "$3"]))
.await
.expect("Sync failed");
// New item gets added
assert_next_matches_with_timeout!(timeline_stream, VectorDiff::PushBack { value } => {
@@ -869,58 +860,51 @@ async fn test_ensure_max_concurrency_is_observed() {
struct TestHelper {
pub client: Client,
pub server: MockServer,
pub server: MatrixMockServer,
pub room_id: OwnedRoomId,
pub sync_settings: SyncSettings,
pub sync_response_builder: SyncResponseBuilder,
}
impl TestHelper {
async fn new() -> Self {
let (client, server) = logged_in_client_with_server().await;
Self {
client,
server,
room_id: owned_room_id!("!a98sd12bjh:example.org"),
sync_settings: SyncSettings::new().timeout(Duration::from_millis(3000)),
sync_response_builder: SyncResponseBuilder::new(),
}
let server = MatrixMockServer::new().await;
let client = server.client_builder().build().await;
Self { client, server, room_id: owned_room_id!("!a98sd12bjh:example.org") }
}
async fn setup_initial_sync_response(&mut self) -> Result<SyncResponse, matrix_sdk::Error> {
async fn do_initial_sync(&mut self) {
let joined_room_builder = JoinedRoomBuilder::new(&self.room_id)
// Set up encryption
.add_state_event(StateTestEvent::Encryption);
// Mark the room as joined.
let json_response = self
.sync_response_builder
.add_joined_room(joined_room_builder)
.build_json_sync_response();
mock_sync(&self.server, json_response, None).await;
self.client.sync_once(self.sync_settings.clone()).await
self.server
.mock_sync()
.ok_and_run(&self.client, move |sync_builder| {
// Mark the room as joined.
sync_builder.add_joined_room(joined_room_builder);
})
.await;
}
async fn setup_sync_response(
&mut self,
text_messages: Vec<(TimelineEvent, bool)>,
pinned_event_ids: Option<Vec<&str>>,
) -> Result<SyncResponse, matrix_sdk::Error> {
let mut joined_room_builder = JoinedRoomBuilder::new(&self.room_id);
for (timeline_event, add_to_timeline) in text_messages {
let deserialized_event = timeline_event.raw().deserialize()?;
mock_event(
&self.server,
&self.room_id,
deserialized_event.event_id(),
timeline_event.clone(),
)
.await;
async fn mock_events(&mut self, events: Vec<TimelineEvent>) {
for event in events {
self.server
.mock_room_event()
.room(self.room_id.to_owned())
.match_event_id()
.ok(event)
.mount()
.await;
}
}
if add_to_timeline {
joined_room_builder =
joined_room_builder.add_timeline_event(timeline_event.into_raw());
}
async fn sync_once(
&mut self,
timeline_events: Vec<TimelineEvent>,
pinned_event_ids: Option<Vec<&str>>,
) -> Result<(), matrix_sdk::Error> {
let mut joined_room_builder = JoinedRoomBuilder::new(&self.room_id);
for timeline_event in timeline_events {
joined_room_builder = joined_room_builder.add_timeline_event(timeline_event.into_raw());
}
if let Some(pinned_event_ids) = pinned_event_ids {
@@ -944,13 +928,14 @@ impl TestHelper {
)))
}
// Mark the room as joined.
let json_response = self
.sync_response_builder
.add_joined_room(joined_room_builder)
.build_json_sync_response();
mock_sync(&self.server, json_response, None).await;
self.client.sync_once(self.sync_settings.clone()).await
self.server
.mock_sync()
.ok_and_run(&self.client, move |sync_builder| {
sync_builder.add_joined_room(joined_room_builder);
})
.await;
Ok(())
}
}