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;
@@ -120,6 +121,7 @@ fn main() -> Result<()> {
     let process_user = get_process_user_test();
     let process_rlimtis = get_process_rlimits_test();
     let no_pivot = get_no_pivot_test();
+    let kill = get_kill_test();
     let process_oom_score_adj = get_process_oom_score_adj_test();
 
     tm.add_test_group(Box::new(cl));
@@ -147,6 +149,7 @@ fn main() -> Result<()> {
     tm.add_test_group(Box::new(process_user));
     tm.add_test_group(Box::new(process_rlimtis));
     tm.add_test_group(Box::new(no_pivot));
+    tm.add_test_group(Box::new(kill));
     tm.add_test_group(Box::new(process_oom_score_adj));
 
     tm.add_test_group(Box::new(io_priority_test));

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

@@ -0,0 +1,111 @@
+use anyhow::anyhow;
+use test_framework::{ConditionalTest, TestGroup, TestResult};
+
+use crate::tests::lifecycle::ContainerLifecycle;
+
+fn run_kill_test_cases() -> TestResult {
+    let mut container = ContainerLifecycle::new();
+    let mut results = vec![];
+    let container_id = container.get_id().to_string();
+
+    // kill with empty id
+    container.set_id("");
+    results.push((
+        "kill without ID",
+        match container.kill() {
+            TestResult::Failed(_) => TestResult::Passed,
+            TestResult::Passed => TestResult::Failed(anyhow!("Expected failure but got success")),
+            _ => TestResult::Failed(anyhow!("Unexpected test result")),
+        },
+    ));
+
+    // kill for non existed container
+    container.set_id("non-existent-container-id");
+    results.push((
+        "kill non-existent container",
+        match container.kill() {
+            TestResult::Failed(_) => TestResult::Passed,
+            TestResult::Passed => TestResult::Failed(anyhow!("Expected failure but got success")),
+            _ => TestResult::Failed(anyhow!("Unexpected test result")),
+        },
+    ));
+
+    // kill created container
+    container.set_id(&container_id);
+    match container.create() {
+        TestResult::Passed => {}
+        _ => return TestResult::Failed(anyhow!("Failed to create container")),
+    }
+    results.push((
+        "kill created container",
+        match container.kill() {
+            TestResult::Passed => TestResult::Passed,
+            TestResult::Failed(_) => {
+                TestResult::Failed(anyhow!("Expected success but got failure"))
+            }
+            _ => TestResult::Failed(anyhow!("Unexpected test result")),
+        },
+    ));
+
+    // kill stopped container
+    match container.delete() {
+        TestResult::Passed => {}
+        _ => return TestResult::Failed(anyhow!("Failed to delete container")),
+    }
+    results.push((
+        "kill stopped container",
+        match container.kill() {
+            TestResult::Failed(_) => TestResult::Passed,
+            TestResult::Passed => TestResult::Failed(anyhow!("Expected failure but got success")),
+            _ => TestResult::Failed(anyhow!("Unexpected test result")),
+        },
+    ));
+
+    // 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!(),
+    }
+    results.push((
+        "kill running container",
+        match container.kill() {
+            TestResult::Passed => TestResult::Passed,
+            TestResult::Failed(_) => {
+                TestResult::Failed(anyhow!("Expected success but got failure"))
+            }
+            _ => TestResult::Failed(anyhow!("Unexpected test result")),
+        },
+    ));
+
+    match container.delete() {
+        TestResult::Passed => {}
+        _ => return TestResult::Failed(anyhow!("Failed to delete container")),
+    }
+
+    for (name, result) in results {
+        if let TestResult::Failed(err) = result {
+            return TestResult::Failed(anyhow!("Test '{}' failed: {:?}", name, err));
+        }
+    }
+
+    TestResult::Passed
+}
+
+pub fn get_kill_test() -> TestGroup {
+    let mut test_group = TestGroup::new("kill_container");
+    let kill_test = ConditionalTest::new(
+        "test_kill_container",
+        Box::new(|| true),
+        Box::new(run_kill_test_cases),
+    );
+    test_group.add(vec![Box::new(kill_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;