Light, fluffy, and always free - The AWS Local Emulator alternative
fix(lambda): accept name, partial ARN, and full ARN for {FunctionName} (#450)
TiMd75c32c9f7bd
diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaArnUtils.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaArnUtils.javanew file mode 100644index 0000000000..878059a680--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaArnUtils.java@@ -0,0 +1,157 @@+package io.github.hectorvent.floci.services.lambda;++import io.github.hectorvent.floci.core.common.AwsException;++import java.util.regex.Pattern;++/**+ * Parses the many forms AWS Lambda accepts for a {@code FunctionName} path+ * parameter: bare name, partial ARN ({@code ACCT:function:NAME}), or full ARN+ * ({@code arn:aws:lambda:REGION:ACCT:function:NAME}), each optionally suffixed+ * with {@code :qualifier} (version or alias).+ */+public final class LambdaArnUtils {++ private static final Pattern NAME_PATTERN = Pattern.compile("[a-zA-Z0-9-_]+");+ private static final Pattern ACCOUNT_PATTERN = Pattern.compile("\\d{12}");+ private static final Pattern QUALIFIER_PATTERN = Pattern.compile("\\$LATEST|[a-zA-Z0-9-_]+");++ private LambdaArnUtils() {}++ /**+ * Resolved components of a Lambda function reference.+ *+ * @param name short function name (never null/blank)+ * @param qualifier version or alias, or null if absent+ * @param region region extracted from a full ARN, or null for bare+ * name / partial ARN inputs+ */+ public record ResolvedFunctionRef(String name, String qualifier, String region) {}++ /**+ * Parses a {@code FunctionName} path parameter. Throws+ * {@link AwsException} ({@code InvalidParameterValueException}, HTTP 400)+ * on any malformed input.+ */+ public static ResolvedFunctionRef resolve(String input) {+ if (input == null || input.isBlank()) {+ throw invalid("FunctionName must not be blank");+ }++ if (input.startsWith("arn:")) {+ return parseFullArn(input);+ }+ if (input.contains(":function:")) {+ return parsePartialArn(input);+ }+ return parseNameWithOptionalQualifier(input);+ }++ /**+ * Resolves an input and reconciles any embedded qualifier with a+ * {@code ?Qualifier=} query-string value. If both are supplied and differ,+ * throws 400. Returns the effective qualifier (may be null).+ */+ public static ResolvedFunctionRef resolveWithQualifier(String input, String queryQualifier) {+ ResolvedFunctionRef ref = resolve(input);+ String embedded = ref.qualifier();+ String normalizedQuery = (queryQualifier == null || queryQualifier.isBlank()) ? null : queryQualifier;++ if (embedded != null && normalizedQuery != null && !embedded.equals(normalizedQuery)) {+ throw invalid("The derived qualifier from the function name does not match the specified qualifier.");+ }+ String effective = embedded != null ? embedded : normalizedQuery;+ if (effective != null && !QUALIFIER_PATTERN.matcher(effective).matches()) {+ throw invalid("Invalid qualifier: " + effective);+ }+ return new ResolvedFunctionRef(ref.name(), effective, ref.region());+ }++ private static ResolvedFunctionRef parseFullArn(String input) {+ // arn:aws:lambda:REGION:ACCT:function:NAME[:QUALIFIER]+ String[] parts = input.split(":", -1);+ if (parts.length < 7 || parts.length > 8) {+ throw invalid("Invalid ARN: " + input);+ }+ if (!"arn".equals(parts[0]) || !"aws".equals(parts[1]) || !"lambda".equals(parts[2])) {+ throw invalid("Invalid ARN: " + input);+ }+ String region = parts[3];+ String account = parts[4];+ if (region.isBlank()) {+ throw invalid("ARN missing region: " + input);+ }+ if (!ACCOUNT_PATTERN.matcher(account).matches()) {+ throw invalid("ARN has invalid account id: " + input);+ }+ if (!"function".equals(parts[5])) {+ throw invalid("ARN resource type must be 'function': " + input);+ }+ String name = parts[6];+ validateName(name);+ String qualifier = parts.length == 8 ? parts[7] : null;+ if (qualifier != null) {+ validateQualifier(qualifier);+ }+ return new ResolvedFunctionRef(name, qualifier, region);+ }++ private static ResolvedFunctionRef parsePartialArn(String input) {+ // ACCT:function:NAME[:QUALIFIER]+ String[] parts = input.split(":", -1);+ if (parts.length < 3 || parts.length > 4) {+ throw invalid("Invalid partial ARN: " + input);+ }+ if (!"function".equals(parts[1])) {+ throw invalid("Partial ARN resource type must be 'function': " + input);+ }+ String account = parts[0];+ if (!ACCOUNT_PATTERN.matcher(account).matches()) {+ throw invalid("Partial ARN has invalid account id: " + input);+ }+ String name = parts[2];+ validateName(name);+ String qualifier = parts.length == 4 ? parts[3] : null;+ if (qualifier != null) {+ validateQualifier(qualifier);+ }+ return new ResolvedFunctionRef(name, qualifier, null);+ }++ private static ResolvedFunctionRef parseNameWithOptionalQualifier(String input) {+ // NAME[:QUALIFIER]+ String[] parts = input.split(":", -1);+ if (parts.length > 2) {+ throw invalid("Invalid FunctionName: " + input);+ }+ String name = parts[0];+ validateName(name);+ String qualifier = parts.length == 2 ? parts[1] : null;+ if (qualifier != null) {+ validateQualifier(qualifier);+ }+ return new ResolvedFunctionRef(name, qualifier, null);+ }++ private static void validateName(String name) {+ if (name == null || name.isEmpty()) {+ throw invalid("FunctionName segment is empty");+ }+ if (!NAME_PATTERN.matcher(name).matches()) {+ throw invalid("FunctionName contains invalid characters: " + name);+ }+ }++ private static void validateQualifier(String qualifier) {+ if (qualifier.isEmpty()) {+ throw invalid("Qualifier segment is empty");+ }+ if (!QUALIFIER_PATTERN.matcher(qualifier).matches()) {+ throw invalid("Invalid qualifier: " + qualifier);+ }+ }++ private static AwsException invalid(String message) {+ return new AwsException("InvalidParameterValueException", message, 400);+ }+}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 7a13282e6b..81013eda49 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@@ -182,6 +182,10 @@ public class LambdaService {if (functionName == null || functionName.isBlank()) {throw new AwsException("InvalidParameterValueException", "FunctionName is required", 400);}+ // Accept bare name, partial ARN, or full ARN. Normalize to the short+ // name so duplicate detection works regardless of which form the+ // caller supplies across successive calls.+ functionName = canonicalFunctionName(region, functionName);if (role == null || role.isBlank()) {throw new AwsException("InvalidParameterValueException", "Role is required", 400);}@@ -250,17 +254,48 @@ public class LambdaService {}public LambdaFunction getFunction(String region, String functionName) {- return functionStore.get(region, functionName)+ String canonical = canonicalFunctionName(region, functionName);+ return functionStore.get(region, canonical).orElseThrow(() -> new AwsException("ResourceNotFoundException","Function not found: " + functionName, 404));}+ /**+ * Resolves a {@code FunctionName} path parameter (bare name, partial ARN,+ * or full ARN, with optional {@code :qualifier}) to its canonical short+ * name, enforcing a region match when the input is a full ARN.+ */+ String canonicalFunctionName(String region, String functionName) {+ LambdaArnUtils.ResolvedFunctionRef ref = LambdaArnUtils.resolve(functionName);+ enforceRegion(region, ref);+ return ref.name();+ }++ /**+ * Resolves a {@code FunctionName} path parameter and reconciles any+ * embedded qualifier with an explicit {@code ?Qualifier=} query-string+ * value, enforcing region match when the input is a full ARN.+ */+ LambdaArnUtils.ResolvedFunctionRef resolveWithRegion(String region, String functionName, String queryQualifier) {+ LambdaArnUtils.ResolvedFunctionRef ref = LambdaArnUtils.resolveWithQualifier(functionName, queryQualifier);+ enforceRegion(region, ref);+ return ref;+ }++ private void enforceRegion(String region, LambdaArnUtils.ResolvedFunctionRef ref) {+ if (ref.region() != null && !ref.region().equals(region)) {+ throw new AwsException("InvalidParameterValueException",+ "Region '" + ref.region() + "' in ARN does not match request region '" + region + "'", 400);+ }+ }+public List<LambdaFunction> listFunctions(String region) {return functionStore.list(region);}public LambdaFunction updateFunctionCode(String region, String functionName, Map<String, Object> request) {LambdaFunction fn = getFunction(region, functionName);+ functionName = fn.getFunctionName();String zipFileBase64 = (String) request.get("ZipFile");String imageUri = (String) request.get("ImageUri");@@ -290,6 +325,7 @@ public class LambdaService {public void deleteFunction(String region, String functionName) {LambdaFunction fn = getFunction(region, functionName); // throws 404 if not found+ functionName = fn.getFunctionName();String arn = fn.getFunctionArn();warmPool.drainFunction(functionName);// Take the same per-function lock used by Put/DeleteFunctionConcurrency@@ -332,9 +368,9 @@ public class LambdaService {"Only SQS, Kinesis, and DynamoDB Streams event sources are supported.", 400);}- // Resolve function — supports both short name and ARN- String resolvedName = functionName.contains(":") ?- functionName.substring(functionName.lastIndexOf(':') + 1) : functionName;+ // Resolve function — supports bare name, partial ARN, or full ARN+ LambdaArnUtils.ResolvedFunctionRef fnRef = LambdaArnUtils.resolve(functionName);+ String resolvedName = fnRef.name();// Extract region from the event source ARN (parts[3] for all supported ARN formats)String resolvedRegion;@@ -346,6 +382,14 @@ public class LambdaService {resolvedRegion = parts.length > 3 ? parts[3] : region;}+ // If the caller supplied a full function ARN, its region must agree+ // with the region derived from the event source ARN. Otherwise we'd+ // silently bind a different-region function of the same name.+ if (fnRef.region() != null && !fnRef.region().equals(resolvedRegion)) {+ throw new AwsException("InvalidParameterValueException",+ "Function ARN region '" + fnRef.region() + "' does not match event source region '" + resolvedRegion + "'", 400);+ }+LambdaFunction fn = getFunction(resolvedRegion, resolvedName);int batchSize = toInt(request.get("BatchSize"), 10);@@ -407,7 +451,10 @@ public class LambdaService {public List<EventSourceMapping> listEventSourceMappings(String functionArn) {if (functionArn != null && !functionArn.isBlank()) {- return esmStore.listByFunction(functionArn);+ // 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);}return esmStore.list();}@@ -451,6 +498,7 @@ public class LambdaService {public LambdaFunction publishVersion(String region, String functionName, String description) {LambdaFunction fn = getFunction(region, functionName);+ functionName = fn.getFunctionName();int version = versionCounters.merge(region + "::" + functionName, 1, Integer::sum);LambdaFunction snapshot = new LambdaFunction();snapshot.setFunctionName(fn.getFunctionName());@@ -475,8 +523,8 @@ public class LambdaService {}public List<LambdaFunction> listVersionsByFunction(String region, String functionName) {- getFunction(region, functionName); // verify function exists- return functionStore.listVersions(region, functionName);+ LambdaFunction fn = getFunction(region, functionName); // verify function exists+ return functionStore.listVersions(region, fn.getFunctionName());}// ──────────────────────────── Aliases ────────────────────────────@@ -484,6 +532,7 @@ public class LambdaService {public LambdaAlias createAlias(String region, String functionName, String aliasName,String functionVersion, String description) {LambdaFunction fn = getFunction(region, functionName);+ functionName = fn.getFunctionName();if (aliasStore != null && aliasStore.get(region, functionName, aliasName).isPresent()) {throw new AwsException("ResourceConflictException", "Alias already exists: " + aliasName, 409);}@@ -506,15 +555,16 @@ public class LambdaService {if (aliasStore == null) {throw new AwsException("ResourceNotFoundException", "Alias not found: " + aliasName, 404);}- return aliasStore.get(region, functionName, aliasName)+ String canonical = canonicalFunctionName(region, functionName);+ return aliasStore.get(region, canonical, aliasName).orElseThrow(() -> new AwsException("ResourceNotFoundException","Alias not found: " + aliasName, 404));}public List<LambdaAlias> listAliases(String region, String functionName) {- getFunction(region, functionName); // verify function exists+ LambdaFunction fn = getFunction(region, functionName); // verify function existsif (aliasStore == null) return List.of();- return aliasStore.list(region, functionName);+ return aliasStore.list(region, fn.getFunctionName());}public LambdaAlias updateAlias(String region, String functionName, String aliasName,@@ -529,14 +579,18 @@ public class LambdaService {}public void deleteAlias(String region, String functionName, String aliasName) {- getAlias(region, functionName, aliasName); // verify it exists- if (aliasStore != null) aliasStore.delete(region, functionName, aliasName);- LOG.infov("Deleted alias {0} for function {1}", aliasName, functionName);+ String canonical = canonicalFunctionName(region, functionName);+ getAlias(region, canonical, aliasName); // verify it exists+ if (aliasStore != null) aliasStore.delete(region, canonical, aliasName);+ LOG.infov("Deleted alias {0} for function {1}", aliasName, canonical);}// ──────────────────────────── Function URL Config ────────────────────────────public LambdaUrlConfig createFunctionUrlConfig(String region, String functionName, String qualifier, Map<String, Object> request) {+ LambdaArnUtils.ResolvedFunctionRef ref = resolveWithRegion(region, functionName, qualifier);+ functionName = ref.name();+ qualifier = ref.qualifier();LambdaUrlConfig urlConfig = new LambdaUrlConfig();urlConfig.setAuthType((String) request.getOrDefault("AuthType", "NONE"));if (request.containsKey("InvokeMode")) {@@ -589,6 +643,9 @@ public class LambdaService {}public LambdaUrlConfig getFunctionUrlConfig(String region, String functionName, String qualifier) {+ LambdaArnUtils.ResolvedFunctionRef ref = resolveWithRegion(region, functionName, qualifier);+ functionName = ref.name();+ qualifier = ref.qualifier();LambdaUrlConfig urlConfig;if (qualifier != null && !qualifier.equals("$LATEST")) {urlConfig = getAlias(region, functionName, qualifier).getUrlConfig();@@ -603,6 +660,9 @@ public class LambdaService {}public LambdaUrlConfig updateFunctionUrlConfig(String region, String functionName, String qualifier, Map<String, Object> request) {+ LambdaArnUtils.ResolvedFunctionRef ref = resolveWithRegion(region, functionName, qualifier);+ functionName = ref.name();+ qualifier = ref.qualifier();LambdaUrlConfig urlConfig = getFunctionUrlConfig(region, functionName, qualifier);if (request.containsKey("AuthType")) {@@ -646,6 +706,9 @@ public class LambdaService {}public void deleteFunctionUrlConfig(String region, String functionName, String qualifier) {+ LambdaArnUtils.ResolvedFunctionRef ref = resolveWithRegion(region, functionName, qualifier);+ functionName = ref.name();+ qualifier = ref.qualifier();if (qualifier != null && !qualifier.equals("$LATEST")) {LambdaAlias alias = getAlias(region, functionName, qualifier);if (alias.getUrlConfig() == null) {@@ -872,26 +935,49 @@ public class LambdaService {// ──────────────────────────── Tags ────────────────────────────public Map<String, String> listTags(String functionArn) {- String[] parts = functionArn.split(":");- LambdaFunction fn = getFunction(parts[3], parts[6]);+ TagTarget target = resolveTagTarget(functionArn);+ LambdaFunction fn = getFunction(target.region, target.name);return fn.getTags() != null ? fn.getTags() : Map.of();}public void tagResource(String functionArn, Map<String, String> tags) {- String[] parts = functionArn.split(":");- LambdaFunction fn = getFunction(parts[3], parts[6]);+ TagTarget target = resolveTagTarget(functionArn);+ LambdaFunction fn = getFunction(target.region, target.name);if (fn.getTags() == null) fn.setTags(new java.util.HashMap<>());fn.getTags().putAll(tags);- functionStore.save(parts[3], fn);+ functionStore.save(target.region, fn);}public void untagResource(String functionArn, List<String> tagKeys) {- String[] parts = functionArn.split(":");- LambdaFunction fn = getFunction(parts[3], parts[6]);+ TagTarget target = resolveTagTarget(functionArn);+ LambdaFunction fn = getFunction(target.region, target.name);if (fn.getTags() != null) {tagKeys.forEach(fn.getTags()::remove);}- functionStore.save(parts[3], fn);+ functionStore.save(target.region, fn);+ }++ private record TagTarget(String region, String name) {}++ /**+ * Resolves a tag-endpoint ARN to a (region, shortName) pair. The Lambda+ * tag APIs only accept an unqualified full function ARN; reject partial+ * ARNs, bare names, and qualified ARNs.+ */+ private TagTarget resolveTagTarget(String functionArn) {+ if (functionArn == null || functionArn.isBlank()) {+ throw new AwsException("InvalidParameterValueException", "Resource ARN is required", 400);+ }+ if (!functionArn.startsWith("arn:")) {+ throw new AwsException("InvalidParameterValueException",+ "Resource ARN must be a full Lambda function ARN: " + functionArn, 400);+ }+ LambdaArnUtils.ResolvedFunctionRef ref = LambdaArnUtils.resolve(functionArn);+ if (ref.qualifier() != null) {+ throw new AwsException("InvalidParameterValueException",+ "Tag operations require an unqualified function ARN: " + functionArn, 400);+ }+ return new TagTarget(ref.region(), ref.name());}private int toInt(Object value, int defaultValue) {diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaArnUtilsTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaArnUtilsTest.javanew file mode 100644index 0000000000..5d226d2aba--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaArnUtilsTest.java@@ -0,0 +1,98 @@+package io.github.hectorvent.floci.services.lambda;++import io.github.hectorvent.floci.core.common.AwsException;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;+import org.junit.jupiter.params.provider.ValueSource;++import static org.junit.jupiter.api.Assertions.*;++class LambdaArnUtilsTest {++ @ParameterizedTest+ @CsvSource({+ // input, expectedName, expectedQualifier, expectedRegion+ "my-fn, my-fn, , ",+ "my-fn:prod, my-fn, prod, ",+ "my-fn:$LATEST, my-fn, $LATEST, ",+ "my-fn:42, my-fn, 42, ",+ "000000000000:function:my-fn, my-fn, , ",+ "000000000000:function:my-fn:prod, my-fn, prod, ",+ "arn:aws:lambda:us-east-1:000000000000:function:my-fn, my-fn, , us-east-1",+ "arn:aws:lambda:eu-west-1:123456789012:function:my-fn, my-fn, , eu-west-1",+ "arn:aws:lambda:us-east-1:000000000000:function:my-fn:prod, my-fn, prod, us-east-1",+ "arn:aws:lambda:us-east-1:000000000000:function:my-fn:$LATEST, my-fn, $LATEST, us-east-1",+ "arn:aws:lambda:us-east-1:000000000000:function:my_fn-1, my_fn-1, , us-east-1",+ })+ void resolveAcceptsValidForms(String input, String expectedName, String expectedQualifier, String expectedRegion) {+ LambdaArnUtils.ResolvedFunctionRef ref = LambdaArnUtils.resolve(input);+ assertEquals(expectedName, ref.name());+ assertEquals(emptyToNull(expectedQualifier), ref.qualifier());+ assertEquals(emptyToNull(expectedRegion), ref.region());+ }++ @ParameterizedTest+ @ValueSource(strings = {+ "",+ " ",+ "foo:function:",+ ":function:foo",+ "foo:function:name:q1:q2",+ "arn:aws:lambda:us-east-1:000000000000:function:",+ "arn:aws:lambda::000000000000:function:my-fn",+ "arn:aws:lambda:us-east-1:abc:function:my-fn",+ "arn:aws:lambda:us-east-1:000000000000:layer:my-layer",+ "arn:aws:s3:us-east-1:000000000000:function:my-fn",+ "arn:aws:lambda:us-east-1:000000000000:function:my-fn:q1:q2",+ "my-fn:bad/qualifier",+ "my:fn:extra:segments",+ "name with spaces",+ "name!bang",+ })+ void resolveRejectsMalformedInputs(String input) {+ AwsException ex = assertThrows(AwsException.class, () -> LambdaArnUtils.resolve(input));+ assertEquals("InvalidParameterValueException", ex.getErrorCode());+ assertEquals(400, ex.getHttpStatus());+ }++ @Test+ void resolveRejectsNull() {+ assertThrows(AwsException.class, () -> LambdaArnUtils.resolve(null));+ }++ @Test+ void resolveWithQualifierTakesEmbeddedWhenOnlyEmbedded() {+ LambdaArnUtils.ResolvedFunctionRef ref = LambdaArnUtils.resolveWithQualifier("my-fn:prod", null);+ assertEquals("prod", ref.qualifier());+ }++ @Test+ void resolveWithQualifierTakesQueryWhenOnlyQuery() {+ LambdaArnUtils.ResolvedFunctionRef ref = LambdaArnUtils.resolveWithQualifier("my-fn", "prod");+ assertEquals("prod", ref.qualifier());+ }++ @Test+ void resolveWithQualifierAcceptsMatching() {+ LambdaArnUtils.ResolvedFunctionRef ref = LambdaArnUtils.resolveWithQualifier("my-fn:prod", "prod");+ assertEquals("prod", ref.qualifier());+ }++ @Test+ void resolveWithQualifierRejectsConflict() {+ AwsException ex = assertThrows(AwsException.class,+ () -> LambdaArnUtils.resolveWithQualifier("my-fn:prod", "dev"));+ assertEquals(400, ex.getHttpStatus());+ }++ @Test+ void resolveWithQualifierTreatsBlankQueryAsAbsent() {+ LambdaArnUtils.ResolvedFunctionRef ref = LambdaArnUtils.resolveWithQualifier("my-fn:prod", "");+ assertEquals("prod", ref.qualifier());+ }++ private static String emptyToNull(String s) {+ return (s == null || s.isEmpty()) ? null : s;+ }+}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 9e83f4ebdc..9ea9b95e84 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@@ -101,6 +101,69 @@ class LambdaServiceTest {assertEquals(404, ex.getHttpStatus());}+ @Test+ void getFunctionAcceptsPartialArn() {+ service.createFunction(REGION, baseRequest("arn-fn"));+ LambdaFunction fn = service.getFunction(REGION, "000000000000:function:arn-fn");+ assertEquals("arn-fn", fn.getFunctionName());+ }++ @Test+ void getFunctionAcceptsFullArn() {+ service.createFunction(REGION, baseRequest("arn-fn"));+ LambdaFunction fn = service.getFunction(REGION,+ "arn:aws:lambda:us-east-1:000000000000:function:arn-fn");+ assertEquals("arn-fn", fn.getFunctionName());+ }++ @Test+ void getFunctionAcceptsArnWithQualifier() {+ service.createFunction(REGION, baseRequest("arn-fn"));+ LambdaFunction fn = service.getFunction(REGION,+ "arn:aws:lambda:us-east-1:000000000000:function:arn-fn:prod");+ assertEquals("arn-fn", fn.getFunctionName());+ }++ @Test+ void getFunctionRejectsRegionMismatch() {+ service.createFunction(REGION, baseRequest("region-fn"));+ AwsException ex = assertThrows(AwsException.class, () -> service.getFunction(REGION,+ "arn:aws:lambda:eu-west-1:000000000000:function:region-fn"));+ assertEquals("InvalidParameterValueException", ex.getErrorCode());+ assertEquals(400, ex.getHttpStatus());+ }++ @Test+ void getFunctionRejectsMalformedArn() {+ AwsException ex = assertThrows(AwsException.class, () -> service.getFunction(REGION,+ "arn:aws:lambda:us-east-1:000000000000:layer:my-layer"));+ assertEquals(400, ex.getHttpStatus());+ }++ @Test+ void createFunctionDeduplicatesAcrossNameAndArn() {+ service.createFunction(REGION, baseRequest("dedup-fn"));+ Map<String, Object> req = baseRequest("arn:aws:lambda:us-east-1:000000000000:function:dedup-fn");+ AwsException ex = assertThrows(AwsException.class, () -> service.createFunction(REGION, req));+ assertEquals("ResourceConflictException", ex.getErrorCode());+ }++ @Test+ void deleteFunctionAcceptsFullArn() {+ service.createFunction(REGION, baseRequest("delete-arn-fn"));+ service.deleteFunction(REGION,+ "arn:aws:lambda:us-east-1:000000000000:function:delete-arn-fn");+ assertThrows(AwsException.class, () -> service.getFunction(REGION, "delete-arn-fn"));+ }++ @Test+ void putFunctionConcurrencyAcceptsFullArn() {+ service.createFunction(REGION, baseRequest("concurrency-arn-fn"));+ service.putFunctionConcurrency(REGION,+ "arn:aws:lambda:us-east-1:000000000000:function:concurrency-arn-fn", 5);+ assertEquals(5, service.getFunctionConcurrency(REGION, "concurrency-arn-fn"));+ }+@Testvoid listFunctionsReturnsAllInRegion() {service.createFunction(REGION, baseRequest("fn-1"));