[#198]: use command runner downstream & tests

Author: siddh34

cli/src/errors.rs

@@ -122,3 +122,18 @@ impl fmt::Display for CliError {
         }
     }
 }
+
+# [cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_display_base_error() {
+        let err = CliError::BaseError {
+            reason: "some reason".to_string(),
+        };
+        let err_str = format!("{}", err);
+        assert!(err_str.contains("An error occured. Reason:"));
+        assert!(err_str.contains("some reason"));
+    }
+}

cli/src/essential.rs

@@ -1,3 +1,4 @@
+use crate::command_runner::{CommandRunner, RealCommandRunner};
 use crate::errors::CliError;
 use std::borrow::Cow;
 use std::thread;
@@ -130,10 +131,17 @@ pub fn update_cli() -> Result<(), CliError> {
 //
 // This function returns the latest version of the CLI from the crates.io registry
 pub fn get_latest_cfcli_version() -> Result<String, CliError> {
-    let output = Command::new("cargo")
-        .args(["search", "cortexflow-cli", "--limit", "1"])
-        .output()
-        .expect("Error");
+    get_latest_cfcli_version_with(&RealCommandRunner)
+}
+
+fn get_latest_cfcli_version_with(runner: &dyn CommandRunner) -> Result<String, CliError> {
+    let args = [
+        "search".to_string(),
+        "cortexflow-cli".to_string(),
+        "--limit".to_string(),
+        "1".to_string(),
+    ];
+    let output = runner.run("cargo", &args).expect("Error");
 
     if !output.status.success() {
         return Err(CliError::InstallerError {
@@ -410,10 +418,18 @@ pub async fn update_configmap(config_struct: MetadataConfigFile) -> Result<(), C
 
 #[cfg(test)]
 mod tests {
-    use crate::essential::extract_version_from_output;
+    use crate::command_runner::test_support::StubCommandRunner;
+    use crate::essential::{create_configs, extract_version_from_output, get_latest_cfcli_version_with};
+
+    #[test]
+    fn creates_an_empty_blocklist_configuration() {
+        let configs = create_configs();
+
+        assert_eq!(configs.blocklist, vec![String::new()]);
+    }
 
     #[test]
-    fn test_version_extraction() {
+    fn extracts_the_version_from_cargo_search_output() {
         let command_stdout = String::from(
             r#"cortexflow-cli = "0.1.4-test_123"    
             # CortexFlow command line interface made to interact with the CortexBrain core components...
@@ -423,4 +439,19 @@ mod tests {
         let extracted_command = extract_version_from_output(command_stdout.into());
         assert_eq!(extracted_command, "0.1.4-test_123");
     }
+
+    #[test]
+    fn get_latest_cfcli_version_returns_parsed_version_on_success() {
+        let runner = StubCommandRunner::success(
+            r#"cortexflow-cli = "0.1.5"    # CortexFlow command line interface"#,
+        );
+        let version = get_latest_cfcli_version_with(&runner);
+        assert_eq!(version.unwrap(), "0.1.5");
+    }
+
+    #[test]
+    fn get_latest_cfcli_version_errors_on_command_failure() {
+        let runner = StubCommandRunner::failure("network unreachable");
+        assert!(get_latest_cfcli_version_with(&runner).is_err());
+    }
 }

cli/src/install.rs

@@ -1,3 +1,4 @@
+use crate::command_runner::{CommandRunner, RealCommandRunner};
 use crate::errors::CliError;
 use crate::essential::{BASE_COMMAND, connect_to_client, create_config_file, create_configs};
 use clap::{Args, Subcommand};
@@ -453,13 +454,16 @@ fn rm_installation_files(file_to_remove: InstallationType) -> Result<(), CliErro
 // Returns a CliError if something fails
 
 fn download_file(src: &str) -> Result<(), CliError> {
-    let output =
-        Command::new("wget")
-            .args([src])
-            .output()
-            .map_err(|e| CliError::InstallerError {
-                reason: e.to_string(),
-            })?;
+    download_file_with(&RealCommandRunner, src)
+}
+
+fn download_file_with(runner: &dyn CommandRunner, src: &str) -> Result<(), CliError> {
+    let args = [src.to_string()];
+    let output = runner
+        .run("wget", &args)
+        .map_err(|e| CliError::InstallerError {
+            reason: e.to_string(),
+        })?;
 
     if !output.status.success() {
         return Err(CliError::InstallerError {
@@ -486,6 +490,13 @@ fn download_file(src: &str) -> Result<(), CliError> {
 // Returns an CliError if something fails
 
 fn rm_file(file_to_remove: &str) -> Result<(), CliError> {
+    // rm -f never fails for a missing file, so check existence first
+    if !std::path::Path::new(file_to_remove).exists() {
+        return Err(CliError::InstallerError {
+            reason: format!("File not found: {}", file_to_remove),
+        });
+    }
+
     let output = Command::new("rm")
         .args(["-f", file_to_remove])
         .output()
@@ -508,3 +519,78 @@ fn rm_file(file_to_remove: &str) -> Result<(), CliError> {
     thread::sleep(Duration::from_secs(2));
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_rm_file() {
+        let file_name = "test_file.txt";
+        std::fs::write(file_name, "test content").unwrap();
+        assert!(rm_file(file_name).is_ok());
+        assert!(!std::path::Path::new(file_name).exists());
+    }
+
+    #[test]
+    fn test_download_file_with_success() {
+        let runner = crate::command_runner::test_support::StubCommandRunner::success("");
+        assert!(download_file_with(&runner, "https://example.com/file.yaml").is_ok());
+    }
+
+    #[test]
+    fn test_download_file_with_command_failure() {
+        let runner = crate::command_runner::test_support::StubCommandRunner::failure("404 Not Found");
+        assert!(download_file_with(&runner, "https://example.com/missing.yaml").is_err());
+    }
+
+    #[test]
+    fn test_download_file_with_io_error() {
+        let runner = crate::command_runner::test_support::StubCommandRunner::io_error();
+        assert!(download_file_with(&runner, "https://example.com/file.yaml").is_err());
+    }
+
+    #[test]
+    fn test_rm_file_failure() {
+        let file_name = "non_existent_file.txt";
+        assert!(rm_file(file_name).is_err());
+    }
+
+    #[test]
+    fn test_rm_file_cleanup_only() {
+        let file_name = "test_file.txt";
+        std::fs::write(file_name, "test content").unwrap();
+        // Clean up without removing
+        rm_file(file_name).unwrap();
+    }
+
+    #[test]
+    fn test_rm_file_failure_cleanup() {
+        let file_name = "non_existent_file.txt";
+        // Attempt to clean up a non-existent file
+        assert!(rm_file(file_name).is_err());
+    }
+
+    #[test]
+    fn test_rm_file_success_cleanup() {
+        let file_name = "test_file.txt";
+        std::fs::write(file_name, "test content").unwrap();
+        // Clean up a file that exists
+        assert!(rm_file(file_name).is_ok());
+    }
+
+    #[test]
+    fn test_rm_file_success_cleanup_only() {
+        let file_name = "test_file.txt";
+        std::fs::write(file_name, "test content").unwrap();
+        // Clean up a file that exists
+        assert!(rm_file(file_name).is_ok());
+    }
+
+    #[test]
+    fn test_rm_file_failure_cleanup_only() {
+        let file_name = "non_existent_file.txt";
+        // Attempt to clean up a non-existent file
+        assert!(rm_file(file_name).is_err());
+    }
+}