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

test: add a new method for the state pinned events in the event factory

Browse Source
This commit is contained in:
Benjamin Bouvier
2026-02-10 16:57:37 +01:00
parent 1e0c930a12
commit 7fbb2ddae1
8 changed files with 38 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files
benchmarks/benches/room_bench.rs
+2 -16
View File
@@ -18,7 +18,6 @@ use ruma::{
serde::Raw,
user_id,
};
use serde_json::json;
use tokio::runtime::Builder;
use wiremock::{Request, ResponseTemplate};
@@ -114,21 +113,8 @@ pub fn load_pinned_events_benchmark(c: &mut Criterion) {
let pinned_event_ids: Vec<OwnedEventId> = (0..PINNED_EVENTS_COUNT)
.map(|i| EventId::parse(format!("${i}")).expect("Invalid event id"))
.collect();
joined_room_builder = joined_room_builder.add_state_event(StateTestEvent::Custom(json!(
{
"content": {
"pinned": pinned_event_ids
},
"event_id": "$15139375513VdeRF:localhost",
"origin_server_ts": 151393755,
"sender": "@example:localhost",
"state_key": "",
"type": "m.room.pinned_events",
"unsigned": {
"age": 703422
}
}
)));
joined_room_builder =
joined_room_builder.add_state_bulk(vec![f.room_pinned_events(pinned_event_ids).into()]);
let (server, client, room) = runtime.block_on(async move {
let server = MatrixMockServer::new().await;
crates/matrix-sdk-base/src/room/room_info.rs
+6 -6
View File
@@ -1350,13 +1350,10 @@ mod tests {
use std::sync::Arc;
use assert_matches::assert_matches;
use matrix_sdk_test::{
async_test,
test_json::{TAG, sync_events::PINNED_EVENTS},
};
use matrix_sdk_test::{async_test, event_factory::EventFactory, test_json::TAG};
use ruma::{
assign, events::room::pinned_events::RoomPinnedEventsEventContent, owned_event_id,
owned_mxc_uri, owned_user_id, room_id, serde::Raw,
owned_mxc_uri, owned_user_id, room_id, serde::Raw, user_id,
};
use serde_json::json;
use similar_asserts::assert_eq;
@@ -1544,7 +1541,10 @@ mod tests {
let tag_event = raw_tag_event.deserialize().unwrap();
changes.add_room_account_data(&room_info.room_id, tag_event, raw_tag_event);
let raw_pinned_events_event = Raw::new(&*PINNED_EVENTS).unwrap().cast_unchecked();
let f = EventFactory::new().room(&room_info.room_id).sender(user_id!("@example:localhost"));
let raw_pinned_events_event: Raw<_> = f
.room_pinned_events(vec![owned_event_id!("$a"), owned_event_id!("$b")])
.into_raw_sync_state();
let pinned_events_event = raw_pinned_events_event.deserialize().unwrap();
changes.add_state_event(&room_info.room_id, pinned_events_event, raw_pinned_events_event);
crates/matrix-sdk-ui/tests/integration/timeline/pinned_event.rs
+5 -20
View File
@@ -29,14 +29,12 @@ use ruma::{
EncryptedEventScheme, MegolmV1AesSha2ContentInit, RoomEncryptedEventContent,
},
message::RoomMessageEventContentWithoutRelation,
pinned_events::RoomPinnedEventsEventContent,
},
},
owned_device_id, owned_room_id, owned_user_id, room_id,
serde::Raw,
user_id,
};
use serde_json::json;
use stream_assert::assert_pending;
use tokio::time::sleep;
use wiremock::{
@@ -866,7 +864,8 @@ async fn test_ensure_max_concurrency_is_observed() {
let (client, server) = logged_in_client_with_server().await;
let room_id = owned_room_id!("!a_room:example.org");
let pinned_event_ids: Vec<String> = (0..100).map(|idx| format!("${idx}")).collect();
let pinned_event_ids: Vec<OwnedEventId> =
(0..100).map(|idx| EventId::parse(format!("${idx}")).unwrap()).collect();
let max_concurrent_requests = 10;
@@ -874,25 +873,12 @@ async fn test_ensure_max_concurrency_is_observed() {
client.event_cache().config_mut().await.max_pinned_events_concurrent_requests =
max_concurrent_requests;
let f = EventFactory::new().room(&room_id).sender(user_id!("@example:localhost"));
let joined_room_builder = JoinedRoomBuilder::new(&room_id)
// Set up encryption
.add_state_event(StateTestEvent::Encryption)
// Add 100 pinned events
.add_state_event(StateTestEvent::Custom(json!(
{
"content": {
"pinned": pinned_event_ids
},
"event_id": "$15139375513VdeRF:localhost",
"origin_server_ts": 151393755,
"sender": "@example:localhost",
"state_key": "",
"type": "m.room.pinned_events",
"unsigned": {
"age": 703422
}
}
)));
.add_state_bulk(vec![f.room_pinned_events(pinned_event_ids).into()]);
let pinned_event =
EventFactory::new().room(&room_id).sender(*BOB).text_msg("A message").into_raw_timeline();
@@ -1000,9 +986,8 @@ impl PinnedEventsSync {
if let Some(pinned_event_ids) = self.pinned_event_ids {
let pinned_events_event = EventFactory::new()
.room(&self.room_id)
.event(RoomPinnedEventsEventContent::new(pinned_event_ids))
.sender(user_id!("@example:localhost"))
.state_key("")
.room_pinned_events(pinned_event_ids)
.into();
joined_room_builder = joined_room_builder.add_state_bulk(vec![pinned_events_event]);
crates/matrix-sdk/tests/integration/client.rs
+4 -2
View File
@@ -27,7 +27,6 @@ use matrix_sdk_test::{
MIXED_INVITED_ROOM_ID, MIXED_JOINED_ROOM_ID, MIXED_KNOCKED_ROOM_ID, MIXED_LEFT_ROOM_ID,
MIXED_SYNC,
},
sync_events::PINNED_EVENTS,
},
};
use ruma::{
@@ -1371,7 +1370,10 @@ async fn test_restore_room() {
let tag_event = raw_tag_event.deserialize().unwrap();
changes.add_room_account_data(room_id, tag_event, raw_tag_event);
let raw_pinned_events_event = Raw::new(&*PINNED_EVENTS).unwrap().cast_unchecked();
let f = EventFactory::new().room(room_id).sender(user_id!("@example:localhost"));
let raw_pinned_events_event: Raw<_> = f
.room_pinned_events(vec![owned_event_id!("$a"), owned_event_id!("$b")])
.into_raw_sync_state();
let pinned_events_event = raw_pinned_events_event.deserialize().unwrap();
changes.add_state_event(room_id, pinned_events_event, raw_pinned_events_event);
crates/matrix-sdk/tests/integration/room/pinned_events.rs
+12 -26
View File
@@ -9,7 +9,7 @@ use matrix_sdk::{
timeout::timeout,
};
use matrix_sdk_base::event_cache::store::MemoryStore;
use matrix_sdk_test::{JoinedRoomBuilder, StateTestEvent, async_test, event_factory::EventFactory};
use matrix_sdk_test::{JoinedRoomBuilder, async_test, event_factory::EventFactory};
use ruma::{EventId, event_id, owned_event_id, room_id, user_id};
use serde_json::json;
use tokio::time::Duration;
@@ -50,14 +50,15 @@ impl PinningTestSetup<'_> {
}
async fn mock_sync(&mut self, include_pinned_state_event: bool) {
let f = EventFactory::new().sender(user_id!("@a:b.c"));
let f = EventFactory::new().room(self.room_id).sender(user_id!("@a:b.c"));
let mut joined_room_builder = JoinedRoomBuilder::new(self.room_id)
.add_timeline_event(f.text_msg("A").event_id(self.event_id).into_raw_sync());
if include_pinned_state_event {
joined_room_builder =
joined_room_builder.add_state_event(StateTestEvent::RoomPinnedEvents);
let pinned_events =
f.room_pinned_events(vec![owned_event_id!("$a"), owned_event_id!("$b")]);
joined_room_builder = joined_room_builder.add_state_bulk(vec![pinned_events.into()]);
}
self.server.sync_room(&self.client, joined_room_builder).await;
@@ -177,21 +178,12 @@ async fn test_pinned_events_are_reloaded_from_storage() {
// This is important: the pinned events list must include our event ID,
// otherwise the initial reload from network will clear the storage-loaded
// events.
let pinned_events_state = StateTestEvent::Custom(json!({
"content": {
"pinned": [pinned_event_id]
},
"event_id": "$pinned_events_state",
"origin_server_ts": 151393755,
"sender": "@example:localhost",
"state_key": "",
"type": "m.room.pinned_events",
}));
let pinned_events_state = f.room_pinned_events(vec![pinned_event_id.to_owned()]);
let room = server
.sync_room(
&client,
JoinedRoomBuilder::new(room_id).add_state_event(pinned_events_state),
JoinedRoomBuilder::new(room_id).add_state_bulk(vec![pinned_events_state.into()]),
)
.await;
@@ -314,19 +306,13 @@ async fn test_pinned_events_dont_include_thread_responses() {
// This is important: the pinned events list must include our event ID,
// otherwise the initial reload from network will clear the storage-loaded
// events.
let pinned_events_state = StateTestEvent::Custom(json!({
"content": {
"pinned": [pinned_event_id]
},
"event_id": "$pinned_events_state",
"origin_server_ts": 151393755,
"sender": "@example:localhost",
"state_key": "",
"type": "m.room.pinned_events",
}));
let pinned_events_state = f.room_pinned_events(vec![pinned_event_id.to_owned()]);
let room = server
.sync_room(&client, JoinedRoomBuilder::new(room_id).add_state_event(pinned_events_state))
.sync_room(
&client,
JoinedRoomBuilder::new(room_id).add_state_bulk(vec![pinned_events_state.into()]),
)
.await;
// Get the room event cache and subscribe to pinned events.
testing/matrix-sdk-test/src/event_factory.rs
+9
View File
@@ -71,6 +71,7 @@ use ruma::{
RoomMessageEventContentWithoutRelation,
},
name::RoomNameEventContent,
pinned_events::RoomPinnedEventsEventContent,
power_levels::RoomPowerLevelsEventContent,
redaction::RoomRedactionEventContent,
server_acl::RoomServerAclEventContent,
@@ -975,6 +976,14 @@ impl EventFactory {
event
}
/// Create a state event for the room's pinned events.
pub fn room_pinned_events(
&self,
pinned: Vec<OwnedEventId>,
) -> EventBuilder<RoomPinnedEventsEventContent> {
self.event(RoomPinnedEventsEventContent::new(pinned)).state_key("")
}
/// Create a new `m.member_hints` event with the given service members.
///
/// ```
testing/matrix-sdk-test/src/sync_builder/test_event.rs
-2
View File
@@ -28,7 +28,6 @@ pub enum StateTestEvent {
RedactedState,
RoomAvatar,
RoomName,
RoomPinnedEvents,
RoomTopic,
Custom(JsonValue),
}
@@ -62,7 +61,6 @@ impl From<StateTestEvent> for JsonValue {
StateTestEvent::RedactedState => test_json::sync_events::REDACTED_STATE.to_owned(),
StateTestEvent::RoomAvatar => test_json::sync_events::ROOM_AVATAR.to_owned(),
StateTestEvent::RoomName => test_json::sync_events::NAME.to_owned(),
StateTestEvent::RoomPinnedEvents => test_json::sync_events::PINNED_EVENTS.to_owned(),
StateTestEvent::RoomTopic => test_json::sync_events::TOPIC.to_owned(),
StateTestEvent::Custom(json) => json,
}
testing/matrix-sdk-test/src/test_json/sync_events.rs
-16
View File
@@ -323,22 +323,6 @@ pub static NAME_STRIPPED: Lazy<JsonValue> = Lazy::new(|| {
})
});
pub static PINNED_EVENTS: Lazy<JsonValue> = Lazy::new(|| {
json!({
"content": {
"pinned": [ "$a", "$b" ]
},
"event_id": "$15139375513VdeRF:localhost",
"origin_server_ts": 151393755,
"sender": "@example:localhost",
"state_key": "",
"type": "m.room.pinned_events",
"unsigned": {
"age": 703422
}
})
});
pub static POWER_LEVELS: Lazy<JsonValue> = Lazy::new(|| {
json!({
"content": {