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 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}; use crate::{EventId, MilliSecondsSinceUnixEpoch, RoomId, ServerName, ServerSigningKeyId, UserId};
/// Enum for PDU schemas /// Enum for PDU schemas
@ -53,7 +53,7 @@ pub struct RoomV1Pdu {
// TODO: Encode event type as content enum variant, like event enums do // TODO: Encode event type as content enum variant, like event enums do
/// The event's type. /// The event's type.
#[serde(rename = "type")] #[serde(rename = "type")]
pub kind: EventType, pub kind: RoomEventType,
/// The event's content. /// The event's content.
pub content: Box<RawJsonValue>, pub content: Box<RawJsonValue>,
@ -112,7 +112,7 @@ pub struct RoomV3Pdu {
// TODO: Encode event type as content enum variant, like event enums do // TODO: Encode event type as content enum variant, like event enums do
/// The event's type. /// The event's type.
#[serde(rename = "type")] #[serde(rename = "type")]
pub kind: EventType, pub kind: RoomEventType,
/// The event's content. /// The event's content.
pub content: Box<RawJsonValue>, 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 serde::{Deserialize, Serialize};
use crate::{ use crate::{
events::EventType, events::RoomEventType,
power_levels::{default_power_level, NotificationPowerLevels}, power_levels::{default_power_level, NotificationPowerLevels},
UserId, UserId,
}; };
@ -45,7 +45,7 @@ pub struct RoomPowerLevelsEventContent {
)] )]
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")] #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
#[ruma_event(skip_redaction)] #[ruma_event(skip_redaction)]
pub events: BTreeMap<EventType, Int>, pub events: BTreeMap<RoomEventType, Int>,
/// The default level required to send message events. /// 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 serde_json::{json, to_value as to_json_value};
use super::{default_power_level, NotificationPowerLevels, RoomPowerLevelsEventContent}; use super::{default_power_level, NotificationPowerLevels, RoomPowerLevelsEventContent};
use crate::events::{EventType, StateEvent, Unsigned}; use crate::events::{StateEvent, Unsigned};
#[test] #[test]
fn serialization_with_optional_fields_as_none() { fn serialization_with_optional_fields_as_none() {
@ -231,7 +231,7 @@ mod tests {
content: RoomPowerLevelsEventContent { content: RoomPowerLevelsEventContent {
ban: int!(23), ban: int!(23),
events: btreemap! { events: btreemap! {
EventType::Dummy => int!(23) "m.dummy".into() => int!(23)
}, },
events_default: int!(23), events_default: int!(23),
invite: 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. // Make just one field different so we at least know they're two different objects.
ban: int!(42), ban: int!(42),
events: btreemap! { events: btreemap! {
EventType::Dummy => int!(42) "m.dummy".into() => int!(42)
}, },
events_default: int!(42), events_default: int!(42),
invite: int!(42), invite: int!(42),

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

@ -6,7 +6,7 @@ use ruma_common::{
event_id, event_id,
events::{ events::{
pdu::{EventHash, Pdu, RoomV1Pdu, RoomV3Pdu}, pdu::{EventHash, Pdu, RoomV1Pdu, RoomV3Pdu},
EventType, RoomEventType,
}, },
room_id, server_name, server_signing_key_id, user_id, MilliSecondsSinceUnixEpoch, 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(), sender: user_id!("@sender:example.com").to_owned(),
origin: "matrix.org".into(), origin: "matrix.org".into(),
origin_server_ts: MilliSecondsSinceUnixEpoch(1_592_050_773_658_u64.try_into().unwrap()), 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(), content: to_raw_json_value(&json!({ "testing": 123 })).unwrap(),
state_key: Some("state".into()), state_key: Some("state".into()),
prev_events: vec![( prev_events: vec![(
@ -100,7 +100,7 @@ fn serialize_pdu_as_v3() {
sender: user_id!("@sender:example.com").to_owned(), sender: user_id!("@sender:example.com").to_owned(),
origin: "matrix.org".into(), origin: "matrix.org".into(),
origin_server_ts: MilliSecondsSinceUnixEpoch(1_592_050_773_658_u64.try_into().unwrap()), 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(), content: to_raw_json_value(&json!({ "testing": 123 })).unwrap(),
state_key: Some("state".into()), state_key: Some("state".into()),
prev_events: vec![event_id!("$previousevent:matrix.org").to_owned()], 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}, join_rules::{JoinRule, RoomJoinRulesEventContent},
member::{MembershipState, RoomMemberEventContent}, member::{MembershipState, RoomMemberEventContent},
}, },
EventType, RoomEventType,
}, },
room_id, user_id, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, UserId, room_id, user_id, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, UserId,
}; };
@ -240,7 +240,7 @@ impl TestStore<StateEvent> {
let create_event = to_pdu_event::<&EventId>( let create_event = to_pdu_event::<&EventId>(
"CREATE", "CREATE",
alice(), alice(),
EventType::RoomCreate, RoomEventType::RoomCreate,
Some(""), Some(""),
to_raw_json_value(&json!({ "creator": alice() })).unwrap(), to_raw_json_value(&json!({ "creator": alice() })).unwrap(),
&[], &[],
@ -252,7 +252,7 @@ impl TestStore<StateEvent> {
let alice_mem = to_pdu_event( let alice_mem = to_pdu_event(
"IMA", "IMA",
alice(), alice(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(alice().to_string().as_str()), Some(alice().to_string().as_str()),
member_content_join(), member_content_join(),
&[cre.clone()], &[cre.clone()],
@ -263,7 +263,7 @@ impl TestStore<StateEvent> {
let join_rules = to_pdu_event( let join_rules = to_pdu_event(
"IJR", "IJR",
alice(), alice(),
EventType::RoomJoinRules, RoomEventType::RoomJoinRules,
Some(""), Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Public)).unwrap(), to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Public)).unwrap(),
&[cre.clone(), alice_mem.event_id().to_owned()], &[cre.clone(), alice_mem.event_id().to_owned()],
@ -276,7 +276,7 @@ impl TestStore<StateEvent> {
let bob_mem = to_pdu_event( let bob_mem = to_pdu_event(
"IMB", "IMB",
bob(), bob(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(bob().to_string().as_str()), Some(bob().to_string().as_str()),
member_content_join(), member_content_join(),
&[cre.clone(), join_rules.event_id().to_owned()], &[cre.clone(), join_rules.event_id().to_owned()],
@ -287,7 +287,7 @@ impl TestStore<StateEvent> {
let charlie_mem = to_pdu_event( let charlie_mem = to_pdu_event(
"IMC", "IMC",
charlie(), charlie(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(charlie().to_string().as_str()), Some(charlie().to_string().as_str()),
member_content_join(), member_content_join(),
&[cre, join_rules.event_id().to_owned()], &[cre, join_rules.event_id().to_owned()],
@ -367,7 +367,7 @@ fn member_content_join() -> Box<RawJsonValue> {
fn to_pdu_event<S>( fn to_pdu_event<S>(
id: &str, id: &str,
sender: Box<UserId>, sender: Box<UserId>,
ev_type: EventType, ev_type: RoomEventType,
state_key: Option<&str>, state_key: Option<&str>,
content: Box<RawJsonValue>, content: Box<RawJsonValue>,
auth_events: &[S], auth_events: &[S],
@ -413,7 +413,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>( to_pdu_event::<&EventId>(
"CREATE", "CREATE",
alice(), alice(),
EventType::RoomCreate, RoomEventType::RoomCreate,
Some(""), Some(""),
to_raw_json_value(&json!({ "creator": alice() })).unwrap(), to_raw_json_value(&json!({ "creator": alice() })).unwrap(),
&[], &[],
@ -422,7 +422,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event( to_pdu_event(
"IMA", "IMA",
alice(), alice(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(alice().to_string().as_str()), Some(alice().to_string().as_str()),
member_content_join(), member_content_join(),
&["CREATE"], &["CREATE"],
@ -431,7 +431,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event( to_pdu_event(
"IPOWER", "IPOWER",
alice(), alice(),
EventType::RoomPowerLevels, RoomEventType::RoomPowerLevels,
Some(""), Some(""),
to_raw_json_value(&json!({ "users": { alice().to_string(): 100 } })).unwrap(), to_raw_json_value(&json!({ "users": { alice().to_string(): 100 } })).unwrap(),
&["CREATE", "IMA"], &["CREATE", "IMA"],
@ -440,7 +440,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event( to_pdu_event(
"IJR", "IJR",
alice(), alice(),
EventType::RoomJoinRules, RoomEventType::RoomJoinRules,
Some(""), Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Public)).unwrap(), to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Public)).unwrap(),
&["CREATE", "IMA", "IPOWER"], &["CREATE", "IMA", "IPOWER"],
@ -449,7 +449,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event( to_pdu_event(
"IMB", "IMB",
bob(), bob(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(bob().to_string().as_str()), Some(bob().to_string().as_str()),
member_content_join(), member_content_join(),
&["CREATE", "IJR", "IPOWER"], &["CREATE", "IJR", "IPOWER"],
@ -458,7 +458,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event( to_pdu_event(
"IMC", "IMC",
charlie(), charlie(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(charlie().to_string().as_str()), Some(charlie().to_string().as_str()),
member_content_join(), member_content_join(),
&["CREATE", "IJR", "IPOWER"], &["CREATE", "IJR", "IPOWER"],
@ -467,7 +467,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>( to_pdu_event::<&EventId>(
"START", "START",
charlie(), charlie(),
EventType::RoomTopic, RoomEventType::RoomTopic,
Some(""), Some(""),
to_raw_json_value(&json!({})).unwrap(), to_raw_json_value(&json!({})).unwrap(),
&[], &[],
@ -476,7 +476,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>( to_pdu_event::<&EventId>(
"END", "END",
charlie(), charlie(),
EventType::RoomTopic, RoomEventType::RoomTopic,
Some(""), Some(""),
to_raw_json_value(&json!({})).unwrap(), to_raw_json_value(&json!({})).unwrap(),
&[], &[],
@ -495,7 +495,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event( to_pdu_event(
"PA", "PA",
alice(), alice(),
EventType::RoomPowerLevels, RoomEventType::RoomPowerLevels,
Some(""), Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(), to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
&["CREATE", "IMA", "IPOWER"], // auth_events &["CREATE", "IMA", "IPOWER"], // auth_events
@ -504,7 +504,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event( to_pdu_event(
"PB", "PB",
alice(), alice(),
EventType::RoomPowerLevels, RoomEventType::RoomPowerLevels,
Some(""), Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(), to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
&["CREATE", "IMA", "IPOWER"], &["CREATE", "IMA", "IPOWER"],
@ -513,7 +513,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event( to_pdu_event(
"MB", "MB",
alice(), alice(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(ella().as_str()), Some(ella().as_str()),
member_content_ban(), member_content_ban(),
&["CREATE", "IMA", "PB"], &["CREATE", "IMA", "PB"],
@ -522,7 +522,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event( to_pdu_event(
"IME", "IME",
ella(), ella(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(ella().as_str()), Some(ella().as_str()),
member_content_join(), member_content_join(),
&["CREATE", "IJR", "PA"], &["CREATE", "IJR", "PA"],
@ -536,7 +536,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
mod event { mod event {
use ruma_common::{ use ruma_common::{
events::{pdu::Pdu, EventType}, events::{pdu::Pdu, RoomEventType},
EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId, EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId,
}; };
use ruma_state_res::Event; use ruma_state_res::Event;
@ -568,7 +568,7 @@ mod event {
} }
} }
fn event_type(&self) -> &EventType { fn event_type(&self) -> &RoomEventType {
match &self.rest { match &self.rest {
Pdu::RoomV1Pdu(ev) => &ev.kind, Pdu::RoomV1Pdu(ev) => &ev.kind,
Pdu::RoomV3Pdu(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, power_levels::RoomPowerLevelsEventContent,
third_party_invite::RoomThirdPartyInviteEventContent, third_party_invite::RoomThirdPartyInviteEventContent,
}, },
EventType, RoomEventType,
}, },
serde::{Base64, Raw}, serde::{Base64, Raw},
RoomVersionId, UserId, RoomVersionId, UserId,
@ -45,22 +45,22 @@ struct PowerLevelsContentInvite {
/// ///
/// This function will return an error if the supplied `content` is not a JSON object. /// This function will return an error if the supplied `content` is not a JSON object.
pub fn auth_types_for_event( pub fn auth_types_for_event(
kind: &EventType, kind: &RoomEventType,
sender: &UserId, sender: &UserId,
state_key: Option<&str>, state_key: Option<&str>,
content: &RawJsonValue, content: &RawJsonValue,
) -> serde_json::Result<Vec<(EventType, String)>> { ) -> serde_json::Result<Vec<(RoomEventType, String)>> {
if kind == &EventType::RoomCreate { if kind == &RoomEventType::RoomCreate {
return Ok(vec![]); return Ok(vec![]);
} }
let mut auth_types = vec![ let mut auth_types = vec![
(EventType::RoomPowerLevels, "".to_owned()), (RoomEventType::RoomPowerLevels, "".to_owned()),
(EventType::RoomMember, sender.to_string()), (RoomEventType::RoomMember, sender.to_string()),
(EventType::RoomCreate, "".to_owned()), (RoomEventType::RoomCreate, "".to_owned()),
]; ];
if kind == &EventType::RoomMember { if kind == &RoomEventType::RoomMember {
#[derive(Deserialize)] #[derive(Deserialize)]
struct RoomMemberContentFields { struct RoomMemberContentFields {
membership: Option<Raw<MembershipState>>, membership: Option<Raw<MembershipState>>,
@ -75,7 +75,7 @@ pub fn auth_types_for_event(
if [MembershipState::Join, MembershipState::Invite, MembershipState::Knock] if [MembershipState::Join, MembershipState::Invite, MembershipState::Knock]
.contains(&membership) .contains(&membership)
{ {
let key = (EventType::RoomJoinRules, "".to_owned()); let key = (RoomEventType::RoomJoinRules, "".to_owned());
if !auth_types.contains(&key) { if !auth_types.contains(&key) {
auth_types.push(key); auth_types.push(key);
} }
@ -83,21 +83,21 @@ pub fn auth_types_for_event(
if let Some(Ok(u)) = if let Some(Ok(u)) =
content.join_authorised_via_users_server.map(|m| m.deserialize()) 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) { if !auth_types.contains(&key) {
auth_types.push(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) { if !auth_types.contains(&key) {
auth_types.push(key); auth_types.push(key);
} }
if membership == MembershipState::Invite { if membership == MembershipState::Invite {
if let Some(Ok(t_id)) = content.third_party_invite.map(|t| t.deserialize()) { 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) { if !auth_types.contains(&key) {
auth_types.push(key); auth_types.push(key);
} }
@ -123,7 +123,7 @@ pub fn auth_check<E: Event>(
room_version: &RoomVersion, room_version: &RoomVersion,
incoming_event: impl Event, incoming_event: impl Event,
current_third_party_invite: Option<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> { ) -> Result<bool> {
info!( info!(
"auth_check beginning for {} ({})", "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 // Implementation of https://spec.matrix.org/v1.2/rooms/v1/#authorization-rules
// //
// 1. If type is m.room.create: // 1. If type is m.room.create:
if *incoming_event.event_type() == EventType::RoomCreate { if *incoming_event.event_type() == RoomEventType::RoomCreate {
#[derive(Deserialize)] #[derive(Deserialize)]
struct RoomCreateContentFields { struct RoomCreateContentFields {
room_version: Option<Raw<RoomVersionId>>, 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 => { None => {
warn!("no m.room.create event in auth chain"); warn!("no m.room.create event in auth chain");
return Ok(false); return Ok(false);
@ -228,7 +228,7 @@ pub fn auth_check<E: Event>(
// Only in some room versions 6 and below // Only in some room versions 6 and below
if room_version.special_case_aliases_auth { if room_version.special_case_aliases_auth {
// 4. If type is m.room.aliases // 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"); info!("starting m.room.aliases check");
// If sender's domain doesn't matches state_key, reject // 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 // If type is m.room.member
let power_levels_event = fetch_state(&EventType::RoomPowerLevels, ""); let power_levels_event = fetch_state(&RoomEventType::RoomPowerLevels, "");
let sender_member_event = fetch_state(&EventType::RoomMember, sender.as_str()); 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"); info!("starting m.room.member check");
let state_key = match incoming_event.state_key() { let state_key = match incoming_event.state_key() {
None => { None => {
@ -270,7 +270,7 @@ pub fn auth_check<E: Event>(
let user_for_join_auth_membership = user_for_join_auth let user_for_join_auth_membership = user_for_join_auth
.as_ref() .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()) .and_then(|mem| from_json_str::<GetMembership>(mem.content().get()).ok())
.map(|mem| mem.membership) .map(|mem| mem.membership)
.unwrap_or(MembershipState::Leave); .unwrap_or(MembershipState::Leave);
@ -278,13 +278,13 @@ pub fn auth_check<E: Event>(
if !valid_membership_change( if !valid_membership_change(
room_version, room_version,
target_user, target_user,
fetch_state(&EventType::RoomMember, target_user.as_str()).as_ref(), fetch_state(&RoomEventType::RoomMember, target_user.as_str()).as_ref(),
sender, sender,
sender_member_event.as_ref(), sender_member_event.as_ref(),
&incoming_event, &incoming_event,
current_third_party_invite, current_third_party_invite,
power_levels_event.as_ref(), 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.as_deref(),
&user_for_join_auth_membership, &user_for_join_auth_membership,
room_create_event, 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 // Allow if and only if sender's current power level is greater than
// or equal to the invite level // 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 { let invite_level = match &power_levels_event {
Some(power_levels) => { Some(power_levels) => {
from_json_str::<PowerLevelsContentInvite>(power_levels.content().get())?.invite 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 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"); info!("starting m.room.power_levels check");
if let Some(required_pwr_lvl) = check_power_levels( if let Some(required_pwr_lvl) = check_power_levels(
@ -388,7 +388,7 @@ pub fn auth_check<E: Event>(
// power levels. // power levels.
if room_version.extra_redaction_checks if room_version.extra_redaction_checks
&& *incoming_event.event_type() == EventType::RoomRedaction && *incoming_event.event_type() == RoomEventType::RoomRedaction
{ {
#[derive(Deserialize)] #[derive(Deserialize)]
struct PowerLevelsContentRedact { struct PowerLevelsContentRedact {
@ -762,7 +762,6 @@ fn check_power_levels(
let old_list = &current_content.events; let old_list = &current_content.events;
let new_list = &user_content.events; let new_list = &user_content.events;
for ev_id in old_list.keys().chain(new_list.keys()) { for ev_id in old_list.keys().chain(new_list.keys()) {
let ev_id: &EventType = ev_id;
event_levels_to_check.insert(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 /// 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. /// `e_type` based on the rooms "m.room.power_level" event.
fn get_send_level( fn get_send_level(
e_type: &EventType, e_type: &RoomEventType,
state_key: Option<&str>, state_key: Option<&str>,
power_lvl: Option<impl Event>, power_lvl: Option<impl Event>,
) -> Int { ) -> Int {
@ -975,7 +974,7 @@ mod tests {
}, },
member::{MembershipState, RoomMemberEventContent}, member::{MembershipState, RoomMemberEventContent},
}, },
EventType, RoomEventType,
}; };
use serde_json::value::to_raw_value as to_raw_json_value; use serde_json::value::to_raw_value as to_raw_json_value;
@ -1004,7 +1003,7 @@ mod tests {
let requester = to_pdu_event( let requester = to_pdu_event(
"HELLO", "HELLO",
alice(), alice(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(charlie().as_str()), Some(charlie().as_str()),
member_content_ban(), member_content_ban(),
&[], &[],
@ -1018,16 +1017,16 @@ mod tests {
assert!(valid_membership_change( assert!(valid_membership_change(
&RoomVersion::V6, &RoomVersion::V6,
&target_user, &target_user,
fetch_state(EventType::RoomMember, target_user.to_string()), fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender, &sender,
fetch_state(EventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<StateEvent>, None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None, None,
&MembershipState::Leave, &MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(), fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
) )
.unwrap()); .unwrap());
} }
@ -1048,7 +1047,7 @@ mod tests {
let requester = to_pdu_event( let requester = to_pdu_event(
"HELLO", "HELLO",
charlie(), charlie(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(charlie().as_str()), Some(charlie().as_str()),
member_content_join(), member_content_join(),
&["CREATE"], &["CREATE"],
@ -1062,16 +1061,16 @@ mod tests {
assert!(!valid_membership_change( assert!(!valid_membership_change(
&RoomVersion::V6, &RoomVersion::V6,
&target_user, &target_user,
fetch_state(EventType::RoomMember, target_user.to_string()), fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender, &sender,
fetch_state(EventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<StateEvent>, None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None, None,
&MembershipState::Leave, &MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(), fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
) )
.unwrap()); .unwrap());
} }
@ -1092,7 +1091,7 @@ mod tests {
let requester = to_pdu_event( let requester = to_pdu_event(
"HELLO", "HELLO",
alice(), alice(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(alice().as_str()), Some(alice().as_str()),
member_content_join(), member_content_join(),
&["CREATE"], &["CREATE"],
@ -1106,16 +1105,16 @@ mod tests {
assert!(valid_membership_change( assert!(valid_membership_change(
&RoomVersion::V6, &RoomVersion::V6,
&target_user, &target_user,
fetch_state(EventType::RoomMember, target_user.to_string()), fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender, &sender,
fetch_state(EventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<StateEvent>, None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None, None,
&MembershipState::Leave, &MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(), fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
) )
.unwrap()); .unwrap());
} }
@ -1136,7 +1135,7 @@ mod tests {
let requester = to_pdu_event( let requester = to_pdu_event(
"HELLO", "HELLO",
charlie(), charlie(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(alice().as_str()), Some(alice().as_str()),
member_content_ban(), member_content_ban(),
&[], &[],
@ -1150,16 +1149,16 @@ mod tests {
assert!(!valid_membership_change( assert!(!valid_membership_change(
&RoomVersion::V6, &RoomVersion::V6,
&target_user, &target_user,
fetch_state(EventType::RoomMember, target_user.to_string()), fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender, &sender,
fetch_state(EventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<StateEvent>, None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None, None,
&MembershipState::Leave, &MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(), fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
) )
.unwrap()); .unwrap());
} }
@ -1172,7 +1171,7 @@ mod tests {
*events.get_mut(&event_id("IJR")).unwrap() = to_pdu_event( *events.get_mut(&event_id("IJR")).unwrap() = to_pdu_event(
"IJR", "IJR",
alice(), alice(),
EventType::RoomJoinRules, RoomEventType::RoomJoinRules,
Some(""), Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Restricted( to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Restricted(
Restricted::new(vec![AllowRule::RoomMembership(RoomMembership::new( Restricted::new(vec![AllowRule::RoomMembership(RoomMembership::new(
@ -1197,7 +1196,7 @@ mod tests {
let requester = to_pdu_event( let requester = to_pdu_event(
"HELLO", "HELLO",
ella(), ella(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(ella().as_str()), Some(ella().as_str()),
to_raw_json_value(&RoomMemberEventContent::new(MembershipState::Join)).unwrap(), to_raw_json_value(&RoomMemberEventContent::new(MembershipState::Join)).unwrap(),
&["CREATE", "IJR", "IPOWER", "new"], &["CREATE", "IJR", "IPOWER", "new"],
@ -1211,32 +1210,32 @@ mod tests {
assert!(valid_membership_change( assert!(valid_membership_change(
&RoomVersion::V9, &RoomVersion::V9,
&target_user, &target_user,
fetch_state(EventType::RoomMember, target_user.to_string()), fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender, &sender,
fetch_state(EventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<StateEvent>, None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
Some(&alice()), Some(&alice()),
&MembershipState::Join, &MembershipState::Join,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(), fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
) )
.unwrap()); .unwrap());
assert!(!valid_membership_change( assert!(!valid_membership_change(
&RoomVersion::V9, &RoomVersion::V9,
&target_user, &target_user,
fetch_state(EventType::RoomMember, target_user.to_string()), fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender, &sender,
fetch_state(EventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<StateEvent>, None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
Some(&ella()), Some(&ella()),
&MembershipState::Leave, &MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(), fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
) )
.unwrap()); .unwrap());
} }
@ -1249,7 +1248,7 @@ mod tests {
*events.get_mut(&event_id("IJR")).unwrap() = to_pdu_event( *events.get_mut(&event_id("IJR")).unwrap() = to_pdu_event(
"IJR", "IJR",
alice(), alice(),
EventType::RoomJoinRules, RoomEventType::RoomJoinRules,
Some(""), Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Knock)).unwrap(), to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Knock)).unwrap(),
&["CREATE", "IMA", "IPOWER"], &["CREATE", "IMA", "IPOWER"],
@ -1266,7 +1265,7 @@ mod tests {
let requester = to_pdu_event( let requester = to_pdu_event(
"HELLO", "HELLO",
ella(), ella(),
EventType::RoomMember, RoomEventType::RoomMember,
Some(ella().as_str()), Some(ella().as_str()),
to_raw_json_value(&RoomMemberEventContent::new(MembershipState::Knock)).unwrap(), to_raw_json_value(&RoomMemberEventContent::new(MembershipState::Knock)).unwrap(),
&[], &[],
@ -1280,16 +1279,16 @@ mod tests {
assert!(valid_membership_change( assert!(valid_membership_change(
&RoomVersion::V7, &RoomVersion::V7,
&target_user, &target_user,
fetch_state(EventType::RoomMember, target_user.to_string()), fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender, &sender,
fetch_state(EventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<StateEvent>, None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None, None,
&MembershipState::Leave, &MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(), fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
) )
.unwrap()); .unwrap());
} }

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

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

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

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