Light, fluffy, and always free - The AWS Local Emulator alternative
fix(lambda): validate enum and pattern-constrained request fields (#4611)
Sam Fakhreddinee6d22e8bcfdd
diff --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 366afa6973..98692799f2 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@@ -315,8 +315,9 @@ public class LambdaController {@GET@Path("/event-source-mappings")- public Response listEventSourceMappings(@QueryParam("FunctionName") String functionArn) {- List<EventSourceMapping> esms = lambdaService.listEventSourceMappings(functionArn);+ public Response listEventSourceMappings(@QueryParam("FunctionName") String functionArn,+ @QueryParam("EventSourceArn") String eventSourceArn) {+ List<EventSourceMapping> esms = lambdaService.listEventSourceMappings(functionArn, eventSourceArn);ObjectNode root = objectMapper.createObjectNode();ArrayNode items = root.putArray("EventSourceMappings");for (EventSourceMapping esm : esms) {diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaLayerService.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaLayerService.javaindex 2f1a76c47c..30a5edb141 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaLayerService.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaLayerService.java@@ -124,6 +124,10 @@ public class LambdaLayerService {String description = (String) request.get("Description");String licenseInfo = (String) request.get("LicenseInfo");+ LambdaService.validateEnumList(request.get("CompatibleRuntimes"), "compatibleRuntimes",+ LambdaService.RUNTIME_VALUES, 15);+ LambdaService.validateEnumList(request.get("CompatibleArchitectures"), "compatibleArchitectures",+ LambdaService.ARCHITECTURE_VALUES, 2);List<String> compatibleRuntimes = request.get("CompatibleRuntimes") instanceof List? (List<String>) request.get("CompatibleRuntimes") : null;List<String> compatibleArchitectures = request.get("CompatibleArchitectures") instanceof Listdiff --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 0935413d31..46c991b930 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@@ -82,9 +82,36 @@ public class LambdaService implements ResourceProvider {// The model's own Role pattern, which AWS quotes verbatim in its validation message; it// already accepts every partition.private static final Pattern ROLE_ARN_PATTERN = Pattern.compile(- "arn:(aws[a-zA-Z-]*)?:iam::\\d{12}:role/?[a-zA-Z_0-9+=,.@\\-_/]+");- private static final Pattern HANDLER_PATTERN = Pattern.compile("\\S+");+ "^arn:(aws[a-zA-Z-]*)?:iam::\\d{12}:role/?[a-zA-Z_0-9+=,.@\\-_/]+$");+ private static final Pattern HANDLER_PATTERN = Pattern.compile("^[^\\s]+$");private static final int MAX_HANDLER_LENGTH = 128;+ private static final Pattern KMS_KEY_ARN_PATTERN = Pattern.compile(+ "^(arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)?$");+ private static final Pattern LAYER_VERSION_ARN_PATTERN = Pattern.compile(+ "^((arn:(aws[a-zA-Z-]*)?:lambda:(eusc-)?[a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:\\d{12}:layer:[a-zA-Z0-9-_]+:[0-9]+)"+ + "|(arn:[a-zA-Z0-9-]+:lambda:::awslayer:[a-zA-Z0-9-_]+))$");+ private static final Pattern ALIAS_NAME_PATTERN = Pattern.compile("^(?!^[0-9]+$)([a-zA-Z0-9-_]+)$");+ private static final Pattern FUNCTION_URL_QUALIFIER_PATTERN = Pattern.compile("^(?!^\\d+$)[0-9a-zA-Z-_]+$");+ private static final Pattern EVENT_SOURCE_ARN_PATTERN = Pattern.compile(+ "^arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9-])+:((eusc-)?[a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1})?:(\\d{12})?:(.*)$");+ private static final Pattern LIST_ESM_FUNCTION_NAME_PATTERN = Pattern.compile(+ "^(arn:(aws[a-zA-Z-]*)?:lambda:)?((eusc-)?[a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?"+ + "(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST(\\.PUBLISHED)?|[a-zA-Z0-9-_]+))?$");++ /** botocore lambda/2015-03-31 Runtime shape enum, kept in sync with service-2.json. */+ static final List<String> RUNTIME_VALUES = List.of(+ "nodejs", "nodejs4.3", "nodejs6.10", "nodejs8.10", "nodejs10.x", "nodejs12.x", "nodejs14.x",+ "nodejs16.x", "nodejs18.x", "nodejs20.x", "nodejs22.x", "nodejs24.x", "nodejs26.x",+ "java8", "java8.al2", "java11", "java17", "java21", "java25",+ "python2.7", "python3.6", "python3.7", "python3.8", "python3.9", "python3.10", "python3.11",+ "python3.12", "python3.13", "python3.14", "python3.15",+ "dotnetcore1.0", "dotnetcore2.0", "dotnetcore2.1", "dotnetcore3.1", "dotnet6", "dotnet8", "dotnet10",+ "nodejs4.3-edge", "go1.x", "ruby2.5", "ruby2.7", "ruby3.2", "ruby3.3", "ruby3.4", "ruby4.0",+ "provided", "provided.al2", "provided.al2023",+ "java8.al2023", "java11.al2023", "java17.al2023");+ static final List<String> ARCHITECTURE_VALUES = List.of("x86_64", "arm64");+ private static final List<String> FUNCTION_URL_AUTH_TYPE_VALUES = List.of("NONE", "AWS_IAM");+ private static final List<String> INVOKE_MODE_VALUES = List.of("BUFFERED", "RESPONSE_STREAM");private static final List<String> FUNCTION_ARCHITECTURES = List.of("x86_64", "arm64");private static final List<String> FUNCTION_RESPONSE_TYPES = List.of("ReportBatchItemFailures");@@ -381,6 +408,7 @@ public class LambdaService implements ResourceProvider {String role = (String) request.get("Role");String handler = (String) request.get("Handler");String runtime = (String) request.get("Runtime");+ validateEnum(request.get("PackageType"), "packageType", List.of("Zip", "Image"));String packageType = request.getOrDefault("PackageType", "Zip").toString();String description = (String) request.get("Description");int timeout = toInt(request.get("Timeout"), config != null ? config.services().lambda().defaultTimeoutSeconds() : 3);@@ -396,12 +424,17 @@ public class LambdaService implements ResourceProvider {if (role == null || role.isBlank()) {throw new AwsException("InvalidParameterValueException", "Role is required", 400);}+ validatePattern(role, "role", ROLE_ARN_PATTERN);if ("Zip".equals(packageType) && (handler == null || handler.isBlank())) {throw new AwsException("InvalidParameterValueException", "Handler is required", 400);}+ validatePattern(handler, "handler", HANDLER_PATTERN);+ validateMaxLength(handler, "handler", 128);if ("Zip".equals(packageType) && (runtime == null || runtime.isBlank())) {throw new AwsException("InvalidParameterValueException", "Runtime is required for Zip package type", 400);}+ validateEnum(runtime, "runtime", RUNTIME_VALUES);+ validateMaxLength(description, "description", 256);if (functionStore.get(region, functionName).isPresent()) {throw new AwsException("ResourceConflictException",@@ -455,16 +488,18 @@ public class LambdaService implements ResourceProvider {}// Layers+ validateArnList(request.get("Layers"), "layers", LAYER_VERSION_ARN_PATTERN, 5);@SuppressWarnings("unchecked")- List<String> layers = request.get("Layers") instanceof List- ? (List<String>) request.get("Layers") : null;+ List<String> layers = (List<String>) request.get("Layers");if (layers != null) {validateLayersResolvable(layers);fn.setLayers(new ArrayList<>(layers));}if (request.containsKey("KMSKeyArn")) {- fn.setKmsKeyArn((String) request.get("KMSKeyArn"));+ Object kmsKeyArn = request.get("KMSKeyArn");+ validatePattern(kmsKeyArn, "kmsKeyArn", KMS_KEY_ARN_PATTERN);+ fn.setKmsKeyArn((String) kmsKeyArn);}if (vpcConfig != null) {@@ -740,12 +775,19 @@ public class LambdaService implements ResourceProvider {// same reference, not a copy), so validating this late would leave every// already-applied field (Description, Timeout, ...) live on a rejected update, since// nothing here is transactional and there's a single save() at the very end.+ if (request.containsKey("Layers")) {+ validateArnList(request.get("Layers"), "layers", LAYER_VERSION_ARN_PATTERN, 5);+ }@SuppressWarnings("unchecked")- List<String> layerList = request.containsKey("Layers") && request.get("Layers") instanceof List- ? (List<String>) request.get("Layers") : null;+ List<String> layerList = (List<String>) request.get("Layers");if (request.containsKey("Layers")) {validateLayersResolvable(layerList);}+ validateMaxLength(request.get("Description"), "description", 256);+ if (request.containsKey("Runtime")) {+ validateEnum(request.get("Runtime"), "runtime", RUNTIME_VALUES);+ }+ validatePattern(request.get("KMSKeyArn"), "kmsKeyArn", KMS_KEY_ARN_PATTERN);if (request.containsKey("SnapStart")) {validateSnapStart(snapStart);}@@ -1207,6 +1249,7 @@ public class LambdaService implements ResourceProvider {if (eventSourceArn == null || eventSourceArn.isBlank()) {throw new AwsException("InvalidParameterValueException", "EventSourceArn is required", 400);}+ validatePattern(eventSourceArn, "eventSourceArn", EVENT_SOURCE_ARN_PATTERN);if (!eventSourceArn.contains(":sqs:") && !eventSourceArn.contains(":kinesis:")&& !eventSourceArn.contains(":dynamodb:")) {throw new AwsException("InvalidParameterValueException",@@ -1767,13 +1810,27 @@ public class LambdaService implements ResourceProvider {}public List<EventSourceMapping> listEventSourceMappings(String functionArn) {+ return listEventSourceMappings(functionArn, null);+ }++ public List<EventSourceMapping> listEventSourceMappings(String functionArn, String eventSourceArn) {+ validatePattern(functionArn, "functionName", LIST_ESM_FUNCTION_NAME_PATTERN);+ validatePattern(eventSourceArn, "eventSourceArn", EVENT_SOURCE_ARN_PATTERN);+ List<EventSourceMapping> mappings;if (functionArn != null && !functionArn.isBlank()) {// Accept bare name, partial ARN, or full ARN. The store matches// entries by their canonical short name, so normalize first.String shortName = LambdaArnUtils.resolve(functionArn).name();- return esmStore.listByFunction(shortName);+ mappings = esmStore.listByFunction(shortName);+ } else {+ mappings = esmStore.list();+ }+ if (eventSourceArn != null && !eventSourceArn.isBlank()) {+ mappings = mappings.stream()+ .filter(esm -> eventSourceArn.equals(esm.getEventSourceArn()))+ .toList();}- return esmStore.list();+ return mappings;}public EventSourceMapping updateEventSourceMapping(String uuid, Map<String, Object> request) {@@ -2341,7 +2398,7 @@ public class LambdaService implements ResourceProvider {validateLogGroup(logging.get("LogGroup"));}- private static void validateEnum(Object value, String field, List<String> allowed) {+ static void validateEnum(Object value, String field, List<String> allowed) {if (value == null || allowed.contains(value)) {return;}@@ -2351,6 +2408,78 @@ public class LambdaService implements ResourceProvider {+ String.join(", ", allowed) + "]", 400);}+ /**+ * A list member is either absent (null) or a JSON array; any other JSON type is a deserialization+ * failure, so it must not be mistaken for an absent member and silently clear a stored value.+ */+ private static Object requireListOrNull(Object value, String field) {+ if (value != null && !(value instanceof List<?>)) {+ throw new AwsException("SerializationException", field + " must be a JSON array or null", 400);+ }+ return value;+ }++ /** Validates every element of a request-supplied list against an enum, and its max size. */+ static void validateEnumList(Object value, String field, List<String> allowed, int maxItems) {+ if (!(requireListOrNull(value, field) instanceof List<?> list)) {+ return;+ }+ if (list.size() > maxItems) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value at '" + field + "' failed to satisfy constraint: "+ + "Member must have length less than or equal to " + maxItems, 400);+ }+ for (Object item : list) {+ validateEnum(item, field + ".member", allowed);+ }+ }++ /** Validates a request-supplied string against a botocore regex constraint, when present. */+ private static void validatePattern(Object value, String field, Pattern pattern) {+ if (!(value instanceof String s) || s.isEmpty()) {+ return;+ }+ if (!pattern.matcher(s).matches()) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + s + "' at '" + field + "' failed to satisfy "+ + "constraint: Member must satisfy regular expression pattern: " + pattern.pattern(), 400);+ }+ }++ /** Validates every element of a request-supplied string list against a pattern, and its max size. */+ private static void validateArnList(Object value, String field, Pattern pattern, int maxItems) {+ if (!(requireListOrNull(value, field) instanceof List<?> list)) {+ return;+ }+ if (list.size() > maxItems) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value at '" + field + "' failed to satisfy constraint: "+ + "Member must have length less than or equal to " + maxItems, 400);+ }+ for (Object item : list) {+ validatePattern(item, field + ".member", pattern);+ }+ }++ /** Enforces a shape's 1-character minimum: an empty string is rejected, and null too when the member is required. */+ private static void validateNonEmpty(String value, String field, boolean required) {+ if ((value == null && required) || (value != null && value.isEmpty())) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + (value == null ? "" : value) + "' at '" + field+ + "' failed to satisfy constraint: Member must have length greater than or equal to 1",+ 400);+ }+ }++ private static void validateMaxLength(Object value, String field, int maxLength) {+ if (!(value instanceof String s) || s.length() <= maxLength) {+ return;+ }+ throw new AwsException("ValidationException",+ "1 validation error detected: Value at '" + field + "' failed to satisfy constraint: "+ + "Member must have length less than or equal to " + maxLength, 400);+ }+/*** LogGroup is the one LoggingConfig member with a documented length and character* constraint rather than an enum: 1-512 characters, {@code [.\-_/#A-Za-z0-9]+}.@@ -2471,6 +2600,7 @@ public class LambdaService implements ResourceProvider {public LambdaAlias createAlias(String region, String functionName, String aliasName,String functionVersion, String description,java.util.Map<String, Double> routingConfig) {+ validateAliasName(aliasName);LambdaFunction fn = getFunction(region, functionName);functionName = fn.getFunctionName();if (aliasStore != null && aliasStore.get(region, functionName, aliasName).isPresent()) {@@ -2511,6 +2641,7 @@ public class LambdaService implements ResourceProvider {public LambdaAlias updateAlias(String region, String functionName, String aliasName,String functionVersion, String description,java.util.Map<String, Double> routingConfig) {+ validateAliasName(aliasName);LambdaAlias alias = getAlias(region, functionName, aliasName);if (functionVersion != null) alias.setFunctionVersion(functionVersion);if (description != null) alias.setDescription(description);@@ -2521,7 +2652,21 @@ public class LambdaService implements ResourceProvider {return alias;}+ /** FunctionUrlQualifier in botocore: 1-128 characters, not all digits. */+ private static void validateFunctionUrlQualifier(String qualifier) {+ validateNonEmpty(qualifier, "qualifier", false);+ validatePattern(qualifier, "qualifier", FUNCTION_URL_QUALIFIER_PATTERN);+ }++ /** Alias shape in botocore: 1-128 characters matching {@link #ALIAS_NAME_PATTERN}. */+ private static void validateAliasName(String aliasName) {+ validateNonEmpty(aliasName, "name", true);+ validateMaxLength(aliasName, "name", 128);+ validatePattern(aliasName, "name", ALIAS_NAME_PATTERN);+ }+public void deleteAlias(String region, String functionName, String aliasName) {+ validatePattern(aliasName, "name", ALIAS_NAME_PATTERN);String canonical = canonicalFunctionName(region, functionName);getAlias(region, canonical, aliasName); // verify it existsif (aliasStore != null) aliasStore.delete(region, canonical, aliasName);@@ -2531,13 +2676,18 @@ public class LambdaService implements ResourceProvider {// ──────────────────────────── Function URL Config ────────────────────────────public LambdaUrlConfig createFunctionUrlConfig(String region, String functionName, String qualifier, Map<String, Object> request) {+ validateFunctionUrlQualifier(qualifier);LambdaArnUtils.ResolvedFunctionRef ref = resolveWithRegion(region, functionName, qualifier);functionName = ref.name();qualifier = ref.qualifier();+ Object authType = request.getOrDefault("AuthType", "NONE");+ validateEnum(authType, "authType", FUNCTION_URL_AUTH_TYPE_VALUES);+ Object invokeMode = request.get("InvokeMode");+ validateEnum(invokeMode, "invokeMode", INVOKE_MODE_VALUES);LambdaUrlConfig urlConfig = new LambdaUrlConfig();- urlConfig.setAuthType((String) request.getOrDefault("AuthType", "NONE"));- if (request.containsKey("InvokeMode")) {- urlConfig.setInvokeMode((String) request.get("InvokeMode"));+ urlConfig.setAuthType((String) authType);+ if (invokeMode != null) {+ urlConfig.setInvokeMode((String) invokeMode);}String accountId = regionResolver.getAccountId();@@ -2591,6 +2741,11 @@ public class LambdaService implements ResourceProvider {}public LambdaUrlConfig getFunctionUrlConfig(String region, String functionName, String qualifier) {+ validateFunctionUrlQualifier(qualifier);+ return lookupFunctionUrlConfig(region, functionName, qualifier);+ }++ private LambdaUrlConfig lookupFunctionUrlConfig(String region, String functionName, String qualifier) {LambdaArnUtils.ResolvedFunctionRef ref = resolveWithRegion(region, functionName, qualifier);functionName = ref.name();qualifier = ref.qualifier();@@ -2608,16 +2763,27 @@ public class LambdaService implements ResourceProvider {}public LambdaUrlConfig updateFunctionUrlConfig(String region, String functionName, String qualifier, Map<String, Object> request) {+ validateFunctionUrlQualifier(qualifier);LambdaArnUtils.ResolvedFunctionRef ref = resolveWithRegion(region, functionName, qualifier);functionName = ref.name();qualifier = ref.qualifier();- LambdaUrlConfig urlConfig = getFunctionUrlConfig(region, functionName, qualifier);+ LambdaUrlConfig urlConfig = lookupFunctionUrlConfig(region, functionName, qualifier);+ // urlConfig is the live object nested in the stored function or alias, so both enums are+ // validated before either is applied: a rejected request must leave the config unchanged.+ Object authType = request.get("AuthType");+ Object invokeMode = request.get("InvokeMode");+ if (request.containsKey("AuthType")) {+ validateEnum(authType, "authType", FUNCTION_URL_AUTH_TYPE_VALUES);+ }+ if (request.containsKey("InvokeMode")) {+ validateEnum(invokeMode, "invokeMode", INVOKE_MODE_VALUES);+ }if (request.containsKey("AuthType")) {- urlConfig.setAuthType((String) request.get("AuthType"));+ urlConfig.setAuthType((String) authType);}if (request.containsKey("InvokeMode")) {- urlConfig.setInvokeMode((String) request.get("InvokeMode"));+ urlConfig.setInvokeMode((String) invokeMode);}String now = DateTimeFormatter.ISO_INSTANT.format(Instant.now().atOffset(ZoneOffset.UTC));@@ -2654,6 +2820,7 @@ public class LambdaService implements ResourceProvider {}public void deleteFunctionUrlConfig(String region, String functionName, String qualifier) {+ validateFunctionUrlQualifier(qualifier);LambdaArnUtils.ResolvedFunctionRef ref = resolveWithRegion(region, functionName, qualifier);functionName = ref.name();qualifier = ref.qualifier();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 cc113efc67..0a79dae7d2 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@@ -1737,4 +1737,112 @@ class EsmIntegrationTest {given().delete(LAMBDA_BASE + "/event-source-mappings/" + uuid).then().statusCode(202);}++ // ── Request-shape validation ────────────────────────────────────────────────++ @Test+ @Order(90)+ void createEventSourceMapping_rejectsUnknownFunctionResponseType() {+ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s",+ "FunctionResponseTypes": ["Bogus"]+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"));+ }++ @Test+ @Order(91)+ void updateEventSourceMapping_appliesAndRejectsFunctionResponseTypes() {+ String uuid = given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s"+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(202)+ .extract().path("UUID");++ try {+ given()+ .contentType("application/json")+ .body("{ \"FunctionResponseTypes\": [\"Bogus\"] }")+ .when()+ .put(LAMBDA_BASE + "/event-source-mappings/" + uuid)+ .then()+ .statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"));++ given()+ .contentType("application/json")+ .body("{ \"FunctionResponseTypes\": [\"ReportBatchItemFailures\"] }")+ .when()+ .put(LAMBDA_BASE + "/event-source-mappings/" + uuid)+ .then()+ .statusCode(202)+ .body("FunctionResponseTypes", hasItem("ReportBatchItemFailures"));+ } finally {+ given().delete(LAMBDA_BASE + "/event-source-mappings/" + uuid);+ }+ }++ @Test+ @Order(92)+ void listEventSourceMappings_rejectsMalformedEventSourceArn() {+ given()+ .when()+ .get(LAMBDA_BASE + "/event-source-mappings?EventSourceArn=not-an-arn")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }++ @Test+ @Order(93)+ void listEventSourceMappings_filtersByEventSourceArn() {+ String uuid = given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "EventSourceArn": "%s"+ }+ """.formatted(FUNCTION_NAME, QUEUE_ARN))+ .when()+ .post(LAMBDA_BASE + "/event-source-mappings")+ .then()+ .statusCode(202)+ .extract().path("UUID");++ try {+ given()+ .when()+ .get(LAMBDA_BASE + "/event-source-mappings?EventSourceArn=" + QUEUE_ARN)+ .then()+ .statusCode(200)+ .body("EventSourceMappings.UUID", hasItem(uuid));++ given()+ .when()+ .get(LAMBDA_BASE + "/event-source-mappings?EventSourceArn=" + STREAM_ARN)+ .then()+ .statusCode(200)+ .body("EventSourceMappings.UUID", not(hasItem(uuid)));+ } finally {+ given().delete(LAMBDA_BASE + "/event-source-mappings/" + uuid);+ }+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaLayerCodePathIsolationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaLayerCodePathIsolationTest.javaindex 30a17e7606..f01d10d567 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaLayerCodePathIsolationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaLayerCodePathIsolationTest.java@@ -1,6 +1,7 @@package io.github.hectorvent.floci.services.lambda;import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;import io.github.hectorvent.floci.services.lambda.model.LambdaLayerVersion;@@ -20,6 +21,7 @@ import java.util.zip.ZipOutputStream;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNotEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.Mockito.mock;import static org.mockito.Mockito.when;@@ -113,6 +115,24 @@ class LambdaLayerCodePathIsolationTest {assertEqualsContent(restored.getCodeLocalPath(), "persisted");}+ @Test+ void publishLayerVersionRejectsBareStringCompatibilityLists(@TempDir Path baseDir) throws Exception {+ // Catches: a non-list CompatibleRuntimes/CompatibleArchitectures being ignored instead of rejected+ LambdaLayerService service = serviceFor(baseDir, "111111111111");+ Map<String, Object> runtimes = Map.of("Content", Map.of("ZipFile", zipBase64("r")),+ "CompatibleRuntimes", "python3.12");+ Map<String, Object> architectures = Map.of("Content", Map.of("ZipFile", zipBase64("a")),+ "CompatibleArchitectures", "x86_64");++ AwsException badRuntimes = assertThrows(AwsException.class,+ () -> service.publishLayerVersion("us-east-1", LAYER_NAME, runtimes));+ AwsException badArchitectures = assertThrows(AwsException.class,+ () -> service.publishLayerVersion("us-east-1", LAYER_NAME, architectures));++ assertEquals("SerializationException", badRuntimes.getErrorCode());+ assertEquals("SerializationException", badArchitectures.getErrorCode());+ }+private static LambdaLayerVersion publish(LambdaLayerService service, String content) throws Exception {return service.publishLayerVersion("us-east-1", LAYER_NAME, request(content));}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaLayerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaLayerIntegrationTest.javaindex 97d682bae3..1c2c522da3 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaLayerIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaLayerIntegrationTest.java@@ -501,4 +501,60 @@ class LambdaLayerIntegrationTest {.statusCode(200);// Layer should no longer appear (all versions deleted)}++ // ── Request-shape validation ────────────────────────────────────────────────++ @Test+ @Order(23)+ void publishLayerVersion_rejectsUnknownCompatibleRuntime() throws Exception {+ given()+ .contentType("application/json")+ .body("""+ {+ "Content": { "ZipFile": "%s" },+ "CompatibleRuntimes": ["cobol99"]+ }+ """.formatted(layerZipBase64()))+ .when()+ .post("/2018-10-31/layers/validation-test-layer/versions")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }++ @Test+ @Order(24)+ void publishLayerVersion_rejectsUnknownCompatibleArchitecture() throws Exception {+ given()+ .contentType("application/json")+ .body("""+ {+ "Content": { "ZipFile": "%s" },+ "CompatibleArchitectures": ["mips"]+ }+ """.formatted(layerZipBase64()))+ .when()+ .post("/2018-10-31/layers/validation-test-layer/versions")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }++ @Test+ @Order(25)+ void publishLayerVersion_rejectsTooManyCompatibleArchitectures() throws Exception {+ given()+ .contentType("application/json")+ .body("""+ {+ "Content": { "ZipFile": "%s" },+ "CompatibleArchitectures": ["x86_64", "arm64", "x86_64"]+ }+ """.formatted(layerZipBase64()))+ .when()+ .post("/2018-10-31/layers/validation-test-layer/versions")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServiceTest.javaindex e1a1dff207..5e65956135 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServiceTest.java@@ -9,6 +9,7 @@ import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.lambda.model.EventSourceMapping;import io.github.hectorvent.floci.services.lambda.model.LambdaFileSystemConfig;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.zip.CodeStore;import io.github.hectorvent.floci.services.lambda.zip.ZipExtractor;import org.junit.jupiter.api.BeforeEach;@@ -20,6 +21,7 @@ import java.io.ByteArrayOutputStream;import java.nio.charset.StandardCharsets;import java.nio.file.Files;import java.nio.file.Path;+import java.util.ArrayList;import java.util.Base64;import java.util.HashSet;import java.util.HashMap;@@ -1315,6 +1317,306 @@ class LambdaServiceTest {}}+ // ──────────────────────────── Request-shape validation ────────────────────────────++ @Test+ void createFunctionRejectsUnknownRuntime() {+ Map<String, Object> request = baseRequest("bad-runtime-fn");+ request.put("Runtime", "cobol99");++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));+ assertEquals("ValidationException", error.getErrorCode());+ }++ @Test+ void updateFunctionConfigurationRejectsUnknownRuntime() {+ service.createFunction(REGION, baseRequest("update-bad-runtime-fn"));++ AwsException error = assertThrows(AwsException.class,+ () -> service.updateFunctionConfiguration(REGION, "update-bad-runtime-fn",+ Map.of("Runtime", "cobol99")));+ assertEquals("ValidationException", error.getErrorCode());+ }++ @Test+ void createFunctionRejectsMalformedRoleArn() {+ Map<String, Object> request = baseRequest("bad-role-fn");+ request.put("Role", "not-an-arn");++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));+ assertEquals("ValidationException", error.getErrorCode());+ }++ @Test+ void createFunctionRejectsHandlerWithWhitespace() {+ Map<String, Object> request = baseRequest("bad-handler-fn");+ request.put("Handler", "index handler");++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));+ assertEquals("ValidationException", error.getErrorCode());+ }++ @Test+ void createFunctionRejectsDescriptionOverMaxLength() {+ Map<String, Object> request = baseRequest("bad-description-fn");+ request.put("Description", "x".repeat(257));++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));+ assertEquals("ValidationException", error.getErrorCode());+ }++ @Test+ void createFunctionRejectsMalformedKmsKeyArn() {+ Map<String, Object> request = baseRequest("bad-kms-fn");+ request.put("KMSKeyArn", "not-an-arn");++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));+ assertEquals("ValidationException", error.getErrorCode());+ }++ @Test+ void createFunctionRejectsMalformedLayerArn() {+ Map<String, Object> request = baseRequest("bad-layer-fn");+ request.put("Layers", List.of("not-a-layer-arn"));++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));+ assertEquals("ValidationException", error.getErrorCode());+ }++ @Test+ void createFunctionRejectsMoreThanFiveLayers() {+ Map<String, Object> request = baseRequest("too-many-layers-fn");+ List<String> layers = new ArrayList<>();+ for (int i = 0; i < 6; i++) {+ layers.add("arn:aws:lambda:us-east-1:000000000000:layer:l" + i + ":1");+ }+ request.put("Layers", layers);++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));+ assertEquals("ValidationException", error.getErrorCode());+ }++ @Test+ void updateFunctionConfigurationRejectsMalformedLayerArn() {+ service.createFunction(REGION, baseRequest("update-bad-layer-fn"));++ AwsException error = assertThrows(AwsException.class,+ () -> service.updateFunctionConfiguration(REGION, "update-bad-layer-fn",+ Map.of("Layers", List.of("not-a-layer-arn"))));+ assertEquals("ValidationException", error.getErrorCode());+ }++ // Architectures is validated by upstream's validateArchitectures, which reports the error+ // botocore actually models for CreateFunction: ValidationException is not in that operation's+ // error set, InvalidParameterValueException is.+ @Test+ void createFunctionRejectsUnknownArchitecture() {+ Map<String, Object> request = baseRequest("bad-arch-fn");+ request.put("Architectures", List.of("mips"));++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));+ assertEquals("InvalidParameterValueException", error.getErrorCode());+ }++ @Test+ void createFunctionRejectsMoreThanOneArchitecture() {+ Map<String, Object> request = baseRequest("too-many-arch-fn");+ request.put("Architectures", List.of("x86_64", "arm64"));++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));+ assertEquals("InvalidParameterValueException", error.getErrorCode());+ }++ @Test+ void updateFunctionCodeAppliesValidArchitecture() {+ service.createFunction(REGION, baseRequest("update-code-arch-fn"));++ LambdaFunction updated = service.updateFunctionCode(REGION, "update-code-arch-fn",+ Map.of("Architectures", List.of("arm64")));++ assertEquals(List.of("arm64"), updated.getArchitectures());+ }++ @Test+ void updateFunctionCodeRejectsUnknownArchitecture() {+ service.createFunction(REGION, baseRequest("update-code-bad-arch-fn"));++ AwsException error = assertThrows(AwsException.class,+ () -> service.updateFunctionCode(REGION, "update-code-bad-arch-fn",+ Map.of("Architectures", List.of("mips"))));+ assertEquals("InvalidParameterValueException", error.getErrorCode());+ }++ @Test+ void deleteAliasRejectsMalformedName() {+ AwsException error = assertThrows(AwsException.class,+ () -> service.deleteAlias(REGION, "some-fn", "123"));+ assertEquals("ValidationException", error.getErrorCode());+ }++ @Test+ void createFunctionUrlConfigRejectsUnknownAuthType() {+ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunctionUrlConfig(REGION, "any-fn", null,+ Map.of("AuthType", "BOGUS")));+ assertEquals("ValidationException", error.getErrorCode());+ }++ @Test+ void createFunctionUrlConfigRejectsUnknownInvokeMode() {+ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunctionUrlConfig(REGION, "any-fn", null,+ Map.of("InvokeMode", "BOGUS")));+ assertEquals("ValidationException", error.getErrorCode());+ }++ @Test+ void createFunctionUrlConfigRejectsAllNumericQualifier() {+ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunctionUrlConfig(REGION, "any-fn", "123", Map.of()));+ assertEquals("ValidationException", error.getErrorCode());+ }++ @Test+ void updateFunctionUrlConfig_invalidInvokeMode_leavesAuthTypeUnchanged() {+ // Catches: UpdateFunctionUrlConfig applying AuthType to the stored config before InvokeMode is rejected+ service.createFunction(REGION, baseRequest("url-atomic-fn"));+ LambdaUrlConfig seeded = new LambdaUrlConfig();+ seeded.setAuthType("NONE");+ service.getFunction(REGION, "url-atomic-fn").setUrlConfig(seeded);++ AwsException error = assertThrows(AwsException.class,+ () -> service.updateFunctionUrlConfig(REGION, "url-atomic-fn", null,+ Map.of("AuthType", "AWS_IAM", "InvokeMode", "BOGUS")));++ assertEquals("ValidationException", error.getErrorCode());+ assertEquals("NONE", service.getFunctionUrlConfig(REGION, "url-atomic-fn", null).getAuthType());+ }++ @Test+ void getAndDeleteFunctionUrlConfig_rejectMalformedQualifier() {+ // Catches: Get/DeleteFunctionUrlConfig skipping the FunctionUrlQualifier constraint that Create/Update enforce+ AwsException numeric = assertThrows(AwsException.class,+ () -> service.getFunctionUrlConfig(REGION, "any-fn", "123"));+ AwsException empty = assertThrows(AwsException.class,+ () -> service.getFunctionUrlConfig(REGION, "any-fn", ""));+ AwsException deleteNumeric = assertThrows(AwsException.class,+ () -> service.deleteFunctionUrlConfig(REGION, "any-fn", "123"));++ assertEquals("ValidationException", numeric.getErrorCode());+ assertEquals("ValidationException", empty.getErrorCode());+ assertEquals("ValidationException", deleteNumeric.getErrorCode());+ }++ @Test+ void updateFunctionConfiguration_overlongDescription_isRejectedAndNotStored() {+ // Catches: UpdateFunctionConfiguration persisting a Description over the 256-character shape limit+ service.createFunction(REGION, baseRequest("update-desc-fn"));++ AwsException error = assertThrows(AwsException.class,+ () -> service.updateFunctionConfiguration(REGION, "update-desc-fn",+ Map.of("Description", "d".repeat(257))));++ assertEquals("ValidationException", error.getErrorCode());+ assertNull(service.getFunction(REGION, "update-desc-fn").getDescription());+ }++ @Test+ void createFunction_bareStringLayers_isRejectedAsSerializationError() {+ // Catches: a non-list Layers value being treated as absent instead of rejected+ Map<String, Object> request = baseRequest("bare-layers-fn");+ request.put("Layers", "arn:aws:lambda:us-east-1:000000000000:layer:l0:1");++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));++ assertEquals("SerializationException", error.getErrorCode());+ }++ @Test+ void updateFunctionConfiguration_bareStringLayers_isRejectedAndKeepsStoredLayers() {+ // Catches: a non-list Layers value on update silently clearing the stored layers+ service.createFunction(REGION, baseRequest("bare-layers-update-fn"));++ AwsException error = assertThrows(AwsException.class,+ () -> service.updateFunctionConfiguration(REGION, "bare-layers-update-fn",+ Map.of("Layers", "not-a-list")));++ assertEquals("SerializationException", error.getErrorCode());+ }++ @Test+ void listEventSourceMappingsRejectsMalformedFunctionName() {+ AwsException error = assertThrows(AwsException.class,+ () -> service.listEventSourceMappings("not a valid name!"));+ assertEquals("ValidationException", error.getErrorCode());+ }++ // Catches: EventSourceArn pattern missing the optional eusc- region prefix from the Arn shape.+ @Test+ void listEventSourceMappingsAcceptsEuscRegionEventSourceArn() {+ assertEquals(List.of(),+ service.listEventSourceMappings(null, "arn:aws-eusc:sqs:eusc-de-east-1:000000000000:q"));+ }++ // Catches: FunctionName pattern missing "." in the name characters, so a dotted name is rejected.+ @Test+ void listEventSourceMappingsAcceptsDottedFunctionName() {+ assertNotRejectedByListEsmPattern("my.func");+ }++ // Catches: FunctionName pattern missing the optional eusc- region prefix.+ @Test+ void listEventSourceMappingsAcceptsEuscRegionFunctionArn() {+ assertEquals(List.of(), service.listEventSourceMappings(+ "arn:aws-eusc:lambda:eusc-de-east-1:000000000000:function:my-func"));+ }++ // Catches: FunctionName pattern missing the $LATEST.PUBLISHED qualifier.+ @Test+ void listEventSourceMappingsAcceptsLatestPublishedQualifier() {+ assertNotRejectedByListEsmPattern(+ "arn:aws:lambda:us-east-1:000000000000:function:my-func:$LATEST.PUBLISHED");+ }++ // LambdaArnUtils.resolve still rejects dotted names and $LATEST.PUBLISHED downstream, so only the+ // ListEventSourceMappings pattern check (anchored with ^) is asserted here.+ private void assertNotRejectedByListEsmPattern(String functionName) {+ try {+ service.listEventSourceMappings(functionName);+ } catch (AwsException e) {+ assertFalse(e.getMessage().contains("pattern: ^(arn:"), e.getMessage());+ }+ }++ // Catches: LayerVersionArn pattern missing the AWS-managed awslayer alternative, so a valid+ // AWS-managed layer ARN is rejected as a ValidationException.+ @Test+ void createFunctionAcceptsAwsManagedLayerArn() {+ Map<String, Object> request = baseRequest("aws-layer-fn");+ request.put("Layers", List.of("arn:aws:lambda:::awslayer:AmazonLinux2"));++ LambdaFunction created = service.createFunction(REGION, request);++ assertEquals(List.of("arn:aws:lambda:::awslayer:AmazonLinux2"), created.getLayers());+ }++ @Test+ void listEventSourceMappingsRejectsMalformedEventSourceArn() {+ AwsException error = assertThrows(AwsException.class,+ () -> service.listEventSourceMappings(null, "not-an-arn"));+ assertEquals("ValidationException", error.getErrorCode());+ }+@Testvoid createEventSourceMapping_selfManagedKafka_success() {service.createFunction(REGION, baseRequest("kafka-fn"));@@ -1518,6 +1820,26 @@ class LambdaServiceTest {)));}+ @Test+ void updateEventSourceMapping_invalidLaterField_leavesBatchSizeAndEnabledUnchanged() {+ // Catches: UpdateEventSourceMapping mutating the stored mapping before a later member fails validation+ service.createFunction(REGION, baseRequest("kafka-fn-update-atomic"));+ EventSourceMapping esm = service.createEventSourceMapping(REGION, Map.of(+ "FunctionName", "kafka-fn-update-atomic",+ "Topics", List.of("valid-topic"),+ "SelfManagedEventSource", Map.of(+ "Endpoints", Map.of("KAFKA_BOOTSTRAP_SERVERS", List.of("localhost:9092")))));++ assertThrows(AwsException.class, () -> service.updateEventSourceMapping(esm.getUuid(), Map.of(+ "BatchSize", 5,+ "Enabled", false,+ "FunctionResponseTypes", List.of("Bogus"))));++ EventSourceMapping stored = service.getEventSourceMapping(esm.getUuid());+ assertEquals(10, stored.getBatchSize());+ assertTrue(stored.isEnabled());+ }+@Testvoid updateEventSourceMapping_functionTargetValidation() {service.createFunction(REGION, baseRequest("fn-esm-target-1"));@@ -1762,4 +2084,71 @@ class LambdaServiceTest {pool.shutdownNow();}}++ @Test+ void updateFunctionConfiguration_malformedKmsKeyArn_isRejectedAndNotStored() {+ // Catches: UpdateFunctionConfiguration storing a KMSKeyArn that violates the botocore pattern+ service.createFunction(REGION, baseRequest("kms-update-fn"));++ AwsException error = assertThrows(AwsException.class, () -> service.updateFunctionConfiguration(+ REGION, "kms-update-fn", new HashMap<>(Map.of("KMSKeyArn", "not-an-arn"))));++ assertEquals("ValidationException", error.getErrorCode());+ assertNull(service.getFunction(REGION, "kms-update-fn").getKmsKeyArn());+ }++ @Test+ void createAlias_invalidName_isRejectedAndNotStored() {+ // Catches: CreateAlias accepting an all-digit or over-128-character alias name+ service.createFunction(REGION, baseRequest("alias-name-fn"));++ AwsException digits = assertThrows(AwsException.class,+ () -> service.createAlias(REGION, "alias-name-fn", "123", "$LATEST", null, null));+ AwsException tooLong = assertThrows(AwsException.class,+ () -> service.createAlias(REGION, "alias-name-fn", "a".repeat(129), "$LATEST", null, null));++ assertEquals("ValidationException", digits.getErrorCode());+ assertEquals("ValidationException", tooLong.getErrorCode());+ assertEquals(0, service.listAliases(REGION, "alias-name-fn").size());+ }++ @Test+ void createAlias_emptyOrMissingName_isRejected() {+ // Catches: CreateAlias accepting an empty or null alias name despite the 1-character minimum+ service.createFunction(REGION, baseRequest("alias-empty-fn"));++ AwsException empty = assertThrows(AwsException.class,+ () -> service.createAlias(REGION, "alias-empty-fn", "", "$LATEST", null, null));+ AwsException missing = assertThrows(AwsException.class,+ () -> service.createAlias(REGION, "alias-empty-fn", null, "$LATEST", null, null));++ assertEquals("ValidationException", empty.getErrorCode());+ assertEquals("ValidationException", missing.getErrorCode());+ assertEquals(0, service.listAliases(REGION, "alias-empty-fn").size());+ }++ @Test+ void createEventSourceMapping_malformedEventSourceArn_isRejectedAndNotStored() {+ // Catches: CreateEventSourceMapping accepting an ARN that only contains ":sqs:" but is not a valid ARN+ LambdaFunction fn = service.createFunction(REGION, baseRequest("esm-arn-fn"));++ AwsException error = assertThrows(AwsException.class, () -> service.createEventSourceMapping(REGION,+ new HashMap<>(Map.of("FunctionName", "esm-arn-fn", "EventSourceArn", "junk:sqs:queue"))));++ assertEquals("ValidationException", error.getErrorCode());+ assertEquals(0, service.listEventSourceMappings(fn.getFunctionArn()).size());+ }++ @Test+ void createFunction_unknownPackageType_isRejectedAndNotStored() {+ // Catches: CreateFunction accepting a PackageType outside the Zip/Image enum+ Map<String, Object> request = baseRequest("package-type-fn");+ request.put("PackageType", "Rar");++ AwsException error = assertThrows(AwsException.class, () -> service.createFunction(REGION, request));++ assertEquals("ValidationException", error.getErrorCode());+ assertEquals("ResourceNotFoundException",+ assertThrows(AwsException.class, () -> service.getFunction(REGION, "package-type-fn")).getErrorCode());+ }}