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

Rename *EventStub -> Sync*Event

Browse Source
This commit is contained in:
Devin R 2020-07-14 13:44:39 -04:00
parent 7b909efccc
commit 204a90ac43
12 changed files with 123 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
ruma-client-api/src/r0/sync/sync_events.rs
View File

@ -6,8 +6,8 @@ use js_int::UInt;
use ruma_api::ruma_api;
use ruma_common::presence::PresenceState;
use ruma_events::{
presence::PresenceEvent, AnyBasicEvent, AnyEphemeralRoomEventStub, AnyRoomEventStub,
AnyStateEventStub, AnyStrippedStateEventStub, AnyToDeviceEvent, EventJson,
presence::PresenceEvent, AnyBasicEvent, AnyStrippedStateEvent, AnySyncEphemeralRoomEvent,
AnySyncRoomEvent, AnySyncStateEvent, AnyToDeviceEvent, EventJson,
};
use ruma_identifiers::{RoomId, UserId};
use serde::{Deserialize, Serialize};
@ -242,7 +242,7 @@ pub struct Timeline {
pub prev_batch: Option<String>,
/// A list of events.
pub events: Vec<EventJson<AnyRoomEventStub>>,
pub events: Vec<EventJson<AnySyncRoomEvent>>,
}
impl Timeline {
@ -256,7 +256,7 @@ impl Timeline {
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct State {
/// A list of state events.
pub events: Vec<EventJson<AnyStateEventStub>>,
pub events: Vec<EventJson<AnySyncStateEvent>>,
}
impl State {
@ -284,7 +284,7 @@ impl AccountData {
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct Ephemeral {
/// A list of events.
pub events: Vec<EventJson<AnyEphemeralRoomEventStub>>,
pub events: Vec<EventJson<AnySyncEphemeralRoomEvent>>,
}
impl Ephemeral {
@ -343,7 +343,7 @@ impl InvitedRoom {
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InviteState {
/// A list of state events.
pub events: Vec<EventJson<AnyStrippedStateEventStub>>,
pub events: Vec<EventJson<AnyStrippedStateEvent>>,
}
impl InviteState {

56
ruma-events-macros/src/event_enum.rs
View File

@ -15,7 +15,7 @@ fn is_non_stripped_room_event(kind: &EventKind, var: &EventKindVariation) -> boo
fn has_prev_content_field(kind: &EventKind, var: &EventKindVariation) -> bool {
matches!(kind, EventKind::State(_))
&& matches!(var, EventKindVariation::Full | EventKindVariation::Stub)
&& matches!(var, EventKindVariation::Full | EventKindVariation::Sync)
}
type EventKindFn = fn(&EventKind, &EventKindVariation) -> bool;
@ -48,8 +48,8 @@ pub fn expand_event_enum(input: EventEnumInput) -> syn::Result<TokenStream> {
let event_enum =
expand_any_with_deser(name, events, attrs, &variants, &EventKindVariation::Full);
let event_stub_enum =
expand_any_with_deser(name, events, attrs, &variants, &EventKindVariation::Stub);
let sync_event_enum =
expand_any_with_deser(name, events, attrs, &variants, &EventKindVariation::Sync);
let event_stripped_enum =
expand_any_with_deser(name, events, attrs, &variants, &EventKindVariation::Stripped);
@ -61,7 +61,7 @@ pub fn expand_event_enum(input: EventEnumInput) -> syn::Result<TokenStream> {
Ok(quote! {
#event_enum
#event_stub_enum
#sync_event_enum
#event_stripped_enum
@ -154,26 +154,26 @@ fn expand_any_redacted(
use EventKindVariation::*;
if kind.is_state() {
let state_full = expand_any_with_deser(kind, events, attrs, variants, &Redacted);
let state_stub = expand_any_with_deser(kind, events, attrs, variants, &RedactedStub);
let state_stripped =
let full_state = expand_any_with_deser(kind, events, attrs, variants, &Redacted);
let sync_state = expand_any_with_deser(kind, events, attrs, variants, &RedactedSync);
let stripped_state =
expand_any_with_deser(kind, events, attrs, variants, &RedactedStripped);
quote! {
#state_full
#full_state
#state_stub
#sync_state
#state_stripped
#stripped_state
}
} else if kind.is_message() {
let message_full = expand_any_with_deser(kind, events, attrs, variants, &Redacted);
let message_stub = expand_any_with_deser(kind, events, attrs, variants, &RedactedStub);
let full_message = expand_any_with_deser(kind, events, attrs, variants, &Redacted);
let sync_message = expand_any_with_deser(kind, events, attrs, variants, &RedactedSync);
quote! {
#message_full
#full_message
#message_stub
#sync_message
}
} else {
TokenStream::new()
@ -250,7 +250,7 @@ fn expand_custom_variant(
) -> (TokenStream, TokenStream) {
use EventKindVariation::*;
if matches!(var, Redacted | RedactedStub | RedactedStripped) {
if matches!(var, Redacted | RedactedSync | RedactedStripped) {
(
quote! {
/// A redacted event not defined by the Matrix specification
@ -317,7 +317,7 @@ fn accessor_methods(
let ident = kind.to_event_enum_ident(var)?;
// matching `EventKindVariation`s
if let Redacted | RedactedStub | RedactedStripped = var {
if let Redacted | RedactedSync | RedactedStripped = var {
return redacted_accessor_methods(kind, var, variants);
}
@ -408,15 +408,15 @@ fn to_event_path(name: &LitStr, struct_name: &Ident) -> TokenStream {
let path = path.iter().map(|s| Ident::new(s, span));
match struct_name.to_string().as_str() {
"MessageEvent" | "MessageEventStub" if name == "m.room.redaction" => {
"MessageEvent" | "SyncMessageEvent" if name == "m.room.redaction" => {
let redaction = if struct_name == "MessageEvent" {
quote! { RedactionEvent }
} else {
quote! { RedactionEventStub }
quote! { SyncRedactionEvent }
};
quote! { ::ruma_events::room::redaction::#redaction }
}
"ToDeviceEvent" | "StateEventStub" | "StrippedStateEventStub" | "MessageEventStub" => {
"ToDeviceEvent" | "SyncStateEvent" | "StrippedStateEvent" | "SyncMessageEvent" => {
let content = format_ident!("{}EventContent", event);
quote! { ::ruma_events::#struct_name<::ruma_events::#( #path )::*::#content> }
}
@ -523,10 +523,10 @@ mod kw {
// If the variants of this enum change `to_event_path` needs to be updated as well.
enum EventKindVariation {
Full,
Stub,
Sync,
Stripped,
Redacted,
RedactedStub,
RedactedSync,
RedactedStripped,
}
@ -554,19 +554,17 @@ impl EventKind {
match (self, var) {
// all `EventKind`s are valid event structs and event enums.
(_, Full) => Some(format_ident!("{}Event", self.get_ident())),
(Self::Ephemeral(i), Stub) | (Self::Message(i), Stub) | (Self::State(i), Stub) => {
Some(format_ident!("{}EventStub", i))
(Self::Ephemeral(i), Sync) | (Self::Message(i), Sync) | (Self::State(i), Sync) => {
Some(format_ident!("Sync{}Event", i))
}
(Self::State(i), Stripped) => Some(format_ident!("Stripped{}EventStub", i)),
(Self::State(i), Stripped) => Some(format_ident!("Stripped{}Event", i)),
(Self::Message(i), Redacted) | (Self::State(i), Redacted) => {
Some(format_ident!("Redacted{}Event", i))
}
(Self::Message(i), RedactedStub) | (Self::State(i), RedactedStub) => {
Some(format_ident!("Redacted{}EventStub", i))
}
(Self::State(i), RedactedStripped) => {
Some(format_ident!("RedactedStripped{}EventStub", i))
(Self::Message(i), RedactedSync) | (Self::State(i), RedactedSync) => {
Some(format_ident!("RedactedSync{}Event", i))
}
(Self::State(i), RedactedStripped) => Some(format_ident!("RedactedStripped{}Event", i)),
_ => None,
}
}

30
ruma-events/src/enums.rs
View File

@ -117,18 +117,18 @@ pub enum AnyRoomEvent {
RedactedState(AnyRedactedStateEvent),
}
/// Any room event stub (room event without a `room_id`, as returned in `/sync` responses)
/// Any sync room event (room event without a `room_id`, as returned in `/sync` responses)
#[derive(Clone, Debug, Serialize)]
#[serde(untagged)]
pub enum AnyRoomEventStub {
/// Any message event stub
Message(AnyMessageEventStub),
/// Any state event stub
State(AnyStateEventStub),
/// Any message event stub that has been redacted.
RedactedMessage(AnyRedactedMessageEventStub),
/// Any state event stub that has been redacted.
RedactedState(AnyRedactedStateEventStub),
pub enum AnySyncRoomEvent {
/// Any sync message event
Message(AnySyncMessageEvent),
/// Any sync state event
State(AnySyncStateEvent),
/// Any sync message event that has been redacted.
RedactedMessage(AnyRedactedSyncMessageEvent),
/// Any sync state event that has been redacted.
RedactedState(AnyRedactedSyncStateEvent),
}
// FIXME `#[serde(untagged)]` deserialization fails for these enums which
@ -192,7 +192,7 @@ impl<'de> de::Deserialize<'de> for AnyRoomEvent {
}
}
impl<'de> de::Deserialize<'de> for AnyRoomEventStub {
impl<'de> de::Deserialize<'de> for AnySyncRoomEvent {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: de::Deserializer<'de>,
@ -203,16 +203,16 @@ impl<'de> de::Deserialize<'de> for AnyRoomEventStub {
if state_key.is_some() {
Ok(match unsigned {
Some(unsigned) if unsigned.redacted_because.is_some() => {
AnyRoomEventStub::RedactedState(from_raw_json_value(&json)?)
AnySyncRoomEvent::RedactedState(from_raw_json_value(&json)?)
}
_ => AnyRoomEventStub::State(from_raw_json_value(&json)?),
_ => AnySyncRoomEvent::State(from_raw_json_value(&json)?),
})
} else {
Ok(match unsigned {
Some(unsigned) if unsigned.redacted_because.is_some() => {
AnyRoomEventStub::RedactedMessage(from_raw_json_value(&json)?)
AnySyncRoomEvent::RedactedMessage(from_raw_json_value(&json)?)
}
_ => AnyRoomEventStub::Message(from_raw_json_value(&json)?),
_ => AnySyncRoomEvent::Message(from_raw_json_value(&json)?),
})
}
}

14
ruma-events/src/event_kinds.rs
View File

@ -27,7 +27,7 @@ pub struct EphemeralRoomEvent<C: EphemeralRoomEventContent> {
/// An ephemeral room event without a `room_id`.
#[derive(Clone, Debug, Event)]
pub struct EphemeralRoomEventStub<C: EphemeralRoomEventContent> {
pub struct SyncEphemeralRoomEvent<C: EphemeralRoomEventContent> {
/// Data specific to the event type.
pub content: C,
}
@ -56,7 +56,7 @@ pub struct MessageEvent<C: MessageEventContent> {
/// A message event without a `room_id`.
#[derive(Clone, Debug, Event)]
pub struct MessageEventStub<C: MessageEventContent> {
pub struct SyncMessageEvent<C: MessageEventContent> {
/// Data specific to the event type.
pub content: C,
@ -97,7 +97,7 @@ pub struct RedactedMessageEvent<C: RedactedMessageEventContent> {
/// A redacted message event without a `room_id`.
#[derive(Clone, Debug, Event)]
pub struct RedactedMessageEventStub<C: RedactedMessageEventContent> {
pub struct RedactedSyncMessageEvent<C: RedactedMessageEventContent> {
/// Data specific to the event type.
// #[serde(default, skip_serializing_if = "is_zst")]
pub content: C,
@ -148,7 +148,7 @@ pub struct StateEvent<C: StateEventContent> {
/// A state event without a `room_id`.
#[derive(Clone, Debug, Event)]
pub struct StateEventStub<C: StateEventContent> {
pub struct SyncStateEvent<C: StateEventContent> {
/// Data specific to the event type.
pub content: C,
@ -177,7 +177,7 @@ pub struct StateEventStub<C: StateEventContent> {
/// A stripped-down state event, used for previews of rooms the user has been
/// invited to.
#[derive(Clone, Debug, Event)]
pub struct StrippedStateEventStub<C: StateEventContent> {
pub struct StrippedStateEvent<C: StateEventContent> {
/// Data specific to the event type.
pub content: C,
@ -221,7 +221,7 @@ pub struct RedactedStateEvent<C: RedactedStateEventContent> {
/// A redacted state event without a `room_id`.
#[derive(Clone, Debug, Event)]
pub struct RedactedStateEventStub<C: RedactedStateEventContent> {
pub struct RedactedSyncStateEvent<C: RedactedStateEventContent> {
/// Data specific to the event type.
// #[serde(default, skip_serializing_if = "is_zst")]
pub content: C,
@ -247,7 +247,7 @@ pub struct RedactedStateEventStub<C: RedactedStateEventContent> {
/// A stripped-down redacted state event.
#[derive(Clone, Debug, Event)]
pub struct RedactedStrippedStateEventStub<C: RedactedStateEventContent> {
pub struct RedactedStrippedStateEvent<C: RedactedStateEventContent> {
/// Data specific to the event type.
pub content: C,

16
ruma-events/src/lib.rs
View File

@ -165,17 +165,17 @@ pub use self::{
algorithm::Algorithm,
enums::{
AnyBasicEvent, AnyBasicEventContent, AnyEphemeralRoomEvent, AnyEphemeralRoomEventContent,
AnyEphemeralRoomEventStub, AnyEvent, AnyMessageEvent, AnyMessageEventContent,
AnyMessageEventStub, AnyRedactedMessageEvent, AnyRedactedMessageEventStub,
AnyRedactedStateEvent, AnyRedactedStateEventStub, AnyRedactedStrippedStateEventStub,
AnyRoomEvent, AnyRoomEventStub, AnyStateEvent, AnyStateEventContent, AnyStateEventStub,
AnyStrippedStateEventStub, AnyToDeviceEvent, AnyToDeviceEventContent,
AnyEvent, AnyMessageEvent, AnyMessageEventContent, AnyRedactedMessageEvent,
AnyRedactedStateEvent, AnyRedactedStrippedStateEvent, AnyRedactedSyncMessageEvent,
AnyRedactedSyncStateEvent, AnyRoomEvent, AnyStateEvent, AnyStateEventContent,
AnyStrippedStateEvent, AnySyncEphemeralRoomEvent, AnySyncMessageEvent, AnySyncRoomEvent,
AnySyncStateEvent, AnyToDeviceEvent, AnyToDeviceEventContent,
},
error::{FromStrError, InvalidInput},
event_kinds::{
BasicEvent, EphemeralRoomEvent, EphemeralRoomEventStub, MessageEvent, MessageEventStub,
RedactedMessageEvent, RedactedMessageEventStub, RedactedStateEvent, RedactedStateEventStub,
RedactedStrippedStateEventStub, StateEvent, StateEventStub, StrippedStateEventStub,
BasicEvent, EphemeralRoomEvent, MessageEvent, RedactedMessageEvent, RedactedStateEvent,
RedactedStrippedStateEvent, RedactedSyncMessageEvent, RedactedSyncStateEvent, StateEvent,
StrippedStateEvent, SyncEphemeralRoomEvent, SyncMessageEvent, SyncStateEvent,
ToDeviceEvent,
},
event_type::EventType,

6
ruma-events/src/room/member.rs
View File

@ -7,7 +7,7 @@ use ruma_identifiers::UserId;
use serde::{Deserialize, Serialize};
use strum::{Display, EnumString};
use crate::{StateEvent, StateEventStub, StrippedStateEventStub};
use crate::{StateEvent, StrippedStateEvent, SyncStateEvent};
/// The current membership state of a user in the room.
///
@ -222,7 +222,7 @@ impl MemberEvent {
}
}
impl StateEventStub<MemberEventContent> {
impl SyncStateEvent<MemberEventContent> {
/// Helper function for membership change. Check [the specification][spec] for details.
///
/// [spec]: https://matrix.org/docs/spec/client_server/latest#m-room-member
@ -231,7 +231,7 @@ impl StateEventStub<MemberEventContent> {
}
}
impl StrippedStateEventStub<MemberEventContent> {
impl StrippedStateEvent<MemberEventContent> {
/// Helper function for membership change. Check [the specification][spec] for details.
///
/// [spec]: https://matrix.org/docs/spec/client_server/latest#m-room-member

2
ruma-events/src/room/redaction.rs
View File

@ -38,7 +38,7 @@ pub struct RedactionEvent {
/// Redaction event without a `room_id`.
#[derive(Clone, Debug, Event)]
pub struct RedactionEventStub {
pub struct SyncRedactionEvent {
/// Data specific to the event type.
pub content: RedactionEventContent,

18
ruma-events/tests/custom.rs
View File

@ -5,9 +5,9 @@ use std::{
use matches::assert_matches;
use ruma_events::{
custom::CustomEventContent, AnyMessageEvent, AnyMessageEventStub, AnyRoomEventStub,
AnyStateEvent, AnyStateEventContent, EventJson, MessageEvent, MessageEventStub, StateEvent,
StateEventStub, UnsignedData,
custom::CustomEventContent, AnyMessageEvent, AnyStateEvent, AnyStateEventContent,
AnySyncMessageEvent, AnySyncRoomEvent, EventJson, MessageEvent, StateEvent, SyncMessageEvent,
SyncStateEvent, UnsignedData,
};
use ruma_identifiers::{EventId, RoomId, UserId};
use serde_json::{
@ -157,7 +157,7 @@ fn deserialize_custom_state_event() {
}
#[test]
fn deserialize_custom_state_stub_event() {
fn deserialize_custom_state_sync_event() {
let json_data = custom_state_event();
let expected_content = json!({
@ -169,9 +169,9 @@ fn deserialize_custom_state_stub_event() {
});
assert_matches!(
from_json_value::<StateEventStub<AnyStateEventContent>>(json_data)
from_json_value::<SyncStateEvent<AnyStateEventContent>>(json_data)
.unwrap(),
StateEventStub {
SyncStateEvent {
content: AnyStateEventContent::Custom(CustomEventContent {
json, event_type,
}),
@ -191,7 +191,7 @@ fn deserialize_custom_state_stub_event() {
}
#[test]
fn deserialize_custom_message_stub_event() {
fn deserialize_custom_message_sync_event() {
let json_data = json!({
"content": {
"m.relates_to": {
@ -219,9 +219,9 @@ fn deserialize_custom_message_stub_event() {
});
assert_matches!(
from_json_value::<AnyRoomEventStub>(json_data)
from_json_value::<AnySyncRoomEvent>(json_data)
.unwrap(),
AnyRoomEventStub::Message(AnyMessageEventStub::Custom(MessageEventStub {
AnySyncRoomEvent::Message(AnySyncMessageEvent::Custom(SyncMessageEvent {
content: CustomEventContent {
json, event_type,
},

38
ruma-events/tests/enums.rs
View File

@ -10,9 +10,9 @@ use ruma_events::{
message::{MessageEventContent, TextMessageEventContent},
power_levels::PowerLevelsEventContent,
},
AnyEvent, AnyMessageEvent, AnyMessageEventStub, AnyRoomEvent, AnyRoomEventStub, AnyStateEvent,
AnyStateEventContent, AnyStateEventStub, MessageEvent, MessageEventStub, StateEvent,
StateEventStub,
AnyEvent, AnyMessageEvent, AnyRoomEvent, AnyStateEvent, AnyStateEventContent,
AnySyncMessageEvent, AnySyncRoomEvent, AnySyncStateEvent, MessageEvent, StateEvent,
SyncMessageEvent, SyncStateEvent,
};
fn message_event() -> JsonValue {
@ -34,7 +34,7 @@ fn message_event() -> JsonValue {
})
}
fn message_event_stub() -> JsonValue {
fn message_event_sync() -> JsonValue {
json!({
"content": {
"body": "baba",
@ -69,7 +69,7 @@ fn aliases_event() -> JsonValue {
})
}
fn aliases_event_stub() -> JsonValue {
fn aliases_event_sync() -> JsonValue {
json!({
"content": {
"aliases": ["#somewhere:localhost"]
@ -86,7 +86,7 @@ fn aliases_event_stub() -> JsonValue {
}
#[test]
fn power_event_stub_deserialization() {
fn power_event_sync_deserialization() {
let json_data = json!({
"content": {
"ban": 50,
@ -118,9 +118,9 @@ fn power_event_stub_deserialization() {
});
assert_matches!(
from_json_value::<AnyRoomEventStub>(json_data),
Ok(AnyRoomEventStub::State(
AnyStateEventStub::RoomPowerLevels(StateEventStub {
from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnySyncRoomEvent::State(
AnySyncStateEvent::RoomPowerLevels(SyncStateEvent {
content: PowerLevelsEventContent {
ban, ..
},
@ -132,13 +132,13 @@ fn power_event_stub_deserialization() {
}
#[test]
fn message_event_stub_deserialization() {
let json_data = message_event_stub();
fn message_event_sync_deserialization() {
let json_data = message_event_sync();
assert_matches!(
from_json_value::<AnyRoomEventStub>(json_data),
Ok(AnyRoomEventStub::Message(
AnyMessageEventStub::RoomMessage(MessageEventStub {
from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnySyncRoomEvent::Message(
AnySyncMessageEvent::RoomMessage(SyncMessageEvent {
content: MessageEventContent::Text(TextMessageEventContent {
body,
formatted: Some(formatted),
@ -152,13 +152,13 @@ fn message_event_stub_deserialization() {
}
#[test]
fn aliases_event_stub_deserialization() {
let json_data = aliases_event_stub();
fn aliases_event_sync_deserialization() {
let json_data = aliases_event_sync();
assert_matches!(
from_json_value::<AnyRoomEventStub>(json_data),
Ok(AnyRoomEventStub::State(
AnyStateEventStub::RoomAliases(StateEventStub {
from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnySyncRoomEvent::State(
AnySyncStateEvent::RoomAliases(SyncStateEvent {
content: AliasesEventContent {
aliases,
},

30
ruma-events/tests/redacted.rs
View File

@ -12,9 +12,9 @@ use ruma_events::{
message::RedactedMessageEventContent,
redaction::{RedactionEvent, RedactionEventContent},
},
AnyRedactedMessageEvent, AnyRedactedMessageEventStub, AnyRedactedStateEventStub, AnyRoomEvent,
AnyRoomEventStub, EventJson, RedactedMessageEvent, RedactedMessageEventStub,
RedactedStateEventStub, UnsignedData,
AnyRedactedMessageEvent, AnyRedactedSyncMessageEvent, AnyRedactedSyncStateEvent, AnyRoomEvent,
AnySyncRoomEvent, EventJson, RedactedMessageEvent, RedactedSyncMessageEvent,
RedactedSyncStateEvent, UnsignedData,
};
use ruma_identifiers::{EventId, RoomId, UserId};
use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
@ -25,7 +25,7 @@ fn is_zst<T>(_: &T) -> bool {
#[test]
fn redacted_message_event_serialize() {
let redacted = RedactedMessageEventStub {
let redacted = RedactedSyncMessageEvent {
content: RedactedMessageEventContent,
event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(),
origin_server_ts: UNIX_EPOCH + Duration::from_millis(1),
@ -46,7 +46,7 @@ fn redacted_message_event_serialize() {
#[test]
fn redacted_aliases_event_serialize() {
let redacted = RedactedStateEventStub {
let redacted = RedactedSyncStateEvent {
content: RedactedAliasesEventContent { aliases: None },
event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(),
state_key: "".to_string(),
@ -108,9 +108,9 @@ fn redacted_deserialize_any_room() {
}
#[test]
fn redacted_deserialize_any_room_stub() {
fn redacted_deserialize_any_room_sync() {
let mut unsigned = UnsignedData::default();
// The presence of `redacted_because` triggers the event enum (AnyRoomEventStub in this case)
// The presence of `redacted_because` triggers the event enum (AnySyncRoomEvent in this case)
// to return early with `RedactedContent` instead of failing to deserialize according
// to the event type string.
unsigned.redacted_because = Some(EventJson::from(RedactionEvent {
@ -134,11 +134,11 @@ fn redacted_deserialize_any_room_stub() {
let actual = to_json_value(&redacted).unwrap();
assert_matches!(
from_json_value::<EventJson<AnyRoomEventStub>>(actual)
from_json_value::<EventJson<AnySyncRoomEvent>>(actual)
.unwrap()
.deserialize()
.unwrap(),
AnyRoomEventStub::RedactedMessage(AnyRedactedMessageEventStub::RoomMessage(RedactedMessageEventStub {
AnySyncRoomEvent::RedactedMessage(AnyRedactedSyncMessageEvent::RoomMessage(RedactedSyncMessageEvent {
event_id, content, ..
})) if event_id == EventId::try_from("$h29iv0s8:example.com").unwrap()
&& is_zst(&content)
@ -171,11 +171,11 @@ fn redacted_state_event_deserialize() {
});
assert_matches!(
from_json_value::<EventJson<AnyRoomEventStub>>(redacted)
from_json_value::<EventJson<AnySyncRoomEvent>>(redacted)
.unwrap()
.deserialize()
.unwrap(),
AnyRoomEventStub::RedactedState(AnyRedactedStateEventStub::RoomCreate(RedactedStateEventStub {
AnySyncRoomEvent::RedactedState(AnyRedactedSyncStateEvent::RoomCreate(RedactedSyncStateEvent {
content: RedactedCreateEventContent {
creator,
},
@ -210,11 +210,11 @@ fn redacted_custom_event_serialize() {
});
assert_matches!(
from_json_value::<EventJson<AnyRoomEventStub>>(redacted.clone())
from_json_value::<EventJson<AnySyncRoomEvent>>(redacted.clone())
.unwrap()
.deserialize()
.unwrap(),
AnyRoomEventStub::RedactedState(AnyRedactedStateEventStub::Custom(RedactedStateEventStub {
AnySyncRoomEvent::RedactedState(AnyRedactedSyncStateEvent::Custom(RedactedSyncStateEvent {
content: RedactedCustomEventContent {
event_type,
},
@ -225,7 +225,7 @@ fn redacted_custom_event_serialize() {
&& event_type == "m.made.up"
);
let x = from_json_value::<EventJson<crate::AnyRedactedStateEventStub>>(redacted)
let x = from_json_value::<EventJson<crate::AnyRedactedSyncStateEvent>>(redacted)
.unwrap()
.deserialize()
.unwrap();
@ -245,7 +245,7 @@ fn redacted_custom_event_deserialize() {
unsigned: UnsignedData::default(),
}));
let redacted = RedactedStateEventStub {
let redacted = RedactedSyncStateEvent {
content: RedactedCustomEventContent { event_type: "m.made.up".to_string() },
event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(),
sender: UserId::try_from("@carl:example.com").unwrap(),

8
ruma-events/tests/state_event.rs
View File

@ -7,7 +7,7 @@ use js_int::UInt;
use matches::assert_matches;
use ruma_events::{
room::{aliases::AliasesEventContent, avatar::AvatarEventContent, ImageInfo, ThumbnailInfo},
AnyRoomEvent, AnyStateEvent, AnyStateEventContent, EventJson, StateEvent, StateEventStub,
AnyRoomEvent, AnyStateEvent, AnyStateEventContent, EventJson, StateEvent, SyncStateEvent,
UnsignedData,
};
use ruma_identifiers::{EventId, RoomAliasId, RoomId, UserId};
@ -132,13 +132,13 @@ fn deserialize_aliases_with_prev_content() {
}
#[test]
fn deserialize_aliases_stub_with_room_id() {
fn deserialize_aliases_sync_with_room_id() {
let json_data = aliases_event_with_prev_content();
assert_matches!(
from_json_value::<StateEventStub<AnyStateEventContent>>(json_data)
from_json_value::<SyncStateEvent<AnyStateEventContent>>(json_data)
.unwrap(),
StateEventStub {
SyncStateEvent {
content: AnyStateEventContent::RoomAliases(content),
event_id,
origin_server_ts,

18
ruma-events/tests/stripped.rs
View File

@ -3,14 +3,14 @@ use std::convert::TryFrom;
use js_int::uint;
use ruma_events::{
room::{join_rules::JoinRule, topic::TopicEventContent},
AnyStateEventContent, AnyStrippedStateEventStub, StrippedStateEventStub,
AnyStateEventContent, AnyStrippedStateEvent, StrippedStateEvent,
};
use ruma_identifiers::UserId;
use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
#[test]
fn serialize_stripped_state_event_any_content() {
let event = StrippedStateEventStub {
let event = StrippedStateEvent {
content: AnyStateEventContent::RoomTopic(TopicEventContent {
topic: "Testing room".to_string(),
}),
@ -32,7 +32,7 @@ fn serialize_stripped_state_event_any_content() {
#[test]
fn serialize_stripped_state_event_any_event() {
let event = AnyStrippedStateEventStub::RoomTopic(StrippedStateEventStub {
let event = AnyStrippedStateEvent::RoomTopic(StrippedStateEvent {
content: TopicEventContent { topic: "Testing room".to_string() },
state_key: "".to_string(),
sender: UserId::try_from("@example:localhost").unwrap(),
@ -95,9 +95,9 @@ fn deserialize_stripped_state_events() {
}
});
let event = from_json_value::<AnyStrippedStateEventStub>(name_event).unwrap();
let event = from_json_value::<AnyStrippedStateEvent>(name_event).unwrap();
match event {
AnyStrippedStateEventStub::RoomName(event) => {
AnyStrippedStateEvent::RoomName(event) => {
assert_eq!(event.content.name(), Some("Ruma"));
assert_eq!(event.state_key, "");
assert_eq!(event.sender.to_string(), "@example:localhost");
@ -105,9 +105,9 @@ fn deserialize_stripped_state_events() {
_ => unreachable!(),
}
let event = from_json_value::<AnyStrippedStateEventStub>(join_rules_event).unwrap();
let event = from_json_value::<AnyStrippedStateEvent>(join_rules_event).unwrap();
match event {
AnyStrippedStateEventStub::RoomJoinRules(event) => {
AnyStrippedStateEvent::RoomJoinRules(event) => {
assert_eq!(event.content.join_rule, JoinRule::Public);
assert_eq!(event.state_key, "");
assert_eq!(event.sender.to_string(), "@example:localhost");
@ -115,9 +115,9 @@ fn deserialize_stripped_state_events() {
_ => unreachable!(),
}
let event = from_json_value::<AnyStrippedStateEventStub>(avatar_event).unwrap();
let event = from_json_value::<AnyStrippedStateEvent>(avatar_event).unwrap();
match event {
AnyStrippedStateEventStub::RoomAvatar(event) => {
AnyStrippedStateEvent::RoomAvatar(event) => {
let image_info = event.content.info.unwrap();
assert_eq!(image_info.height.unwrap(), uint!(128));