Light, fluffy, and always free - The AWS Local Emulator alternative
feat(lambda): support ScalingConfig.MaximumConcurrency on SQS event source mappings (#490)
Kenshin Okinakad8243b880350
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaEsmScalingConfigTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaEsmScalingConfigTest.javanew file mode 100644index 0000000000..857c02c81f--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaEsmScalingConfigTest.java@@ -0,0 +1,172 @@+package com.floci.test;++import org.junit.jupiter.api.*;+import software.amazon.awssdk.core.SdkBytes;+import software.amazon.awssdk.services.lambda.LambdaClient;+import software.amazon.awssdk.services.lambda.model.*;+import software.amazon.awssdk.services.lambda.model.Runtime;+import software.amazon.awssdk.services.sqs.SqsClient;+import software.amazon.awssdk.services.sqs.model.CreateQueueRequest;+import software.amazon.awssdk.services.sqs.model.DeleteQueueRequest;+import software.amazon.awssdk.services.sqs.model.GetQueueAttributesRequest;+import software.amazon.awssdk.services.sqs.model.QueueAttributeName;++import java.util.HashSet;+import java.util.Set;++import static org.assertj.core.api.Assertions.*;++@DisplayName("Lambda - ESM ScalingConfig")+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class LambdaEsmScalingConfigTest {++ private static final String FUNCTION_NAME = "sdk-test-esm-scaling-fn";+ private static final String SQS_QUEUE_NAME = "sdk-test-esm-scaling-queue";+ private static final String ROLE = "arn:aws:iam::000000000000:role/lambda-role";++ private static LambdaClient lambda;+ private static SqsClient sqs;+ private static String queueArn;+ private static String queueUrl;+ private static final Set<String> createdEsmUuids = new HashSet<>();++ @BeforeAll+ static void setup() {+ lambda = TestFixtures.lambdaClient();+ sqs = TestFixtures.sqsClient();++ lambda.createFunction(CreateFunctionRequest.builder()+ .functionName(FUNCTION_NAME)+ .runtime(Runtime.NODEJS20_X)+ .role(ROLE)+ .handler("index.handler")+ .code(FunctionCode.builder()+ .zipFile(SdkBytes.fromByteArray(LambdaUtils.minimalZip()))+ .build())+ .build());++ queueUrl = sqs.createQueue(CreateQueueRequest.builder()+ .queueName(SQS_QUEUE_NAME)+ .build())+ .queueUrl();+ queueArn = sqs.getQueueAttributes(GetQueueAttributesRequest.builder()+ .queueUrl(queueUrl)+ .attributeNames(QueueAttributeName.QUEUE_ARN)+ .build())+ .attributes()+ .get(QueueAttributeName.QUEUE_ARN);+ }++ @AfterAll+ static void cleanup() {+ if (lambda != null) {+ for (String uuid : createdEsmUuids) {+ try {+ lambda.deleteEventSourceMapping(DeleteEventSourceMappingRequest.builder()+ .uuid(uuid).build());+ } catch (Exception ignored) {}+ }+ try {+ lambda.deleteFunction(DeleteFunctionRequest.builder()+ .functionName(FUNCTION_NAME).build());+ } catch (Exception ignored) {}+ lambda.close();+ }+ if (sqs != null) {+ try {+ sqs.deleteQueue(DeleteQueueRequest.builder().queueUrl(queueUrl).build());+ } catch (Exception ignored) {}+ sqs.close();+ }+ }++ @Test+ @Order(1)+ void createEsm_withScalingConfig_roundTrips() {+ CreateEventSourceMappingResponse created = lambda.createEventSourceMapping(+ CreateEventSourceMappingRequest.builder()+ .functionName(FUNCTION_NAME)+ .eventSourceArn(queueArn)+ .batchSize(5)+ .scalingConfig(ScalingConfig.builder().maximumConcurrency(7).build())+ .build());+ createdEsmUuids.add(created.uuid());++ assertThat(created.scalingConfig()).isNotNull();+ assertThat(created.scalingConfig().maximumConcurrency()).isEqualTo(7);++ GetEventSourceMappingResponse fetched = lambda.getEventSourceMapping(+ GetEventSourceMappingRequest.builder().uuid(created.uuid()).build());+ assertThat(fetched.scalingConfig()).isNotNull();+ assertThat(fetched.scalingConfig().maximumConcurrency()).isEqualTo(7);+ }++ @Test+ @Order(2)+ void createEsm_withoutScalingConfig_doesNotExposeIt() {+ CreateEventSourceMappingResponse created = lambda.createEventSourceMapping(+ CreateEventSourceMappingRequest.builder()+ .functionName(FUNCTION_NAME)+ .eventSourceArn(queueArn)+ .batchSize(2)+ .build());+ createdEsmUuids.add(created.uuid());++ // SDK models an omitted object as null (or an unset builder); both are acceptable+ assertThat(created.scalingConfig() == null+ || created.scalingConfig().maximumConcurrency() == null).isTrue();+ }++ @Test+ @Order(3)+ void createEsm_withMaximumConcurrencyBelowTwo_throwsInvalidParameter() {+ assertThatThrownBy(() -> lambda.createEventSourceMapping(+ CreateEventSourceMappingRequest.builder()+ .functionName(FUNCTION_NAME)+ .eventSourceArn(queueArn)+ .scalingConfig(ScalingConfig.builder().maximumConcurrency(1).build())+ .build()))+ .isInstanceOf(InvalidParameterValueException.class);+ }++ @Test+ @Order(4)+ void createEsm_withMaximumConcurrencyAboveThousand_throwsInvalidParameter() {+ assertThatThrownBy(() -> lambda.createEventSourceMapping(+ CreateEventSourceMappingRequest.builder()+ .functionName(FUNCTION_NAME)+ .eventSourceArn(queueArn)+ .scalingConfig(ScalingConfig.builder().maximumConcurrency(1001).build())+ .build()))+ .isInstanceOf(InvalidParameterValueException.class);+ }++ @Test+ @Order(5)+ void updateEsm_addsThenClearsScalingConfig() {+ CreateEventSourceMappingResponse created = lambda.createEventSourceMapping(+ CreateEventSourceMappingRequest.builder()+ .functionName(FUNCTION_NAME)+ .eventSourceArn(queueArn)+ .batchSize(4)+ .build());+ createdEsmUuids.add(created.uuid());++ UpdateEventSourceMappingResponse added = lambda.updateEventSourceMapping(+ UpdateEventSourceMappingRequest.builder()+ .uuid(created.uuid())+ .scalingConfig(ScalingConfig.builder().maximumConcurrency(3).build())+ .build());+ assertThat(added.scalingConfig()).isNotNull();+ assertThat(added.scalingConfig().maximumConcurrency()).isEqualTo(3);++ // Clear by sending an empty ScalingConfig — AWS treats this as "reset".+ UpdateEventSourceMappingResponse cleared = lambda.updateEventSourceMapping(+ UpdateEventSourceMappingRequest.builder()+ .uuid(created.uuid())+ .scalingConfig(ScalingConfig.builder().build())+ .build());+ assertThat(cleared.scalingConfig() == null+ || cleared.scalingConfig().maximumConcurrency() == null).isTrue();+ }+}diff --git a/docs/services/lambda.md b/docs/services/lambda.mdindex a1e0557019..7e516f8824 100644--- a/docs/services/lambda.md+++ b/docs/services/lambda.md@@ -178,6 +178,34 @@ aws lambda create-event-source-mapping \--endpoint-url $AWS_ENDPOINT_URL```+### ScalingConfig (SQS only)++`CreateEventSourceMapping` and `UpdateEventSourceMapping` accept a+`ScalingConfig.MaximumConcurrency` integer between 2 and 1000 on SQS+event sources, matching the AWS wire format. `GetEventSourceMapping` and+`ListEventSourceMappings` echo the value back when set; responses omit+the `ScalingConfig` field entirely when no cap is configured.++```bash+aws lambda create-event-source-mapping \+ --function-name my-function \+ --event-source-arn $QUEUE_ARN \+ --scaling-config MaximumConcurrency=5 \+ --endpoint-url $AWS_ENDPOINT_URL+```++Validation mirrors AWS: values outside 2–1000 are rejected with+`InvalidParameterValueException`, and `ScalingConfig` on a non-SQS event+source (Kinesis / DynamoDB Streams) is also rejected — those services+use `ParallelizationFactor` instead, which is a separate field.++!!! note "Enforcement status"+ The configured `MaximumConcurrency` is persisted and returned on the+ wire, but the SQS poller does not yet cap concurrent invocations at+ this value (the poller today serializes invocations per ESM to one+ at a time regardless). Real parallel dispatch capped by+ `MaximumConcurrency` is tracked as a follow-up.+## Supported RuntimesAny runtime that has an official AWS Lambda container image works with Floci (e.g. `nodejs22.x`, `python3.13`, `java21`, `go1.x`, `provided.al2023`).\ No newline at end of filediff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaController.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaController.javaindex 0276c65b41..7887143830 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaController.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaController.java@@ -295,6 +295,14 @@ public class LambdaController {if (esm.getFunctionResponseTypes() != null) {esm.getFunctionResponseTypes().forEach(responseTypes::add);}+ // Only emit ScalingConfig when a cap is actually set — AWS omits the+ // field entirely on mappings with no MaximumConcurrency rather than+ // returning an empty object.+ Integer maxConcurrency = esm.getMaximumConcurrency();+ if (maxConcurrency != null) {+ ObjectNode scaling = node.putObject("ScalingConfig");+ scaling.put("MaximumConcurrency", maxConcurrency.intValue());+ }@SuppressWarnings("unchecked")Map<String, Object> result = objectMapper.convertValue(node, Map.class);return result;diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.javaindex 30610eb479..24bb9b1e00 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java@@ -5,11 +5,12 @@ import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.services.lambda.model.EventSourceMapping;-import io.github.hectorvent.floci.services.lambda.model.InvokeResult;import io.github.hectorvent.floci.services.lambda.model.InvocationType;+import io.github.hectorvent.floci.services.lambda.model.InvokeResult;import io.github.hectorvent.floci.services.lambda.model.LambdaAlias;import io.github.hectorvent.floci.services.lambda.model.LambdaFunction;import io.github.hectorvent.floci.services.lambda.model.LambdaUrlConfig;+import io.github.hectorvent.floci.services.lambda.model.ScalingConfig;import io.github.hectorvent.floci.services.lambda.zip.CodeStore;import io.github.hectorvent.floci.services.lambda.zip.ZipExtractor;import io.github.hectorvent.floci.services.s3.S3Service;@@ -442,6 +443,8 @@ public class LambdaService {? (List<String>) request.get("FunctionResponseTypes"): new ArrayList<>();+ ScalingConfig scalingConfig = parseScalingConfig(request, eventSourceArn);+String queueUrl = eventSourceArn.contains(":sqs:") ? AwsArnUtils.arnToQueueUrl(eventSourceArn, config.effectiveBaseUrl()) : null;EventSourceMapping esm = new EventSourceMapping();@@ -454,6 +457,7 @@ public class LambdaService {esm.setBatchSize(batchSize);esm.setEnabled(enabled);esm.setState(enabled ? "Enabled" : "Disabled");+ esm.setScalingConfig(scalingConfig);esm.setFunctionResponseTypes(functionResponseTypes);esm.setLastModified(System.currentTimeMillis());@@ -465,6 +469,53 @@ public class LambdaService {return esm;}+ /**+ * Parses {@code ScalingConfig} out of a create/update request and applies+ * AWS-level validation: {@code MaximumConcurrency} must be in [2, 1000]+ * and is only valid on SQS event sources. Returns {@code null} when no+ * config was supplied or when the supplied config has no cap (AWS treats+ * an empty ScalingConfig as "clear the cap").+ */+ private ScalingConfig parseScalingConfig(Map<String, Object> request, String eventSourceArn) {+ Object raw = request.get("ScalingConfig");+ if (raw == null) {+ return null;+ }+ if (!(raw instanceof Map<?, ?>)) {+ throw new AwsException("InvalidParameterValueException",+ "ScalingConfig must be a JSON object", 400);+ }+ boolean isSqs = eventSourceArn != null && eventSourceArn.contains(":sqs:");+ Map<?, ?> map = (Map<?, ?>) raw;+ Object mc = map.get("MaximumConcurrency");+ if (mc == null) {+ if (!isSqs) {+ throw new AwsException("InvalidParameterValueException",+ "ScalingConfig is only supported for Amazon SQS event source mappings", 400);+ }+ return null;+ }+ if (!(mc instanceof Number)) {+ throw new AwsException("InvalidParameterValueException",+ "ScalingConfig.MaximumConcurrency must be a numeric value", 400);+ }+ double d = ((Number) mc).doubleValue();+ if (Double.isNaN(d) || Double.isInfinite(d) || d != Math.floor(d)) {+ throw new AwsException("InvalidParameterValueException",+ "ScalingConfig.MaximumConcurrency must be an integer", 400);+ }+ long longValue = ((Number) mc).longValue();+ if (longValue < 2 || longValue > 1000) {+ throw new AwsException("InvalidParameterValueException",+ "ScalingConfig.MaximumConcurrency must be between 2 and 1000 (got " + longValue + ")", 400);+ }+ if (!isSqs) {+ throw new AwsException("InvalidParameterValueException",+ "ScalingConfig is only supported for Amazon SQS event source mappings", 400);+ }+ return new ScalingConfig((int) longValue);+ }+private void startPollingHelper(EventSourceMapping esm) {if (esm.getEventSourceArn().contains(":sqs:")) {poller.startPolling(esm);@@ -514,6 +565,11 @@ public class LambdaService {esm.setEnabled(nowEnabled);esm.setState(nowEnabled ? "Enabled" : "Disabled");}+ if (request.containsKey("ScalingConfig")) {+ // AWS: passing ScalingConfig resets it. An empty object or one+ // with MaximumConcurrency=null clears the cap.+ esm.setScalingConfig(parseScalingConfig(request, esm.getEventSourceArn()));+ }esm.setLastModified(System.currentTimeMillis());esmStore.save(esm);diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/model/EventSourceMapping.java b/src/main/java/io/github/hectorvent/floci/services/lambda/model/EventSourceMapping.javaindex b42759afd1..38fdb60c67 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/model/EventSourceMapping.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/model/EventSourceMapping.java@@ -24,6 +24,7 @@ public class EventSourceMapping {private long lastModified;private List<String> functionResponseTypes = new ArrayList<>();private Map<String, String> shardSequenceNumbers = new HashMap<>();+ private ScalingConfig scalingConfig;public EventSourceMapping() {}@@ -71,4 +72,12 @@ public class EventSourceMapping {public void setShardSequenceNumbers(Map<String, String> shardSequenceNumbers) {this.shardSequenceNumbers = shardSequenceNumbers != null ? shardSequenceNumbers : new java.util.HashMap<>();}++ public ScalingConfig getScalingConfig() { return scalingConfig; }+ public void setScalingConfig(ScalingConfig scalingConfig) { this.scalingConfig = scalingConfig; }++ /** Convenience accessor: returns {@code null} when no cap is configured. */+ public Integer getMaximumConcurrency() {+ return scalingConfig != null ? scalingConfig.getMaximumConcurrency() : null;+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/model/ScalingConfig.java b/src/main/java/io/github/hectorvent/floci/services/lambda/model/ScalingConfig.javanew file mode 100644index 0000000000..a8c7880349--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/model/ScalingConfig.java@@ -0,0 +1,38 @@+package io.github.hectorvent.floci.services.lambda.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * AWS Lambda Event Source Mapping scaling configuration.+ *+ * <p>Currently carries only {@code MaximumConcurrency}, the SQS-only cap on+ * how many Lambda invocations an ESM may run in parallel. The rest of the+ * AWS schema (none today) can extend this class as needed.+ *+ * <p>Wire shape:+ * <pre>{@code+ * "ScalingConfig": { "MaximumConcurrency": 5 }+ * }</pre>+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class ScalingConfig {++ private Integer maximumConcurrency;++ public ScalingConfig() {+ }++ public ScalingConfig(Integer maximumConcurrency) {+ this.maximumConcurrency = maximumConcurrency;+ }++ public Integer getMaximumConcurrency() {+ return maximumConcurrency;+ }++ public void setMaximumConcurrency(Integer maximumConcurrency) {+ this.maximumConcurrency = maximumConcurrency;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/EsmIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/EsmIntegrationTest.javaindex fb79b20ce9..33c2039a34 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/EsmIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/EsmIntegrationTest.java@@ -254,4 +254,336 @@ class EsmIntegrationTest {.then().statusCode(404);}++ // ──────────────────────────── ScalingConfig ────────────────────────────++ @Test+ @Order(40)+ void createEventSourceMappingWithScalingConfigRoundTrips() {+ String uuid = given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "BatchSize": 5,+ "ScalingConfig": { "MaximumConcurrency": 7 }+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(202)+ .body("ScalingConfig.MaximumConcurrency", equalTo(7))+ .extract()+ .path("UUID");++ given()+ .when()+ .get(LAMBDA_BASE + "/event-source-mappings/" + uuid)+ .then()+ .statusCode(200)+ .body("ScalingConfig.MaximumConcurrency", equalTo(7));++ given().delete(LAMBDA_BASE + "/event-source-mappings/" + uuid).then().statusCode(202);+ }++ @Test+ @Order(41)+ void createEventSourceMappingRejectsMaximumConcurrencyBelowMinimum() {+ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "ScalingConfig": { "MaximumConcurrency": 1 }+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(400)+ .body("message", containsString("between 2 and 1000"));+ }++ @Test+ @Order(42)+ void createEventSourceMappingRejectsMaximumConcurrencyAboveMaximum() {+ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "ScalingConfig": { "MaximumConcurrency": 1001 }+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(400)+ .body("message", containsString("between 2 and 1000"));+ }++ @Test+ @Order(43)+ void createEventSourceMappingRejectsScalingConfigOnNonSqsSource() {+ // MaximumConcurrency is SQS-only in AWS. Kinesis uses ParallelizationFactor.+ String kinesisArn = "arn:aws:kinesis:" + REGION + ":" + ACCOUNT_ID + ":stream/irrelevant";+ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "ScalingConfig": { "MaximumConcurrency": 5 }+ }+ """.formatted(FUNCTION_NAME, kinesisArn))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(400)+ .body("message", containsString("only supported for Amazon SQS"));+ }++ @Test+ @Order(44)+ void createEventSourceMappingRejectsEmptyScalingConfigOnNonSqsSource() {+ String kinesisArn = "arn:aws:kinesis:" + REGION + ":" + ACCOUNT_ID + ":stream/irrelevant";+ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "ScalingConfig": {}+ }+ """.formatted(FUNCTION_NAME, kinesisArn))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(400)+ .body("message", containsString("only supported for Amazon SQS"));+ }++ @Test+ @Order(45)+ void createEventSourceMappingRejectsNonIntegerMaximumConcurrency() {+ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "ScalingConfig": { "MaximumConcurrency": 2.5 }+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(400)+ .body("message", containsString("must be an integer"));+ }++ @Test+ @Order(46)+ void createEventSourceMappingRejectsStringMaximumConcurrency() {+ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "ScalingConfig": { "MaximumConcurrency": "7" }+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(400)+ .body("message", containsString("numeric"));+ }++ @Test+ @Order(47)+ void createEventSourceMappingRejectsNonObjectScalingConfig() {+ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "ScalingConfig": "not-an-object"+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(400)+ .body("message", containsString("JSON object"));+ }++ @Test+ @Order(48)+ void responseOmitsScalingConfigWhenUnset() {+ // A mapping created without ScalingConfig should not expose the key+ // in subsequent responses — AWS omits the field rather than returning+ // an empty object.+ String uuid = given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "BatchSize": 2+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(202)+ .body("$", not(hasKey("ScalingConfig")))+ .extract()+ .path("UUID");++ given().delete(LAMBDA_BASE + "/event-source-mappings/" + uuid).then().statusCode(202);+ }++ @Test+ @Order(49)+ void updateEventSourceMappingRejectsInvalidScalingConfig() {+ String uuid = given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "BatchSize": 2+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(202)+ .extract()+ .path("UUID");++ // Below minimum+ given()+ .contentType("application/json")+ .body("{ \"ScalingConfig\": { \"MaximumConcurrency\": 1 } }")+ .when()+ .put(LAMBDA_BASE + "/event-source-mappings/" + uuid)+ .then()+ .statusCode(400)+ .body("message", containsString("between 2 and 1000"));++ // Above maximum+ given()+ .contentType("application/json")+ .body("{ \"ScalingConfig\": { \"MaximumConcurrency\": 1001 } }")+ .when()+ .put(LAMBDA_BASE + "/event-source-mappings/" + uuid)+ .then()+ .statusCode(400)+ .body("message", containsString("between 2 and 1000"));++ given().delete(LAMBDA_BASE + "/event-source-mappings/" + uuid).then().statusCode(202);+ }++ @Test+ @Order(50)+ void listEventSourceMappingsWithMixedScalingConfig() {+ // Create one ESM with ScalingConfig and one without.+ String uuidWith = given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "BatchSize": 3,+ "ScalingConfig": { "MaximumConcurrency": 10 }+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(202)+ .extract()+ .path("UUID");++ String uuidWithout = given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "BatchSize": 4+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(202)+ .extract()+ .path("UUID");++ // List should return both; one with ScalingConfig and one without.+ given()+ .when()+ .get(LAMBDA_BASE + "/event-source-mappings?FunctionName=" + FUNCTION_ARN)+ .then()+ .statusCode(200)+ .body("EventSourceMappings.find { it.UUID == '" + uuidWith + "' }.ScalingConfig.MaximumConcurrency",+ equalTo(10))+ .body("EventSourceMappings.find { it.UUID == '" + uuidWithout + "' }.ScalingConfig",+ nullValue());++ given().delete(LAMBDA_BASE + "/event-source-mappings/" + uuidWith).then().statusCode(202);+ given().delete(LAMBDA_BASE + "/event-source-mappings/" + uuidWithout).then().statusCode(202);+ }++ @Test+ @Order(51)+ void updateEventSourceMappingAddsAndClearsScalingConfig() {+ String uuid = given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "BatchSize": 4+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(202)+ .body("$", not(hasKey("ScalingConfig")))+ .extract()+ .path("UUID");++ // Add+ given()+ .contentType("application/json")+ .body("{ \"ScalingConfig\": { \"MaximumConcurrency\": 3 } }")+ .when()+ .put(LAMBDA_BASE + "/event-source-mappings/" + uuid)+ .then()+ .statusCode(202)+ .body("ScalingConfig.MaximumConcurrency", equalTo(3));++ // Clear by sending an empty ScalingConfig (AWS semantics)+ given()+ .contentType("application/json")+ .body("{ \"ScalingConfig\": {} }")+ .when()+ .put(LAMBDA_BASE + "/event-source-mappings/" + uuid)+ .then()+ .statusCode(202)+ .body("$", not(hasKey("ScalingConfig")));++ given().delete(LAMBDA_BASE + "/event-source-mappings/" + uuid).then().statusCode(202);+ }}