take care of delete

Signed-off-by: Akiyama <[email protected]>

Author: YamasouA

Diff for: tests/contest/contest/src/tests/kill/kill_test.rs

@@ -7,7 +7,7 @@ use test_framework::{Test, TestGroup, TestResult};
 use crate::tests::lifecycle::ContainerLifecycle;
 
 fn create_spec(args: &[&str]) -> Result<Spec> {
-    let args_vec: Vec<String> = args.iter().map(|&a| a.to_string()).collect();
+    let args_vec: Vec<String> = args.iter().map(|&a| a.into()).collect();
     let spec = SpecBuilder::default()
         .process(
             ProcessBuilder::default()
@@ -20,52 +20,72 @@ fn create_spec(args: &[&str]) -> Result<Spec> {
     Ok(spec)
 }
 
+fn failed_and_delete(text: String, container: ContainerLifecycle) -> TestResult {
+    let delete_result = container.delete();
+    match delete_result {
+        TestResult::Passed => TestResult::Failed(anyhow!(text)),
+        TestResult::Failed(err) => TestResult::Failed(anyhow!(
+            "{}; also container deletion failed: {:?}",
+            text,
+            err
+        )),
+        _ => TestResult::Failed(anyhow!("{}; unexpected delete result", text)),
+    }
+}
+
+fn merge_test_results(kill_result: TestResult, delete_result: TestResult) -> TestResult {
+    match (kill_result, delete_result) {
+        (TestResult::Failed(err), _) => TestResult::Failed(err),
+        (TestResult::Passed, TestResult::Failed(err)) => {
+            TestResult::Failed(anyhow!("Delete failed: {:?}", err))
+        }
+        (TestResult::Passed, TestResult::Passed) => TestResult::Passed,
+        _ => TestResult::Failed(anyhow!("Unexpected result")),
+    }
+}
+
 fn kill_with_empty_id_test() -> TestResult {
     let mut container = ContainerLifecycle::new();
 
     // kill with empty id
     container.set_id("");
-    let result = match container.kill() {
+    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();
+    let container = ContainerLifecycle::new();
 
     // kill for non existed container
-    container.set_id("non-existent-container-id");
-    let result = match container.kill() {
+    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")),
+        _ => return failed_and_delete("Failed to create container".to_string(), container),
     }
-    let result = container.kill();
-    container.delete();
-    result
+    let kill_result = container.kill();
+    let delete_result = container.delete();
+    merge_test_results(kill_result, delete_result)
 }
 
 fn kill_stopped_container_test() -> TestResult {
@@ -75,20 +95,20 @@ fn kill_stopped_container_test() -> TestResult {
     // kill stopped container
     match container.create_with_spec(spec) {
         TestResult::Passed => {}
-        _ => return TestResult::Failed(anyhow!("Failed to create container")),
+        _ => return failed_and_delete("Failed to create container".to_string(), container),
     }
     match container.start() {
         TestResult::Passed => {}
-        _ => return TestResult::Failed(anyhow!("Failed to start container")),
+        _ => return failed_and_delete("Failed to start container".to_string(), container),
     }
     container.waiting_for_status(Duration::from_secs(10), Duration::from_secs(1), "stopped");
-    let result = match container.kill() {
+    let kill_result = match container.kill() {
         TestResult::Failed(_) => TestResult::Passed,
         TestResult::Passed => TestResult::Failed(anyhow!("Expected failure but got success")),
         _ => TestResult::Failed(anyhow!("Unexpected test result")),
     };
-    container.delete();
-    result
+    let delete_result = container.delete();
+    merge_test_results(kill_result, delete_result)
 }
 
 fn kill_start_container_test() -> TestResult {
@@ -98,20 +118,17 @@ fn kill_start_container_test() -> TestResult {
     // kill start container
     match container.create_with_spec(spec) {
         TestResult::Passed => {}
-        _ => return TestResult::Failed(anyhow!("Failed to recreate container")),
+        _ => return failed_and_delete("Failed to recreate container".to_string(), container),
     }
 
     match container.start() {
         TestResult::Passed => {}
-        TestResult::Failed(err) => {
-            return TestResult::Failed(anyhow!("Failed to start container: {:?}", err));
-        }
-        _ => unreachable!(),
+        _ => return failed_and_delete(("Failed to start container").to_string(), container),
     }
     container.waiting_for_status(Duration::from_secs(10), Duration::from_secs(1), "running");
-    let result = container.kill();
-    container.delete();
-    result
+    let kill_result = container.kill();
+    let delete_result = container.delete();
+    merge_test_results(kill_result, delete_result)
 }
 
 pub fn get_kill_test() -> TestGroup {