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

events: Further clean up tests

Browse Source
This commit is contained in:
Jonas Platte 2021-09-19 19:10:52 +02:00
parent 9929a3f8d5
commit 2bf17fd727
No known key found for this signature in database
GPG Key ID: CC154DE0E30B7C67
20 changed files with 65 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
crates/ruma-events/benches/event_deserialize.rs
View File

@ -53,10 +53,7 @@ fn deserialize_any_room_event(c: &mut Criterion) {
c.bench_function("deserialize to `AnyRoomEvent`", |b| {
b.iter(|| {
let _ = serde_json::from_value::<Raw<AnyRoomEvent>>(json_data.clone())
.unwrap()
.deserialize()
.unwrap();
let _ = serde_json::from_value::<AnyRoomEvent>(json_data.clone()).unwrap();
})
});
}
@ -67,10 +64,7 @@ fn deserialize_any_state_event(c: &mut Criterion) {
c.bench_function("deserialize to `AnyStateEvent`", |b| {
b.iter(|| {
let _ = serde_json::from_value::<Raw<AnyStateEvent>>(json_data.clone())
.unwrap()
.deserialize()
.unwrap();
let _ = serde_json::from_value::<AnyStateEvent>(json_data.clone()).unwrap();
})
});
}
@ -81,12 +75,9 @@ fn deserialize_specific_event(c: &mut Criterion) {
c.bench_function("deserialize to `StateEvent<PowerLevelsEventContent>`", |b| {
b.iter(|| {
let _ = serde_json::from_value::<Raw<StateEvent<PowerLevelsEventContent>>>(
json_data.clone(),
)
.unwrap()
.deserialize()
.unwrap();
let _ =
serde_json::from_value::<StateEvent<PowerLevelsEventContent>>(json_data.clone())
.unwrap();
})
});
}

4
crates/ruma-events/src/direct.rs
View File

@ -40,7 +40,6 @@ mod tests {
use std::{collections::BTreeMap, convert::TryFrom};
use ruma_identifiers::{RoomId, ServerName, UserId};
use ruma_serde::Raw;
use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
use super::{DirectEvent, DirectEventContent};
@ -78,8 +77,7 @@ mod tests {
"type": "m.direct"
});
let event: DirectEvent =
from_json_value::<Raw<_>>(json_data).unwrap().deserialize().unwrap();
let event: DirectEvent = from_json_value(json_data).unwrap();
let direct_rooms = event.content.get(&alice).unwrap();
assert!(direct_rooms.contains(&rooms[0]));

6
crates/ruma-events/src/ignored_user_list.rs
View File

