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

Run rustfmt.

Browse Source
This commit is contained in:
Jimmy Cuadra 2018-05-18 23:54:13 -07:00
parent 601f00e820
commit 3acc5c3a93
22 changed files with 282 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
src/collections/all.rs
View File

@ -1,7 +1,6 @@
//! Enums for heterogeneous collections of events, inclusive for every event type that implements
//! the trait of the same name.
use {CustomEvent, CustomRoomEvent, CustomStateEvent, EventType};
use call::answer::AnswerEvent;
use call::candidates::CandidatesEvent;
use call::hangup::HangupEvent;
@ -26,10 +25,11 @@ use room::third_party_invite::ThirdPartyInviteEvent;
use room::topic::TopicEvent;
use tag::TagEvent;
use typing::TypingEvent;
use {CustomEvent, CustomRoomEvent, CustomStateEvent, EventType};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::de::Error;
use serde_json::{Value, from_value};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::{from_value, Value};
/// A basic event, room event, or state event.
#[derive(Clone, Debug)]
@ -171,7 +171,10 @@ pub enum StateEvent {
}
impl Serialize for Event {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match *self {
Event::CallAnswer(ref event) => event.serialize(serializer),
Event::CallCandidates(ref event) => event.serialize(serializer),
@ -205,7 +208,10 @@ impl Serialize for Event {
}
impl<'de> Deserialize<'de> for Event {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value: Value = Deserialize::deserialize(deserializer)?;
let event_type_value = match value.get("type") {
@ -419,8 +425,9 @@ impl<'de> Deserialize<'de> for Event {
};
Ok(Event::CustomState(event))
} else if value.get("event_id").is_some() && value.get("room_id").is_some() &&
value.get("sender").is_some() {
} else if value.get("event_id").is_some() && value.get("room_id").is_some()
&& value.get("sender").is_some()
{
let event = match from_value::<CustomRoomEvent>(value) {
Ok(event) => event,
Err(error) => return Err(D::Error::custom(error.to_string())),
@ -441,7 +448,10 @@ impl<'de> Deserialize<'de> for Event {
}
impl Serialize for RoomEvent {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match *self {
RoomEvent::CallAnswer(ref event) => event.serialize(serializer),
RoomEvent::CallCandidates(ref event) => event.serialize(serializer),
@ -469,7 +479,10 @@ impl Serialize for RoomEvent {
}
impl<'de> Deserialize<'de> for RoomEvent {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value: Value = Deserialize::deserialize(deserializer)?;
let event_type_value = match value.get("type") {
@ -652,11 +665,11 @@ impl<'de> Deserialize<'de> for RoomEvent {
Ok(RoomEvent::CustomRoom(event))
}
}
EventType::Direct |
EventType::Presence |
EventType::Receipt |
EventType::Tag |
EventType::Typing => {
EventType::Direct
| EventType::Presence
| EventType::Receipt
| EventType::Tag
| EventType::Typing => {
return Err(D::Error::custom("not a room event".to_string()));
}
}
@ -664,7 +677,10 @@ impl<'de> Deserialize<'de> for RoomEvent {
}
impl Serialize for StateEvent {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match *self {
StateEvent::RoomAliases(ref event) => event.serialize(serializer),
StateEvent::RoomAvatar(ref event) => event.serialize(serializer),
@ -685,7 +701,10 @@ impl Serialize for StateEvent {
}
impl<'de> Deserialize<'de> for StateEvent {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value: Value = Deserialize::deserialize(deserializer)?;
let event_type_value = match value.get("type") {
@ -811,17 +830,17 @@ impl<'de> Deserialize<'de> for StateEvent {
Ok(StateEvent::CustomState(event))
}
EventType::CallAnswer |
EventType::CallCandidates |
EventType::CallHangup |
EventType::CallInvite |
EventType::Direct |
EventType::Presence |
EventType::Receipt |
EventType::RoomMessage |
EventType::RoomRedaction |
EventType::Tag |
EventType::Typing => {
EventType::CallAnswer
| EventType::CallCandidates
| EventType::CallHangup
| EventType::CallInvite
| EventType::Direct
| EventType::Presence
| EventType::Receipt
| EventType::RoomMessage
| EventType::RoomRedaction
| EventType::Tag
| EventType::Typing => {
return Err(D::Error::custom("not a state event".to_string()));
}
}

92
src/collections/only.rs
View File

@ -1,7 +1,6 @@
//! Enums for heterogeneous collections of events, exclusive to event types that implement "at
//! most" the trait of the same name.
use {CustomEvent, CustomRoomEvent, EventType};
use call::answer::AnswerEvent;
use call::candidates::CandidatesEvent;
use call::hangup::HangupEvent;
@ -13,10 +12,11 @@ use room::message::MessageEvent;
use room::redaction::RedactionEvent;
use tag::TagEvent;
use typing::TypingEvent;
use {CustomEvent, CustomRoomEvent, EventType};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::de::Error;
use serde_json::{Value, from_value};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::{from_value, Value};
pub use super::all::StateEvent;
@ -57,7 +57,10 @@ pub enum RoomEvent {
}
impl Serialize for Event {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match *self {
Event::Direct(ref event) => event.serialize(serializer),
Event::Presence(ref event) => event.serialize(serializer),
@ -70,7 +73,10 @@ impl Serialize for Event {
}
impl<'de> Deserialize<'de> for Event {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value: Value = Deserialize::deserialize(deserializer)?;
let event_type_value = match value.get("type") {
@ -132,21 +138,38 @@ impl<'de> Deserialize<'de> for Event {
Ok(Event::Custom(event))
}
EventType::CallAnswer | EventType::CallCandidates | EventType::CallHangup |
EventType::CallInvite | EventType::RoomAliases | EventType::RoomAvatar |
EventType::RoomCanonicalAlias | EventType::RoomCreate | EventType::RoomGuestAccess |
EventType::RoomHistoryVisibility | EventType::RoomJoinRules | EventType::RoomMember |
EventType::RoomMessage | EventType::RoomName | EventType::RoomPinnedEvents |
EventType::RoomPowerLevels | EventType::RoomRedaction | EventType::RoomThirdPartyInvite |
EventType::RoomTopic => {
return Err(D::Error::custom("not exclusively a basic event".to_string()));
EventType::CallAnswer
| EventType::CallCandidates
| EventType::CallHangup
| EventType::CallInvite
| EventType::RoomAliases
| EventType::RoomAvatar
| EventType::RoomCanonicalAlias
| EventType::RoomCreate
| EventType::RoomGuestAccess
| EventType::RoomHistoryVisibility
| EventType::RoomJoinRules
| EventType::RoomMember
| EventType::RoomMessage
| EventType::RoomName
| EventType::RoomPinnedEvents
| EventType::RoomPowerLevels
| EventType::RoomRedaction
| EventType::RoomThirdPartyInvite
| EventType::RoomTopic => {
return Err(D::Error::custom(
"not exclusively a basic event".to_string(),
));
}
}
}
}
impl Serialize for RoomEvent {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match *self {
RoomEvent::CallAnswer(ref event) => event.serialize(serializer),
RoomEvent::CallCandidates(ref event) => event.serialize(serializer),
@ -160,7 +183,10 @@ impl Serialize for RoomEvent {
}
impl<'de> Deserialize<'de> for RoomEvent {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value: Value = Deserialize::deserialize(deserializer)?;
let event_type_value = match value.get("type") {
@ -230,24 +256,24 @@ impl<'de> Deserialize<'de> for RoomEvent {
Ok(RoomEvent::CustomRoom(event))
}
EventType::Direct |
EventType::Presence |
EventType::Receipt |
EventType::RoomAliases |
EventType::RoomAvatar |
EventType::RoomCanonicalAlias |
EventType::RoomCreate |
EventType::RoomGuestAccess |
EventType::RoomHistoryVisibility |
EventType::RoomJoinRules |
EventType::RoomMember |
EventType::RoomName |
EventType::RoomPinnedEvents |
EventType::RoomPowerLevels |
EventType::RoomThirdPartyInvite |
EventType::RoomTopic |
EventType::Tag |
EventType::Typing => {
EventType::Direct
| EventType::Presence
| EventType::Receipt
| EventType::RoomAliases
| EventType::RoomAvatar
| EventType::RoomCanonicalAlias
| EventType::RoomCreate
| EventType::RoomGuestAccess
| EventType::RoomHistoryVisibility
| EventType::RoomJoinRules
| EventType::RoomMember
| EventType::RoomName
| EventType::RoomPinnedEvents
| EventType::RoomPowerLevels
| EventType::RoomThirdPartyInvite
| EventType::RoomTopic
| EventType::Tag
| EventType::Typing => {
return Err(D::Error::custom("not exclusively a room event".to_string()));
}
}

28
src/direct.rs
View File

@ -2,7 +2,7 @@
use std::collections::HashMap;
use ruma_identifiers::{UserId, RoomId};
use ruma_identifiers::{RoomId, UserId};
event! {
/// Informs the client about the rooms that are considered direct by a user.
@ -19,12 +19,12 @@ pub type DirectEventContent = HashMap<UserId, Vec<RoomId>>;
mod tests {
use std::collections::HashMap;
use ruma_identifiers::{UserId, RoomId};
use ruma_identifiers::{RoomId, UserId};
use serde_json::{from_str, to_string};
use super::super::EventType;
use collections;
use direct::{DirectEvent, DirectEventContent};
use super::super::EventType;
#[test]
fn serialization() {
@ -43,7 +43,8 @@ mod tests {
to_string(&event).unwrap(),
format!(
r#"{{"content":{{"{}":["{}"]}},"type":"m.direct"}}"#,
alice.to_string(), room[0].to_string()
alice.to_string(),
room[0].to_string()
)
);
}
@ -53,13 +54,18 @@ mod tests {
let alice = UserId::new("ruma.io").unwrap();
let rooms = vec![
RoomId::new("ruma.io").unwrap(),
RoomId::new("ruma.io").unwrap()
RoomId::new("ruma.io").unwrap(),
];
let json_data = format!(r#"{{
let json_data = format!(
r#"{{
"content": {{ "{}": ["{}", "{}"] }},
"type": "m.direct"
}}"#, alice.to_string(), rooms[0].to_string(), rooms[1].to_string());
}}"#,
alice.to_string(),
rooms[0].to_string(),
rooms[1].to_string()
);
let event = from_str::<DirectEvent>(&json_data).unwrap();
assert_eq!(event.event_type, EventType::Direct);
@ -75,8 +81,8 @@ mod tests {
let direct_rooms = event.content.get(&alice).unwrap();
assert!(direct_rooms.contains(&rooms[0]));
assert!(direct_rooms.contains(&rooms[1]));
},
_ => assert!(false)
}
_ => assert!(false),
};
match from_str::<collections::only::Event>(&json_data).unwrap() {
@ -86,8 +92,8 @@ mod tests {
let direct_rooms = event.content.get(&alice).unwrap();
assert!(direct_rooms.contains(&rooms[0]));
assert!(direct_rooms.contains(&rooms[1]));
},
_ => assert!(false)
}
_ => assert!(false),
};
}
}

30
src/lib.rs
View File

@ -102,17 +102,19 @@
extern crate ruma_identifiers;
extern crate ruma_signatures;
extern crate serde;
#[macro_use] extern crate serde_derive;
#[macro_use]
extern crate serde_derive;
extern crate serde_json;
use std::fmt::{Debug, Display, Formatter, Error as FmtError, Result as FmtResult};
use std::fmt::{Debug, Display, Error as FmtError, Formatter, Result as FmtResult};
use ruma_identifiers::{EventId, RoomId, UserId};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::de::{Error as SerdeError, Visitor};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::Value;
#[macro_use] mod macros;
#[macro_use]
mod macros;
pub mod call;
/// Enums for heterogeneous collections of events.
@ -188,7 +190,10 @@ pub enum EventType {
}
/// A basic event.
pub trait Event where Self: Debug + for<'a> Deserialize<'a> + Serialize {
pub trait Event
where
Self: Debug + for<'a> Deserialize<'a> + Serialize,
{
/// The event-type-specific payload this event carries.
type Content: Debug + for<'a> Deserialize<'a> + Serialize;
@ -308,13 +313,19 @@ impl<'a> From<&'a str> for EventType {
}
impl Serialize for EventType {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(&self.to_string())
}
}
impl<'de> Deserialize<'de> for EventType {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct EventTypeVisitor;
impl<'de> Visitor<'de> for EventTypeVisitor {
@ -324,7 +335,10 @@ impl<'de> Deserialize<'de> for EventType {
write!(formatter, "a Matrix event type as a string")
}
fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: SerdeError {
fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
where
E: SerdeError,
{
Ok(EventType::from(v))
}
}

6
src/macros.rs
View File

@ -65,7 +65,7 @@ macro_rules! impl_event {
&self.event_type
}
}
}
};
}
macro_rules! room_event {
@ -138,7 +138,7 @@ macro_rules! impl_room_event {
&self.sender
}
}
}
};
}
macro_rules! state_event {
@ -207,5 +207,5 @@ macro_rules! impl_state_event {
&self.state_key
}
}
}
};
}

28
src/room/message.rs
View File

@ -1,8 +1,8 @@
//! Types for the *m.room.message* event.
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::de::Error;
use serde_json::{Value, from_value};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::{from_value, Value};
use super::{ImageInfo, ThumbnailInfo};
@ -260,7 +260,10 @@ impl_enum! {
}
impl Serialize for MessageEventContent {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match *self {
MessageEventContent::Audio(ref content) => content.serialize(serializer),
MessageEventContent::Emote(ref content) => content.serialize(serializer),
@ -275,7 +278,10 @@ impl Serialize for MessageEventContent {
}
impl<'de> Deserialize<'de> for MessageEventContent {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value: Value = Deserialize::deserialize(deserializer)?;
let message_type_value = match value.get("msgtype") {
@ -361,18 +367,16 @@ impl<'de> Deserialize<'de> for MessageEventContent {
mod tests {
use serde_json::{from_str, to_string};
use super::{AudioMessageEventContent, MessageType, MessageEventContent};
use super::{AudioMessageEventContent, MessageEventContent, MessageType};
#[test]
fn serialization() {
let message_event_content = MessageEventContent::Audio(
AudioMessageEventContent {
let message_event_content = MessageEventContent::Audio(AudioMessageEventContent {
body: "test".to_string(),
info: None,
msgtype: MessageType::Audio,
url: "http://example.com/audio.mp3".to_string(),
}
);
});
assert_eq!(
to_string(&message_event_content).unwrap(),
@ -382,14 +386,12 @@ mod tests {
#[test]
fn deserialization() {
let message_event_content = MessageEventContent::Audio(
AudioMessageEventContent {
let message_event_content = MessageEventContent::Audio(AudioMessageEventContent {
body: "test".to_string(),
info: None,
msgtype: MessageType::Audio,
url: "http://example.com/audio.mp3".to_string(),
}
);
});
assert_eq!(
from_str::<MessageEventContent>(

6
src/room/pinned_events.rs
View File

@ -19,17 +19,15 @@ mod tests {
use ruma_identifiers::{EventId, RoomId, UserId};
use serde_json::{from_str, to_string};
use room::pinned_events::{PinnedEventsContent, PinnedEventsEvent};
use Event;
use EventType;
use RoomEvent;
use StateEvent;
use room::pinned_events::{PinnedEventsEvent, PinnedEventsContent};
#[test]
fn serialization_deserialization() {
let mut content: PinnedEventsContent = PinnedEventsContent {
pinned: Vec::new()
};
let mut content: PinnedEventsContent = PinnedEventsContent { pinned: Vec::new() };
content.pinned.push(EventId::new("example.com").unwrap());
content.pinned.push(EventId::new("example.com").unwrap());

56
src/stripped.rs
View File

@ -5,11 +5,10 @@
//! state event to be created, when the other fields can be inferred from a larger context, or where
//! the other fields are otherwise inapplicable.
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::de::Error;
use serde_json::{Value, from_value};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::{from_value, Value};
use EventType;
use room::aliases::AliasesEventContent;
use room::avatar::AvatarEventContent;
use room::canonical_alias::CanonicalAliasEventContent;
@ -22,6 +21,7 @@ use room::name::NameEventContent;
use room::power_levels::PowerLevelsEventContent;
use room::third_party_invite::ThirdPartyInviteEventContent;
use room::topic::TopicEventContent;
use EventType;
/// A stripped-down version of a state event that is included along with some other events.
#[derive(Clone, Debug)]
@ -76,7 +76,10 @@ pub struct StrippedStateContent<C> {
}
impl Serialize for StrippedState {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match *self {
StrippedState::RoomAliases(ref event) => event.serialize(serializer),
StrippedState::RoomAvatar(ref event) => event.serialize(serializer),
@ -95,7 +98,10 @@ impl Serialize for StrippedState {
}
impl<'de> Deserialize<'de> for StrippedState {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value: Value = Deserialize::deserialize(deserializer)?;
let event_type_value = match value.get("type") {
@ -116,7 +122,7 @@ impl<'de> Deserialize<'de> for StrippedState {
};
Ok(StrippedState::RoomAliases(event))
},
}
EventType::RoomAvatar => {
let event = match from_value::<StrippedRoomAvatar>(value) {
Ok(event) => event,
@ -124,7 +130,7 @@ impl<'de> Deserialize<'de> for StrippedState {
};
Ok(StrippedState::RoomAvatar(event))
},
}
EventType::RoomCanonicalAlias => {
let event = match from_value::<StrippedRoomCanonicalAlias>(value) {
Ok(event) => event,
@ -132,7 +138,7 @@ impl<'de> Deserialize<'de> for StrippedState {
};
Ok(StrippedState::RoomCanonicalAlias(event))
},
}
EventType::RoomCreate => {
let event = match from_value::<StrippedRoomCreate>(value) {
Ok(event) => event,
@ -140,7 +146,7 @@ impl<'de> Deserialize<'de> for StrippedState {
};
Ok(StrippedState::RoomCreate(event))
},
}
EventType::RoomGuestAccess => {
let event = match from_value::<StrippedRoomGuestAccess>(value) {
Ok(event) => event,
@ -148,7 +154,7 @@ impl<'de> Deserialize<'de> for StrippedState {
};
Ok(StrippedState::RoomGuestAccess(event))
},
}
EventType::RoomHistoryVisibility => {
let event = match from_value::<StrippedRoomHistoryVisibility>(value) {
Ok(event) => event,
@ -156,7 +162,7 @@ impl<'de> Deserialize<'de> for StrippedState {
};
Ok(StrippedState::RoomHistoryVisibility(event))
},
}
EventType::RoomJoinRules => {
let event = match from_value::<StrippedRoomJoinRules>(value) {
Ok(event) => event,
@ -164,7 +170,7 @@ impl<'de> Deserialize<'de> for StrippedState {
};
Ok(StrippedState::RoomJoinRules(event))
},
}
EventType::RoomMember => {
let event = match from_value::<StrippedRoomMember>(value) {
Ok(event) => event,
@ -172,7 +178,7 @@ impl<'de> Deserialize<'de> for StrippedState {
};
Ok(StrippedState::RoomMember(event))
},
}
EventType::RoomName => {
let event = match from_value::<StrippedRoomName>(value) {
Ok(event) => event,
@ -180,7 +186,7 @@ impl<'de> Deserialize<'de> for StrippedState {
};
Ok(StrippedState::RoomName(event))
},
}
EventType::RoomPowerLevels => {
let event = match from_value::<StrippedRoomPowerLevels>(value) {
Ok(event) => event,
@ -188,7 +194,7 @@ impl<'de> Deserialize<'de> for StrippedState {
};
Ok(StrippedState::RoomPowerLevels(event))
},
}
EventType::RoomThirdPartyInvite => {
let event = match from_value::<StrippedRoomThirdPartyInvite>(value) {
Ok(event) => event,
@ -196,7 +202,7 @@ impl<'de> Deserialize<'de> for StrippedState {
};
Ok(StrippedState::RoomThirdPartyInvite(event))
},
}
EventType::RoomTopic => {
let event = match from_value::<StrippedRoomTopic>(value) {
Ok(event) => event,
@ -204,7 +210,7 @@ impl<'de> Deserialize<'de> for StrippedState {
};
Ok(StrippedState::RoomTopic(event))
},
}
_ => {
return Err(D::Error::custom("not a state event".to_string()));
}
@ -250,18 +256,20 @@ pub type StrippedRoomTopic = StrippedStateContent<TopicEventContent>;
#[cfg(test)]
mod tests {
use EventType;
use super::{StrippedRoomTopic, StrippedState};
use room::join_rules::JoinRule;
use room::topic::TopicEventContent;
use serde_json::{from_str, to_string};
use super::{StrippedRoomTopic, StrippedState};
use EventType;
#[test]
fn serialize_stripped_state_event() {
let content = StrippedRoomTopic {
content: TopicEventContent { topic: "Testing room".to_string() },
content: TopicEventContent {
topic: "Testing room".to_string(),
},
state_key: "".to_string(),
event_type: EventType::RoomTopic
event_type: EventType::RoomTopic,
};
let event = StrippedState::RoomTopic(content);
@ -319,7 +327,7 @@ mod tests {
assert_eq!(event.content.name, "Ruma");
assert_eq!(event.event_type, EventType::RoomName);
assert_eq!(event.state_key, "");
},
}
_ => {
assert!(false);
}
@ -330,7 +338,7 @@ mod tests {
assert_eq!(event.content.join_rule, JoinRule::Public);
assert_eq!(event.event_type, EventType::RoomJoinRules);
assert_eq!(event.state_key, "");
},
}
_ => {
assert!(false);
}
@ -348,7 +356,7 @@ mod tests {
assert_eq!(event.content.url, "https://domain.com/image.jpg");
assert_eq!(event.event_type, EventType::RoomAvatar);
assert_eq!(event.state_key, "");
},
}
_ => {
assert!(false);
}