add tests

src/commander.rs

@@ -84,13 +84,13 @@ impl Commander {
         let user_name = self.socket_user.trim();
         let group_name = self.socket_group.trim();
 
-        let user_id = match self.get_id_by_name_and_flag(user_name, "-u") {
+        let user_id = match Commander::get_id_by_name_and_flag(user_name, "-u") {
             Some(id) => Some(id),
             None if user_name.is_empty() => None,
             None => return Err(format!("Could not find user {user_name}")),
         };
 
-        let group_id = match self.get_id_by_name_and_flag(group_name, "-g") {
+        let group_id = match Commander::get_id_by_name_and_flag(group_name, "-g") {
             Some(id) => Some(id),
             None if group_name.is_empty() => None,
             None => return Err(format!("Could not find group {group_name}")),
@@ -105,7 +105,37 @@ impl Commander {
         Ok(())
     }
 
-    fn get_id_by_name_and_flag(&self, name: &str, flag: &str) -> Option<u32> {
+    fn run_cycle(&self, stream: &mut UnixStream) -> Result<(), String> {
+        let msg = Commander::read_string(stream)?;
+
+        let commander_data: CommanderData = toml::from_str(&msg)
+            .map_err(|e| format!("Could not deserialize CommanderData: {e}"))?;
+
+        let command_name = &commander_data.command_name;
+        let command = self
+            .config
+            .get(command_name)
+            .ok_or(format!("Unknown command name: {}", command_name))?;
+
+        Commander::run_command(command, commander_data.ip);
+        Ok(())
+    }
+
+    fn run_command(command: &str, ip_str: String) {
+        info!("Running command {command}");
+        match Command::new("sh").arg("-c").arg(command).env("RUROCO_IP", ip_str).output() {
+            Ok(result) => {
+                info!(
+                    "Successfully executed {command}\nstdout: {}\nstderr: {}",
+                    Commander::vec_to_str(&result.stdout),
+                    Commander::vec_to_str(&result.stderr)
+                )
+            }
+            Err(e) => error!("Error executing {command}: {e}"),
+        };
+    }
+
+    fn get_id_by_name_and_flag(name: &str, flag: &str) -> Option<u32> {
         if name.is_empty() {
             return None;
         }
@@ -129,45 +159,32 @@ impl Commander {
         }
     }
 
-    fn read_string(&self, stream: &mut UnixStream) -> Result<String, String> {
+    fn read_string(stream: &mut UnixStream) -> Result<String, String> {
         let mut buffer = String::new();
         stream
             .read_to_string(&mut buffer)
             .map_err(|e| format!("Could not read command from Unix Stream to string: {e}"))?;
         Ok(buffer)
     }
 
-    fn run_cycle(&self, stream: &mut UnixStream) -> Result<(), String> {
-        let msg = self.read_string(stream)?;
-
-        let commander_data: CommanderData = toml::from_str(&msg)
-            .map_err(|e| format!("Could not deserialize CommanderData: {e}"))?;
-
-        let command_name = &commander_data.command_name;
-        let command = self
-            .config
-            .get(command_name)
-            .ok_or(format!("Unknown command name: {}", command_name))?;
-
-        self.run_command(command, commander_data.ip);
-        Ok(())
+    fn vec_to_str(stdout: &[u8]) -> &str {
+        str::from_utf8(stdout).unwrap_or("")
     }
+}
 
-    fn run_command(&self, command: &str, ip_str: String) {
-        info!("Running command {command}");
-        match Command::new("sh").arg("-c").arg(command).env("RUROCO_IP", ip_str).output() {
-            Ok(result) => {
-                info!(
-                    "Successfully executed {command}\nstdout: {}\nstderr: {}",
-                    Self::vec_to_str(&result.stdout),
-                    Self::vec_to_str(&result.stderr)
-                )
-            }
-            Err(e) => error!("Error executing {command}: {e}"),
-        };
+#[cfg(test)]
+mod tests {
+    use crate::commander::Commander;
+
+    #[test]
+    fn test_get_id_by_name_and_flag() {
+        assert_eq!(Commander::get_id_by_name_and_flag("root", "-u"), Some(0));
+        assert_eq!(Commander::get_id_by_name_and_flag("root", "-g"), Some(0));
     }
 
-    fn vec_to_str(stdout: &[u8]) -> &str {
-        str::from_utf8(stdout).unwrap_or("")
+    #[test]
+    fn test_get_id_by_name_and_flag_unknown_user() {
+        assert_eq!(Commander::get_id_by_name_and_flag("barfoobaz", "-u"), None);
+        assert_eq!(Commander::get_id_by_name_and_flag("barfoobaz", "-g"), None);
     }
 }

src/config_client.rs

@@ -59,3 +59,27 @@ fn validate_key_size(key_str: &str) -> Result<u32, String> {
         Err(e) => Err(format!("Could not parse {key_str} to u32: {e}")),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::config_client::{default_private_pem_path, validate_key_size};
+    use std::env;
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_validate_key_size() {
+        assert!(validate_key_size("invalid").is_err());
+        assert!(validate_key_size("1024").is_err());
+        assert!(validate_key_size("2048").is_err());
+        assert!(validate_key_size("4096").is_ok());
+        assert!(validate_key_size("8192").is_ok());
+    }
+
+    #[test]
+    fn test_default_private_pem_path() {
+        assert_eq!(
+            default_private_pem_path(),
+            PathBuf::from(env::var("HOME").unwrap()).join(".config/ruroco/ruroco_private.pem")
+        );
+    }
+}

tests/common_test.rs

@@ -0,0 +1,37 @@
+#[cfg(test)]
+mod tests {
+    use ruroco::common::{get_blocklist_path, get_socket_path, init_logger, resolve_path};
+    use std::path::PathBuf;
+    use std::{env, fs};
+
+    #[test]
+    fn test_get_blocklist_path() {
+        assert_eq!(
+            get_blocklist_path(&PathBuf::from("/foo/bar/baz")),
+            PathBuf::from("/foo/bar/baz/blocklist.toml")
+        );
+    }
+
+    #[test]
+    fn test_get_socket_path() {
+        assert_eq!(
+            get_socket_path(&PathBuf::from("/foo/bar/baz")),
+            PathBuf::from("/foo/bar/baz/ruroco.socket")
+        );
+    }
+
+    #[test]
+    fn test_resolve_absolute_path() {
+        assert_eq!(resolve_path(&PathBuf::from("/foo/bar/baz")), PathBuf::from("/foo/bar/baz"));
+    }
+
+    #[test]
+    fn test_resolve_relative_path() {
+        init_logger();
+        let _ = fs::create_dir_all(PathBuf::from("./tmp/foo"));
+        assert_eq!(
+            resolve_path(&PathBuf::from("./tmp/foo")),
+            env::current_dir().unwrap().join("tmp/foo")
+        );
+    }
+}