Light, fluffy, and always free - The AWS Local Emulator alternative
fix(apigateway): return embedded resource methods (#5109)
vamsiakd508a4e19749
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ApiGatewayResourceMethodsCompatibilityTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ApiGatewayResourceMethodsCompatibilityTest.javanew file mode 100644index 0000000000..492a594077--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ApiGatewayResourceMethodsCompatibilityTest.java@@ -0,0 +1,98 @@+package com.floci.test;++import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.apigateway.ApiGatewayClient;+import software.amazon.awssdk.services.apigateway.model.IntegrationType;+import software.amazon.awssdk.services.apigateway.model.Method;+import software.amazon.awssdk.services.apigateway.model.Resource;++import java.util.List;+import java.util.Map;++import static org.assertj.core.api.Assertions.assertThat;++@DisplayName("API Gateway embedded resource methods")+class ApiGatewayResourceMethodsCompatibilityTest {++ @Test+ @DisplayName("Collection and individual resource reads embed supported method fields")+ void sdkResourceReadsEmbedMethodConfiguration() {+ try (ApiGatewayClient client = TestFixtures.apiGatewayClient()) {+ String apiId = client.createRestApi(request -> request+ .name(TestFixtures.uniqueName("resource-methods"))).id();+ try {+ String rootId = client.getResources(request -> request.restApiId(apiId)).items().get(0).id();+ String resourceId = client.createResource(request -> request.restApiId(apiId)+ .parentId(rootId).pathPart("widgets")).id();+ client.putMethod(request -> request.restApiId(apiId).resourceId(resourceId).httpMethod("GET")+ .authorizationType("NONE")+ .requestParameters(Map.of("method.request.header.X-Trace", true))+ .requestModels(Map.of("application/json", "Empty")));+ client.putMethod(request -> request.restApiId(apiId).resourceId(resourceId).httpMethod("POST")+ .authorizationType("AWS_IAM").apiKeyRequired(true));+ client.putIntegration(request -> request.restApiId(apiId).resourceId(resourceId).httpMethod("GET")+ .type(IntegrationType.MOCK).timeoutInMillis(9000)+ .requestTemplates(Map.of("application/json", "{\"statusCode\":200}")));+ client.putMethodResponse(request -> request.restApiId(apiId).resourceId(resourceId).httpMethod("GET")+ .statusCode("200").responseParameters(Map.of("method.response.header.X-Trace", true)));++ List<Resource> resources = client.getResources(request -> request.restApiId(apiId)+ .embed("methods")).items();+ Resource embedded = resources.stream().filter(resource -> resource.id().equals(resourceId))+ .findFirst().orElseThrow();+ assertThat(embedded.resourceMethods()).containsOnlyKeys("GET", "POST");+ Method get = embedded.resourceMethods().get("GET");+ assertThat(get.httpMethod()).isEqualTo("GET");+ assertThat(get.authorizationType()).isEqualTo("NONE");+ assertThat(get.requestParameters()).containsEntry("method.request.header.X-Trace", true);+ assertThat(get.requestModels()).containsEntry("application/json", "Empty");+ assertThat(get.methodIntegration().type()).isEqualTo(IntegrationType.MOCK);+ assertThat(get.methodIntegration().timeoutInMillis()).isEqualTo(9000);+ assertThat(get.methodIntegration().requestTemplates())+ .containsEntry("application/json", "{\"statusCode\":200}");+ assertThat(get.methodResponses().get("200").responseParameters())+ .containsEntry("method.response.header.X-Trace", true);+ assertThat(embedded.resourceMethods().get("POST").authorizationType()).isEqualTo("AWS_IAM");+ assertThat(embedded.resourceMethods().get("POST").apiKeyRequired()).isTrue();++ assertThat(client.getResource(request -> request.restApiId(apiId).resourceId(resourceId)+ .embed("methods")).resourceMethods()).isEqualTo(embedded.resourceMethods());+ Resource summary = client.getResources(request -> request.restApiId(apiId)).items().stream()+ .filter(resource -> resource.id().equals(resourceId)).findFirst().orElseThrow();+ assertThat(summary.resourceMethods()).containsOnlyKeys("GET", "POST");+ assertThat(summary.resourceMethods().get("GET").httpMethod()).isNull();+ assertThat(summary.resourceMethods().get("GET").methodIntegration()).isNull();+ assertThat(client.getResource(request -> request.restApiId(apiId).resourceId(resourceId))+ .resourceMethods()).isEqualTo(summary.resourceMethods());+ assertThat(client.getMethod(request -> request.restApiId(apiId).resourceId(resourceId)+ .httpMethod("GET")).methodIntegration().type()).isEqualTo(IntegrationType.MOCK);+ } finally {+ client.deleteRestApi(request -> request.restApiId(apiId));+ }+ }+ }++ @Test+ @DisplayName("Root resource ANY method is listed and disappears after deletion")+ void sdkRootMethodsReflectDeletion() {+ try (ApiGatewayClient client = TestFixtures.apiGatewayClient()) {+ String apiId = client.createRestApi(request -> request+ .name(TestFixtures.uniqueName("root-methods"))).id();+ try {+ String rootId = client.getResources(request -> request.restApiId(apiId)).items().get(0).id();+ assertThat(client.getResource(request -> request.restApiId(apiId).resourceId(rootId)+ .embed("methods")).resourceMethods()).isEmpty();+ client.putMethod(request -> request.restApiId(apiId).resourceId(rootId).httpMethod("ANY")+ .authorizationType("NONE"));+ assertThat(client.getResources(request -> request.restApiId(apiId).embed("methods"))+ .items().get(0).resourceMethods().get("ANY").httpMethod()).isEqualTo("ANY");+ client.deleteMethod(request -> request.restApiId(apiId).resourceId(rootId).httpMethod("ANY"));+ assertThat(client.getResources(request -> request.restApiId(apiId).embed("methods"))+ .items().get(0).resourceMethods()).isEmpty();+ } finally {+ client.deleteRestApi(request -> request.restApiId(apiId));+ }+ }+ }+}diff --git a/docs/services/api-gateway.md b/docs/services/api-gateway.mdindex aa1d497a18..7c61fdce99 100644--- a/docs/services/api-gateway.md+++ b/docs/services/api-gateway.md@@ -379,6 +379,17 @@ Passthrough keeps repeated values repeated, in both directions: `?tag=a&tag=b` r- **Request** — the body is the rendered `requestTemplates` entry selected by the incoming `Content-Type` (falling back to the type without its charset), subject to `passthroughBehavior` (`NEVER` and `WHEN_NO_TEMPLATES` return `415`). Only headers and query parameters named by `integration.request.*` mappings are forwarded; unmapped inbound headers are **not** passed through — that passthrough is `HTTP_PROXY`'s job.- **Response** — the backend's reply runs through the method's integration responses. As in AWS, `selectionPattern` is matched against the backend's **HTTP status code** (for `AWS`/Lambda integrations it is matched against the error message instead), so `"5\\d{2}"` on a `502` integration response remaps any backend `5xx` to `502`. The matched response's `responseTemplates` render the body, `responseParameters` map `integration.response.header.*` (case-insensitively) or `integration.response.body.<jsonpath>` onto `method.response.header.*`, and `$context.responseOverride` assignments take precedence. With no integration responses configured, the backend's status and body are relayed as-is.+### Resource Method Introspection++`GetResources` and `GetResource` return the configured HTTP method names in `resourceMethods`,+with empty objects by default. Request `embed=methods` to include the supported method fields:+authorization settings, request parameters and models, method responses, and integration+configuration. Resources without methods omit `resourceMethods`.++For example, `aws apigateway get-resources --rest-api-id <id> --embed methods` lists method+metadata without a separate `get-method` call for each operation. Stage OpenAPI export+(`GetExport`) is not implemented.+### Integration Settings`PutIntegration` persists and `GetIntegration` returns the full configuration, including the mapping templates and integration responses that IaC tools diff against:diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayController.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayController.javaindex 39cc902340..7dee3e1fd3 100644--- a/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayController.java+++ b/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayController.java@@ -419,12 +419,14 @@ public class ApiGatewayController {@GET@Path("/restapis/{apiId}/resources")- public Response getResources(@Context HttpHeaders headers, @PathParam("apiId") String apiId) {+ public Response getResources(@Context HttpHeaders headers, @PathParam("apiId") String apiId,+ @QueryParam("embed") List<String> embed) {String region = regionResolver.resolveRegion(headers);List<ApiGatewayResource> resources = service.getResources(region, apiId);ObjectNode root = objectMapper.createObjectNode();ArrayNode items = root.putArray("item");- resources.forEach(r -> items.add(toResourceNode(r)));+ boolean embedMethods = embed != null && embed.contains("methods");+ resources.forEach(r -> items.add(toResourceNode(r, embedMethods)));return Response.ok(root.toString()).type(MediaType.APPLICATION_JSON).build();}@@ -432,9 +434,11 @@ public class ApiGatewayController {@Path("/restapis/{apiId}/resources/{resourceId}")public Response getResource(@Context HttpHeaders headers,@PathParam("apiId") String apiId,- @PathParam("resourceId") String resourceId) {+ @PathParam("resourceId") String resourceId,+ @QueryParam("embed") List<String> embed) {String region = regionResolver.resolveRegion(headers);- return Response.ok(toResourceNode(service.getResource(region, apiId, resourceId))).build();+ boolean embedMethods = embed != null && embed.contains("methods");+ return Response.ok(toResourceNode(service.getResource(region, apiId, resourceId), embedMethods)).build();}@PATCH@@ -2215,11 +2219,20 @@ public class ApiGatewayController {}private ObjectNode toResourceNode(ApiGatewayResource r) {+ return toResourceNode(r, false);+ }++ private ObjectNode toResourceNode(ApiGatewayResource r, boolean embedMethods) {ObjectNode node = objectMapper.createObjectNode();node.put("id", r.getId());if (r.getParentId() != null) node.put("parentId", r.getParentId());if (r.getPathPart() != null) node.put("pathPart", r.getPathPart());node.put("path", r.getPath());+ if (!r.getResourceMethods().isEmpty()) {+ ObjectNode methods = node.putObject("resourceMethods");+ r.getResourceMethods().forEach((httpMethod, method) -> methods.set(httpMethod,+ embedMethods ? toMethodNode(method, r.getId()) : objectMapper.createObjectNode()));+ }return node;}@@ -2245,6 +2258,10 @@ public class ApiGatewayController {if (m.getMethodIntegration() != null) {node.set("methodIntegration", toIntegrationNode(m.getMethodIntegration(), resourceId));}+ if (!m.getMethodResponses().isEmpty()) {+ ObjectNode responses = node.putObject("methodResponses");+ m.getMethodResponses().forEach((status, response) -> responses.set(status, toMethodResponseNode(response)));+ }return node;}diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/model/ApiGatewayResource.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/model/ApiGatewayResource.javaindex 25fe58e0c2..0b0cf6593e 100644--- a/src/main/java/io/github/hectorvent/floci/services/apigateway/model/ApiGatewayResource.java+++ b/src/main/java/io/github/hectorvent/floci/services/apigateway/model/ApiGatewayResource.java@@ -4,8 +4,8 @@ import io.quarkus.runtime.annotations.RegisterForReflection;import com.fasterxml.jackson.annotation.JsonIgnoreProperties;-import java.util.HashMap;import java.util.Map;+import java.util.concurrent.ConcurrentHashMap;@JsonIgnoreProperties(ignoreUnknown = true)@RegisterForReflection@@ -16,7 +16,7 @@ public class ApiGatewayResource {private String parentId;private String pathPart;private String path;- private Map<String, MethodConfig> resourceMethods = new HashMap<>();+ private Map<String, MethodConfig> resourceMethods = new ConcurrentHashMap<>();public String getId() { return id; }public void setId(String id) { this.id = id; }@@ -35,6 +35,6 @@ public class ApiGatewayResource {public Map<String, MethodConfig> getResourceMethods() { return resourceMethods; }public void setResourceMethods(Map<String, MethodConfig> resourceMethods) {- this.resourceMethods = resourceMethods != null ? resourceMethods : new HashMap<>();+ this.resourceMethods = resourceMethods != null ? new ConcurrentHashMap<>(resourceMethods) : new ConcurrentHashMap<>();}}diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/model/MethodConfig.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/model/MethodConfig.javaindex 76e677f325..ed87154fca 100644--- a/src/main/java/io/github/hectorvent/floci/services/apigateway/model/MethodConfig.java+++ b/src/main/java/io/github/hectorvent/floci/services/apigateway/model/MethodConfig.java@@ -8,6 +8,7 @@ import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;+import java.util.concurrent.ConcurrentHashMap;@JsonIgnoreProperties(ignoreUnknown = true)@RegisterForReflection@@ -21,7 +22,7 @@ public class MethodConfig {private boolean apiKeyRequired;private Map<String, Boolean> requestParameters = new HashMap<>();private Map<String, String> requestModels = new HashMap<>();- private Map<String, MethodResponse> methodResponses = new HashMap<>();+ private Map<String, MethodResponse> methodResponses = new ConcurrentHashMap<>();private Integration methodIntegration;public String getHttpMethod() { return httpMethod; }@@ -56,7 +57,7 @@ public class MethodConfig {public Map<String, MethodResponse> getMethodResponses() { return methodResponses; }public void setMethodResponses(Map<String, MethodResponse> methodResponses) {- this.methodResponses = methodResponses != null ? methodResponses : new HashMap<>();+ this.methodResponses = methodResponses != null ? new ConcurrentHashMap<>(methodResponses) : new ConcurrentHashMap<>();}public Integration getMethodIntegration() { return methodIntegration; }diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayResourceMethodsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayResourceMethodsIntegrationTest.javanew file mode 100644index 0000000000..1fed60631c--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayResourceMethodsIntegrationTest.java@@ -0,0 +1,139 @@+package io.github.hectorvent.floci.services.apigateway;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.http.ContentType;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.anEmptyMap;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasKey;+import static org.hamcrest.Matchers.not;+import static org.hamcrest.Matchers.nullValue;++@QuarkusTest+class ApiGatewayResourceMethodsIntegrationTest {++ private String apiId;+ private String rootId;+ private String resourceId;++ @BeforeEach+ void setup() {+ apiId = given().contentType(ContentType.JSON).body("{\"name\":\"resource-methods\"}")+ .when().post("/restapis").then().statusCode(201).extract().path("id");+ rootId = given().when().get(resourcesPath()).then().statusCode(200).extract().path("item[0].id");+ resourceId = given().contentType(ContentType.JSON).body("{\"pathPart\":\"widgets\"}")+ .when().post(resourcesPath() + "/" + rootId)+ .then().statusCode(201).extract().path("id");+ given().contentType(ContentType.JSON).body("""+ {"authorizationType":"NONE","requestParameters":{"method.request.header.X-Trace":true},+ "requestModels":{"application/json":"Empty"}}+ """)+ .when().put(methodPath("GET")).then().statusCode(201);+ given().contentType(ContentType.JSON).body("{\"authorizationType\":\"AWS_IAM\",\"apiKeyRequired\":true}")+ .when().put(methodPath("POST")).then().statusCode(201);+ given().contentType(ContentType.JSON).body("""+ {"responseParameters":{"method.response.header.X-Trace":true}}+ """)+ .when().put(methodPath("GET") + "/responses/200").then().statusCode(201);+ given().contentType(ContentType.JSON).body("""+ {"type":"HTTP","httpMethod":"POST","uri":"https://example.invalid/widgets",+ "timeoutInMillis":12000,"requestTemplates":{"application/json":"{}"},+ "requestParameters":{"integration.request.header.X-Trace":"method.request.header.X-Trace"}}+ """)+ .when().put(methodPath("GET") + "/integration").then().statusCode(201);+ }++ @AfterEach+ void cleanup() {+ if (apiId != null) {+ given().when().delete("/restapis/" + apiId).then().statusCode(202);+ }+ }++ @Test+ void collectionEmbedReturnsMethodAndIntegrationMetadata() {+ given().queryParam("embed", "methods").when().get(resourcesPath())+ .then().statusCode(200)+ .body("item.find { it.id == '" + resourceId + "' }.resourceMethods.GET.httpMethod", equalTo("GET"))+ .body("item.find { it.id == '" + resourceId + "' }.resourceMethods.GET.authorizationType", equalTo("NONE"))+ .body("item.find { it.id == '" + resourceId + "' }.resourceMethods.POST.authorizationType", equalTo("AWS_IAM"))+ .body("item.find { it.id == '" + resourceId + "' }.resourceMethods.POST.apiKeyRequired", equalTo(true))+ .body("item.find { it.id == '" + resourceId + "' }.resourceMethods.GET.methodIntegration.uri",+ equalTo("https://example.invalid/widgets"));+ }++ @Test+ void individualEmbedPreservesStoredRequestAndResponseConfiguration() {+ given().queryParam("embed", "methods").when().get(resourcePath())+ .then().statusCode(200)+ .body("resourceMethods.GET.requestParameters.'method.request.header.X-Trace'", equalTo(true))+ .body("resourceMethods.GET.requestModels.'application/json'", equalTo("Empty"))+ .body("resourceMethods.GET.methodResponses.'200'.statusCode", equalTo("200"))+ .body("resourceMethods.GET.methodResponses.'200'.responseParameters.'method.response.header.X-Trace'",+ equalTo(true))+ .body("resourceMethods.GET.methodIntegration.timeoutInMillis", equalTo(12000))+ .body("resourceMethods.GET.methodIntegration.requestTemplates.'application/json'", equalTo("{}"))+ .body("resourceMethods.GET.methodIntegration.requestParameters.'integration.request.header.X-Trace'",+ equalTo("method.request.header.X-Trace"));+ }++ @Test+ void ordinaryReadsReturnMethodNamesWithoutErasingStoredMetadata() {+ given().when().get(resourcesPath()).then().statusCode(200)+ .body("item.find { it.id == '" + resourceId + "' }.resourceMethods.GET", anEmptyMap())+ .body("item.find { it.id == '" + resourceId + "' }.resourceMethods.POST", anEmptyMap());+ given().when().get(resourcePath()).then().statusCode(200)+ .body("resourceMethods.GET", anEmptyMap()).body("resourceMethods.POST", anEmptyMap());+ given().when().get(methodPath("GET")).then().statusCode(200)+ .body("authorizationType", equalTo("NONE"))+ .body("methodIntegration.uri", equalTo("https://example.invalid/widgets"));+ given().queryParam("embed", "methods").when().get(resourcePath()).then().statusCode(200)+ .body("resourceMethods.GET.authorizationType", equalTo("NONE"));+ }++ @Test+ void emptyResourcesDoNotInventMethods() {+ given().queryParam("embed", "methods").when().get(resourcesPath() + "/" + rootId)+ .then().statusCode(200).body("resourceMethods", nullValue());+ given().queryParam("embed", "methods").when().get(resourcesPath()).then().statusCode(200)+ .body("item.find { it.id == '" + rootId + "' }.resourceMethods", nullValue());+ }++ @Test+ void embeddedReadsReflectMethodUpdatesAndDeletion() {+ given().contentType(ContentType.JSON).body("""+ {"patchOperations":[{"op":"replace","path":"/authorizationType","value":"AWS_IAM"}]}+ """)+ .when().patch(methodPath("GET")).then().statusCode(200);+ given().when().delete(methodPath("POST")).then().statusCode(202);+ given().queryParam("embed", "methods").when().get(resourcePath()).then().statusCode(200)+ .body("resourceMethods.GET.authorizationType", equalTo("AWS_IAM"))+ .body("resourceMethods", not(hasKey("POST")));+ given().queryParam("embed", "methods").when().get(resourcesPath()).then().statusCode(200)+ .body("item.find { it.id == '" + resourceId + "' }.resourceMethods", not(hasKey("POST")));+ }++ @Test+ void embeddedReadsKeepNotFoundErrors() {+ given().queryParam("embed", "methods").when().get("/restapis/missing-api/resources")+ .then().statusCode(404);+ given().queryParam("embed", "methods").when().get(resourcesPath() + "/missing-resource")+ .then().statusCode(404);+ }++ private String resourcesPath() {+ return "/restapis/" + apiId + "/resources";+ }++ private String resourcePath() {+ return resourcesPath() + "/" + resourceId;+ }++ private String methodPath(String httpMethod) {+ return resourcePath() + "/methods/" + httpMethod;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/model/ApiGatewayMethodMapConcurrencyTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/model/ApiGatewayMethodMapConcurrencyTest.javanew file mode 100644index 0000000000..ca59ad04f7--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/model/ApiGatewayMethodMapConcurrencyTest.java@@ -0,0 +1,121 @@+package io.github.hectorvent.floci.services.apigateway.model;++import com.fasterxml.jackson.databind.ObjectMapper;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.EnumSource;++import java.util.HashMap;+import java.util.Map;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.Future;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicBoolean;++import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertSame;+import static org.junit.jupiter.api.Assertions.assertTrue;++class ApiGatewayMethodMapConcurrencyTest {++ enum MapSource { NEW, SETTER, JACKSON, NULL_RESET }++ @ParameterizedTest+ @EnumSource(MapSource.class)+ void resourceMethodsTolerateWritesDuringReadTraversal(MapSource source) throws Exception {+ ApiGatewayResource resource = switch (source) {+ case NEW -> new ApiGatewayResource();+ case SETTER -> {+ ApiGatewayResource configured = new ApiGatewayResource();+ configured.setResourceMethods(new HashMap<>());+ yield configured;+ }+ case JACKSON -> new ObjectMapper().readValue(+ "{\"resourceMethods\":{\"GET\":{\"httpMethod\":\"GET\"}}}", ApiGatewayResource.class);+ case NULL_RESET -> {+ ApiGatewayResource configured = new ApiGatewayResource();+ configured.setResourceMethods(null);+ yield configured;+ }+ };+ MethodConfig method = new MethodConfig();+ method.setHttpMethod("GET");+ mutateDuringTraversal(resource.getResourceMethods(), "GET", "POST", "DELETE", method);+ }++ @ParameterizedTest+ @EnumSource(MapSource.class)+ void methodResponsesTolerateWritesDuringReadTraversal(MapSource source) throws Exception {+ MethodConfig method = switch (source) {+ case NEW -> new MethodConfig();+ case SETTER -> {+ MethodConfig configured = new MethodConfig();+ configured.setMethodResponses(new HashMap<>());+ yield configured;+ }+ case JACKSON -> new ObjectMapper().readValue(+ "{\"methodResponses\":{\"200\":{\"statusCode\":\"200\"}}}", MethodConfig.class);+ case NULL_RESET -> {+ MethodConfig configured = new MethodConfig();+ configured.setMethodResponses(null);+ yield configured;+ }+ };+ mutateDuringTraversal(method.getMethodResponses(), "200", "400", "500",+ new MethodResponse("200", Map.of("method.response.header.X-Trace", true)));+ }++ @Test+ void resourceSetterOwnsItsMapAndKeepsMethodConfiguration() {+ MethodConfig method = new MethodConfig();+ method.setHttpMethod("GET");+ Map<String, MethodConfig> input = new HashMap<>(Map.of("GET", method));+ ApiGatewayResource resource = new ApiGatewayResource();+ resource.setResourceMethods(input);+ input.clear();++ assertSame(method, resource.getResourceMethods().get("GET"));+ resource.getResourceMethods().put("POST", new MethodConfig());+ assertTrue(input.isEmpty(), "Mutating the stored map must not mutate the setter's input");+ }++ @Test+ void responseSetterOwnsItsMapAndKeepsResponseConfiguration() {+ MethodResponse response = new MethodResponse("200", Map.of("method.response.header.X-Trace", true));+ Map<String, MethodResponse> input = new HashMap<>(Map.of("200", response));+ MethodConfig method = new MethodConfig();+ method.setMethodResponses(input);+ input.clear();++ assertEquals(response, method.getMethodResponses().get("200"));+ method.getMethodResponses().put("400", new MethodResponse("400", Map.of()));+ assertTrue(input.isEmpty(), "Mutating the stored map must not mutate the setter's input");+ }++ private static <T> void mutateDuringTraversal(Map<String, T> map, String first, String second,+ String added, T value) {+ map.put(first, value);+ map.put(second, value);+ AtomicBoolean changed = new AtomicBoolean();+ try (ExecutorService writer = Executors.newSingleThreadExecutor()) {+ assertDoesNotThrow(() -> map.forEach((key, entry) -> {+ if (changed.compareAndSet(false, true)) {+ Future<?> mutation = writer.submit(() -> {+ map.put(added, value);+ map.remove(second);+ });+ assertDoesNotThrow(() -> mutation.get(5, TimeUnit.SECONDS));+ }+ assertNotNull(key);+ assertNotNull(entry);+ }));+ }+ assertTrue(changed.get(), "The writer must run while the reader is traversing the map");+ assertSame(value, map.get(added));+ assertFalse(map.containsKey(second));+ }+}