mock NCTalk and add test to users with Mock

Author: Michel von Czettritz

Cargo.toml

@@ -20,6 +20,10 @@ exclude = [
   "tags",
 ]
 
+[dev-dependencies]
+mockall = { version = "0.13.0" }
+mockall_derive = { version = "0.13.0"}
+
 [dependencies]
 reqwest = { version = "0.12", features = ["json"] }
 tokio = { version = "1", features = ["full"] }

src/backend/nc_message.rs

@@ -2,7 +2,7 @@ use crate::backend::nc_request::NCReqDataMessage;
 use chrono::prelude::*;
 
 /// `NextCloud` message interface
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct NCMessage(NCReqDataMessage);
 
 impl From<NCReqDataMessage> for NCMessage {

src/backend/nc_request.rs

@@ -12,7 +12,7 @@ use reqwest::{
 use serde::{Deserialize, Deserializer, Serialize};
 use std::{collections::HashMap, error::Error};
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct NCRequest {
     base_url: String,
     client: Client,

src/backend/nc_room.rs

@@ -19,8 +19,17 @@ pub enum NCRoomTypes {
     NoteToSelf,
 }
 
+impl Default for NCRoomTypes {
+    fn default() -> Self {
+        NCRoomTypes::OneToOne
+    }
+}
+#[cfg(test)]
+use mockall::{automock, predicate::*};
+
+#[cfg_attr(test, automock)]
 #[async_trait]
-pub trait NCRoomInterface: Debug + Send + Display + Ord {
+pub trait NCRoomInterface: Debug + Send + Display + Ord + Default{
     fn get_last_room_level_message_id(&self) -> Option<i32>;
     fn has_unread(&self) -> bool;
     fn is_dm(&self) -> bool;
@@ -39,17 +48,17 @@ pub trait NCRoomInterface: Debug + Send + Display + Ord {
     async fn update_if_id_is_newer(
         &mut self,
         message_id: i32,
-        data_option: Option<&NCReqDataRoom>,
+        data_option: Option<NCReqDataRoom>,
     ) -> Result<(), Box<dyn std::error::Error>>;
     async fn send(&self, message: String) -> Result<String, Box<dyn std::error::Error>>;
     async fn update(
         &mut self,
-        data_option: Option<&NCReqDataRoom>,
+        data_option: Option<NCReqDataRoom>,
     ) -> Result<(), Box<dyn std::error::Error>>;
     async fn mark_as_read(&self) -> Result<(), Box<dyn std::error::Error>>;
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct NCRoom {
     requester: NCRequest,
     notifier: NCNotify,
@@ -239,7 +248,7 @@ impl NCRoomInterface for NCRoom {
 
     async fn update(
         &mut self,
-        data_option: Option<&NCReqDataRoom>,
+        data_option: Option<NCReqDataRoom>,
     ) -> Result<(), Box<dyn std::error::Error>> {
         if let Some(data) = data_option {
             self.room_data = data.clone();
@@ -289,7 +298,7 @@ impl NCRoomInterface for NCRoom {
     async fn update_if_id_is_newer(
         &mut self,
         message_id: i32,
-        data_option: Option<&NCReqDataRoom>,
+        data_option: Option<NCReqDataRoom>,
     ) -> Result<(), Box<dyn std::error::Error>> {
         use std::cmp::Ordering;
 
@@ -352,3 +361,39 @@ impl std::ops::Deref for NCRoom {
         &self.room_data.displayName
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    static BUTZ: &str = "Butz";
+    impl std::ops::Deref for MockNCRoomInterface {
+        type Target = str;
+        fn deref(&self) -> &Self::Target {
+            BUTZ
+        }
+    }
+impl Ord for MockNCRoomInterface {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.to_string().cmp(&other.to_string())
+    }
+}
+
+impl PartialOrd for MockNCRoomInterface {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl PartialEq for MockNCRoomInterface {
+    fn eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
+impl Eq for MockNCRoomInterface {}
+impl std::fmt::Display for MockNCRoomInterface {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+}

src/backend/nc_talk.rs

@@ -7,14 +7,14 @@ use crate::{
     config::{self},
 };
 use async_trait::async_trait;
-use core::panic;
 use itertools::Itertools;
 use std::{collections::HashMap, error::Error, fmt::Debug, path::PathBuf};
 
 use super::nc_room::{NCRoom, NCRoomTypes};
 
+
 #[async_trait]
-pub trait NCBackend: Debug + Send {
+pub trait NCBackend: Debug + Send + Default {
     type Room: NCRoomInterface;
     fn write_to_log(&mut self) -> Result<(), std::io::Error>;
     fn get_current_room_token(&self) -> &str;
@@ -24,14 +24,14 @@ pub trait NCBackend: Debug + Send {
     fn get_room_by_displayname(&self, name: &str) -> &str;
     fn get_dm_keys_display_name_mapping(&self) -> Vec<(String, String)>;
     fn get_group_keys_display_name_mapping(&self) -> Vec<(String, String)>;
-    fn get_room_keys(&self) -> Vec<&String>;
+    fn get_room_keys(&self) -> Vec<&'_ String>;
     async fn send_message(&mut self, message: String) -> Result<(), Box<dyn Error>>;
     async fn select_room(&mut self, token: String) -> Result<(), Box<dyn Error>>;
     async fn update_rooms(&mut self, force_update: bool) -> Result<(), Box<dyn Error>>;
     fn add_room(&mut self, room_option: Option<Self::Room>);
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct NCTalk {
     rooms: HashMap<String, NCRoom>,
     chat_data_path: PathBuf,
@@ -136,7 +136,7 @@ impl NCTalk {
                         json_room
                             .update_if_id_is_newer(
                                 message_id,
-                                Some(initial_message_ids.get(token).unwrap()),
+                                Some((*initial_message_ids.get(token).unwrap()).clone()),
                             )
                             .await?;
                         rooms.insert(token.clone(), json_room);
@@ -361,10 +361,10 @@ impl NCBackend for NCTalk {
                     .get_mut(room.token.as_str())
                     .ok_or("Failed to get Room ref.")?;
                 if force_update {
-                    room_ref.update(Some(&room)).await?;
+                    room_ref.update(Some(room)).await?;
                 } else {
                     room_ref
-                        .update_if_id_is_newer(room.lastMessage.id, Some(&room))
+                        .update_if_id_is_newer(room.lastMessage.id, Some(room))
                         .await?;
                 }
             } else {
@@ -389,10 +389,51 @@ impl NCBackend for NCTalk {
         }
     }
 }
+
+#[cfg(test)]
+use mockall::{mock, predicate::*};
+#[cfg(test)]
+use crate::backend::nc_room::MockNCRoomInterface;
+
+
+#[cfg(test)]
+mock!{
+    #[derive(Debug)]
+    pub NCTalk{}
+    #[async_trait]
+    impl NCBackend for NCTalk{
+        type Room = MockNCRoomInterface;
+        fn write_to_log(&mut self) -> Result<(), std::io::Error>;
+        fn get_current_room_token(&self) -> &str;
+        fn get_room(&self, token: &str) -> &<MockNCTalk as NCBackend>::Room;
+        fn get_current_room(&self) -> &<MockNCTalk as NCBackend>::Room;
+        fn get_unread_rooms(&self) -> Vec<String>;
+        fn get_room_by_displayname(&self, name: &str) -> &str;
+        fn get_dm_keys_display_name_mapping(&self) -> Vec<(String, String)>;
+        fn get_group_keys_display_name_mapping(&self) -> Vec<(String, String)>;
+        fn get_room_keys<'a>(&'a self) -> Vec<&'a String>;
+        async fn send_message(& mut self, message: String) -> Result<(), Box<dyn Error>>;
+        async fn select_room(&mut self, token: String) -> Result<(), Box<dyn Error>>;
+        async fn update_rooms(& mut self, force_update: bool) -> Result<(), Box<dyn Error>>;
+        fn add_room(&mut self, room_option: Option<<MockNCTalk as NCBackend>::Room>);
+    }
+}
+#[cfg(test)]
+impl std::fmt::Display for MockNCTalk {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+
 #[cfg(test)]
 mod tests {
+        // use crate::backend::nc_room::MockNCRoomInterface;
+
+        // use super::*;
+
+
 
-    // use super::*;
 
     // #[derive(Debug, Default)]
     // pub struct MockBackend {

src/ui/users.rs

@@ -75,20 +75,32 @@ impl<'a> StatefulWidget for &Users<'a> {
 #[cfg(test)]
 mod tests {
     use backend::TestBackend;
+    use crate::backend::{nc_request::NCReqDataParticipants, nc_room::MockNCRoomInterface, nc_talk::MockNCTalk};
 
     use super::*;
 
     #[test]
     fn render_users() {
+        let mut mock_nc_backend = MockNCTalk::new();
         let backend = TestBackend::new(10, 10);
         let mut terminal = Terminal::new(backend).unwrap();
-        let users = Users::new();
+        let mut users = Users::new();
+
+        let mut mock_room = MockNCRoomInterface::new();
+        let mut dummy_user = NCReqDataParticipants::default();
+        dummy_user.displayName = "Butz".to_string();
+        mock_room.expect_get_users().return_const(vec![dummy_user]);
+        mock_nc_backend.expect_get_current_room().once().return_const(mock_room);
+        users.update(&mock_nc_backend);
+
+
         terminal
             .draw(|frame| users.render_area(frame, Rect::new(0, 0, 8, 8)))
             .unwrap();
+
         let mut expected = Buffer::with_lines([
             "│Users    ",
-            "│         ",
+            "│Butz     ",
             "│         ",
             "│         ",
             "│         ",
@@ -103,7 +115,11 @@ mod tests {
         for x in 1..=7 {
             expected[(x, 0)].set_style(Style::new().green().on_black().bold());
         }
+        for x in 1..=7 {
+            expected[(x, 1)].set_style(Style::new().white().on_black().bold());
+        }
 
         terminal.backend().assert_buffer(&expected);
+
     }
 }