chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use RoomEventType instead of EventType for PDUs and power levels

Browse Source
This commit is contained in:
Jonas Platte 2022-03-15 16:35:08 +01:00
parent 6f6e7ca68e
commit ce785064a9
No known key found for this signature in database
GPG Key ID: BBA95679259D342F
8 changed files with 174 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
crates/ruma-common/src/events/pdu.rs
View File

@ -14,7 +14,7 @@ use serde::{
};
use serde_json::{from_str as from_json_str, value::RawValue as RawJsonValue};
use super::EventType;
use super::RoomEventType;
use crate::{EventId, MilliSecondsSinceUnixEpoch, RoomId, ServerName, ServerSigningKeyId, UserId};
/// Enum for PDU schemas
@ -53,7 +53,7 @@ pub struct RoomV1Pdu {
// TODO: Encode event type as content enum variant, like event enums do
/// The event's type.
#[serde(rename = "type")]
pub kind: EventType,
pub kind: RoomEventType,
/// The event's content.
pub content: Box<RawJsonValue>,
@ -112,7 +112,7 @@ pub struct RoomV3Pdu {
// TODO: Encode event type as content enum variant, like event enums do
/// The event's type.
#[serde(rename = "type")]
pub kind: EventType,
pub kind: RoomEventType,
/// The event's content.
pub content: Box<RawJsonValue>,

10
crates/ruma-common/src/events/room/power_levels.rs
View File

@ -9,7 +9,7 @@ use ruma_macros::EventContent;
use serde::{Deserialize, Serialize};
use crate::{
events::EventType,
events::RoomEventType,
power_levels::{default_power_level, NotificationPowerLevels},
UserId,
};
@ -45,7 +45,7 @@ pub struct RoomPowerLevelsEventContent {
)]
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
#[ruma_event(skip_redaction)]
pub events: BTreeMap<EventType, Int>,
pub events: BTreeMap<RoomEventType, Int>,
/// The default level required to send message events.
///
@ -182,7 +182,7 @@ mod tests {
use serde_json::{json, to_value as to_json_value};
use super::{default_power_level, NotificationPowerLevels, RoomPowerLevelsEventContent};
use crate::events::{EventType, StateEvent, Unsigned};
use crate::events::{StateEvent, Unsigned};
#[test]
fn serialization_with_optional_fields_as_none() {
@ -231,7 +231,7 @@ mod tests {
content: RoomPowerLevelsEventContent {
ban: int!(23),
events: btreemap! {
EventType::Dummy => int!(23)
"m.dummy".into() => int!(23)
},
events_default: int!(23),
invite: int!(23),
@ -250,7 +250,7 @@ mod tests {
// Make just one field different so we at least know they're two different objects.
ban: int!(42),
events: btreemap! {
EventType::Dummy => int!(42)
"m.dummy".into() => int!(42)
},
events_default: int!(42),
invite: int!(42),

6
crates/ruma-common/tests/events/pdu.rs
View File

@ -6,7 +6,7 @@ use ruma_common::{
event_id,
events::{
pdu::{EventHash, Pdu, RoomV1Pdu, RoomV3Pdu},
EventType,
RoomEventType,
},
room_id, server_name, server_signing_key_id, user_id, MilliSecondsSinceUnixEpoch,
};
@ -34,7 +34,7 @@ fn serialize_pdu_as_v1() {
sender: user_id!("@sender:example.com").to_owned(),
origin: "matrix.org".into(),
origin_server_ts: MilliSecondsSinceUnixEpoch(1_592_050_773_658_u64.try_into().unwrap()),
kind: EventType::RoomPowerLevels,
kind: RoomEventType::RoomPowerLevels,
content: to_raw_json_value(&json!({ "testing": 123 })).unwrap(),
state_key: Some("state".into()),
prev_events: vec![(
@ -100,7 +100,7 @@ fn serialize_pdu_as_v3() {
sender: user_id!("@sender:example.com").to_owned(),
origin: "matrix.org".into(),
origin_server_ts: MilliSecondsSinceUnixEpoch(1_592_050_773_658_u64.try_into().unwrap()),
kind: EventType::RoomPowerLevels,
kind: RoomEventType::RoomPowerLevels,
content: to_raw_json_value(&json!({ "testing": 123 })).unwrap(),
state_key: Some("state".into()),
prev_events: vec![event_id!("$previousevent:matrix.org").to_owned()],

42
crates/ruma-state-res/benches/state_res_bench.rs
View File

@ -28,7 +28,7 @@ use ruma_common::{
join_rules::{JoinRule, RoomJoinRulesEventContent},
member::{MembershipState, RoomMemberEventContent},
},
EventType,
RoomEventType,
},
room_id, user_id, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, UserId,
};
@ -240,7 +240,7 @@ impl TestStore<StateEvent> {
let create_event = to_pdu_event::<&EventId>(
"CREATE",
alice(),
EventType::RoomCreate,
RoomEventType::RoomCreate,
Some(""),
to_raw_json_value(&json!({ "creator": alice() })).unwrap(),
&[],
@ -252,7 +252,7 @@ impl TestStore<StateEvent> {
let alice_mem = to_pdu_event(
"IMA",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().to_string().as_str()),
member_content_join(),
&[cre.clone()],
@ -263,7 +263,7 @@ impl TestStore<StateEvent> {
let join_rules = to_pdu_event(
"IJR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Public)).unwrap(),
&[cre.clone(), alice_mem.event_id().to_owned()],
@ -276,7 +276,7 @@ impl TestStore<StateEvent> {
let bob_mem = to_pdu_event(
"IMB",
bob(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(bob().to_string().as_str()),
member_content_join(),
&[cre.clone(), join_rules.event_id().to_owned()],
@ -287,7 +287,7 @@ impl TestStore<StateEvent> {
let charlie_mem = to_pdu_event(
"IMC",
charlie(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(charlie().to_string().as_str()),
member_content_join(),
&[cre, join_rules.event_id().to_owned()],
@ -367,7 +367,7 @@ fn member_content_join() -> Box<RawJsonValue> {
fn to_pdu_event<S>(
id: &str,
sender: Box<UserId>,
ev_type: EventType,
ev_type: RoomEventType,
state_key: Option<&str>,
content: Box<RawJsonValue>,
auth_events: &[S],
@ -413,7 +413,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>(
"CREATE",
alice(),
EventType::RoomCreate,
RoomEventType::RoomCreate,
Some(""),
to_raw_json_value(&json!({ "creator": alice() })).unwrap(),
&[],
@ -422,7 +422,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IMA",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().to_string().as_str()),
member_content_join(),
&["CREATE"],
@ -431,7 +431,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IPOWER",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice().to_string(): 100 } })).unwrap(),
&["CREATE", "IMA"],
@ -440,7 +440,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IJR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Public)).unwrap(),
&["CREATE", "IMA", "IPOWER"],
@ -449,7 +449,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IMB",
bob(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(bob().to_string().as_str()),
member_content_join(),
&["CREATE", "IJR", "IPOWER"],
@ -458,7 +458,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IMC",
charlie(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(charlie().to_string().as_str()),
member_content_join(),
&["CREATE", "IJR", "IPOWER"],
@ -467,7 +467,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>(
"START",
charlie(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
&[],
@ -476,7 +476,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>(
"END",
charlie(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
&[],
@ -495,7 +495,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"PA",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
&["CREATE", "IMA", "IPOWER"], // auth_events
@ -504,7 +504,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"PB",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
&["CREATE", "IMA", "IPOWER"],
@ -513,7 +513,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"MB",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().as_str()),
member_content_ban(),
&["CREATE", "IMA", "PB"],
@ -522,7 +522,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IME",
ella(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().as_str()),
member_content_join(),
&["CREATE", "IJR", "PA"],
@ -536,7 +536,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
mod event {
use ruma_common::{
events::{pdu::Pdu, EventType},
events::{pdu::Pdu, RoomEventType},
EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId,
};
use ruma_state_res::Event;
@ -568,7 +568,7 @@ mod event {
}
}
fn event_type(&self) -> &EventType {
fn event_type(&self) -> &RoomEventType {
match &self.rest {
Pdu::RoomV1Pdu(ev) => &ev.kind,
Pdu::RoomV3Pdu(ev) => &ev.kind,

141
crates/ruma-state-res/src/event_auth.rs
View File

@ -10,7 +10,7 @@ use ruma_common::{
power_levels::RoomPowerLevelsEventContent,
third_party_invite::RoomThirdPartyInviteEventContent,
},
EventType,
RoomEventType,
},
serde::{Base64, Raw},
RoomVersionId, UserId,
@ -45,22 +45,22 @@ struct PowerLevelsContentInvite {
///
/// This function will return an error if the supplied `content` is not a JSON object.
pub fn auth_types_for_event(
kind: &EventType,
kind: &RoomEventType,
sender: &UserId,
state_key: Option<&str>,
content: &RawJsonValue,
) -> serde_json::Result<Vec<(EventType, String)>> {
if kind == &EventType::RoomCreate {
) -> serde_json::Result<Vec<(RoomEventType, String)>> {
if kind == &RoomEventType::RoomCreate {
return Ok(vec![]);
}
let mut auth_types = vec![
(EventType::RoomPowerLevels, "".to_owned()),
(EventType::RoomMember, sender.to_string()),
(EventType::RoomCreate, "".to_owned()),
(RoomEventType::RoomPowerLevels, "".to_owned()),
(RoomEventType::RoomMember, sender.to_string()),
(RoomEventType::RoomCreate, "".to_owned()),
];
if kind == &EventType::RoomMember {
if kind == &RoomEventType::RoomMember {
#[derive(Deserialize)]
struct RoomMemberContentFields {
membership: Option<Raw<MembershipState>>,
@ -75,7 +75,7 @@ pub fn auth_types_for_event(
if [MembershipState::Join, MembershipState::Invite, MembershipState::Knock]
.contains(&membership)
{
let key = (EventType::RoomJoinRules, "".to_owned());
let key = (RoomEventType::RoomJoinRules, "".to_owned());
if !auth_types.contains(&key) {
auth_types.push(key);
}
@ -83,21 +83,21 @@ pub fn auth_types_for_event(
if let Some(Ok(u)) =
content.join_authorised_via_users_server.map(|m| m.deserialize())
{
let key = (EventType::RoomMember, u.to_string());
let key = (RoomEventType::RoomMember, u.to_string());
if !auth_types.contains(&key) {
auth_types.push(key);
}
}
}
let key = (EventType::RoomMember, state_key.to_owned());
let key = (RoomEventType::RoomMember, state_key.to_owned());
if !auth_types.contains(&key) {
auth_types.push(key);
}
if membership == MembershipState::Invite {
if let Some(Ok(t_id)) = content.third_party_invite.map(|t| t.deserialize()) {
let key = (EventType::RoomThirdPartyInvite, t_id.signed.token);
let key = (RoomEventType::RoomThirdPartyInvite, t_id.signed.token);
if !auth_types.contains(&key) {
auth_types.push(key);
}
@ -123,7 +123,7 @@ pub fn auth_check<E: Event>(
room_version: &RoomVersion,
incoming_event: impl Event,
current_third_party_invite: Option<impl Event>,
fetch_state: impl Fn(&EventType, &str) -> Option<E>,
fetch_state: impl Fn(&RoomEventType, &str) -> Option<E>,
) -> Result<bool> {
info!(
"auth_check beginning for {} ({})",
@ -144,7 +144,7 @@ pub fn auth_check<E: Event>(
// Implementation of https://spec.matrix.org/v1.2/rooms/v1/#authorization-rules
//
// 1. If type is m.room.create:
if *incoming_event.event_type() == EventType::RoomCreate {
if *incoming_event.event_type() == RoomEventType::RoomCreate {
#[derive(Deserialize)]
struct RoomCreateContentFields {
room_version: Option<Raw<RoomVersionId>>,
@ -208,7 +208,7 @@ pub fn auth_check<E: Event>(
}
*/
let room_create_event = match fetch_state(&EventType::RoomCreate, "") {
let room_create_event = match fetch_state(&RoomEventType::RoomCreate, "") {
None => {
warn!("no m.room.create event in auth chain");
return Ok(false);
@ -228,7 +228,7 @@ pub fn auth_check<E: Event>(
// Only in some room versions 6 and below
if room_version.special_case_aliases_auth {
// 4. If type is m.room.aliases
if *incoming_event.event_type() == EventType::RoomAliases {
if *incoming_event.event_type() == RoomEventType::RoomAliases {
info!("starting m.room.aliases check");
// If sender's domain doesn't matches state_key, reject
@ -243,10 +243,10 @@ pub fn auth_check<E: Event>(
}
// If type is m.room.member
let power_levels_event = fetch_state(&EventType::RoomPowerLevels, "");
let sender_member_event = fetch_state(&EventType::RoomMember, sender.as_str());
let power_levels_event = fetch_state(&RoomEventType::RoomPowerLevels, "");
let sender_member_event = fetch_state(&RoomEventType::RoomMember, sender.as_str());
if *incoming_event.event_type() == EventType::RoomMember {
if *incoming_event.event_type() == RoomEventType::RoomMember {
info!("starting m.room.member check");
let state_key = match incoming_event.state_key() {
None => {
@ -270,7 +270,7 @@ pub fn auth_check<E: Event>(
let user_for_join_auth_membership = user_for_join_auth
.as_ref()
.and_then(|auth_user| fetch_state(&EventType::RoomMember, auth_user.as_str()))
.and_then(|auth_user| fetch_state(&RoomEventType::RoomMember, auth_user.as_str()))
.and_then(|mem| from_json_str::<GetMembership>(mem.content().get()).ok())
.map(|mem| mem.membership)
.unwrap_or(MembershipState::Leave);
@ -278,13 +278,13 @@ pub fn auth_check<E: Event>(
if !valid_membership_change(
room_version,
target_user,
fetch_state(&EventType::RoomMember, target_user.as_str()).as_ref(),
fetch_state(&RoomEventType::RoomMember, target_user.as_str()).as_ref(),
sender,
sender_member_event.as_ref(),
&incoming_event,
current_third_party_invite,
power_levels_event.as_ref(),
fetch_state(&EventType::RoomJoinRules, "").as_ref(),
fetch_state(&RoomEventType::RoomJoinRules, "").as_ref(),
user_for_join_auth.as_deref(),
&user_for_join_auth_membership,
room_create_event,
@ -338,7 +338,7 @@ pub fn auth_check<E: Event>(
// Allow if and only if sender's current power level is greater than
// or equal to the invite level
if *incoming_event.event_type() == EventType::RoomThirdPartyInvite {
if *incoming_event.event_type() == RoomEventType::RoomThirdPartyInvite {
let invite_level = match &power_levels_event {
Some(power_levels) => {
from_json_str::<PowerLevelsContentInvite>(power_levels.content().get())?.invite
@ -360,7 +360,7 @@ pub fn auth_check<E: Event>(
}
// If type is m.room.power_levels
if *incoming_event.event_type() == EventType::RoomPowerLevels {
if *incoming_event.event_type() == RoomEventType::RoomPowerLevels {
info!("starting m.room.power_levels check");
if let Some(required_pwr_lvl) = check_power_levels(
@ -388,7 +388,7 @@ pub fn auth_check<E: Event>(
// power levels.
if room_version.extra_redaction_checks
&& *incoming_event.event_type() == EventType::RoomRedaction
&& *incoming_event.event_type() == RoomEventType::RoomRedaction
{
#[derive(Deserialize)]
struct PowerLevelsContentRedact {
@ -762,7 +762,6 @@ fn check_power_levels(
let old_list = &current_content.events;
let new_list = &user_content.events;
for ev_id in old_list.keys().chain(new_list.keys()) {
let ev_id: &EventType = ev_id;
event_levels_to_check.insert(ev_id);
}
@ -889,7 +888,7 @@ fn check_redaction(
/// Helper function to fetch the power level needed to send an event of type
/// `e_type` based on the rooms "m.room.power_level" event.
fn get_send_level(
e_type: &EventType,
e_type: &RoomEventType,
state_key: Option<&str>,
power_lvl: Option<impl Event>,
) -> Int {
@ -975,7 +974,7 @@ mod tests {
},
member::{MembershipState, RoomMemberEventContent},
},
EventType,
RoomEventType,
};
use serde_json::value::to_raw_value as to_raw_json_value;
@ -1004,7 +1003,7 @@ mod tests {
let requester = to_pdu_event(
"HELLO",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(charlie().as_str()),
member_content_ban(),
&[],
@ -1018,16 +1017,16 @@ mod tests {
assert!(valid_membership_change(
&RoomVersion::V6,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
&MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
}
@ -1048,7 +1047,7 @@ mod tests {
let requester = to_pdu_event(
"HELLO",
charlie(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(charlie().as_str()),
member_content_join(),
&["CREATE"],
@ -1062,16 +1061,16 @@ mod tests {
assert!(!valid_membership_change(
&RoomVersion::V6,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
&MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
}
@ -1092,7 +1091,7 @@ mod tests {
let requester = to_pdu_event(
"HELLO",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().as_str()),
member_content_join(),
&["CREATE"],
@ -1106,16 +1105,16 @@ mod tests {
assert!(valid_membership_change(
&RoomVersion::V6,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
&MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
}
@ -1136,7 +1135,7 @@ mod tests {
let requester = to_pdu_event(
"HELLO",
charlie(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().as_str()),
member_content_ban(),
&[],
@ -1150,16 +1149,16 @@ mod tests {
assert!(!valid_membership_change(
&RoomVersion::V6,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
&MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
}
@ -1172,7 +1171,7 @@ mod tests {
*events.get_mut(&event_id("IJR")).unwrap() = to_pdu_event(
"IJR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Restricted(
Restricted::new(vec![AllowRule::RoomMembership(RoomMembership::new(
@ -1197,7 +1196,7 @@ mod tests {
let requester = to_pdu_event(
"HELLO",
ella(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().as_str()),
to_raw_json_value(&RoomMemberEventContent::new(MembershipState::Join)).unwrap(),
&["CREATE", "IJR", "IPOWER", "new"],
@ -1211,32 +1210,32 @@ mod tests {
assert!(valid_membership_change(
&RoomVersion::V9,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
Some(&alice()),
&MembershipState::Join,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
assert!(!valid_membership_change(
&RoomVersion::V9,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
Some(&ella()),
&MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
}
@ -1249,7 +1248,7 @@ mod tests {
*events.get_mut(&event_id("IJR")).unwrap() = to_pdu_event(
"IJR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Knock)).unwrap(),
&["CREATE", "IMA", "IPOWER"],
@ -1266,7 +1265,7 @@ mod tests {
let requester = to_pdu_event(
"HELLO",
ella(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().as_str()),
to_raw_json_value(&RoomMemberEventContent::new(MembershipState::Knock)).unwrap(),
&[],
@ -1280,16 +1279,16 @@ mod tests {
assert!(valid_membership_change(
&RoomVersion::V7,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
&MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
}

95
crates/ruma-state-res/src/lib.rs
View File

@ -10,7 +10,7 @@ use js_int::{int, Int};
use ruma_common::{
events::{
room::member::{MembershipState, RoomMemberEventContent},
EventType,
RoomEventType,
},
EventId, MilliSecondsSinceUnixEpoch, RoomVersionId, UserId,
};
@ -31,7 +31,7 @@ pub use room_version::RoomVersion;
pub use state_event::Event;
/// A mapping of event type and state_key to some value `T`, usually an `EventId`.
pub type StateMap<T> = HashMap<(EventType, String), T>;
pub type StateMap<T> = HashMap<(RoomEventType, String), T>;
/// Resolve sets of state events as they come in.
///
@ -132,7 +132,7 @@ where
trace!("{:?}", events_to_resolve);
// This "epochs" power level event
let power_event = resolved_control.get(&(EventType::RoomPowerLevels, "".into()));
let power_event = resolved_control.get(&(RoomEventType::RoomPowerLevels, "".into()));
debug!("power event: {:?}", power_event);
@ -368,7 +368,7 @@ fn get_power_level_for_sender<E: Event>(
for aid in event.as_ref().map(|pdu| pdu.auth_events()).into_iter().flatten() {
if let Some(aev) = fetch_event(aid.borrow()) {
if is_type_and_key(&aev, &EventType::RoomPowerLevels, "") {
if is_type_and_key(&aev, &RoomEventType::RoomPowerLevels, "") {
pl = Some(aev);
break;
}
@ -458,7 +458,7 @@ fn iterative_auth_check<E: Event + Clone>(
// The key for this is (eventType + a state_key of the signed token not sender) so
// search for it
let current_third_party = auth_events.iter().find_map(|(_, pdu)| {
(*pdu.event_type() == EventType::RoomThirdPartyInvite).then(|| pdu)
(*pdu.event_type() == RoomEventType::RoomThirdPartyInvite).then(|| pdu)
});
if auth_check(room_version, &event, current_third_party, |ty, key| {
@ -509,7 +509,7 @@ fn mainline_sort<E: Event>(
for aid in event.auth_events() {
let ev = fetch_event(aid.borrow())
.ok_or_else(|| Error::NotFound(format!("Failed to find {}", aid)))?;
if is_type_and_key(&ev, &EventType::RoomPowerLevels, "") {
if is_type_and_key(&ev, &RoomEventType::RoomPowerLevels, "") {
pl = Some(aid.to_owned());
break;
}
@ -568,7 +568,7 @@ fn get_mainline_depth<E: Event>(
for aid in sort_ev.auth_events() {
let aev = fetch_event(aid.borrow())
.ok_or_else(|| Error::NotFound(format!("Failed to find {}", aid)))?;
if is_type_and_key(&aev, &EventType::RoomPowerLevels, "") {
if is_type_and_key(&aev, &RoomEventType::RoomPowerLevels, "") {
event = Some(aev);
break;
}
@ -610,16 +610,16 @@ fn is_power_event_id<E: Event>(event_id: &EventId, fetch: impl Fn(&EventId) -> O
}
}
fn is_type_and_key(ev: impl Event, ev_type: &EventType, state_key: &str) -> bool {
fn is_type_and_key(ev: impl Event, ev_type: &RoomEventType, state_key: &str) -> bool {
ev.event_type() == ev_type && ev.state_key() == Some(state_key)
}
fn is_power_event(event: impl Event) -> bool {
match event.event_type() {
EventType::RoomPowerLevels | EventType::RoomJoinRules | EventType::RoomCreate => {
event.state_key() == Some("")
}
EventType::RoomMember => {
RoomEventType::RoomPowerLevels
| RoomEventType::RoomJoinRules
| RoomEventType::RoomCreate => event.state_key() == Some(""),
RoomEventType::RoomMember => {
if let Ok(content) = from_json_str::<RoomMemberEventContent>(event.content().get()) {
if [MembershipState::Leave, MembershipState::Ban].contains(&content.membership) {
return Some(event.sender().as_str()) != event.state_key();
@ -645,7 +645,7 @@ mod tests {
use ruma_common::{
events::{
room::join_rules::{JoinRule, RoomJoinRulesEventContent},
EventType,
RoomEventType,
},
EventId, MilliSecondsSinceUnixEpoch, RoomVersionId,
};
@ -701,7 +701,8 @@ mod tests {
events_to_sort.shuffle(&mut rand::thread_rng());
let power_level = resolved_power.get(&(EventType::RoomPowerLevels, "".to_owned())).cloned();
let power_level =
resolved_power.get(&(RoomEventType::RoomPowerLevels, "".to_owned())).cloned();
let sorted_event_ids =
crate::mainline_sort(&events_to_sort, power_level, |id| events.get(id).map(Arc::clone))
@ -740,28 +741,28 @@ mod tests {
to_init_pdu_event(
"PA",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"MA",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().to_string().as_str()),
member_content_join(),
),
to_init_pdu_event(
"MB",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(bob().to_string().as_str()),
member_content_ban(),
),
to_init_pdu_event(
"PB",
bob(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
@ -787,42 +788,42 @@ mod tests {
to_init_pdu_event(
"T1",
alice(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"PA1",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"T2",
alice(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"PA2",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 0 } })).unwrap(),
),
to_init_pdu_event(
"PB",
bob(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"T3",
bob(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
@ -848,28 +849,28 @@ mod tests {
to_init_pdu_event(
"T1",
alice(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"PA",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"T2",
bob(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"MB",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(bob().to_string().as_str()),
member_content_ban(),
),
@ -895,14 +896,14 @@ mod tests {
to_init_pdu_event(
"JR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Private)).unwrap(),
),
to_init_pdu_event(
"ME",
ella(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().to_string().as_str()),
member_content_join(),
),
@ -927,14 +928,14 @@ mod tests {
to_init_pdu_event(
"PA",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"PB",
bob(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50, charlie(): 50 } }))
.unwrap(),
@ -942,7 +943,7 @@ mod tests {
to_init_pdu_event(
"PC",
charlie(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50, charlie(): 0 } }))
.unwrap(),
@ -968,56 +969,56 @@ mod tests {
to_init_pdu_event(
"T1",
alice(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"PA1",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"T2",
alice(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"PA2",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 0 } })).unwrap(),
),
to_init_pdu_event(
"PB",
bob(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"T3",
bob(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"MZ1",
zara(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"T4",
alice(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
@ -1212,7 +1213,7 @@ mod tests {
to_pdu_event(
"PA",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
&["CREATE", "IMA", "IPOWER"], // auth_events
@ -1221,7 +1222,7 @@ mod tests {
to_pdu_event(
"PB",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
&["CREATE", "IMA", "IPOWER"],
@ -1230,7 +1231,7 @@ mod tests {
to_pdu_event(
"MB",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().as_str()),
member_content_ban(),
&["CREATE", "IMA", "PB"],
@ -1239,7 +1240,7 @@ mod tests {
to_pdu_event(
"IME",
ella(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().as_str()),
member_content_join(),
&["CREATE", "IJR", "PA"],
@ -1257,7 +1258,7 @@ mod tests {
to_pdu_event(
"JR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&json!({ "join_rule": "invite" })).unwrap(),
&["CREATE", "IMA", "IPOWER"],
@ -1266,7 +1267,7 @@ mod tests {
to_pdu_event(
"IMZ",
zara(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(zara().as_str()),
member_content_join(),
&["CREATE", "JR", "IPOWER"],

8
crates/ruma-state-res/src/state_event.rs
View File

@ -5,7 +5,7 @@ use std::{
sync::Arc,
};
use ruma_common::{events::EventType, EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId};
use ruma_common::{events::RoomEventType, EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId};
use serde_json::value::RawValue as RawJsonValue;
/// Abstraction of a PDU so users can have their own PDU types.
@ -25,7 +25,7 @@ pub trait Event {
fn origin_server_ts(&self) -> MilliSecondsSinceUnixEpoch;
/// The event type.
fn event_type(&self) -> &EventType;
fn event_type(&self) -> &RoomEventType;
/// The event's content.
fn content(&self) -> &RawJsonValue;
@ -64,7 +64,7 @@ impl<T: Event> Event for &T {
(*self).origin_server_ts()
}
fn event_type(&self) -> &EventType {
fn event_type(&self) -> &RoomEventType {
(*self).event_type()
}
@ -108,7 +108,7 @@ impl<T: Event> Event for Arc<T> {
(**self).origin_server_ts()
}
fn event_type(&self) -> &EventType {
fn event_type(&self) -> &RoomEventType {
(**self).event_type()
}

40
crates/ruma-state-res/src/test_utils.rs
View File

@ -17,7 +17,7 @@ use ruma_common::{
join_rules::{JoinRule, RoomJoinRulesEventContent},
member::{MembershipState, RoomMemberEventContent},
},
EventType,
RoomEventType,
},
room_id, user_id, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, UserId,
};
@ -198,7 +198,7 @@ pub fn do_check(
// Filter out the dummy messages events.
// These act as points in time where there should be a known state to
// test against.
&& **k != (EventType::RoomMessage, "dummy".to_owned())
&& **k != (RoomEventType::RoomMessage, "dummy".to_owned())
})
.map(|(k, v)| (k.clone(), v.clone()))
.collect::<StateMap<Box<EventId>>>();
@ -252,7 +252,7 @@ impl TestStore<StateEvent> {
let create_event = to_pdu_event::<&EventId>(
"CREATE",
alice(),
EventType::RoomCreate,
RoomEventType::RoomCreate,
Some(""),
to_raw_json_value(&json!({ "creator": alice() })).unwrap(),
&[],
@ -264,7 +264,7 @@ impl TestStore<StateEvent> {
let alice_mem = to_pdu_event(
"IMA",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().to_string().as_str()),
member_content_join(),
&[cre.clone()],
@ -275,7 +275,7 @@ impl TestStore<StateEvent> {
let join_rules = to_pdu_event(
"IJR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Public)).unwrap(),
&[cre.clone(), alice_mem.event_id().to_owned()],
@ -288,7 +288,7 @@ impl TestStore<StateEvent> {
let bob_mem = to_pdu_event(
"IMB",
bob(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(bob().to_string().as_str()),
member_content_join(),
&[cre.clone(), join_rules.event_id().to_owned()],
@ -299,7 +299,7 @@ impl TestStore<StateEvent> {
let charlie_mem = to_pdu_event(
"IMC",
charlie(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(charlie().to_string().as_str()),
member_content_join(),
&[cre, join_rules.event_id().to_owned()],
@ -384,7 +384,7 @@ pub fn member_content_join() -> Box<RawJsonValue> {
pub fn to_init_pdu_event(
id: &str,
sender: Box<UserId>,
ev_type: EventType,
ev_type: RoomEventType,
state_key: Option<&str>,
content: Box<RawJsonValue>,
) -> Arc<StateEvent> {
@ -417,7 +417,7 @@ pub fn to_init_pdu_event(
pub fn to_pdu_event<S>(
id: &str,
sender: Box<UserId>,
ev_type: EventType,
ev_type: RoomEventType,
state_key: Option<&str>,
content: Box<RawJsonValue>,
auth_events: &[S],
@ -461,7 +461,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>(
"CREATE",
alice(),
EventType::RoomCreate,
RoomEventType::RoomCreate,
Some(""),
to_raw_json_value(&json!({ "creator": alice() })).unwrap(),
&[],
@ -470,7 +470,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IMA",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().to_string().as_str()),
member_content_join(),
&["CREATE"],
@ -479,7 +479,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IPOWER",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice().to_string(): 100 } })).unwrap(),
&["CREATE", "IMA"],
@ -488,7 +488,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IJR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Public)).unwrap(),
&["CREATE", "IMA", "IPOWER"],
@ -497,7 +497,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IMB",
bob(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(bob().to_string().as_str()),
member_content_join(),
&["CREATE", "IJR", "IPOWER"],
@ -506,7 +506,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IMC",
charlie(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(charlie().to_string().as_str()),
member_content_join(),
&["CREATE", "IJR", "IPOWER"],
@ -515,7 +515,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>(
"START",
charlie(),
EventType::RoomMessage,
RoomEventType::RoomMessage,
Some("dummy"),
to_raw_json_value(&json!({})).unwrap(),
&[],
@ -524,7 +524,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>(
"END",
charlie(),
EventType::RoomMessage,
RoomEventType::RoomMessage,
Some("dummy"),
to_raw_json_value(&json!({})).unwrap(),
&[],
@ -542,7 +542,7 @@ pub fn INITIAL_EVENTS_CREATE_ROOM() -> HashMap<Box<EventId>, Arc<StateEvent>> {
vec![to_pdu_event::<&EventId>(
"CREATE",
alice(),
EventType::RoomCreate,
RoomEventType::RoomCreate,
Some(""),
to_raw_json_value(&json!({ "creator": alice() })).unwrap(),
&[],
@ -563,7 +563,7 @@ pub fn INITIAL_EDGES() -> Vec<Box<EventId>> {
pub mod event {
use ruma_common::{
events::{pdu::Pdu, EventType},
events::{pdu::Pdu, RoomEventType},
EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId,
};
use serde::{Deserialize, Serialize};
@ -596,7 +596,7 @@ pub mod event {
}
}
fn event_type(&self) -> &EventType {
fn event_type(&self) -> &RoomEventType {
match &self.rest {
Pdu::RoomV1Pdu(ev) => &ev.kind,
Pdu::RoomV3Pdu(ev) => &ev.kind,