chore: better testing

Author: darklight3it

examples/basic-lambda-concurrent/src/main.rs

@@ -1,27 +1,38 @@
 // This example requires the following input to succeed:
 // { "command": "do something" }
 
-use lambda_runtime::{service_fn, tracing, Error, LambdaEvent};
+use lambda_runtime::{service_fn, tracing, Diagnostic, Error, LambdaEvent};
 use serde::{Deserialize, Serialize};
 
-/// This is also a made-up example. Requests come into the runtime as unicode
-/// strings in json format, which can map to any structure that implements `serde::Deserialize`
-/// The runtime pays no attention to the contents of the request payload.
 #[derive(Deserialize)]
 struct Request {
     command: String,
 }
 
-/// This is a made-up example of what a response structure may look like.
-/// There is no restriction on what it can be. The runtime requires responses
-/// to be serialized into json. The runtime pays no attention
-/// to the contents of the response payload.
 #[derive(Serialize)]
 struct Response {
     req_id: String,
     msg: String,
 }
 
+#[derive(Debug)]
+struct HandlerError(String);
+
+impl std::fmt::Display for HandlerError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl From<HandlerError> for Diagnostic {
+    fn from(e: HandlerError) -> Diagnostic {
+        Diagnostic {
+            error_type: "HandlerError".into(),
+            error_message: e.0,
+        }
+    }
+}
+
 #[tokio::main]
 async fn main() -> Result<(), Error> {
     // required to enable CloudWatch error logging by the runtime
@@ -38,17 +49,18 @@ async fn main() -> Result<(), Error> {
     Ok(())
 }
 
-pub(crate) async fn my_handler(event: LambdaEvent<Request>) -> Result<Response, Error> {
-    // extract some useful info from the request
+pub(crate) async fn my_handler(event: LambdaEvent<Request>) -> Result<Response, HandlerError> {
     let command = event.payload.command;
 
-    // prepare the response
+    if command == "fail" {
+        return Err(HandlerError("simulated handler error".into()));
+    }
+
     let resp = Response {
         req_id: event.context.request_id,
         msg: format!("Command {command} executed."),
     };
 
-    // return `Response` (it will be serialized to JSON automatically by the runtime)
     Ok(resp)
 }
 

test/dockerized/scenarios/concurrent_scenarios.py

@@ -10,7 +10,7 @@
 
 HANDLER = "basic-lambda-concurrent"
 IMAGE = os.environ.get("TEST_IMAGE", "local/test-base")
-DEFAULT_CONCURRENCY = 2
+DEFAULT_CONCURRENCY = 10
 
 
 def _make_env(concurrency: int = DEFAULT_CONCURRENCY) -> dict:
@@ -40,11 +40,11 @@ def get_concurrent_scenarios():
         image=IMAGE,
     ))
 
-    # Error isolation: N-1 invalid payloads + 1 valid — the valid one must still succeed
+    # Error isolation: N-1 failing requests + 1 valid — the valid one must still succeed
     mixed_batch = [
         Request(
-            payload={"not_a_command": "oops"},
-            assertions=[{"errorType": "&lambda_runtime::deserializer::DeserializeError"}],
+            payload={"command": "fail"},
+            assertions=[{"errorType": "HandlerError"}],
         )
         for _ in range(DEFAULT_CONCURRENCY - 1)
     ] + [