Merge pull request EricCrosson#84 from andrew-scott-fischer/add-tests

Add tests

Author: EricCrosson

src/cli.rs

@@ -12,7 +12,7 @@ fn duration_from_str(
     }
 }
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub(crate) enum Retry {
     ForDuration(Duration),
     NumberOfTimes(u64),
@@ -98,3 +98,60 @@ pub(crate) struct Cli {
     #[arg(help = "The command to run")]
     pub command: Vec<String>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_retry_from_str_number_of_times() {
+        let input = "3x";
+        let expected = Retry::NumberOfTimes(3);
+        let result = Retry::from_str(input).unwrap();
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_retry_from_str_for_duration() {
+        let input = "10s";
+        let expected = Retry::ForDuration(Duration::from_secs(10));
+        let result = Retry::from_str(input).unwrap();
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_retry_from_str_invalid_input() {
+        let input = "abc";
+        let result = Retry::from_str(input);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_cli_up_to_retry_from_str() {
+        let input = "3x";
+        let expected = Retry::NumberOfTimes(3);
+        let cli = Cli::parse_from(&["", "--up-to", input]);
+        assert_eq!(cli.up_to, expected);
+    }
+
+    #[test]
+    fn test_cli_task_timeout_duration_from_str() {
+        let input = "5m";
+        let expected = Some(Duration::from_secs(300));
+        let cli = Cli::parse_from(&["", "--task-timeout", input, "--up-to", "1x"]);
+        assert_eq!(cli.task_timeout, expected);
+    }
+
+    #[test]
+    fn test_cli_command() {
+        let input = vec!["ping", "-c", "1", "google.com"];
+        let expected = input.iter().map(|s| s.to_owned()).collect::<Vec<_>>();
+        let cli = Cli::parse_from(
+            &["", "--up-to", "1x", "--"]
+                .into_iter()
+                .chain(input.into_iter())
+                .collect::<Vec<_>>(),
+        );
+        assert_eq!(cli.command, expected);
+    }
+}

src/main.rs

@@ -103,3 +103,78 @@ async fn main() -> Result<()> {
     let args: Cli = Cli::parse();
     run_tasks(args.command, args.up_to, args.task_timeout).await
 }
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_eval_success() {
+        let command = vec!["true".to_owned()];
+        let exit_status = eval(&command).await.unwrap();
+        assert_eq!(exit_status.success(), true);
+    }
+
+    #[tokio::test]
+    async fn test_eval_failure() {
+        let command = vec!["false".to_owned()];
+        let exit_status = eval(&command).await.unwrap();
+        assert_eq!(exit_status.success(), false);
+    }
+
+    #[tokio::test]
+    async fn test_run_task_success() {
+        let command = vec!["true".to_owned()];
+        let task_outcome = run_task(&command, None).await.unwrap();
+        assert_eq!(task_outcome, TaskOutcome::Success);
+    }
+
+    #[tokio::test]
+    async fn test_run_task_failure() {
+        let command = vec!["false".to_owned()];
+        let task_outcome = run_task(&command, None).await.unwrap();
+        assert_eq!(task_outcome, TaskOutcome::Timeout);
+    }
+
+    #[tokio::test]
+    async fn test_run_task_timeout() {
+        let command = vec!["sleep".to_owned(), "10".to_owned()];
+        let task_timeout = Some(Duration::from_secs(1));
+        let task_outcome = run_task(&command, task_timeout).await.unwrap();
+        assert_eq!(task_outcome, TaskOutcome::Timeout);
+    }
+
+    #[tokio::test]
+    async fn test_loop_task_success() {
+        let command = vec!["true".to_owned()];
+        let task_timeout = Some(Duration::from_secs(5));
+        let task_outcome = loop_task(&command, task_timeout).await.unwrap();
+        assert_eq!(task_outcome, TaskOutcome::Success);
+    }
+
+    #[tokio::test]
+    async fn test_run_tasks_success() {
+        let command = vec!["true".to_owned()];
+        let up_to = Retry::NumberOfTimes(3);
+        let task_timeout = Some(Duration::from_secs(5));
+        let result = run_tasks(command, up_to, task_timeout).await;
+        assert_eq!(result.is_ok(), true);
+    }
+
+    #[tokio::test]
+    async fn test_run_tasks_failure() {
+        let command = vec!["false".to_owned()];
+        let up_to = Retry::NumberOfTimes(3);
+        let task_timeout = Some(Duration::from_secs(5));
+        let result = run_tasks(command, up_to, task_timeout).await;
+        assert_eq!(result.is_err(), true);
+    }
+
+    #[tokio::test]
+    async fn test_run_tasks_timeout() {
+        let command = vec!["sleep".to_owned(), "10".to_owned()];
+        let up_to = Retry::ForDuration(Duration::from_secs(5));
+        let task_timeout = Some(Duration::from_secs(1));
+        let result = run_tasks(command, up_to, task_timeout).await;
+        assert_eq!(result.is_err(), true);
+    }
+}