ForgeFlux/ftest
2
0
Fork 0
Code Issues 2 Pull requests 10 Projects Releases Packages Wiki Activity

feat: run tests in a suite and collect results

Browse source
This commit is contained in:
Aravinth Manivannan 2023-09-27 19:46:59 +05:30
parent c613c7a45e
commit 6d39176cbf
Signed by: realaravinth
GPG key ID: F8F50389936984FF
2 changed files with 107 additions and 79 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/runner/mod.rs
View file

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

165
src/runner/suite.rs
View file

@ -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)]
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);
}
}
}
use url::Url;
// use std::sync::RwLock;
// #[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 {
name: "ftest-docker-cmd-tester".into(),
let mut dummy_test = Test {
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);
std::thread::sleep(std::time::Duration::new(10, 0));
assert_eq!(state.tests.len(), 2);
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,18 +225,29 @@ 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);
let archivable_test = results.tests.get(0).unwrap();
assert_eq!(archivable_test.name, dummy_test.name);
assert_eq!(results.tests.len(), 2);
for archivable_test in results.tests.iter() {
//let archivable_test = results.tests.get(0).unwrap();
let t = if archivable_test.name == dummy_test.name.as_ref() {
dummy_test.clone()
} else {
dummy_test2.clone()
};
assert_eq!(archivable_test.name, t.name);
assert!(archivable_test.result.success);
assert_eq!(archivable_test.result.logs, LOGS);
assert!(archivable_test.result.container.name.contains(&t.name));
assert_eq!(
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"));
@ -236,5 +257,11 @@ mod tests {
.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)));
}
}
}