E2E tests: Improve E2E tests runner

src/bin/tracker_checker.rs

@@ -7,5 +7,5 @@ use torrust_tracker::checker::app;
 
 #[tokio::main]
 async fn main() {
-    app::run().await;
+    app::run().await.expect("Some checks fail");
 }

src/checker/app.rs

@@ -2,18 +2,22 @@
 
 use super::config::Configuration;
 use super::console::Console;
+use super::service::{CheckError, Service};
 use crate::checker::config::parse_from_json;
-use crate::checker::service::Service;
 
 pub const NUMBER_OF_ARGUMENTS: usize = 2;
 
+/// # Errors
+///
+/// If some checks fails it will return a vector with all failing checks.
+///
 /// # Panics
 ///
 /// Will panic if:
 ///
 /// - It can't read the json configuration file.
 /// - The configuration file is invalid.
-pub async fn run() {
+pub async fn run() -> Result<(), Vec<CheckError>> {
     let args = parse_arguments();
     let config = setup_config(&args);
     let console_printer = Console {};
@@ -22,7 +26,7 @@
         console: console_printer,
     };
 
-    service.run_checks().await;
+    service.run_checks().await
 }
 
 pub struct Arguments {

src/checker/service.rs

@@ -14,12 +14,24 @@
     pub(crate) console: Console,
 }
 
+#[derive(Debug)]
+pub enum CheckError {
+    UdpError,
+    HttpError,
+    HealthCheckError { url: Url },
+}
+
 impl Service {
-    pub async fn run_checks(&self) {
+    /// # Errors
+    ///
+    /// Will return OK is all checks pass or an array with the check errors.
+    pub async fn run_checks(&self) -> Result<(), Vec<CheckError>> {
         self.console.println("Running checks for trackers ...");
+
         self.check_udp_trackers();
         self.check_http_trackers();
-        self.run_health_checks().await;
+
+        self.run_health_checks().await
     }
 
     fn check_udp_trackers(&self) {
@@ -38,11 +50,22 @@
         }
     }
 
-    async fn run_health_checks(&self) {
+    async fn run_health_checks(&self) -> Result<(), Vec<CheckError>> {
         self.console.println("Health checks ...");
 
+        let mut check_errors = vec![];
+
         for health_check_url in &self.config.health_checks {
-            self.run_health_check(health_check_url.clone()).await;
+            match self.run_health_check(health_check_url.clone()).await {
+                Ok(()) => {}
+                Err(err) => check_errors.push(err),
+            }
+        }
+
+        if check_errors.is_empty() {
+            Ok(())
+        } else {
+            Err(check_errors)
         }
     }
 
@@ -62,22 +85,25 @@
             .println(&format!("{} - HTTP tracker at {} is OK (TODO)", "✓".green(), url));
     }
 
-    async fn run_health_check(&self, url: Url) {
+    async fn run_health_check(&self, url: Url) -> Result<(), CheckError> {
         let client = Client::builder().timeout(Duration::from_secs(5)).build().unwrap();
 
         match client.get(url.clone()).send().await {
             Ok(response) => {
                 if response.status().is_success() {
                     self.console
                         .println(&format!("{} - Health API at {} is OK", "✓".green(), url));
+                    Ok(())
                 } else {
                     self.console
                         .eprintln(&format!("{} - Health API at {} failing: {:?}", "✗".red(), url, response));
+                    Err(CheckError::HealthCheckError { url })
                 }
             }
             Err(err) => {
                 self.console
                     .eprintln(&format!("{} - Health API at {} failing: {:?}", "✗".red(), url, err));
+                Err(CheckError::HealthCheckError { url })
             }
         }
     }

src/e2e/docker.rs

@@ -4,25 +4,35 @@
 use std::thread::sleep;
 use std::time::{Duration, Instant};
 
-use log::debug;
+use log::{debug, info};
 
 /// Docker command wrapper.
 pub struct Docker {}
 
+#[derive(Clone, Debug)]
 pub struct RunningContainer {
+    pub image: String,
     pub name: String,
     pub output: Output,
 }
 
 impl Drop for RunningContainer {
-    /// Ensures that the temporary container is stopped and removed when the
-    /// struct goes out of scope.
+    /// Ensures that the temporary container is stopped when the struct goes out
+    /// of scope.
     fn drop(&mut self) {
-        let _unused = Docker::stop(self);
-        let _unused = Docker::remove(&self.name);
+        info!("Dropping running container: {}", self.name);
+        if Docker::is_container_running(&self.name) {
+            let _unused = Docker::stop(self);
+        }
     }
 }
 
+/// `docker run` command options.
+pub struct RunOptions {
+    pub env_vars: Vec<(String, String)>,
+    pub ports: Vec<String>,
+}
+
 impl Docker {
     /// Builds a Docker image from a given Dockerfile.
     ///
@@ -55,7 +65,7 @@
     /// # Errors
     ///
     /// Will fail if the docker run command fails.
-    pub fn run(image: &str, container: &str, env_vars: &[(String, String)], ports: &[String]) -> io::Result<RunningContainer> {
+    pub fn run(image: &str, container: &str, options: &RunOptions) -> io::Result<RunningContainer> {
         let initial_args = vec![
             "run".to_string(),
             "--detach".to_string(),
@@ -65,14 +75,14 @@
 
         // Add environment variables
         let mut env_var_args: Vec<String> = vec![];
-        for (key, value) in env_vars {
+        for (key, value) in &options.env_vars {
             env_var_args.push("--env".to_string());
             env_var_args.push(format!("{key}={value}"));
         }
 
         // Add port mappings
         let mut port_args: Vec<String> = vec![];
-        for port in ports {
+        for port in &options.ports {
             port_args.push("--publish".to_string());
             port_args.push(port.to_string());
         }
@@ -85,6 +95,7 @@
 
         if output.status.success() {
             Ok(RunningContainer {
+                image: image.to_owned(),
                 name: container.to_owned(),
                 output,
             })
@@ -174,4 +185,50 @@
 
         false
     }
+
+    /// Checks if a Docker container is running.
+    ///
+    /// # Arguments
+    ///
+    /// * `container` - The name of the Docker container.
+    ///
+    /// # Returns
+    ///
+    /// `true` if the container is running, `false` otherwise.
+    #[must_use]
+    pub fn is_container_running(container: &str) -> bool {
+        match Command::new("docker")
+            .args(["ps", "-f", &format!("name={container}"), "--format", "{{.Names}}"])
+            .output()
+        {
+            Ok(output) => {
+                let output_str = String::from_utf8_lossy(&output.stdout);
+                output_str.contains(container)
+            }
+            Err(_) => false,
+        }
+    }
+
+    /// Checks if a Docker container exists.
+    ///
+    /// # Arguments
+    ///
+    /// * `container` - The name of the Docker container.
+    ///
+    /// # Returns
+    ///
+    /// `true` if the container exists, `false` otherwise.
+    #[must_use]
+    pub fn container_exist(container: &str) -> bool {
+        match Command::new("docker")
+            .args(["ps", "-a", "-f", &format!("name={container}"), "--format", "{{.Names}}"])
+            .output()
+        {
+            Ok(output) => {
+                let output_str = String::from_utf8_lossy(&output.stdout);
+                output_str.contains(container)
+            }
+            Err(_) => false,
+        }
+    }
 }

src/e2e/mod.rs

@@ -2,3 +2,4 @@ pub mod docker;
 pub mod logs_parser;
 pub mod runner;
 pub mod temp_dir;
+pub mod tracker_container;