add kill test

tests/contest/contest/src/main.rs

@@ -16,6 +16,7 @@ use crate::tests::hooks::get_hooks_tests;
 use crate::tests::hostname::get_hostname_test;
 use crate::tests::intel_rdt::get_intel_rdt_test;
 use crate::tests::io_priority::get_io_priority_test;
+use crate::tests::kill::get_kill_test;
 use crate::tests::lifecycle::{ContainerCreate, ContainerLifecycle};
 use crate::tests::linux_ns_itype::get_ns_itype_tests;
 use crate::tests::mounts_recursive::get_mounts_recursive_test;
@@ -125,6 +126,7 @@ fn main() -> Result<()> {
     let process_rlimtis = get_process_rlimits_test();
     let no_pivot = get_no_pivot_test();
     let process_oom_score_adj = get_process_oom_score_adj_test();
+    let kill = get_kill_test();
 
     tm.add_test_group(Box::new(cl));
     tm.add_test_group(Box::new(cc));
@@ -154,6 +156,7 @@ fn main() -> Result<()> {
     tm.add_test_group(Box::new(process_rlimtis));
     tm.add_test_group(Box::new(no_pivot));
     tm.add_test_group(Box::new(process_oom_score_adj));
+    tm.add_test_group(Box::new(kill));
 
     tm.add_test_group(Box::new(io_priority_test));
     tm.add_cleanup(Box::new(cgroups::cleanup_v1));

tests/contest/contest/src/tests/kill/kill_test.rs

@@ -0,0 +1,123 @@
+use anyhow::anyhow;
+use test_framework::{Test, TestGroup, TestResult};
+
+use crate::tests::lifecycle::ContainerLifecycle;
+
+fn kill_with_empty_id_test() -> TestResult {
+    let mut container = ContainerLifecycle::new();
+
+    // kill with empty id
+    container.set_id("");
+    let result = match container.kill() {
+        TestResult::Failed(_) => TestResult::Passed,
+        TestResult::Passed => TestResult::Failed(anyhow!(
+            "Expected killing container with empty id to fail, but was successful"
+        )),
+        _ => TestResult::Failed(anyhow!(
+            "Unexpected killing container with empty id test result"
+        )),
+    };
+    container.delete();
+    result
+}
+
+fn kill_non_existed_container() -> TestResult {
+    let mut container = ContainerLifecycle::new();
+
+    // kill for non existed container
+    container.set_id("non-existent-container-id");
+    let result = match container.kill() {
+        TestResult::Failed(_) => TestResult::Passed,
+        TestResult::Passed => TestResult::Failed(anyhow!(
+            "Expected killing non existed container to fail, but was successful"
+        )),
+        _ => TestResult::Failed(anyhow!(
+            "Unexpected killing non existed container test result"
+        )),
+    };
+    container.delete();
+    result
+}
+fn kill_created_container_test() -> TestResult {
+    let container = ContainerLifecycle::new();
+
+    // kill created container
+    match container.create() {
+        TestResult::Passed => {}
+        _ => return TestResult::Failed(anyhow!("Failed to create container")),
+    }
+    let result = container.kill();
+    container.delete();
+    result
+}
+
+fn kill_stopped_container_test() -> TestResult {
+    let container = ContainerLifecycle::new();
+
+    // kill stopped container
+    match container.create() {
+        TestResult::Passed => {}
+        _ => return TestResult::Failed(anyhow!("Failed to create container")),
+    }
+    match container.delete() {
+        TestResult::Passed => {}
+        _ => return TestResult::Failed(anyhow!("Failed to delete container")),
+    }
+    match container.kill() {
+        TestResult::Failed(_) => TestResult::Passed,
+        TestResult::Passed => TestResult::Failed(anyhow!("Expected failure but got success")),
+        _ => TestResult::Failed(anyhow!("Unexpected test result")),
+    }
+}
+
+fn kill_start_container_test() -> TestResult {
+    let container = ContainerLifecycle::new();
+
+    // kill start container
+    match container.create() {
+        TestResult::Passed => {}
+        _ => return TestResult::Failed(anyhow!("Failed to recreate container")),
+    }
+
+    match container.start() {
+        TestResult::Passed => {}
+        TestResult::Failed(err) => {
+            return TestResult::Failed(anyhow!("Failed to start container: {:?}", err));
+        }
+        _ => unreachable!(),
+    }
+    let result = container.kill();
+    container.delete();
+    result
+}
+
+pub fn get_kill_test() -> TestGroup {
+    let mut test_group = TestGroup::new("kill_container");
+
+    let kill_with_empty_id_test =
+        Test::new("kill_with_empty_id_test", Box::new(kill_with_empty_id_test));
+    let kill_non_existed_container = Test::new(
+        "kill_non_existed_container",
+        Box::new(kill_non_existed_container),
+    );
+    let kill_created_container_test = Test::new(
+        "kill_created_container_test",
+        Box::new(kill_created_container_test),
+    );
+    let kill_stopped_container_test = Test::new(
+        "kill_stopped_container_test",
+        Box::new(kill_stopped_container_test),
+    );
+    let kill_start_container_test = Test::new(
+        "kill_start_container_test",
+        Box::new(kill_start_container_test),
+    );
+    test_group.add(vec![
+        Box::new(kill_with_empty_id_test),
+        Box::new(kill_non_existed_container),
+        Box::new(kill_created_container_test),
+        Box::new(kill_stopped_container_test),
+        Box::new(kill_start_container_test),
+    ]);
+    test_group
+}

tests/contest/contest/src/tests/kill/mod.rs

@@ -0,0 +1,3 @@
+mod kill_test;
+
+pub use kill_test::get_kill_test;

tests/contest/contest/src/tests/lifecycle/container_lifecycle.rs

@@ -33,6 +33,14 @@ impl ContainerLifecycle {
         }
     }
 
+    pub fn set_id(&mut self, id: &str) {
+        self.container_id = id.to_string();
+    }
+
+    pub fn get_id(&self) -> &str {
+        &self.container_id
+    }
+
     pub fn create(&self) -> TestResult {
         create::create(self.project_path.path(), &self.container_id).into()
     }

tests/contest/contest/src/tests/mod.rs

@@ -6,6 +6,7 @@ pub mod hooks;
 pub mod hostname;
 pub mod intel_rdt;
 pub mod io_priority;
+pub mod kill;
 pub mod lifecycle;
 pub mod linux_ns_itype;
 pub mod mounts_recursive;