mx-bookmarks

A small bookmarks tui based on the matrix protocol and MSC2771
git clone git://archive.git.mtrnord.blog/MTRNord/mx-bookmarks.git
Log | Files | Refs | LICENSE

global.rs (4102B)

      1 //! Types for the *dev.nordgedanken.bookmarks.global* event.
      2 //! https://github.com/MTRNord/matrix-doc/blob/bookmarks-spec/proposals/2771-bookmarks.md#alternatives
      3 
      4 use std::{
      5     collections::BTreeMap,
      6     ops::{Deref, DerefMut},
      7 };
      8 
      9 use matrix_sdk::events::macros::BasicEventContent;
     10 use matrix_sdk::identifiers::{RoomId};
     11 use serde::{Deserialize, Serialize};
     12 use crate::extra_ruma::bookmarks::Bookmark;
     13 
     14 /// Informs the client about the events that are bookmarked by the user.
     15 pub type BookmarksEvent = matrix_sdk::events::BasicEvent<BookmarksEventContent>;
     16 
     17 /// The payload for `BookmarksEvent`.
     18 ///
     19 /// A mapping of `RoomId`s to a list of `EventId`s which are considered *bookmarked* for that
     20 /// particular room.
     21 #[derive(Clone, Debug, Deserialize, Serialize, BasicEventContent)]
     22 #[ruma_event(type = "dev.nordgedanken.bookmarks.global")]
     23 pub struct BookmarksEventContent(pub BTreeMap<RoomId, Vec<Bookmark>>);
     24 
     25 impl Deref for BookmarksEventContent {
     26     type Target = BTreeMap<RoomId, Vec<Bookmark>>;
     27 
     28     fn deref(&self) -> &Self::Target {
     29         &self.0
     30     }
     31 }
     32 
     33 impl DerefMut for BookmarksEventContent {
     34     fn deref_mut(&mut self) -> &mut Self::Target {
     35         &mut self.0
     36     }
     37 }
     38 
     39 #[cfg(test)]
     40 mod tests {
     41     use std::{collections::BTreeMap, convert::TryFrom};
     42 
     43     use matrix_sdk::Raw;
     44     use matrix_sdk::identifiers::{RoomId,  EventId};
     45     use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
     46 
     47     use super::{BookmarksEvent, BookmarksEventContent};
     48     use crate::extra_ruma::bookmarks::Bookmark;
     49     use std::borrow::Cow;
     50 
     51     #[test]
     52     fn serialization() {
     53         let mut content = BookmarksEventContent(BTreeMap::new());
     54         let event = EventId::try_from("$h29iv0s8:example.com").unwrap();
     55         let bookmark = Bookmark {
     56             event_id: event.clone(),
     57             title: "test".into(),
     58             comment: "test".into()        };
     59         let events = vec![bookmark.clone()];
     60         let room = RoomId::try_from("!123:ruma.io").unwrap();
     61 
     62         content.insert(room.clone(),events.clone() );
     63 
     64         let event = BookmarksEvent { content };
     65         let json_data = json!({
     66             "content": {
     67                 room.to_string(): vec![
     68                     json!({
     69                         "event_id": events[0].event_id,
     70                         "title": events[0].title,
     71                         "comment": events[0].comment,
     72                     })
     73                ]
     74             },
     75             "type": "dev.nordgedanken.bookmarks.global"
     76         });
     77 
     78         assert_eq!(to_json_value(&event).unwrap(), json_data);
     79     }
     80 
     81     #[test]
     82     fn deserialization() {
     83         let room = RoomId::try_from("!123:ruma.io").unwrap();
     84         let bookmark_one = Bookmark {
     85             event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(),
     86             title: Default::default(),
     87             comment: Default::default()
     88         };
     89         let bookmark_two = Bookmark {
     90             event_id: EventId::try_from("$h29iv0s9:example.com").unwrap(),
     91             title: Default::default(),
     92             comment: Default::default()
     93         };
     94         let events = vec![bookmark_one, bookmark_two];
     95 
     96         let json_data = json!({
     97             "content": {
     98                 room.to_string(): vec![
     99                         json!({
    100                             "event_id": events[0].event_id,
    101                             "title": events[0].title,
    102                             "comment": events[0].comment,
    103                         }),
    104                         json!({
    105                             "event_id": events[1].event_id,
    106                             "title": events[1].title,
    107                             "comment": events[1].comment,
    108                         }),
    109                     ],
    110             },
    111             "type": "dev.nordgedanken.bookmarks.global"
    112         });
    113 
    114         let event: BookmarksEvent =
    115             from_json_value::<Raw<_>>(json_data).unwrap().deserialize().unwrap();
    116         let bookmarks = event.content.get(&room).unwrap();
    117 
    118         assert!(bookmarks.contains(&events[0]));
    119         assert!(bookmarks.contains(&events[1]));
    120     }
    121 }