1use js_int::Int;
6#[cfg(feature = "unstable-msc4293")]
7use ruma_common::canonical_json::RedactionEvent;
8use ruma_common::{
9 OwnedEventId, OwnedMxcUri, OwnedTransactionId, OwnedUserId, ServerSignatures, UserId,
10 room_version_rules::RedactionRules,
11 serde::{CanBeEmpty, Raw, StringEnum},
12};
13use ruma_macros::EventContent;
14use serde::{Deserialize, Serialize};
15
16use crate::{
17 AnyStrippedStateEvent, BundledStateRelations, PossiblyRedactedStateEventContent, PrivOwnedStr,
18 RedactContent, RedactedStateEventContent, StateEventType, StaticEventContent,
19};
20
21mod change;
22
23use self::change::membership_change;
24pub use self::change::{Change, MembershipChange, MembershipDetails};
25
26#[derive(Clone, Debug, Deserialize, Serialize, EventContent)]
47#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
48#[ruma_event(
49 type = "m.room.member",
50 kind = State,
51 state_key_type = OwnedUserId,
52 unsigned_type = RoomMemberUnsigned,
53 custom_redacted,
54 custom_possibly_redacted,
55)]
56pub struct RoomMemberEventContent {
57 #[serde(skip_serializing_if = "Option::is_none")]
62 #[cfg_attr(
63 feature = "compat-empty-string-null",
64 serde(default, deserialize_with = "ruma_common::serde::empty_string_as_none")
65 )]
66 pub avatar_url: Option<OwnedMxcUri>,
67
68 #[serde(skip_serializing_if = "Option::is_none")]
72 pub displayname: Option<String>,
73
74 #[serde(skip_serializing_if = "Option::is_none")]
77 pub is_direct: Option<bool>,
78
79 pub membership: MembershipState,
81
82 #[serde(skip_serializing_if = "Option::is_none")]
85 pub third_party_invite: Option<ThirdPartyInvite>,
86
87 #[cfg(feature = "unstable-msc2448")]
92 #[serde(rename = "xyz.amorgan.blurhash", skip_serializing_if = "Option::is_none")]
93 pub blurhash: Option<String>,
94
95 #[serde(skip_serializing_if = "Option::is_none")]
106 pub reason: Option<String>,
107
108 #[serde(rename = "join_authorised_via_users_server")]
110 #[serde(skip_serializing_if = "Option::is_none")]
111 pub join_authorized_via_users_server: Option<OwnedUserId>,
112
113 #[cfg(feature = "unstable-msc4293")]
115 #[serde(
116 default,
117 rename = "org.matrix.msc4293.redact_events",
118 skip_serializing_if = "ruma_common::serde::is_default"
119 )]
120 pub redact_events: bool,
121}
122
123impl RoomMemberEventContent {
124 pub fn new(membership: MembershipState) -> Self {
126 Self {
127 membership,
128 avatar_url: None,
129 displayname: None,
130 is_direct: None,
131 third_party_invite: None,
132 #[cfg(feature = "unstable-msc2448")]
133 blurhash: None,
134 reason: None,
135 join_authorized_via_users_server: None,
136 #[cfg(feature = "unstable-msc4293")]
137 redact_events: false,
138 }
139 }
140
141 pub fn details(&self) -> MembershipDetails<'_> {
146 MembershipDetails {
147 avatar_url: self.avatar_url.as_deref(),
148 displayname: self.displayname.as_deref(),
149 membership: &self.membership,
150 }
151 }
152
153 pub fn membership_change<'a>(
165 &'a self,
166 prev_details: Option<MembershipDetails<'a>>,
167 sender: &UserId,
168 state_key: &UserId,
169 ) -> MembershipChange<'a> {
170 membership_change(self.details(), prev_details, sender, state_key)
171 }
172}
173
174impl RedactContent for RoomMemberEventContent {
175 type Redacted = RedactedRoomMemberEventContent;
176
177 fn redact(self, rules: &RedactionRules) -> RedactedRoomMemberEventContent {
178 RedactedRoomMemberEventContent {
179 membership: self.membership,
180 third_party_invite: self.third_party_invite.and_then(|i| i.redact(rules)),
181 join_authorized_via_users_server: self
182 .join_authorized_via_users_server
183 .filter(|_| rules.keep_room_member_join_authorised_via_users_server),
184 }
185 }
186}
187
188#[derive(Clone, Debug, Deserialize, Serialize)]
192#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
193pub struct PossiblyRedactedRoomMemberEventContent {
194 #[serde(skip_serializing_if = "Option::is_none")]
199 #[cfg_attr(
200 feature = "compat-empty-string-null",
201 serde(default, deserialize_with = "ruma_common::serde::empty_string_as_none")
202 )]
203 pub avatar_url: Option<OwnedMxcUri>,
204
205 #[serde(skip_serializing_if = "Option::is_none")]
209 pub displayname: Option<String>,
210
211 #[serde(skip_serializing_if = "Option::is_none")]
214 pub is_direct: Option<bool>,
215
216 pub membership: MembershipState,
218
219 #[serde(skip_serializing_if = "Option::is_none")]
222 pub third_party_invite: Option<PossiblyRedactedThirdPartyInvite>,
223
224 #[cfg(feature = "unstable-msc2448")]
229 #[serde(rename = "xyz.amorgan.blurhash", skip_serializing_if = "Option::is_none")]
230 pub blurhash: Option<String>,
231
232 #[serde(skip_serializing_if = "Option::is_none")]
243 pub reason: Option<String>,
244
245 #[serde(rename = "join_authorised_via_users_server")]
247 #[serde(skip_serializing_if = "Option::is_none")]
248 pub join_authorized_via_users_server: Option<OwnedUserId>,
249
250 #[cfg(feature = "unstable-msc4293")]
256 #[serde(
257 default,
258 rename = "org.matrix.msc4293.redact_events",
259 skip_serializing_if = "ruma_common::serde::is_default"
260 )]
261 pub redact_events: bool,
262}
263
264impl PossiblyRedactedRoomMemberEventContent {
265 pub fn new(membership: MembershipState) -> Self {
267 Self {
268 membership,
269 avatar_url: None,
270 displayname: None,
271 is_direct: None,
272 third_party_invite: None,
273 #[cfg(feature = "unstable-msc2448")]
274 blurhash: None,
275 reason: None,
276 join_authorized_via_users_server: None,
277 #[cfg(feature = "unstable-msc4293")]
278 redact_events: false,
279 }
280 }
281
282 pub fn details(&self) -> MembershipDetails<'_> {
287 MembershipDetails {
288 avatar_url: self.avatar_url.as_deref(),
289 displayname: self.displayname.as_deref(),
290 membership: &self.membership,
291 }
292 }
293
294 pub fn membership_change<'a>(
306 &'a self,
307 prev_details: Option<MembershipDetails<'a>>,
308 sender: &UserId,
309 state_key: &UserId,
310 ) -> MembershipChange<'a> {
311 membership_change(self.details(), prev_details, sender, state_key)
312 }
313}
314
315impl PossiblyRedactedStateEventContent for PossiblyRedactedRoomMemberEventContent {
316 type StateKey = OwnedUserId;
317
318 fn event_type(&self) -> StateEventType {
319 StateEventType::RoomMember
320 }
321}
322
323impl StaticEventContent for PossiblyRedactedRoomMemberEventContent {
324 const TYPE: &'static str = RoomMemberEventContent::TYPE;
325 type IsPrefix = <RoomMemberEventContent as StaticEventContent>::IsPrefix;
326}
327
328impl RedactContent for PossiblyRedactedRoomMemberEventContent {
329 type Redacted = Self;
330
331 fn redact(self, rules: &RedactionRules) -> Self {
332 Self {
333 membership: self.membership,
334 third_party_invite: self.third_party_invite.and_then(|i| i.redact(rules)),
335 join_authorized_via_users_server: self
336 .join_authorized_via_users_server
337 .filter(|_| rules.keep_room_member_join_authorised_via_users_server),
338 avatar_url: None,
339 displayname: None,
340 is_direct: None,
341 #[cfg(feature = "unstable-msc2448")]
342 blurhash: None,
343 reason: None,
344 #[cfg(feature = "unstable-msc4293")]
345 redact_events: false,
346 }
347 }
348}
349
350impl From<RoomMemberEventContent> for PossiblyRedactedRoomMemberEventContent {
351 fn from(value: RoomMemberEventContent) -> Self {
352 let RoomMemberEventContent {
353 avatar_url,
354 displayname,
355 is_direct,
356 membership,
357 third_party_invite,
358 #[cfg(feature = "unstable-msc2448")]
359 blurhash,
360 reason,
361 join_authorized_via_users_server,
362 #[cfg(feature = "unstable-msc4293")]
363 redact_events,
364 } = value;
365
366 Self {
367 avatar_url,
368 displayname,
369 is_direct,
370 membership,
371 third_party_invite: third_party_invite.map(Into::into),
372 #[cfg(feature = "unstable-msc2448")]
373 blurhash,
374 reason,
375 join_authorized_via_users_server,
376 #[cfg(feature = "unstable-msc4293")]
377 redact_events,
378 }
379 }
380}
381
382impl From<RedactedRoomMemberEventContent> for PossiblyRedactedRoomMemberEventContent {
383 fn from(value: RedactedRoomMemberEventContent) -> Self {
384 let RedactedRoomMemberEventContent {
385 membership,
386 third_party_invite,
387 join_authorized_via_users_server,
388 } = value;
389
390 Self {
391 avatar_url: None,
392 displayname: None,
393 is_direct: None,
394 membership,
395 third_party_invite: third_party_invite.map(Into::into),
396 #[cfg(feature = "unstable-msc2448")]
397 blurhash: None,
398 reason: None,
399 join_authorized_via_users_server,
400 #[cfg(feature = "unstable-msc4293")]
401 redact_events: false,
402 }
403 }
404}
405
406#[derive(Clone, Debug, Deserialize, Serialize)]
408#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
409pub struct RedactedRoomMemberEventContent {
410 pub membership: MembershipState,
412
413 #[serde(skip_serializing_if = "Option::is_none")]
416 pub third_party_invite: Option<RedactedThirdPartyInvite>,
417
418 #[serde(rename = "join_authorised_via_users_server", skip_serializing_if = "Option::is_none")]
423 pub join_authorized_via_users_server: Option<OwnedUserId>,
424}
425
426impl RedactedRoomMemberEventContent {
427 pub fn new(membership: MembershipState) -> Self {
429 Self { membership, third_party_invite: None, join_authorized_via_users_server: None }
430 }
431
432 pub fn details(&self) -> MembershipDetails<'_> {
437 MembershipDetails { avatar_url: None, displayname: None, membership: &self.membership }
438 }
439
440 pub fn membership_change<'a>(
455 &'a self,
456 prev_details: Option<MembershipDetails<'a>>,
457 sender: &UserId,
458 state_key: &UserId,
459 ) -> MembershipChange<'a> {
460 membership_change(self.details(), prev_details, sender, state_key)
461 }
462}
463
464impl RedactedStateEventContent for RedactedRoomMemberEventContent {
465 type StateKey = OwnedUserId;
466
467 fn event_type(&self) -> StateEventType {
468 StateEventType::RoomMember
469 }
470}
471
472impl StaticEventContent for RedactedRoomMemberEventContent {
473 const TYPE: &'static str = RoomMemberEventContent::TYPE;
474 type IsPrefix = <RoomMemberEventContent as StaticEventContent>::IsPrefix;
475}
476
477impl RoomMemberEvent {
478 pub fn membership(&self) -> &MembershipState {
480 match self {
481 Self::Original(ev) => &ev.content.membership,
482 Self::Redacted(ev) => &ev.content.membership,
483 }
484 }
485
486 #[cfg(feature = "unstable-msc4293")]
494 pub fn should_redact_events(&self) -> bool {
495 if let Self::Original(ev) = self { ev.should_redact_events() } else { false }
496 }
497}
498
499impl SyncRoomMemberEvent {
500 pub fn membership(&self) -> &MembershipState {
502 match self {
503 Self::Original(ev) => &ev.content.membership,
504 Self::Redacted(ev) => &ev.content.membership,
505 }
506 }
507
508 #[cfg(feature = "unstable-msc4293")]
516 pub fn should_redact_events(&self) -> bool {
517 if let Self::Original(ev) = self { ev.should_redact_events() } else { false }
518 }
519}
520
521#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/doc/string_enum.md"))]
523#[derive(Clone, StringEnum)]
524#[ruma_enum(rename_all = "lowercase")]
525#[non_exhaustive]
526pub enum MembershipState {
527 Ban,
529
530 Invite,
532
533 Join,
535
536 Knock,
538
539 Leave,
541
542 #[doc(hidden)]
543 _Custom(PrivOwnedStr),
544}
545
546#[derive(Clone, Debug, Deserialize, Serialize)]
548#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
549pub struct ThirdPartyInvite {
550 pub display_name: String,
553
554 pub signed: Raw<SignedContent>,
558}
559
560impl ThirdPartyInvite {
561 pub fn new(display_name: String, signed: Raw<SignedContent>) -> Self {
563 Self { display_name, signed }
564 }
565
566 fn redact(self, rules: &RedactionRules) -> Option<RedactedThirdPartyInvite> {
571 rules
572 .keep_room_member_third_party_invite_signed
573 .then_some(RedactedThirdPartyInvite { signed: self.signed })
574 }
575}
576
577#[derive(Clone, Debug, Deserialize, Serialize)]
579#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
580pub struct RedactedThirdPartyInvite {
581 pub signed: Raw<SignedContent>,
585}
586
587#[derive(Clone, Debug, Deserialize, Serialize)]
589#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
590pub struct PossiblyRedactedThirdPartyInvite {
591 #[serde(skip_serializing_if = "Option::is_none")]
594 pub display_name: Option<String>,
595
596 pub signed: Raw<SignedContent>,
600}
601
602impl PossiblyRedactedThirdPartyInvite {
603 pub fn new(display_name: String, signed: Raw<SignedContent>) -> Self {
606 Self { display_name: Some(display_name), signed }
607 }
608
609 fn redact(self, rules: &RedactionRules) -> Option<Self> {
614 rules
615 .keep_room_member_third_party_invite_signed
616 .then_some(Self { display_name: None, signed: self.signed })
617 }
618}
619
620impl From<ThirdPartyInvite> for PossiblyRedactedThirdPartyInvite {
621 fn from(value: ThirdPartyInvite) -> Self {
622 let ThirdPartyInvite { display_name, signed } = value;
623 Self { display_name: Some(display_name), signed }
624 }
625}
626
627impl From<RedactedThirdPartyInvite> for PossiblyRedactedThirdPartyInvite {
628 fn from(value: RedactedThirdPartyInvite) -> Self {
629 let RedactedThirdPartyInvite { signed } = value;
630 Self { display_name: None, signed }
631 }
632}
633
634#[derive(Clone, Debug, Deserialize, Serialize)]
637#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
638pub struct SignedContent {
639 pub mxid: OwnedUserId,
643
644 pub signatures: ServerSignatures,
647
648 pub token: String,
650}
651
652impl SignedContent {
653 pub fn new(signatures: ServerSignatures, mxid: OwnedUserId, token: String) -> Self {
655 Self { mxid, signatures, token }
656 }
657}
658
659impl OriginalRoomMemberEvent {
660 pub fn details(&self) -> MembershipDetails<'_> {
665 self.content.details()
666 }
667
668 pub fn prev_content(&self) -> Option<&PossiblyRedactedRoomMemberEventContent> {
672 self.unsigned.prev_content.as_ref()
673 }
674
675 pub fn prev_sender(&self) -> Option<&UserId> {
679 self.unsigned.prev_sender.as_deref()
680 }
681
682 fn prev_details(&self) -> Option<MembershipDetails<'_>> {
683 self.prev_content().map(|c| c.details())
684 }
685
686 pub fn membership_change(&self) -> MembershipChange<'_> {
692 membership_change(self.details(), self.prev_details(), &self.sender, &self.state_key)
693 }
694
695 #[cfg(feature = "unstable-msc4293")]
703 pub fn should_redact_events(&self) -> bool {
704 self.content.redact_events
705 && self.state_key != self.sender
706 && matches!(self.content.membership, MembershipState::Ban | MembershipState::Leave)
707 }
708}
709
710impl RedactedRoomMemberEvent {
711 pub fn details(&self) -> MembershipDetails<'_> {
716 self.content.details()
717 }
718
719 pub fn membership_change<'a>(
729 &'a self,
730 prev_details: Option<MembershipDetails<'a>>,
731 ) -> MembershipChange<'a> {
732 membership_change(self.details(), prev_details, &self.sender, &self.state_key)
733 }
734
735 #[cfg(feature = "unstable-msc4293")]
743 pub fn should_redact_events(&self) -> bool {
744 false
746 }
747}
748
749impl OriginalSyncRoomMemberEvent {
750 pub fn details(&self) -> MembershipDetails<'_> {
755 self.content.details()
756 }
757
758 pub fn prev_content(&self) -> Option<&PossiblyRedactedRoomMemberEventContent> {
762 self.unsigned.prev_content.as_ref()
763 }
764
765 pub fn prev_sender(&self) -> Option<&UserId> {
769 self.unsigned.prev_sender.as_deref()
770 }
771
772 fn prev_details(&self) -> Option<MembershipDetails<'_>> {
773 self.prev_content().map(|c| c.details())
774 }
775
776 pub fn membership_change(&self) -> MembershipChange<'_> {
782 membership_change(self.details(), self.prev_details(), &self.sender, &self.state_key)
783 }
784
785 #[cfg(feature = "unstable-msc4293")]
793 pub fn should_redact_events(&self) -> bool {
794 self.content.redact_events
795 && self.state_key != self.sender
796 && matches!(self.content.membership, MembershipState::Ban | MembershipState::Leave)
797 }
798}
799
800impl RedactedSyncRoomMemberEvent {
801 pub fn details(&self) -> MembershipDetails<'_> {
806 self.content.details()
807 }
808
809 pub fn membership_change<'a>(
819 &'a self,
820 prev_details: Option<MembershipDetails<'a>>,
821 ) -> MembershipChange<'a> {
822 membership_change(self.details(), prev_details, &self.sender, &self.state_key)
823 }
824
825 #[cfg(feature = "unstable-msc4293")]
833 pub fn should_redact_events(&self) -> bool {
834 false
836 }
837}
838
839impl StrippedRoomMemberEvent {
840 pub fn details(&self) -> MembershipDetails<'_> {
845 self.content.details()
846 }
847
848 pub fn membership_change<'a>(
858 &'a self,
859 prev_details: Option<MembershipDetails<'a>>,
860 ) -> MembershipChange<'a> {
861 membership_change(self.details(), prev_details, &self.sender, &self.state_key)
862 }
863
864 #[cfg(feature = "unstable-msc4293")]
872 pub fn should_redact_events(&self) -> bool {
873 self.content.redact_events
874 && self.state_key != self.sender
875 && matches!(self.content.membership, MembershipState::Ban | MembershipState::Leave)
876 }
877}
878
879#[derive(Clone, Debug, Default, Deserialize)]
881#[cfg_attr(not(ruma_unstable_exhaustive_types), non_exhaustive)]
882pub struct RoomMemberUnsigned {
883 pub age: Option<Int>,
889
890 pub transaction_id: Option<OwnedTransactionId>,
893
894 pub replaces_state: Option<OwnedEventId>,
899
900 pub prev_content: Option<PossiblyRedactedRoomMemberEventContent>,
902
903 pub prev_sender: Option<OwnedUserId>,
908
909 #[serde(default)]
912 pub invite_room_state: Vec<Raw<AnyStrippedStateEvent>>,
913
914 #[serde(default)]
916 pub knock_room_state: Vec<Raw<AnyStrippedStateEvent>>,
917
918 #[serde(rename = "m.relations", default)]
922 pub relations: BundledStateRelations,
923}
924
925impl RoomMemberUnsigned {
926 pub fn new() -> Self {
928 Self::default()
929 }
930}
931
932impl CanBeEmpty for RoomMemberUnsigned {
933 fn is_empty(&self) -> bool {
939 let Self {
940 age,
941 transaction_id,
942 replaces_state,
943 prev_content,
944 prev_sender,
945 invite_room_state,
946 knock_room_state,
947 relations,
948 } = self;
949
950 age.is_none()
951 && transaction_id.is_none()
952 && replaces_state.is_none()
953 && prev_content.is_none()
954 && prev_sender.is_none()
955 && invite_room_state.is_empty()
956 && knock_room_state.is_empty()
957 && relations.is_empty()
958 }
959}
960
961#[cfg(feature = "unstable-msc4293")]
962impl RedactionEvent for OriginalRoomMemberEvent {}
963
964#[cfg(feature = "unstable-msc4293")]
965impl RedactionEvent for OriginalSyncRoomMemberEvent {}
966
967#[cfg(feature = "unstable-msc4293")]
968impl RedactionEvent for RoomMemberEvent {}
969
970#[cfg(feature = "unstable-msc4293")]
971impl RedactionEvent for SyncRoomMemberEvent {}
972
973#[cfg(test)]
974mod tests {
975 use assert_matches::assert_matches;
976 use js_int::uint;
977 use maplit::btreemap;
978 use ruma_common::{
979 MilliSecondsSinceUnixEpoch, ServerSigningKeyId, SigningKeyAlgorithm, serde::CanBeEmpty,
980 server_signing_key_version,
981 };
982 use serde_json::{from_value as from_json_value, json};
983 use strass::assert_variant_eq;
984
985 use super::{MembershipState, RoomMemberEventContent};
986 use crate::OriginalStateEvent;
987
988 #[test]
989 fn serde_with_no_prev_content() {
990 let json = json!({
991 "type": "m.room.member",
992 "content": {
993 "membership": "join"
994 },
995 "event_id": "$h29iv0s8:example.com",
996 "origin_server_ts": 1,
997 "room_id": "!n8f893n9:example.com",
998 "sender": "@carl:example.com",
999 "state_key": "@carl:example.com"
1000 });
1001
1002 let ev = from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap();
1003 assert_eq!(ev.event_id, "$h29iv0s8:example.com");
1004 assert_eq!(ev.origin_server_ts, MilliSecondsSinceUnixEpoch(uint!(1)));
1005 assert_eq!(ev.room_id, "!n8f893n9:example.com");
1006 assert_eq!(ev.sender, "@carl:example.com");
1007 assert_eq!(ev.state_key, "@carl:example.com");
1008 assert!(ev.unsigned.is_empty());
1009
1010 assert_eq!(ev.content.avatar_url, None);
1011 assert_eq!(ev.content.displayname, None);
1012 assert_eq!(ev.content.is_direct, None);
1013 assert_eq!(ev.content.membership, MembershipState::Join);
1014 assert_matches!(ev.content.third_party_invite, None);
1015 }
1016
1017 #[test]
1018 fn serde_with_prev_content() {
1019 let json = json!({
1020 "type": "m.room.member",
1021 "content": {
1022 "membership": "join"
1023 },
1024 "event_id": "$h29iv0s8:example.com",
1025 "origin_server_ts": 1,
1026 "room_id": "!n8f893n9:example.com",
1027 "sender": "@carl:example.com",
1028 "state_key": "@carl:example.com",
1029 "unsigned": {
1030 "prev_content": {
1031 "membership": "join"
1032 },
1033 },
1034 });
1035
1036 let ev = from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap();
1037 assert_eq!(ev.event_id, "$h29iv0s8:example.com");
1038 assert_eq!(ev.origin_server_ts, MilliSecondsSinceUnixEpoch(uint!(1)));
1039 assert_eq!(ev.room_id, "!n8f893n9:example.com");
1040 assert_eq!(ev.sender, "@carl:example.com");
1041 assert_eq!(ev.state_key, "@carl:example.com");
1042
1043 assert_eq!(ev.content.avatar_url, None);
1044 assert_eq!(ev.content.displayname, None);
1045 assert_eq!(ev.content.is_direct, None);
1046 assert_eq!(ev.content.membership, MembershipState::Join);
1047 assert_matches!(ev.content.third_party_invite, None);
1048
1049 let prev_content = ev.unsigned.prev_content.unwrap();
1050 assert_eq!(prev_content.avatar_url, None);
1051 assert_eq!(prev_content.displayname, None);
1052 assert_eq!(prev_content.is_direct, None);
1053 assert_eq!(prev_content.membership, MembershipState::Join);
1054 assert_matches!(prev_content.third_party_invite, None);
1055 }
1056
1057 #[test]
1058 fn serde_with_replaces_state() {
1059 let json = json!({
1060 "type": "m.room.member",
1061 "content": {
1062 "membership": "join"
1063 },
1064 "event_id": "$h29iv0s8:example.com",
1065 "origin_server_ts": 1,
1066 "room_id": "!n8f893n9:example.com",
1067 "sender": "@carl:example.com",
1068 "state_key": "@carl:example.com",
1069 "unsigned": {
1070 "replaces_state": "$replaced:example.com",
1071 },
1072 });
1073
1074 let ev = from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap();
1075 assert_variant_eq!(ev.unsigned.replaces_state, Some("$replaced:example.com"));
1076 assert!(!ev.unsigned.is_empty());
1077 }
1078
1079 #[test]
1080 fn serde_with_prev_sender() {
1081 let json = json!({
1082 "type": "m.room.member",
1083 "content": {
1084 "membership": "join"
1085 },
1086 "event_id": "$h29iv0s8:example.com",
1087 "origin_server_ts": 1,
1088 "room_id": "!n8f893n9:example.com",
1089 "sender": "@carl:example.com",
1090 "state_key": "@carl:example.com",
1091 "unsigned": {
1092 "prev_sender": "@alice:example.com",
1093 },
1094 });
1095
1096 let ev = from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap();
1097 assert_variant_eq!(ev.unsigned.prev_sender, Some("@alice:example.com"));
1098 assert_variant_eq!(ev.prev_sender(), Some("@alice:example.com"));
1099 assert!(!ev.unsigned.is_empty());
1100 }
1101
1102 #[test]
1103 fn serde_with_content_full() {
1104 let json = json!({
1105 "type": "m.room.member",
1106 "content": {
1107 "avatar_url": "mxc://example.org/SEsfnsuifSDFSSEF",
1108 "displayname": "Alice Margatroid",
1109 "is_direct": true,
1110 "membership": "invite",
1111 "third_party_invite": {
1112 "display_name": "alice",
1113 "signed": {
1114 "mxid": "@alice:example.org",
1115 "signatures": {
1116 "magic.forest": {
1117 "ed25519:3": "foobar"
1118 }
1119 },
1120 "token": "abc123"
1121 }
1122 }
1123 },
1124 "event_id": "$143273582443PhrSn:example.org",
1125 "origin_server_ts": 233,
1126 "room_id": "!jEsUZKDJdhlrceRyVU:example.org",
1127 "sender": "@alice:example.org",
1128 "state_key": "@alice:example.org"
1129 });
1130
1131 let ev = from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap();
1132 assert_eq!(ev.event_id, "$143273582443PhrSn:example.org");
1133 assert_eq!(ev.origin_server_ts, MilliSecondsSinceUnixEpoch(uint!(233)));
1134 assert_eq!(ev.room_id, "!jEsUZKDJdhlrceRyVU:example.org");
1135 assert_eq!(ev.sender, "@alice:example.org");
1136 assert_eq!(ev.state_key, "@alice:example.org");
1137 assert!(ev.unsigned.is_empty());
1138
1139 assert_variant_eq!(ev.content.avatar_url, Some("mxc://example.org/SEsfnsuifSDFSSEF"));
1140 assert_eq!(ev.content.displayname.as_deref(), Some("Alice Margatroid"));
1141 assert_eq!(ev.content.is_direct, Some(true));
1142 assert_eq!(ev.content.membership, MembershipState::Invite);
1143
1144 let third_party_invite = ev.content.third_party_invite.unwrap();
1145 assert_eq!(third_party_invite.display_name, "alice");
1146 let signed = third_party_invite.signed.deserialize().unwrap();
1147 assert_eq!(signed.mxid, "@alice:example.org");
1148 assert_eq!(signed.signatures.len(), 1);
1149 let server_signatures = signed.signatures.get("magic.forest").unwrap();
1150 assert_eq!(
1151 *server_signatures,
1152 btreemap! {
1153 ServerSigningKeyId::from_parts(
1154 SigningKeyAlgorithm::Ed25519,
1155 server_signing_key_version!("3")
1156 ) => "foobar".to_owned()
1157 }
1158 );
1159 assert_eq!(signed.token, "abc123");
1160 }
1161
1162 #[test]
1163 fn serde_with_prev_content_full() {
1164 let json = json!({
1165 "type": "m.room.member",
1166 "content": {
1167 "membership": "join",
1168 },
1169 "event_id": "$143273582443PhrSn:example.org",
1170 "origin_server_ts": 233,
1171 "room_id": "!jEsUZKDJdhlrceRyVU:example.org",
1172 "sender": "@alice:example.org",
1173 "state_key": "@alice:example.org",
1174 "unsigned": {
1175 "prev_content": {
1176 "avatar_url": "mxc://example.org/SEsfnsuifSDFSSEF",
1177 "displayname": "Alice Margatroid",
1178 "is_direct": true,
1179 "membership": "invite",
1180 "third_party_invite": {
1181 "display_name": "alice",
1182 "signed": {
1183 "mxid": "@alice:example.org",
1184 "signatures": {
1185 "magic.forest": {
1186 "ed25519:3": "foobar",
1187 },
1188 },
1189 "token": "abc123"
1190 },
1191 },
1192 },
1193 },
1194 });
1195
1196 let ev = from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap();
1197 assert_eq!(ev.event_id, "$143273582443PhrSn:example.org");
1198 assert_eq!(ev.origin_server_ts, MilliSecondsSinceUnixEpoch(uint!(233)));
1199 assert_eq!(ev.room_id, "!jEsUZKDJdhlrceRyVU:example.org");
1200 assert_eq!(ev.sender, "@alice:example.org");
1201 assert_eq!(ev.state_key, "@alice:example.org");
1202
1203 assert_eq!(ev.content.avatar_url, None);
1204 assert_eq!(ev.content.displayname, None);
1205 assert_eq!(ev.content.is_direct, None);
1206 assert_eq!(ev.content.membership, MembershipState::Join);
1207 assert_matches!(ev.content.third_party_invite, None);
1208
1209 let prev_content = ev.unsigned.prev_content.unwrap();
1210 assert_variant_eq!(prev_content.avatar_url, Some("mxc://example.org/SEsfnsuifSDFSSEF"));
1211 assert_eq!(prev_content.displayname.as_deref(), Some("Alice Margatroid"));
1212 assert_eq!(prev_content.is_direct, Some(true));
1213 assert_eq!(prev_content.membership, MembershipState::Invite);
1214
1215 let third_party_invite = prev_content.third_party_invite.unwrap();
1216 assert_eq!(third_party_invite.display_name.as_deref(), Some("alice"));
1217 let signed = third_party_invite.signed.deserialize().unwrap();
1218 assert_eq!(signed.mxid, "@alice:example.org");
1219 assert_eq!(signed.signatures.len(), 1);
1220 let server_signatures = signed.signatures.get("magic.forest").unwrap();
1221 assert_eq!(
1222 *server_signatures,
1223 btreemap! {
1224 ServerSigningKeyId::from_parts(
1225 SigningKeyAlgorithm::Ed25519,
1226 server_signing_key_version!("3")
1227 ) => "foobar".to_owned()
1228 }
1229 );
1230 assert_eq!(signed.token, "abc123");
1231 }
1232
1233 #[test]
1234 fn serde_with_join_authorized() {
1235 let json = json!({
1236 "type": "m.room.member",
1237 "content": {
1238 "membership": "join",
1239 "join_authorised_via_users_server": "@notcarl:example.com"
1240 },
1241 "event_id": "$h29iv0s8:example.com",
1242 "origin_server_ts": 1,
1243 "room_id": "!n8f893n9:example.com",
1244 "sender": "@carl:example.com",
1245 "state_key": "@carl:example.com"
1246 });
1247
1248 let ev = from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap();
1249 assert_eq!(ev.event_id, "$h29iv0s8:example.com");
1250 assert_eq!(ev.origin_server_ts, MilliSecondsSinceUnixEpoch(uint!(1)));
1251 assert_eq!(ev.room_id, "!n8f893n9:example.com");
1252 assert_eq!(ev.sender, "@carl:example.com");
1253 assert_eq!(ev.state_key, "@carl:example.com");
1254 assert!(ev.unsigned.is_empty());
1255
1256 assert_eq!(ev.content.avatar_url, None);
1257 assert_eq!(ev.content.displayname, None);
1258 assert_eq!(ev.content.is_direct, None);
1259 assert_eq!(ev.content.membership, MembershipState::Join);
1260 assert_matches!(ev.content.third_party_invite, None);
1261 assert_variant_eq!(
1262 ev.content.join_authorized_via_users_server,
1263 Some("@notcarl:example.com")
1264 );
1265 }
1266}