test: coverage config-related functions

Author: ankddev

src/commands.rs

@@ -15,7 +15,7 @@ use crate::variables;
 pub fn run_command<W: Write>(command: &Commands, config: Option<Config>, mut buffer: W) -> ExitCode {
     match command {
         Commands::InitConfig => {
-            if let Err(error) = config::init_config() {
+            if let Err(error) = config::init_config(config::get_config_file_path(), buffer) {
                 error!("{}", error);
                 return ExitCode::FAILURE;
             }

src/config.rs

@@ -1,45 +1,103 @@
-use std::{fs, io, path::PathBuf};
+use std::{fs, io::{self, Write}, path::PathBuf};
 
 use dirs::config_dir;
 
 use crate::models::{Config, ConfigParsingError};
 
-/// Get path to config file
+/// Get path to config directory
 fn get_config_dir() -> PathBuf {
     config_dir().unwrap_or_default()
 }
 
+/// Get path to config file
+pub fn get_config_file_path() -> PathBuf {
+    get_config_dir().join("envfetch.toml")
+}
+
 /// Read config file
-pub fn read_config() -> Result<Config, ConfigParsingError> {
-    let path = get_config_dir().join("envfetch.toml");
+pub fn read_config_from_file(path: PathBuf) -> Result<Config, ConfigParsingError> {
     if !path.exists() {
         return Err(ConfigParsingError::FileDoesntExists);
     }
 
     let content =
         fs::read_to_string(path).map_err(|err| ConfigParsingError::FSError(err.to_string()))?;
 
+    read_config(content)
+}
+
+/// Read config file
+fn read_config(content: String) -> Result<Config, ConfigParsingError> {
     toml::from_str::<Config>(&content)
         .map_err(|err| ConfigParsingError::ParsingError(err.to_string()))
 }
 
 /// Initialize config file
-pub fn init_config() -> io::Result<()> {
-    let default = include_str!("../assets/default_config.toml");
+pub fn init_config<W: Write>(path: PathBuf, mut buffer: W) -> io::Result<()> {
+    let default = default_config();
 
-    let file = get_config_dir().join("envfetch.toml");
+    fs::write(&path, default)
+        .map(|_| writeln!(buffer, "Successfully initialized config at {}", path.display()).expect("Failed to write to buffer"))
+}
 
-    fs::write(&file, default)
-        .map(|_| eprintln!("Successfully initialized config at {}", file.display()))
+/// Get default config ile content
+fn default_config() -> &'static str {
+    include_str!("../assets/default_config.toml")
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::config::get_config_dir;
+    use super::*;
+    use assert_fs::prelude::*;
     use dirs::config_dir;
 
     #[test]
     fn test_get_config_dir() {
         assert_eq!(get_config_dir(), config_dir().unwrap_or_default());
     }
+
+    #[test]
+    fn test_get_config_file() {
+        assert_eq!(get_config_file_path(), config_dir().unwrap_or_default().join("envfetch.toml"));
+    }
+
+    #[test]
+    fn test_default_config() {
+        assert_eq!(default_config(), include_str!("../assets/default_config.toml"));
+    }
+
+    #[test]
+    fn test_read_config_default() {
+        let result = read_config(default_config().to_owned()).unwrap();
+        assert_eq!(result, Config {
+            print_format: None
+        })
+    }
+
+    #[test]
+    fn test_read_config_from_existent_file() {
+        let file = assert_fs::NamedTempFile::new("envfetch.toml").unwrap();
+        file.write_str(default_config()).unwrap();
+        let result = read_config_from_file(file.path().to_path_buf()).unwrap();
+        assert_eq!(result, Config {
+            print_format: None
+        })
+    }
+
+    #[test]
+    fn test_read_config_from_unexistent_file() {
+        let file = assert_fs::NamedTempFile::new("envfetch.toml").unwrap();
+        let path = file.path().to_path_buf();
+        file.close().unwrap();
+        let result = read_config_from_file(path);
+        assert_eq!(result, Err(ConfigParsingError::FileDoesntExists))
+    }
+
+    #[test]
+    fn test_init_config() {
+        let file = assert_fs::NamedTempFile::new("envfetch.toml").unwrap();
+        let mut buffer = vec![];
+        init_config(file.path().to_path_buf(), &mut buffer).unwrap();
+        assert!(String::from_utf8(buffer).unwrap().contains(&format!("Successfully initialized config at {}", file.display())));
+    }
 }

src/main.rs

@@ -12,7 +12,7 @@ mod utils;
 mod variables;
 
 use clap::Parser;
-use config::read_config;
+use config::{read_config_from_file, get_config_file_path};
 use std::{io::{stdout, Write}, process::ExitCode};
 
 use log::error;
@@ -32,7 +32,7 @@ fn main() -> ExitCode {
             )
         })
         .init();
-    let config = read_config();
+    let config = read_config_from_file(get_config_file_path());
     let config = match config {
         Ok(config) => Some(config),
         Err(ConfigParsingError::FileDoesntExists) => None,

src/models.rs

@@ -138,7 +138,7 @@ pub enum ErrorKind {
     NameValidationError(String),
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum ConfigParsingError {
     FSError(String),
     ParsingError(String),
@@ -184,7 +184,7 @@ impl Display for ErrorKind {
     }
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
 pub struct Config {
     /// Format, used to print variables using print command
     pub print_format: Option<String>,