Assorted CI fixes (#1072)

* fix: remove redundant cloned() call in iterator

* fix: only run cleanup if stack name is set

* fix: only run rustdoc verification against workspace packages

* fix(test): avoid cross-test state pollution in streaming_send_data_error_is_ignored

- Use tokio_unstable with UnhandledPanic::ShutdownRuntime to detect panics
- Create isolated runtime per test to avoid global panic hook interference
- Test verifies spawned tasks handle send_data errors without panicking
- CI: enable tokio_unstable for lambda_runtime tests only

Author: jlizen

.github/actions/rust-build/action.yml

@@ -28,4 +28,6 @@ runs:
     - name: Run tests
       if: ${{ inputs.run-tests == 'true' }}
       shell: bash
+      env:
+        RUSTFLAGS: ${{ inputs.package == 'lambda_runtime' && '--cfg tokio_unstable' || '' }}
       run: cargo test --all-features --verbose --package ${{ inputs.package }}

.github/workflows/check-docs.yml

@@ -37,6 +37,5 @@ jobs:
       - name: Check documentation
         shell: bash
         env:
-            RUSTFLAGS: --cfg docsrs 
             RUSTDOCFLAGS: --cfg docsrs -Dwarnings
-        run: cargo doc --no-deps --document-private-items --all-features
+        run: cargo doc --workspace --no-deps --document-private-items --all-features

.github/workflows/run-integration-test.yml

@@ -55,7 +55,7 @@ jobs:
             TEST_ENDPOINT: ${{ steps.deploy_stack.outputs.TEST_ENDPOINT }}
           run: cd lambda-integration-tests && cargo test
         - name: cleanup
-          if: always()
+          if: always() && steps.deploy_stack.outputs.STACK_NAME
           env:
             AWS_REGION: ${{ secrets.AWS_REGION }}
             STACK_NAME: ${{ steps.deploy_stack.outputs.STACK_NAME }}

lambda-http/src/response.rs

@@ -97,7 +97,6 @@ impl LambdaResponse {
                 let cookies = headers
                     .get_all(SET_COOKIE)
                     .iter()
-                    .cloned()
                     .map(|v| v.to_str().ok().unwrap_or_default().to_string())
                     .collect();
                 headers.remove(SET_COOKIE);

lambda-runtime/src/requests.rs

@@ -218,45 +218,41 @@ mod tests {
         });
     }
 
-    #[tokio::test]
-    async fn streaming_send_data_error_is_ignored() {
+    #[test]
+    #[cfg(tokio_unstable)]
+    fn streaming_send_data_error_is_ignored() {
         use crate::StreamResponse;
-        use std::sync::{
-            atomic::{AtomicBool, Ordering},
-            Arc,
-        };
-
-        // Track if a panic occurred in any spawned task
-        let panicked = Arc::new(AtomicBool::new(false));
-        let panicked_clone = panicked.clone();
 
-        // Set a custom panic hook to detect panics in spawned tasks
-        let old_hook = std::panic::take_hook();
-        std::panic::set_hook(Box::new(move |_| {
-            panicked_clone.store(true, Ordering::SeqCst);
-        }));
-
-        let stream = tokio_stream::iter(vec![Ok::<Bytes, Error>(Bytes::from_static(b"chunk"))]);
+        let runtime = tokio::runtime::Builder::new_current_thread()
+            .unhandled_panic(tokio::runtime::UnhandledPanic::ShutdownRuntime)
+            .enable_all()
+            .build()
+            .unwrap();
 
-        let stream_response: StreamResponse<_> = stream.into();
-        let response = FunctionResponse::StreamingResponse(stream_response);
+        // We don't want to use a global panic hook to avoid shared state across tests, but we need to know
+        // if a background task panics. We accomplish this by using UnhandledPanic::ShutdownRuntime
+        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            runtime.block_on(async {
+                let stream = tokio_stream::iter(vec![Ok::<Bytes, Error>(Bytes::from_static(b"chunk"))]);
 
-        let req: EventCompletionRequest<'_, _, (), _, _, _> = EventCompletionRequest::new("id", response);
+                let stream_response: StreamResponse<_> = stream.into();
+                let response = FunctionResponse::StreamingResponse(stream_response);
 
-        let http_req = req.into_req().expect("into_req should succeed");
+                let req: EventCompletionRequest<'_, _, (), _, _, _> = EventCompletionRequest::new("id", response);
 
-        // immediate drop simulates client disconnection
-        drop(http_req);
+                let http_req = req.into_req().expect("into_req should succeed");
 
-        // give the spawned task time to run and potentially panic
-        tokio::time::sleep(Duration::from_millis(10)).await;
+                // immediate drop simulates client disconnection
+                drop(http_req);
 
-        // Restore the old panic hook
-        std::panic::set_hook(old_hook);
+                // give the spawned task time to complete
+                tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+            })
+        }));
 
         assert!(
-            !panicked.load(Ordering::SeqCst),
-            "spawned task panicked - send_data errors should be ignored, not unwrapped"
+            result.is_ok(),
+            "spawned task panicked - send_data errors should be ignored"
         );
     }
 }