test(conformance): describe slow-TERM delete and lengthen delay

Signed-off-by: Matthew Grossman <mgrossman@nvidia.com>

Author: matthewgrossman

tests/suites/conformance/README.md

@@ -7,7 +7,7 @@ Each file in `tests/` is one suite.
 | Suite | Covers |
 |---|---|
 | `smoke` | Create a sandbox, run `echo` in it, delete it |
-| `lifecycle` | SDK: long-running and run-to-completion sandboxes, running-delete within 10 seconds with a one-second TERM delay, the default command, restart of a stopped sandbox, deleting a stopped sandbox |
+| `lifecycle` | SDK: long-running and run-to-completion sandboxes, prompt delete when the workload is slow to handle TERM, the default command, restart of a stopped sandbox, deleting a stopped sandbox |
 | `cli` | The same lifecycle through the `openshell` CLI: status, create, get, list, exec, stop, start, delete |
 | `persistent-workspace` | Files in `/sandbox` survive stop and start |
 | `policy-advisor` | `policy.local` accepts a proposed rule; a denied address or hostname yields one draft rule |

tests/suites/conformance/tests/lifecycle.rs

@@ -42,21 +42,31 @@ async fn long_running_exec_delete(cx: &mut Context) -> testkit::Result {
     cx.expect_absent(&sandbox).await
 }
 
-/// Deleting a running workload that delays TERM handling by one second finishes
-/// within ten seconds, including disappearance from get and list.
+/// Long enough that the workload is still handling TERM when sandbox shutdown
+/// begins, and below the supervisor's 5s wait before it kills the workload.
+const TERM_HANDLING_DELAY: Duration = Duration::from_secs(3);
+
+/// Well below the 30s termination grace period that a shutdown hang waits out.
+const DELETE_DEADLINE: Duration = Duration::from_secs(10);
+
+/// Many workloads do not exit immediately on TERM, for example while they run
+/// cleanup handlers. Deleting such a running sandbox should still complete
+/// promptly, rather than waiting out the runtime's termination grace period.
 #[testkit::test]
-async fn running_delete_with_delayed_term_completes_within_ten_seconds(
+async fn delete_is_prompt_when_workload_is_slow_to_handle_term(
     cx: &mut Context,
 ) -> testkit::Result {
+    // `sleep & wait` rather than a foreground `sleep`: sh defers traps until a
+    // foreground child exits, but `wait` returns on the signal.
+    let script = format!(
+        "trap 'sleep {}; exit 0' TERM; \
+         touch /tmp/delayed-term-ready; \
+         while :; do sleep 3600 & wait $!; done",
+        TERM_HANDLING_DELAY.as_secs()
+    );
     let sandbox = cx
         .sandbox("dt")
-        .command([
-            "sh",
-            "-c",
-            "trap 'sleep 1; exit 0' TERM; \
-             touch /tmp/delayed-term-ready; \
-             while :; do sleep 3600 & wait $!; done",
-        ])
+        .command(["sh", "-c", script.as_str()])
         .create()
         .await?;
     sandbox.wait_ready().await?;
@@ -85,14 +95,14 @@ async fn running_delete_with_delayed_term_completes_within_ten_seconds(
     // Use one deadline starting before delete, not a fresh timeout per step.
     // Boundary containment may kill the workload before its handler finishes;
     // this asserts bounded deletion, not a graceful workload exit.
-    tokio::time::timeout(Duration::from_secs(10), async {
+    tokio::time::timeout(DELETE_DEADLINE, async {
         sandbox.delete().await?;
         cx.expect_absent(&sandbox).await
     })
     .await
     .map_err(|_| {
         testkit::Error::msg(format!(
-            "sandbox {} was not fully deleted within 10 seconds",
+            "sandbox {} was not fully deleted within {DELETE_DEADLINE:?}",
             sandbox.name()
         ))
     })?