feat: run tests in a suite and collect results

src/runner/mod.rs

@@ -1,2 +1,3 @@
 pub mod init_scripts;
 pub mod results;
+pub mod suite;

src/runner/suite.rs

@@ -114,97 +114,107 @@ impl SuiteRunnerState {
 mod tests {
     use super::*;
 
+    use crate::complaince::result::Result as CResult;
+    use crate::complaince::suite::Test;
     use crate::{AppCtx, Ctx, Settings};
 
     use std::sync::Arc;
-    use std::sync::RwLock;
 
-    #[derive(Clone, Eq, PartialEq, Debug)]
+    use url::Url;
-    enum ContainerState {
+    //    use std::sync::RwLock;
-        NoContainer,
-        Running(String),
-        Stopped,
-        Removed,
-    }
-
-    #[derive(Clone)]
-    struct TestDocker {
-        state: Arc<RwLock<ContainerState>>,
-    }
-
-    impl TestDocker {
-        pub fn new() -> Self {
-            Self {
-                state: Arc::new(RwLock::new(ContainerState::NoContainer)),
-            }
-        }
-    }
-    impl DockerLike for TestDocker {
-        fn version(&self) -> String {
-            unimplemented!();
-        }
-        fn run_container(
-            &self,
-            name: &str,
-            img: &str,
-            detached: bool,
-            env: &HashMap<String, String>,
-            network: Option<String>,
-            pull: bool,
-        ) {
-            let mut w = self.state.write().unwrap();
-            if *w == ContainerState::NoContainer {
-                *w = ContainerState::Running(name.to_string());
-            } else {
-                panic!("Container is {:?}", w);
-            }
-        }
-        fn get_exit_status(&self, name: &str) -> isize {
-            0
-        }
-        fn get_logs(&self, name: &str) -> String {
-            "".into()
-        }
-        fn rm_container(&self, name: &str, force: bool) {
-            let mut w = self.state.write().unwrap();
-            if *w == ContainerState::Stopped {
-                *w = ContainerState::Removed;
-            } else {
-                panic!("Container is {:?}", w);
-            }
-        }
-    }
 
+    //    #[derive(Clone, Eq, PartialEq, Debug)]
+    //    enum ContainerState {
+    //        NoContainer,
+    //        Running(String),
+    //        Stopped,
+    //        Removed,
+    //    }
+    //
+    //    #[derive(Clone)]
+    //    struct TestDocker {
+    //        state: Arc<RwLock<ContainerState>>,
+    //    }
+    //
+    //    impl TestDocker {
+    //        pub fn new() -> Self {
+    //            Self {
+    //                state: Arc::new(RwLock::new(ContainerState::NoContainer)),
+    //            }
+    //        }
+    //    }
+    //    impl DockerLike for TestDocker {
+    //        fn version(&self) -> String {
+    //            unimplemented!();
+    //        }
+    //        fn run_container(
+    //            &self,
+    //            name: &str,
+    //            img: &str,
+    //            detached: bool,
+    //            env: &HashMap<String, String>,
+    //            network: Option<String>,
+    //            pull: bool,
+    //        ) {
+    //            let mut w = self.state.write().unwrap();
+    //            if *w == ContainerState::NoContainer {
+    //                *w = ContainerState::Running(name.to_string());
+    //            } else {
+    //                panic!("Container is {:?}", w);
+    //            }
+    //        }
+    //        fn get_exit_status(&self, name: &str) -> isize {
+    //            0
+    //        }
+    //        fn get_logs(&self, name: &str) -> String {
+    //            "".into()
+    //        }
+    //        fn rm_container(&self, name: &str, force: bool) {
+    //            let mut w = self.state.write().unwrap();
+    //            if *w == ContainerState::Stopped {
+    //                *w = ContainerState::Removed;
+    //            } else {
+    //                panic!("Container is {:?}", w);
+    //            }
+    //        }
+    //    }
+    //
     #[actix_rt::test]
     async fn suite_runner_works() {
         const LOGS: &str = "SUITE RUNNER LOG STRING";
-        use crate::complaince::result::Result as CResult;
-        use crate::complaince::suite::Test;
-        use url::Url;
 
         let settings = Settings::new().unwrap();
         let ctx = Ctx::new(settings.clone()).await;
         //        ctx.docker = Arc::new(TestDocker::new());
         let ctx = AppCtx::new(Arc::new(ctx));
 
-        let dummy_test = Test {
+        let mut dummy_test = Test {
-            name: "ftest-docker-cmd-tester".into(),
+            name: "suite_runner_works".into(),
             url: Url::parse("https://git.batsense.net/ForgeFlux/ftest").unwrap(),
             version: semver::Version::parse("1.0.1").unwrap(),
             container: "forgeflux/ftest-docker-cmd-tester".into(),
             env_vars: None,
         };
+        let mut env = HashMap::new();
+        env.insert("TEST_NAME".into(), dummy_test.name.clone());
+        dummy_test.env_vars = Some(env);
+
+        let mut dummy_test2 = dummy_test.clone();
+        dummy_test2.name = "suite_runner_works2".into();
+        let mut env = HashMap::new();
+        env.insert("TEST_NAME".into(), dummy_test2.name.clone());
+        dummy_test2.env_vars = Some(env);
 
         let suite = Suite {
             name: "suite_runner_works".into(),
             description: "testing suite runner".into(),
             version: semver::Version::parse("1.0.1").unwrap(),
-            tests: vec![dummy_test.clone()],
+            tests: vec![dummy_test.clone(), dummy_test2.clone()],
         };
 
         let state = SuiteRunnerState::launch_suite(&suite, &ctx);
-        assert_eq!(state.tests.len(), 1);
+        assert_eq!(state.tests.len(), 2);
-        std::thread::sleep(std::time::Duration::new(10, 0));
+        std::thread::sleep(std::time::Duration::new(13, 0));
 
         for (k, v) in state.tests.iter() {
             assert_eq!(ctx.docker.get_exit_status(&v.container_name), 0);
@@ -215,26 +225,43 @@ mod tests {
                     test: dummy_test.clone(),
                     success: true,
                     // sent by the app
-                    logs: LOGS.into(),
+                    logs: format!("{}{LOGS}", v.container_name),
                 };
 
                 tx.send(tx_result).await.unwrap();
             }
         }
         let results = state.collect_results(&ctx).await;
-        assert_eq!(results.tests.len(), 1);
+        assert_eq!(results.tests.len(), 2);
-        let archivable_test = results.tests.get(0).unwrap();
+
-        assert_eq!(archivable_test.name, dummy_test.name);
+        for archivable_test in results.tests.iter() {
-        assert!(archivable_test.result.success);
+            //let archivable_test = results.tests.get(0).unwrap();
-        assert_eq!(archivable_test.result.logs, LOGS);
+            let t = if archivable_test.name == dummy_test.name.as_ref() {
-        println!("{}", archivable_test.result.container.logs);
+                dummy_test.clone()
-        assert!(archivable_test.result.container.logs.contains("FTEST_AUTH"));
+            } else {
-        assert!(archivable_test.result.container.logs.contains("FTEST_HOST"));
+                dummy_test2.clone()
-        assert!(archivable_test
+            };
-            .result
+            assert_eq!(archivable_test.name, t.name);
-            .container
+            assert!(archivable_test.result.success);
-            .logs
+            assert!(archivable_test.result.container.name.contains(&t.name));
-            .contains("FTEST_TARGET_HOST"));
+            assert_eq!(
-        assert!(archivable_test.result.container.logs.contains("FTEST_USER"));
+                archivable_test.result.logs,
+                format!("{}{LOGS}", archivable_test.result.container.name)
+            );
+            println!("{}", archivable_test.result.container.logs);
+            assert!(archivable_test.result.container.logs.contains("FTEST_AUTH"));
+            assert!(archivable_test.result.container.logs.contains("FTEST_HOST"));
+            assert!(archivable_test
+                .result
+                .container
+                .logs
+                .contains("FTEST_TARGET_HOST"));
+            assert!(archivable_test.result.container.logs.contains("FTEST_USER"));
+            assert!(archivable_test
+                .result
+                .container
+                .logs
+                .contains(&format!("TEST_NAME={}", t.name)));
+        }
     }
 }