chore: fmt

Author: darklight3it

lambda-runtime/src/layers/api_response.rs

@@ -1,5 +1,10 @@
 use crate::{
-    Diagnostic, EventErrorRequest, IntoFunctionResponse, LambdaEvent, constants::LAMBDA_RUNTIME_INVOCATION_ID, deserializer, rate_limiter::RateLimiter, requests::{EventCompletionRequest, IntoRequest}, runtime::LambdaInvocation,
+    constants::LAMBDA_RUNTIME_INVOCATION_ID,
+    deserializer,
+    rate_limiter::RateLimiter,
+    requests::{EventCompletionRequest, IntoRequest},
+    runtime::LambdaInvocation,
+    Diagnostic, EventErrorRequest, IntoFunctionResponse, LambdaEvent,
 };
 use futures::{ready, Stream};
 use lambda_runtime_api_client::{body::Body, BoxError};
@@ -9,7 +14,6 @@ use std::{fmt::Debug, future::Future, marker::PhantomData, pin::Pin, task, time:
 use tower::Service;
 use tracing::{error, trace, warn};
 
-
 static MALFORMED_INVOCATION_ID_LIMITER: RateLimiter = RateLimiter::new(Duration::from_secs(60));
 
 /// Tower service that turns the result or an error of a handler function into a Lambda Runtime API
@@ -132,7 +136,6 @@ where
             Some(value) => match value.to_str() {
                 Ok(value) => Some(value.to_owned()),
                 Err(error) => {
-
                     if MALFORMED_INVOCATION_ID_LIMITER.allow() {
                         warn!(
                             error = ?error,

lambda-runtime/src/rate_limiter.rs

@@ -66,8 +66,10 @@ impl RateLimiter {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::panic::{catch_unwind, AssertUnwindSafe};
-    use std::thread;
+    use std::{
+        panic::{catch_unwind, AssertUnwindSafe},
+        thread,
+    };
 
     #[test]
     fn allows_first_call() {

test/dockerized/scenarios/concurrent_scenarios.py

@@ -1,12 +1,7 @@
-"""
-Multi-concurrency test scenarios for basic-lambda-concurrent.
-
-The handler expects: { "command": "<string>" }
-and responds with:   { "req_id": "<id>", "msg": "Command <command> executed." }
-"""
+"""Multi-concurrency test scenarios."""
 
 import os
-from containerized_test_runner.models import Request, ConcurrentTest
+from containerized_test_runner.models import ConcurrentTest, Request
 
 HANDLER = "basic-lambda-concurrent"
 INVOCATION_ID_HANDLER = "invocation-id-concurrent"
@@ -16,16 +11,20 @@
 TIMEOUT = 5
 
 
-def _make_env(concurrency: int = DEFAULT_CONCURRENCY) -> dict:
+def _make_env(handler: str = HANDLER, concurrency: int = DEFAULT_CONCURRENCY) -> dict:
     return {
-        "_HANDLER": HANDLER,
+        "_HANDLER": handler,
         "AWS_LAMBDA_MAX_CONCURRENCY": str(concurrency),
         "AWS_LAMBDA_LOG_FORMAT": "JSON",
     }
 
 
-def _invocation_id_env(concurrency: int = DEFAULT_CONCURRENCY, timeout: int = TIMEOUT) -> dict:
-    return _make_env(concurrency) | {
+def _invocation_id_env(
+    handler: str = INVOCATION_ID_HANDLER,
+    concurrency: int = DEFAULT_CONCURRENCY,
+    timeout: int = TIMEOUT,
+) -> dict:
+    return _make_env(handler, concurrency) | {
         "AWS_LAMBDA_FUNCTION_TIMEOUT": str(timeout),
     }
 
@@ -91,7 +90,7 @@ def get_invocation_id_scenarios():
     return [ConcurrentTest(
         name="invocation_id",
         handler=INVOCATION_ID_HANDLER,
-        environment_variables=_invocation_id_env(timeout=TIMEOUT),
+        environment_variables=_invocation_id_env(handler=INVOCATION_ID_HANDLER, timeout=TIMEOUT),
         request_batches=batches,
         image=IMAGE,
     )]