@ -30,7 +30,6 @@ impl IgnoredUserListEventContent {
mod tests {
use matches::assert_matches;
use ruma_identifiers::user_id;
use ruma_serde::Raw;
use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
use super::{IgnoredUserListEvent, IgnoredUserListEventContent};
@ -68,10 +67,7 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<AnyGlobalAccountDataEvent>>(json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<AnyGlobalAccountDataEvent>(json).unwrap(),
AnyGlobalAccountDataEvent::IgnoredUserList(
IgnoredUserListEvent {
content: IgnoredUserListEventContent {

21
crates/ruma-events/src/key/verification/accept.rs
View File

@ -172,7 +172,6 @@ mod tests {
#[cfg(feature = "unstable-pre-spec")]
use ruma_identifiers::event_id;
use ruma_identifiers::user_id;
use ruma_serde::Raw;
use serde_json::{
from_value as from_json_value, json, to_value as to_json_value, Value as JsonValue,
};
@ -295,10 +294,7 @@ mod tests {
// Deserialize the content struct separately to verify `TryFromRaw` is implemented for it.
assert_matches!(
from_json_value::<Raw<AcceptToDeviceEventContent>>(json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<AcceptToDeviceEventContent>(json).unwrap(),
AcceptToDeviceEventContent {
transaction_id,
method: AcceptMethod::SasV1(SasV1Content {
@ -333,10 +329,7 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<ToDeviceEvent<AcceptToDeviceEventContent>>>(json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<ToDeviceEvent<AcceptToDeviceEventContent>>(json).unwrap(),
ToDeviceEvent {
sender,
content: AcceptToDeviceEventContent {
@ -372,10 +365,7 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<ToDeviceEvent<AcceptToDeviceEventContent>>>(json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<ToDeviceEvent<AcceptToDeviceEventContent>>(json).unwrap(),
ToDeviceEvent {
sender,
content: AcceptToDeviceEventContent {
@ -412,10 +402,7 @@ mod tests {
// Deserialize the content struct separately to verify `TryFromRaw` is implemented for it.
assert_matches!(
from_json_value::<Raw<AcceptEventContent>>(json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<AcceptEventContent>(json).unwrap(),
AcceptEventContent {
relates_to: Relation {
event_id

6
crates/ruma-events/src/key/verification/done.rs
View File

@ -49,7 +49,6 @@ impl DoneEventContent {
mod tests {
use matches::assert_matches;
use ruma_identifiers::event_id;
use ruma_serde::Raw;
use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
use super::DoneEventContent;
@ -83,10 +82,7 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<DoneEventContent>>(json_data)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<DoneEventContent>(json_data).unwrap(),
DoneEventContent {
relates_to: Relation {
event_id

11
crates/ruma-events/src/key/verification/ready.rs
View File

@ -73,7 +73,6 @@ impl ReadyEventContent {
mod tests {
use matches::assert_matches;
use ruma_identifiers::{event_id, DeviceIdBox};
use ruma_serde::Raw;
use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
use super::{ReadyEventContent, ReadyToDeviceEventContent};
@ -131,10 +130,7 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<ReadyEventContent>>(json_data)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<ReadyEventContent>(json_data).unwrap(),
ReadyEventContent {
from_device,
relates_to: Relation {
@ -153,10 +149,7 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<ReadyToDeviceEventContent>>(json_data)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<ReadyToDeviceEventContent>(json_data).unwrap(),
ReadyToDeviceEventContent {
from_device,
transaction_id,

31
crates/ruma-events/src/key/verification/start.rs
View File

@ -207,7 +207,6 @@ mod tests {
#[cfg(feature = "unstable-pre-spec")]
use ruma_identifiers::event_id;
use ruma_identifiers::user_id;
use ruma_serde::Raw;
use serde_json::{
from_value as from_json_value, json, to_value as to_json_value, Value as JsonValue,
};
@ -379,10 +378,7 @@ mod tests {
// Deserialize the content struct separately to verify `TryFromRaw` is implemented for it.
assert_matches!(
from_json_value::<Raw<StartToDeviceEventContent>>(json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<StartToDeviceEventContent>(json).unwrap(),
StartToDeviceEventContent {
from_device,
transaction_id,
@ -417,10 +413,7 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<ToDeviceEvent<StartToDeviceEventContent>>>(json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<ToDeviceEvent<StartToDeviceEventContent>>(json).unwrap(),
ToDeviceEvent {
sender,
content: StartToDeviceEventContent {
@ -456,10 +449,7 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<ToDeviceEvent<StartToDeviceEventContent>>>(json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<ToDeviceEvent<StartToDeviceEventContent>>(json).unwrap(),
ToDeviceEvent {
sender,
content: StartToDeviceEventContent {
@ -488,10 +478,7 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<ToDeviceEvent<StartToDeviceEventContent>>>(json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<ToDeviceEvent<StartToDeviceEventContent>>(json).unwrap(),
ToDeviceEvent {
sender,
content: StartToDeviceEventContent {
@ -527,10 +514,7 @@ mod tests {
// Deserialize the content struct separately to verify `TryFromRaw` is implemented for it.
assert_matches!(
from_json_value::<Raw<StartEventContent>>(json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<StartEventContent>(json).unwrap(),
StartEventContent {
from_device,
relates_to: Relation { event_id },
@ -559,10 +543,7 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<StartEventContent>>(json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<StartEventContent>(json).unwrap(),
StartEventContent {
from_device,
relates_to: Relation { event_id },

17
crates/ruma-events/src/room/canonical_alias.rs
View File

@ -42,7 +42,6 @@ mod tests {
use js_int::uint;
use ruma_common::MilliSecondsSinceUnixEpoch;
use ruma_identifiers::{event_id, room_alias_id, room_id, user_id};
use ruma_serde::Raw;
use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
use super::CanonicalAliasEventContent;
@ -93,9 +92,7 @@ mod tests {
});
assert_eq!(
from_json_value::<Raw<StateEvent<CanonicalAliasEventContent>>>(json_data)
.unwrap()
.deserialize()
from_json_value::<StateEvent<CanonicalAliasEventContent>>(json_data)
.unwrap()
.content
.alias,
@ -117,9 +114,7 @@ mod tests {
"type": "m.room.canonical_alias"
});
assert_eq!(
from_json_value::<Raw<StateEvent<CanonicalAliasEventContent>>>(json_data)
.unwrap()
.deserialize()
from_json_value::<StateEvent<CanonicalAliasEventContent>>(json_data)
.unwrap()
.content
.alias,
@ -141,9 +136,7 @@ mod tests {
"type": "m.room.canonical_alias"
});
assert_eq!(
from_json_value::<Raw<StateEvent<CanonicalAliasEventContent>>>(json_data)
.unwrap()
.deserialize()
from_json_value::<StateEvent<CanonicalAliasEventContent>>(json_data)
.unwrap()
.content
.alias,
@ -166,9 +159,7 @@ mod tests {
"type": "m.room.canonical_alias"
});
assert_eq!(
from_json_value::<Raw<StateEvent<CanonicalAliasEventContent>>>(json_data)
.unwrap()
.deserialize()
from_json_value::<StateEvent<CanonicalAliasEventContent>>(json_data)
.unwrap()
.content
.alias,

11
crates/ruma-events/src/room/create.rs
View File

@ -108,7 +108,6 @@ fn default_room_version_id() -> RoomVersionId {
mod tests {
use matches::assert_matches;
use ruma_identifiers::{user_id, RoomVersionId};
use ruma_serde::Raw;
use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
use super::CreateEventContent;
@ -166,10 +165,7 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<CreateEventContent>>(json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<CreateEventContent>(json).unwrap(),
CreateEventContent {
creator,
federate: true,
@ -192,10 +188,7 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<CreateEventContent>>(json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<CreateEventContent>(json).unwrap(),
CreateEventContent {
creator,
federate: true,

11
crates/ruma-events/src/room/encrypted.rs
View File

@ -343,11 +343,7 @@ mod tests {
},
});
let content: EncryptedEventContent =
from_json_value::<Raw<EncryptedEventContent>>(json_data)
.unwrap()
.deserialize()
.unwrap();
let content: EncryptedEventContent = from_json_value(json_data).unwrap();
assert_matches!(
content.scheme,
@ -381,10 +377,7 @@ mod tests {
},
"algorithm": "m.olm.v1.curve25519-aes-sha2"
});
let content = from_json_value::<Raw<EncryptedEventContent>>(json_data)
.unwrap()
.deserialize()
.unwrap();
let content: EncryptedEventContent = from_json_value(json_data).unwrap();
match content.scheme {
EncryptedEventScheme::OlmV1Curve25519AesSha2(c) => {

38
crates/ruma-events/src/room/member.rs
View File

@ -338,7 +338,6 @@ mod tests {
use matches::assert_matches;
use ruma_common::MilliSecondsSinceUnixEpoch;
use ruma_identifiers::{server_name, server_signing_key_id};
use ruma_serde::Raw;
use serde_json::{from_value as from_json_value, json};
use super::{MemberEventContent, MembershipState, SignedContent, ThirdPartyInvite};
@ -359,11 +358,8 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<StateEvent<MemberEventContent>>>(json)
.unwrap()
.deserialize()
.unwrap(),
StateEvent::<MemberEventContent> {
from_json_value::<StateEvent<MemberEventContent>>(json).unwrap(),
StateEvent {
content: MemberEventContent {
avatar_url: None,
displayname: None,
@ -406,11 +402,8 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<StateEvent<MemberEventContent>>>(json)
.unwrap()
.deserialize()
.unwrap(),
StateEvent::<MemberEventContent> {
from_json_value::<StateEvent<MemberEventContent>>(json).unwrap(),
StateEvent {
content: MemberEventContent {
avatar_url: None,
displayname: None,
@ -472,11 +465,8 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<StateEvent<MemberEventContent>>>(json)
.unwrap()
.deserialize()
.unwrap(),
StateEvent::<MemberEventContent> {
from_json_value::<StateEvent<MemberEventContent>>(json).unwrap(),
StateEvent {
content: MemberEventContent {
avatar_url: Some(avatar_url),
displayname: Some(displayname),
@ -547,11 +537,8 @@ mod tests {
});
assert_matches!(
from_json_value::<Raw<StateEvent<MemberEventContent>>>(json)
.unwrap()
.deserialize()
.unwrap(),
StateEvent::<MemberEventContent> {
from_json_value::<StateEvent<MemberEventContent>>(json).unwrap(),
StateEvent {
content: MemberEventContent {
avatar_url: None,
displayname: None,
@ -597,7 +584,7 @@ mod tests {
#[cfg(feature = "compat")]
assert_matches!(
from_json_value::<Raw<StateEvent<MemberEventContent>>>(json!({
from_json_value::<StateEvent<MemberEventContent>>(json!({
"type": "m.room.member",
"content": {
"membership": "join"
@ -625,11 +612,8 @@ mod tests {
"room_id": "!jEsUZKDJdhlrceRyVU:example.org",
"sender": "@alice:example.org",
"state_key": "@alice:example.org"
}))
.unwrap()
.deserialize()
.unwrap(),
StateEvent::<MemberEventContent> {
})).unwrap(),
StateEvent {
content: MemberEventContent {
avatar_url: None,
displayname: None,

28
crates/ruma-events/src/room/name.rs
View File

@ -116,12 +116,7 @@ mod tests {
"type": "m.room.name"
});
assert_eq!(
from_json_value::<Raw<StateEvent<NameEventContent>>>(json_data)
.unwrap()
.deserialize()
.unwrap()
.content
.name,
from_json_value::<StateEvent<NameEventContent>>(json_data).unwrap().content.name,
None
);
}
@ -168,12 +163,7 @@ mod tests {
"type": "m.room.name"
});
assert_eq!(
from_json_value::<Raw<StateEvent<NameEventContent>>>(json_data)
.unwrap()
.deserialize()
.unwrap()
.content
.name,
from_json_value::<StateEvent<NameEventContent>>(json_data).unwrap().content.name,
None
);
}
@ -192,12 +182,7 @@ mod tests {
"type": "m.room.name"
});
assert_eq!(
from_json_value::<Raw<StateEvent<NameEventContent>>>(json_data)
.unwrap()
.deserialize()
.unwrap()
.content
.name,
from_json_value::<StateEvent<NameEventContent>>(json_data).unwrap().content.name,
None
);
}
@ -218,12 +203,7 @@ mod tests {
});
assert_eq!(
from_json_value::<Raw<StateEvent<NameEventContent>>>(json_data)
.unwrap()
.deserialize()
.unwrap()
.content
.name,
from_json_value::<StateEvent<NameEventContent>>(json_data).unwrap().content.name,
name
);
}

8
crates/ruma-events/src/room/pinned_events.rs
View File

@ -31,7 +31,6 @@ mod tests {
use ruma_common::MilliSecondsSinceUnixEpoch;
use ruma_identifiers::{EventId, RoomId, ServerName, UserId};
use ruma_serde::Raw;
use super::PinnedEventsEventContent;
use crate::{StateEvent, Unsigned};
@ -56,11 +55,8 @@ mod tests {
};
let serialized_event = serde_json::to_string(&event).unwrap();
let parsed_event =
serde_json::from_str::<Raw<StateEvent<PinnedEventsEventContent>>>(&serialized_event)
.unwrap()
.deserialize()
.unwrap();
let parsed_event: StateEvent<PinnedEventsEventContent> =
serde_json::from_str(&serialized_event).unwrap();
assert_eq!(parsed_event.event_id, event.event_id);
assert_eq!(parsed_event.room_id, event.room_id);

7
crates/ruma-events/src/room/server_acl.rs
View File

@ -50,7 +50,6 @@ impl ServerAclEventContent {
#[cfg(test)]
mod tests {
use ruma_serde::Raw;
use serde_json::{from_value as from_json_value, json};
use super::ServerAclEventContent;
@ -68,10 +67,8 @@ mod tests {
"type": "m.room.server_acl"
});
let server_acl_event = from_json_value::<Raw<StateEvent<ServerAclEventContent>>>(json_data)
.unwrap()
.deserialize()
.unwrap();
let server_acl_event: StateEvent<ServerAclEventContent> =
from_json_value(json_data).unwrap();
assert!(server_acl_event.content.allow_ip_literals);
assert!(server_acl_event.content.allow.is_empty());

8
crates/ruma-events/tests/ephemeral_event.rs
View File

@ -3,7 +3,6 @@ use maplit::btreemap;
use matches::assert_matches;
use ruma_common::{receipt::ReceiptType, MilliSecondsSinceUnixEpoch};
use ruma_identifiers::{event_id, room_id, user_id};
use ruma_serde::Raw;
use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
use ruma_events::{
@ -42,10 +41,7 @@ fn deserialize_ephemeral_typing() {
});
assert_matches!(
from_json_value::<Raw<AnyEphemeralRoomEvent>>(json_data)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<AnyEphemeralRoomEvent>(json_data).unwrap(),
AnyEphemeralRoomEvent::Typing(EphemeralRoomEvent {
content: TypingEventContent { user_ids, .. },
room_id,
@ -104,7 +100,7 @@ fn deserialize_ephemeral_receipt() {
});
assert_matches!(
from_json_value::<Raw<AnyEphemeralRoomEvent>>(json_data).unwrap().deserialize().unwrap(),
from_json_value::<AnyEphemeralRoomEvent>(json_data).unwrap(),
AnyEphemeralRoomEvent::Receipt(EphemeralRoomEvent {
content: ReceiptEventContent(receipts),
room_id,

9
crates/ruma-events/tests/message_event.rs
View File

@ -116,7 +116,7 @@ fn deserialize_message_call_answer() {
});
assert_matches!(
from_json_value::<Raw<AnyMessageEvent>>(json_data).unwrap().deserialize().unwrap(),
from_json_value::<AnyMessageEvent>(json_data).unwrap(),
AnyMessageEvent::CallAnswer(MessageEvent {
content: AnswerEventContent {
answer: SessionDescription {
@ -170,7 +170,7 @@ fn deserialize_message_sticker() {
});
assert_matches!(
from_json_value::<Raw<AnyMessageEvent>>(json_data).unwrap().deserialize().unwrap(),
from_json_value::<AnyMessageEvent>(json_data).unwrap(),
AnyMessageEvent::Sticker(MessageEvent {
content: StickerEventContent {
body,
@ -240,15 +240,14 @@ fn deserialize_message_then_convert_to_full() {
"type": "m.call.answer"
});
let sync_ev =
from_json_value::<Raw<AnySyncMessageEvent>>(json_data).unwrap().deserialize().unwrap();
let sync_ev: AnySyncMessageEvent = from_json_value(json_data).unwrap();
// Test conversion method
let full = sync_ev.into_full_event(rid);
let full_json = to_json_value(full).unwrap();
assert_matches!(
from_json_value::<Raw<AnyMessageEvent>>(full_json).unwrap().deserialize().unwrap(),
from_json_value::<AnyMessageEvent>(full_json).unwrap(),
AnyMessageEvent::CallAnswer(MessageEvent {
content: AnswerEventContent {
answer: SessionDescription {

22
crates/ruma-events/tests/redacted.rs
View File

@ -16,7 +16,6 @@ use ruma_events::{
RedactedUnsigned, Unsigned,
};
use ruma_identifiers::{event_id, room_id, user_id, RoomVersionId};
use ruma_serde::Raw;
use serde_json::{
from_value as from_json_value, json, to_value as to_json_value, value::to_raw_value,
};
@ -119,10 +118,7 @@ fn redacted_aliases_deserialize() {
let actual = to_json_value(&redacted).unwrap();
assert_matches!(
from_json_value::<Raw<AnySyncRoomEvent>>(actual)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<AnySyncRoomEvent>(actual).unwrap(),
AnySyncRoomEvent::RedactedState(AnyRedactedSyncStateEvent::RoomAliases(
RedactedSyncStateEvent {
content: RedactedAliasesEventContent { aliases, .. },
@ -148,10 +144,7 @@ fn redacted_deserialize_any_room() {
let actual = to_json_value(&redacted).unwrap();
assert_matches!(
from_json_value::<Raw<AnyRoomEvent>>(actual)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<AnyRoomEvent>(actual).unwrap(),
AnyRoomEvent::RedactedMessage(AnyRedactedMessageEvent::RoomMessage(RedactedMessageEvent {
content: RedactedMessageEventContent { .. },
event_id, room_id, ..
@ -186,10 +179,7 @@ fn redacted_deserialize_any_room_sync() {
let actual = to_json_value(&redacted).unwrap();
assert_matches!(
from_json_value::<Raw<AnySyncRoomEvent>>(actual)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<AnySyncRoomEvent>(actual).unwrap(),
AnySyncRoomEvent::RedactedMessage(AnyRedactedSyncMessageEvent::RoomMessage(
RedactedSyncMessageEvent {
content: RedactedMessageEventContent { .. },
@ -215,9 +205,7 @@ fn redacted_state_event_deserialize() {
});
assert_matches!(
from_json_value::<Raw<AnySyncRoomEvent>>(redacted)
.unwrap()
.deserialize()
from_json_value::<AnySyncRoomEvent>(redacted)
.unwrap(),
AnySyncRoomEvent::RedactedState(AnyRedactedSyncStateEvent::RoomCreate(
RedactedSyncStateEvent {
@ -306,7 +294,7 @@ fn redact_method_properly_redacts() {
unsigned: Unsigned::default(),
};
let event = from_json_value::<Raw<AnyMessageEvent>>(ev).unwrap().deserialize().unwrap();
let event: AnyMessageEvent = from_json_value(ev).unwrap();
assert_matches!(
event.redact(redaction, &RoomVersionId::Version6),

6
crates/ruma-events/tests/redaction.rs
View File

@ -6,7 +6,6 @@ use ruma_events::{
AnyMessageEvent, Unsigned,
};
use ruma_identifiers::{event_id, room_id, user_id};
use ruma_serde::Raw;
use serde_json::{
from_value as from_json_value, json, to_value as to_json_value, Value as JsonValue,
};
@ -48,10 +47,7 @@ fn deserialize_redaction() {
let json_data = redaction();
assert_matches!(
from_json_value::<Raw<AnyMessageEvent>>(json_data)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<AnyMessageEvent>(json_data).unwrap(),
AnyMessageEvent::RoomRedaction(RedactionEvent {
content: RedactionEventContent { reason: Some(reas), .. },
redacts,

7
crates/ruma-events/tests/room_message.rs
View File

@ -118,8 +118,7 @@ fn custom_content_deserialization() {
"another_one".into() => json!("abab"),
};
let custom_event =
from_json_value::<Raw<MessageType>>(json_data).unwrap().deserialize().unwrap();
let custom_event: MessageType = from_json_value(json_data).unwrap();
assert_eq!(custom_event.msgtype(), "my_custom_msgtype");
assert_eq!(custom_event.body(), "my custom message");
@ -369,9 +368,7 @@ fn content_deserialization() {
});
assert_matches!(
from_json_value::<Raw<MessageEventContent>>(json_data)
.unwrap()
.deserialize()
from_json_value::<MessageEventContent>(json_data)
.unwrap(),
MessageEventContent {
msgtype: MessageType::Audio(AudioMessageEventContent {

14
crates/ruma-events/tests/state_event.rs
View File

@ -102,7 +102,7 @@ fn deserialize_aliases_with_prev_content() {
let json_data = aliases_event_with_prev_content();
assert_matches!(
from_json_value::<Raw<AnyStateEvent>>(json_data).unwrap().deserialize().unwrap(),
from_json_value::<AnyStateEvent>(json_data).unwrap(),
AnyStateEvent::RoomAliases(StateEvent {
content,
event_id,
@ -182,10 +182,7 @@ fn deserialize_avatar_without_prev_content() {
let expected_url = Some(expected_url);
assert_matches!(
from_json_value::<Raw<AnyStateEvent>>(json_data)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<AnyStateEvent>(json_data).unwrap(),
AnyStateEvent::RoomAvatar(StateEvent {
content: AvatarEventContent {
info: Some(info),
@ -281,17 +278,14 @@ fn deserialize_member_event_with_top_level_membership_field() {
fn deserialize_full_event_convert_to_sync() {
let json_data = aliases_event_with_prev_content();
let full_ev = from_json_value::<Raw<AnyStateEvent>>(json_data).unwrap().deserialize().unwrap();
let full_ev: AnyStateEvent = from_json_value(json_data).unwrap();
// Test conversion to sync event (without room_id field)
let sync: AnySyncStateEvent = full_ev.into();
let sync_json = to_json_value(sync).unwrap();
assert_matches!(
from_json_value::<Raw<AnySyncStateEvent>>(sync_json)
.unwrap()
.deserialize()
.unwrap(),
from_json_value::<AnySyncStateEvent>(sync_json).unwrap(),
AnySyncStateEvent::RoomAliases(SyncStateEvent {
content,
event_id,