Light, fluffy, and always free - The AWS Local Emulator alternative
feat(cloudformation): expand SAM AWS::Serverless::HttpApi to ApiGatew… (#1956)
Aniket Shukla6fa53abd7cd9
diff --git a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/ApiGatewayV2Service.java b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/ApiGatewayV2Service.javaindex 91f9780bfe..cf00436652 100644--- a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/ApiGatewayV2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/ApiGatewayV2Service.java@@ -307,6 +307,22 @@ public class ApiGatewayV2Service {authorizerStore.delete(authorizerKey(region, apiId, authorizerId));}+ /** Restores an authorizer with its original ID for a higher-level transactional rollback. */+ public void restoreAuthorizer(String region, String apiId, Authorizer authorizer) {+ getApi(region, apiId);+ Authorizer restored = new Authorizer();+ restored.setAuthorizerId(authorizer.getAuthorizerId());+ restored.setAuthorizerType(authorizer.getAuthorizerType());+ restored.setName(authorizer.getName());+ restored.setJwtConfiguration(authorizer.getJwtConfiguration());+ restored.setIdentitySource(authorizer.getIdentitySource());+ restored.setAuthorizerUri(authorizer.getAuthorizerUri());+ restored.setAuthorizerPayloadFormatVersion(authorizer.getAuthorizerPayloadFormatVersion());+ restored.setAuthorizerResultTtlInSeconds(authorizer.getAuthorizerResultTtlInSeconds());+ restored.setEnableSimpleResponses(authorizer.getEnableSimpleResponses());+ authorizerStore.put(authorizerKey(region, apiId, restored.getAuthorizerId()), restored);+ }+public Authorizer updateAuthorizer(String region, String apiId, String authorizerId,Map<String, Object> request) {Authorizer auth = getAuthorizer(region, apiId, authorizerId);@@ -356,9 +372,11 @@ public class ApiGatewayV2Service {public Route createRoute(String region, String apiId, Map<String, Object> request) {getApi(region, apiId);+ String requestedRouteKey = (String) request.get("routeKey");+ ensureRouteKeyAvailable(region, apiId, requestedRouteKey, null);Route route = new Route();route.setRouteId(shortId(8));- route.setRouteKey((String) request.get("routeKey"));+ route.setRouteKey(requestedRouteKey);route.setAuthorizationType((String) request.getOrDefault("authorizationType", "NONE"));route.setAuthorizerId((String) request.get("authorizerId"));route.setAuthorizationScopes(toStringList(request.get("authorizationScopes")));@@ -385,11 +403,52 @@ public class ApiGatewayV2Service {routeStore.delete(routeKey(region, apiId, routeId));}+ /** Restores a route without treating any conflicting route as rollback-owned. */+ public void restoreRoute(String region, String apiId, Route route) {+ restoreRoute(region, apiId, route, java.util.Set.of());+ }++ /**+ * Restores a route with its original ID for a higher-level transactional rollback.+ * Only conflicts explicitly identified as part of the failed replacement may be removed;+ * independently managed routes must never be deleted as a rollback side effect.+ */+ public void restoreRoute(String region, String apiId, Route route,+ java.util.Collection<String> replaceableRouteIds) {+ getApi(region, apiId);+ // A failed cleanup can leave a replacement route behind. Remove that conflicting+ // route only when the caller proves it belongs to that failed replacement.+ for (Route existing : getRoutes(region, apiId)) {+ if (!java.util.Objects.equals(existing.getRouteId(), route.getRouteId())+ && java.util.Objects.equals(existing.getRouteKey(), route.getRouteKey())) {+ if (replaceableRouteIds.contains(existing.getRouteId())) {+ routeStore.delete(routeKey(region, apiId, existing.getRouteId()));+ } else {+ throw new AwsException("ConflictException",+ "Cannot restore route with key '" + route.getRouteKey()+ + "' because an independently managed route already exists",+ 409);+ }+ }+ }+ Route restored = new Route();+ restored.setRouteId(route.getRouteId());+ restored.setRouteKey(route.getRouteKey());+ restored.setAuthorizationType(route.getAuthorizationType());+ restored.setAuthorizerId(route.getAuthorizerId());+ restored.setAuthorizationScopes(route.getAuthorizationScopes());+ restored.setTarget(route.getTarget());+ restored.setRouteResponseSelectionExpression(route.getRouteResponseSelectionExpression());+ routeStore.put(routeKey(region, apiId, restored.getRouteId()), restored);+ }+public Route updateRoute(String region, String apiId, String routeId, Map<String, Object> request) {Route route = getRoute(region, apiId, routeId);if (request.containsKey("routeKey") && request.get("routeKey") != null) {- route.setRouteKey((String) request.get("routeKey"));+ String requestedRouteKey = (String) request.get("routeKey");+ ensureRouteKeyAvailable(region, apiId, requestedRouteKey, routeId);+ route.setRouteKey(requestedRouteKey);}if (request.containsKey("authorizationType") && request.get("authorizationType") != null) {route.setAuthorizationType((String) request.get("authorizationType"));@@ -411,6 +470,20 @@ public class ApiGatewayV2Service {return route;}+ private void ensureRouteKeyAvailable(String region, String apiId, String requestedRouteKey,+ String currentRouteId) {+ if (requestedRouteKey == null) {+ return;+ }+ boolean duplicate = getRoutes(region, apiId).stream()+ .anyMatch(existing -> !java.util.Objects.equals(existing.getRouteId(), currentRouteId)+ && requestedRouteKey.equals(existing.getRouteKey()));+ if (duplicate) {+ throw new AwsException("ConflictException",+ "Route with key '" + requestedRouteKey + "' already exists", 409);+ }+ }+// JSON bodies can carry non-string elements (numbers, booleans); downstream code// (response serialization, scope enforcement) assumes String elements, so normalize// at ingestion instead of unchecked-casting. A present-but-non-array value must be@@ -545,6 +618,13 @@ public class ApiGatewayV2Service {integrationStore.delete(integrationKey(region, apiId, integrationId));}+ /** Restores an integration with its original ID for a higher-level transactional rollback. */+ public void restoreIntegration(String region, String apiId, Integration integration) {+ getApi(region, apiId);+ integrationStore.put(integrationKey(region, apiId, integration.getIntegrationId()),+ new Integration(integration));+ }+public Integration updateIntegration(String region, String apiId, String integrationId,Map<String, Object> request) {Integration integration = getIntegration(region, apiId, integrationId);diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.javaindex 0e379aaf79..1bdcd3431b 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java@@ -137,6 +137,7 @@ public class CloudFormationResourceProvisioner {private static final String LAMBDA_NAME_MODE_ATTR = "FlociLambdaFunctionNameMode";private static final String LAMBDA_PACKAGE_TYPE_ATTR = "FlociLambdaPackageType";static final String UPDATE_ROLLBACK_RESTORED_ATTR = "__FlociUpdateRollbackRestored";+ static final String UPDATE_ROLLBACK_FAILURE_ATTR = "__FlociUpdateRollbackFailure";private static final String INLINE_CLEANUP_POLICY_NAME_ATTR = "__FlociInlineCleanupPolicyName";private static final String INLINE_CLEANUP_ROLE_TARGETS_ATTR = "__FlociInlineCleanupRoleTargets";private static final String INLINE_CLEANUP_USER_TARGETS_ATTR = "__FlociInlineCleanupUserTargets";@@ -166,6 +167,11 @@ public class CloudFormationResourceProvisioner {private static final int LAMBDA_DEFAULT_MEMORY_MB = 128;private static final int LAMBDA_DEFAULT_EPHEMERAL_STORAGE_MB = 512;private static final String LAMBDA_DEFAULT_TRACING_MODE = "PassThrough";+ private static final String APIGATEWAY_V2_BODY_ROUTE_IDS_ATTR = "__FlociApiGatewayV2BodyRouteIds";+ private static final String APIGATEWAY_V2_BODY_INTEGRATION_IDS_ATTR =+ "__FlociApiGatewayV2BodyIntegrationIds";+ private static final String APIGATEWAY_V2_BODY_AUTHORIZER_IDS_ATTR =+ "__FlociApiGatewayV2BodyAuthorizerIds";/** Reserved attribute keys used to carry custom-resource state to the later Delete invocation. */private static final String CR_SERVICE_TOKEN_ATTR = "__FlociServiceToken";@@ -5188,6 +5194,611 @@ public class CloudFormationResourceProvisioner {}r.setPhysicalId(api.getApiId());r.getAttributes().put("ApiEndpoint", api.getApiEndpoint());+ reconcileApiGatewayV2BodyRoutes(r, region, api.getApiId(), props, engine);+ }++ /**+ * Reconciles the routes, integrations, and authorizers materialized from an ApiGatewayV2 OpenAPI body.+ * Only IDs stored on this CloudFormation resource are removed, so separately declared V2+ * resources remain outside this generated-resource lifecycle.+ */+ private void reconcileApiGatewayV2BodyRoutes(StackResource r, String region, String apiId, JsonNode props,+ CloudFormationTemplateEngine engine) {+ JsonNode body = resolveApiGatewayV2OpenApiBody(props, engine);+ ApiGatewayV2BodyResourceState previous = null;+ try {+ previous = snapshotApiGatewayV2BodyResources(r, region, apiId);+ // API Gateway requires route keys to be unique. Remove only the tracked body-generated+ // resources before creating their replacements; rollback restores this snapshot.+ deleteApiGatewayV2BodyResources(r, region, apiId);+ } catch (RuntimeException e) {+ rollbackApiGatewayV2BodyReplacement(r, region, apiId,+ new ApiGatewayV2BodyResources(List.of(), List.of(), List.of()), previous, e);+ throw e;+ }++ if (body == null) {+ return;+ }++ ApiGatewayV2BodyResources replacement;+ try {+ replacement = materializeApiGatewayV2BodyRoutes(region, apiId, body);+ } catch (ApiGatewayV2BodyMaterializationException e) {+ rollbackApiGatewayV2BodyReplacement(r, region, apiId, e.resources(), previous, e);+ throw e;+ } catch (RuntimeException e) {+ // materializeApiGatewayV2BodyRoutes already removed its partial replacement.+ rollbackApiGatewayV2BodyReplacement(r, region, apiId,+ new ApiGatewayV2BodyResources(List.of(), List.of(), List.of()), previous, e);+ throw e;+ }+ storeApiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_ROUTE_IDS_ATTR, replacement.routeIds());+ storeApiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_INTEGRATION_IDS_ATTR,+ replacement.integrationIds());+ storeApiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_AUTHORIZER_IDS_ATTR,+ replacement.authorizerIds());+ }++ private JsonNode resolveApiGatewayV2OpenApiBody(JsonNode props, CloudFormationTemplateEngine engine) {+ if (props == null) {+ return null;+ }+ if (props.hasNonNull("Body")) {+ return engine.resolveNode(props.get("Body"));+ }+ if (!props.hasNonNull("BodyS3Location")) {+ return null;+ }++ JsonNode location = engine.resolveNode(props.get("BodyS3Location"));+ ApiGatewayV2BodyS3Location bodyS3Location = parseApiGatewayV2BodyS3Location(location);++ try {+ byte[] document = s3Service.getObject(bodyS3Location.bucket(), bodyS3Location.key(),+ bodyS3Location.version()).getData();+ String content = new String(document, StandardCharsets.UTF_8).trim();+ if (content.startsWith("{") || content.startsWith("[")) {+ return objectMapper.readTree(content);+ }+ return new CloudFormationYamlParser(objectMapper).parse(content);+ } catch (AwsException e) {+ throw e;+ } catch (Exception e) {+ throw new AwsException("ValidationException",+ "Unable to parse OpenAPI document from s3://" + bodyS3Location.bucket() + "/"+ + bodyS3Location.key(), 400);+ }+ }++ private ApiGatewayV2BodyS3Location parseApiGatewayV2BodyS3Location(JsonNode location) {+ if (location != null && location.isTextual()) {+ String uri = location.asText();+ if (uri.startsWith("s3://")) {+ String withoutScheme = uri.substring("s3://".length());+ int slash = withoutScheme.indexOf('/');+ if (slash > 0 && slash < withoutScheme.length() - 1) {+ return new ApiGatewayV2BodyS3Location(withoutScheme.substring(0, slash),+ withoutScheme.substring(slash + 1), null);+ }+ }+ } else if (location != null && location.isObject()) {+ String bucket = textOrNull(location, "Bucket");+ String key = textOrNull(location, "Key");+ if (bucket != null && !bucket.isBlank() && key != null && !key.isBlank()) {+ return new ApiGatewayV2BodyS3Location(bucket, key, textOrNull(location, "Version"));+ }+ }+ throw new AwsException("ValidationException",+ "BodyS3Location must resolve to a non-empty S3 location", 400);+ }++ /**+ * CloudFormation's ApiGatewayV2 {@code Body} is an OpenAPI document. Materialize each+ * declared HTTP operation as the route that API Gateway V2 serves, including its OpenAPI+ * security requirement and a route target when it declares an integration extension.+ */+ private ApiGatewayV2BodyResources materializeApiGatewayV2BodyRoutes(String region, String apiId,+ JsonNode body) {+ List<String> routeIds = new ArrayList<>();+ List<String> integrationIds = new ArrayList<>();+ List<String> authorizerIds = new ArrayList<>();+ try {+ Map<String, OpenApiAuthorizerBinding> authorizers = materializeApiGatewayV2BodyAuthorizers(+ region, apiId, body, authorizerIds);+ JsonNode paths = body.path("paths");+ if (!paths.isObject()) {+ return new ApiGatewayV2BodyResources(routeIds, integrationIds, authorizerIds);+ }++ Iterator<Map.Entry<String, JsonNode>> pathEntries = paths.fields();+ while (pathEntries.hasNext()) {+ Map.Entry<String, JsonNode> pathEntry = pathEntries.next();+ if (!pathEntry.getValue().isObject()) {+ continue;+ }+ Iterator<Map.Entry<String, JsonNode>> operations = pathEntry.getValue().fields();+ while (operations.hasNext()) {+ Map.Entry<String, JsonNode> operation = operations.next();+ String method = operation.getKey();+ if (!isHttpApiOperation(method) || !operation.getValue().isObject()) {+ continue;+ }++ Map<String, Object> routeRequest = new HashMap<>();+ routeRequest.put("routeKey", openApiRouteKey(method, pathEntry.getKey()));+ applyOpenApiRouteSecurity(body, operation.getValue(), pathEntry.getKey(), method,+ authorizers, routeRequest);+ JsonNode integration = operation.getValue().path("x-amazon-apigateway-integration");+ if (integration.isObject()) {+ String integrationType = textOrNull(integration, "type");+ if (integrationType != null && !integrationType.isBlank()) {+ Map<String, Object> integrationRequest = new HashMap<>();+ integrationRequest.put("integrationType", integrationType.toUpperCase(Locale.ROOT));+ putOpenApiIntegrationValue(integrationRequest, "integrationUri", integration, "uri");+ putOpenApiIntegrationValue(integrationRequest, "integrationMethod", integration,+ "httpMethod");+ putOpenApiIntegrationValue(integrationRequest, "payloadFormatVersion", integration,+ "payloadFormatVersion");+ Integration createdIntegration = apiGatewayV2Service.createIntegration(region, apiId,+ integrationRequest);+ integrationIds.add(createdIntegration.getIntegrationId());+ routeRequest.put("target", "integrations/" + createdIntegration.getIntegrationId());+ }+ }+ Route createdRoute = apiGatewayV2Service.createRoute(region, apiId, routeRequest);+ routeIds.add(createdRoute.getRouteId());+ }+ }+ return new ApiGatewayV2BodyResources(routeIds, integrationIds, authorizerIds);+ } catch (RuntimeException e) {+ ApiGatewayV2BodyResources partial = new ApiGatewayV2BodyResources(+ routeIds, integrationIds, authorizerIds);+ List<RuntimeException> cleanupFailures = cleanupApiGatewayV2BodyResources(region, apiId, partial);+ if (!cleanupFailures.isEmpty()) {+ cleanupFailures.forEach(e::addSuppressed);+ throw new ApiGatewayV2BodyMaterializationException(e, partial);+ }+ throw e;+ }+ }++ private Map<String, OpenApiAuthorizerBinding> materializeApiGatewayV2BodyAuthorizers(+ String region, String apiId, JsonNode body, List<String> authorizerIds) {+ Map<String, OpenApiAuthorizerBinding> bindings = new LinkedHashMap<>();+ JsonNode schemes = body.path("components").path("securitySchemes");+ if (!schemes.isObject()) {+ return bindings;+ }++ Iterator<Map.Entry<String, JsonNode>> entries = schemes.fields();+ while (entries.hasNext()) {+ Map.Entry<String, JsonNode> entry = entries.next();+ String schemeName = entry.getKey();+ JsonNode scheme = entry.getValue();+ if (!scheme.isObject()) {+ continue;+ }++ JsonNode definition = scheme.path("x-amazon-apigateway-authorizer");+ if (!definition.isObject()) {+ continue;+ }++ String type = textOrNull(definition, "type");+ String authorizerType;+ String routeAuthorizationType;+ if ("jwt".equalsIgnoreCase(type)) {+ authorizerType = "JWT";+ routeAuthorizationType = "JWT";+ } else if ("request".equalsIgnoreCase(type)) {+ authorizerType = "REQUEST";+ routeAuthorizationType = "CUSTOM";+ } else {+ throw invalidOpenApiV2Security("Authorizer " + schemeName+ + " must declare type jwt or request");+ }++ Map<String, Object> request = new HashMap<>();+ request.put("name", schemeName);+ request.put("authorizerType", authorizerType);+ putOpenApiAuthorizerIdentitySource(request, definition);+ putOpenApiAuthorizerValue(request, "authorizerUri", definition, "authorizerUri");+ putOpenApiAuthorizerValue(request, "authorizerPayloadFormatVersion", definition,+ "authorizerPayloadFormatVersion");+ putOpenApiAuthorizerValue(request, "authorizerResultTtlInSeconds", definition,+ "authorizerResultTtlInSeconds");+ putOpenApiAuthorizerValue(request, "enableSimpleResponses", definition,+ "enableSimpleResponses");++ if ("JWT".equals(authorizerType)) {+ JsonNode jwt = definition.path("jwtConfiguration");+ if (!jwt.isObject()) {+ throw invalidOpenApiV2Security("JWT authorizer " + schemeName+ + " must declare jwtConfiguration");+ }+ Map<String, Object> jwtConfiguration = new HashMap<>();+ jwtConfiguration.put("issuer", textOrNull(jwt, "issuer"));+ jwtConfiguration.put("audience", openApiStringList(jwt.get("audience"),+ "jwtConfiguration.audience for authorizer " + schemeName));+ request.put("jwtConfiguration", jwtConfiguration);+ }++ Authorizer created = apiGatewayV2Service.createAuthorizer(region, apiId, request);+ authorizerIds.add(created.getAuthorizerId());+ bindings.put(schemeName,+ new OpenApiAuthorizerBinding(routeAuthorizationType, created.getAuthorizerId()));+ }+ return bindings;+ }++ private void applyOpenApiRouteSecurity(JsonNode body, JsonNode operation, String path, String method,+ Map<String, OpenApiAuthorizerBinding> authorizers,+ Map<String, Object> routeRequest) {+ JsonNode security = operation.has("security") ? operation.get("security") : body.get("security");+ if (security == null || security.isNull() || security.isMissingNode()) {+ return;+ }+ if (!security.isArray()) {+ throw invalidOpenApiV2Security("security must be an array");+ }+ if (security.isEmpty()) {+ routeRequest.put("authorizationType", "NONE");+ return; // An operation-level empty array explicitly overrides inherited security.+ }++ // Each object is one alternative in the outer OR-list, but names inside one object are+ // an AND requirement. A V2 route can attach only one authorizer, so accepting a multi-name+ // object would silently weaken its authentication contract. AWS classifies multiple+ // security requirements as an HTTP API import error:+ // https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-open-api.html+ // Validate every alternative before selecting a representable one.+ for (JsonNode requirement : security) {+ if (!requirement.isObject()) {+ throw invalidOpenApiV2Security("security requirements must be objects");+ }+ if (requirement.isEmpty()) {+ routeRequest.put("authorizationType", "NONE");+ return; // An empty requirement allows anonymous access by OpenAPI definition.+ }+ if (requirement.size() > 1) {+ throw invalidOpenApiV2Security(+ "HTTP API routes do not support AND security requirements with multiple schemes");+ }+ }+ if (security.size() > 1) {+ throw invalidOpenApiV2Security(+ "HTTP API routes do not support OR security requirements with multiple alternatives");+ }++ String unsupportedScheme = null;+ for (JsonNode requirement : security) {+ Iterator<Map.Entry<String, JsonNode>> schemes = requirement.fields();+ while (schemes.hasNext()) {+ Map.Entry<String, JsonNode> scheme = schemes.next();+ OpenApiAuthorizerBinding binding = authorizers.get(scheme.getKey());+ if (binding == null) {+ unsupportedScheme = scheme.getKey();+ continue;+ }+ routeRequest.put("authorizationType", binding.authorizationType());+ if (binding.authorizerId() != null) {+ routeRequest.put("authorizerId", binding.authorizerId());+ }+ if ("JWT".equals(binding.authorizationType())) {+ List<String> scopes = openApiStringList(scheme.getValue(),+ "security scopes for scheme " + scheme.getKey());+ if (!scopes.isEmpty()) {+ routeRequest.put("authorizationScopes", scopes);+ }+ }+ return;+ }+ }+ throw invalidOpenApiV2Security(+ "Protected operation " + openApiRouteKey(method, path)+ + " references unsupported security scheme '" + unsupportedScheme + "'");+ }++ private static void putOpenApiAuthorizerIdentitySource(Map<String, Object> request, JsonNode definition) {+ JsonNode identitySource = definition.get("identitySource");+ if (identitySource == null || identitySource.isNull()) {+ return;+ }+ if (identitySource.isTextual()) {+ request.put("identitySource", identitySource.asText());+ return;+ }+ request.put("identitySource", openApiStringList(identitySource, "authorizer identitySource"));+ }++ private static void putOpenApiAuthorizerValue(Map<String, Object> request, String requestKey,+ JsonNode definition, String definitionKey) {+ JsonNode value = definition.get(definitionKey);+ if (value == null || value.isNull()) {+ return;+ }+ if (value.isTextual()) {+ request.put(requestKey, value.asText());+ } else if (value.isBoolean()) {+ request.put(requestKey, value.booleanValue());+ } else if (value.isIntegralNumber()) {+ request.put(requestKey, value.intValue());+ } else {+ throw invalidOpenApiV2Security(definitionKey + " has an invalid value");+ }+ }++ private static List<String> openApiStringList(JsonNode value, String fieldName) {+ if (value == null || value.isNull()) {+ return List.of();+ }+ if (!value.isArray()) {+ throw invalidOpenApiV2Security(fieldName + " must be an array of strings");+ }+ List<String> values = new ArrayList<>();+ for (JsonNode element : value) {+ if (!element.isTextual()) {+ throw invalidOpenApiV2Security(fieldName + " must be an array of strings");+ }+ values.add(element.asText());+ }+ return values;+ }++ private static AwsException invalidOpenApiV2Security(String message) {+ return new AwsException("ValidationException", message, 400);+ }++ private void deleteApiGatewayV2BodyResources(StackResource r, String region, String apiId) {+ deleteApiGatewayV2BodyResources(region, apiId, new ApiGatewayV2BodyResources(+ apiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_ROUTE_IDS_ATTR),+ apiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_INTEGRATION_IDS_ATTR),+ apiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_AUTHORIZER_IDS_ATTR)));+ r.getAttributes().remove(APIGATEWAY_V2_BODY_ROUTE_IDS_ATTR);+ r.getAttributes().remove(APIGATEWAY_V2_BODY_INTEGRATION_IDS_ATTR);+ r.getAttributes().remove(APIGATEWAY_V2_BODY_AUTHORIZER_IDS_ATTR);+ }++ private void deleteApiGatewayV2BodyResources(String region, String apiId,+ ApiGatewayV2BodyResources resources) {+ for (String routeId : resources.routeIds()) {+ deleteApiGatewayV2BodyRouteIfPresent(region, apiId, routeId);+ }+ for (String integrationId : resources.integrationIds()) {+ deleteApiGatewayV2BodyIntegrationIfPresent(region, apiId, integrationId);+ }+ for (String authorizerId : resources.authorizerIds()) {+ deleteApiGatewayV2BodyAuthorizerIfPresent(region, apiId, authorizerId);+ }+ }++ private ApiGatewayV2BodyResourceState snapshotApiGatewayV2BodyResources(StackResource r, String region,+ String apiId) {+ List<Route> routes = new ArrayList<>();+ for (String routeId : apiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_ROUTE_IDS_ATTR)) {+ try {+ routes.add(apiGatewayV2Service.getRoute(region, apiId, routeId));+ } catch (AwsException e) {+ if (e.getHttpStatus() != 404) {+ throw e;+ }+ }+ }++ List<Integration> integrations = new ArrayList<>();+ for (String integrationId : apiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_INTEGRATION_IDS_ATTR)) {+ try {+ integrations.add(apiGatewayV2Service.getIntegration(region, apiId, integrationId));+ } catch (AwsException e) {+ if (e.getHttpStatus() != 404) {+ throw e;+ }+ }+ }++ List<Authorizer> authorizers = new ArrayList<>();+ for (String authorizerId : apiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_AUTHORIZER_IDS_ATTR)) {+ try {+ authorizers.add(apiGatewayV2Service.getAuthorizer(region, apiId, authorizerId));+ } catch (AwsException e) {+ if (e.getHttpStatus() != 404) {+ throw e;+ }+ }+ }+ return new ApiGatewayV2BodyResourceState(routes, integrations, authorizers);+ }++ private void rollbackApiGatewayV2BodyReplacement(StackResource r, String region, String apiId,+ ApiGatewayV2BodyResources replacement,+ ApiGatewayV2BodyResourceState previous,+ RuntimeException failure) {+ List<RuntimeException> cleanupFailures = cleanupApiGatewayV2BodyResources(region, apiId, replacement);++ if (previous != null) {+ storeApiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_ROUTE_IDS_ATTR,+ previous.routes().stream().map(Route::getRouteId).toList());+ storeApiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_INTEGRATION_IDS_ATTR,+ previous.integrations().stream().map(Integration::getIntegrationId).toList());+ storeApiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_AUTHORIZER_IDS_ATTR,+ previous.authorizers().stream().map(Authorizer::getAuthorizerId).toList());+ }+ if (!cleanupFailures.isEmpty()) {+ cleanupFailures.forEach(failure::addSuppressed);+ retainApiGatewayV2BodyResourceIds(r, replacement);+ }+ if (previous == null) {+ return;+ }+ try {+ // Routes refer to integrations and authorizers, so restore both before their routes.+ for (Authorizer authorizer : previous.authorizers()) {+ apiGatewayV2Service.restoreAuthorizer(region, apiId, authorizer);+ }+ for (Integration integration : previous.integrations()) {+ apiGatewayV2Service.restoreIntegration(region, apiId, integration);+ }+ for (Route route : previous.routes()) {+ apiGatewayV2Service.restoreRoute(region, apiId, route, replacement.routeIds());+ }+ } catch (RuntimeException restoreFailure) {+ failure.addSuppressed(restoreFailure);+ String reason = restoreFailure.getMessage() != null+ ? restoreFailure.getMessage()+ : restoreFailure.getClass().getSimpleName();+ r.getAttributes().put(UPDATE_ROLLBACK_FAILURE_ATTR, reason);+ }+ }++ private List<RuntimeException> cleanupApiGatewayV2BodyResources(String region, String apiId,+ ApiGatewayV2BodyResources resources) {+ List<RuntimeException> failures = new ArrayList<>();+ for (String routeId : resources.routeIds()) {+ try {+ deleteApiGatewayV2BodyRouteIfPresent(region, apiId, routeId);+ } catch (RuntimeException e) {+ failures.add(e);+ }+ }+ for (String integrationId : resources.integrationIds()) {+ try {+ deleteApiGatewayV2BodyIntegrationIfPresent(region, apiId, integrationId);+ } catch (RuntimeException e) {+ failures.add(e);+ }+ }+ for (String authorizerId : resources.authorizerIds()) {+ try {+ deleteApiGatewayV2BodyAuthorizerIfPresent(region, apiId, authorizerId);+ } catch (RuntimeException e) {+ failures.add(e);+ }+ }+ return failures;+ }++ private void retainApiGatewayV2BodyResourceIds(StackResource r, ApiGatewayV2BodyResources resources) {+ retainApiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_ROUTE_IDS_ATTR, resources.routeIds());+ retainApiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_INTEGRATION_IDS_ATTR,+ resources.integrationIds());+ retainApiGatewayV2BodyResourceIds(r, APIGATEWAY_V2_BODY_AUTHORIZER_IDS_ATTR,+ resources.authorizerIds());+ }++ /**+ * Carries ownership discovered by a failed update onto the last known-good resource metadata+ * that CloudFormation restores. Only additive cleanup tracking belongs here; normal attempted+ * attributes must not overwrite the committed resource state.+ */+ void mergeFailedUpdateResourceTracking(StackResource previous, StackResource attempted) {+ if (!"AWS::ApiGatewayV2::Api".equals(previous.getResourceType())+ || !Objects.equals(previous.getResourceType(), attempted.getResourceType())) {+ return;+ }+ retainApiGatewayV2BodyResourceIds(previous, APIGATEWAY_V2_BODY_ROUTE_IDS_ATTR,+ apiGatewayV2BodyResourceIds(attempted, APIGATEWAY_V2_BODY_ROUTE_IDS_ATTR));+ retainApiGatewayV2BodyResourceIds(previous, APIGATEWAY_V2_BODY_INTEGRATION_IDS_ATTR,+ apiGatewayV2BodyResourceIds(attempted, APIGATEWAY_V2_BODY_INTEGRATION_IDS_ATTR));+ retainApiGatewayV2BodyResourceIds(previous, APIGATEWAY_V2_BODY_AUTHORIZER_IDS_ATTR,+ apiGatewayV2BodyResourceIds(attempted, APIGATEWAY_V2_BODY_AUTHORIZER_IDS_ATTR));+ }++ private static void retainApiGatewayV2BodyResourceIds(StackResource r, String attributeName,+ List<String> resourceIds) {+ LinkedHashSet<String> retained = new LinkedHashSet<>(apiGatewayV2BodyResourceIds(r, attributeName));+ retained.addAll(resourceIds);+ storeApiGatewayV2BodyResourceIds(r, attributeName, new ArrayList<>(retained));+ }++ private static List<String> apiGatewayV2BodyResourceIds(StackResource r, String attributeName) {+ String ids = r.getAttributes().get(attributeName);+ return ids == null || ids.isBlank() ? List.of() : Arrays.asList(ids.split(","));+ }++ private static void storeApiGatewayV2BodyResourceIds(StackResource r, String attributeName,+ List<String> resourceIds) {+ if (resourceIds.isEmpty()) {+ r.getAttributes().remove(attributeName);+ } else {+ r.getAttributes().put(attributeName, String.join(",", resourceIds));+ }+ }++ private void deleteApiGatewayV2BodyRouteIfPresent(String region, String apiId, String routeId) {+ try {+ apiGatewayV2Service.deleteRoute(region, apiId, routeId);+ } catch (AwsException e) {+ if (e.getHttpStatus() != 404) {+ throw e;+ }+ }+ }++ private void deleteApiGatewayV2BodyIntegrationIfPresent(String region, String apiId, String integrationId) {+ try {+ apiGatewayV2Service.deleteIntegration(region, apiId, integrationId);+ } catch (AwsException e) {+ if (e.getHttpStatus() != 404) {+ throw e;+ }+ }+ }++ private void deleteApiGatewayV2BodyAuthorizerIfPresent(String region, String apiId, String authorizerId) {+ try {+ apiGatewayV2Service.deleteAuthorizer(region, apiId, authorizerId);+ } catch (AwsException e) {+ if (e.getHttpStatus() != 404) {+ throw e;+ }+ }+ }++ private record ApiGatewayV2BodyResources(List<String> routeIds, List<String> integrationIds,+ List<String> authorizerIds) {}++ private record ApiGatewayV2BodyResourceState(List<Route> routes, List<Integration> integrations,+ List<Authorizer> authorizers) {}++ private record OpenApiAuthorizerBinding(String authorizationType, String authorizerId) {}++ private record ApiGatewayV2BodyS3Location(String bucket, String key, String version) {}++ private static final class ApiGatewayV2BodyMaterializationException extends RuntimeException {+ private final ApiGatewayV2BodyResources resources;++ private ApiGatewayV2BodyMaterializationException(RuntimeException cause,+ ApiGatewayV2BodyResources resources) {+ super(cause.getMessage(), cause);+ this.resources = resources;+ }++ private ApiGatewayV2BodyResources resources() {+ return resources;+ }+ }++ private static boolean isHttpApiOperation(String method) {+ return switch (method.toLowerCase(Locale.ROOT)) {+ case "get", "put", "post", "delete", "options", "head", "patch", "trace",+ "x-amazon-apigateway-any-method" -> true;+ default -> false;+ };+ }++ private static String openApiRouteKey(String method, String path) {+ String routeMethod = "x-amazon-apigateway-any-method".equals(method) ? "ANY"+ : method.toUpperCase(Locale.ROOT);+ return routeMethod + " " + path;+ }++ private static void putOpenApiIntegrationValue(Map<String, Object> request, String requestKey,+ JsonNode integration, String openApiKey) {+ String value = textOrNull(integration, openApiKey);+ if (value != null) {+ request.put(requestKey, value);+ }}private Map<String, String> parseApiGatewayV2Tags(JsonNode tagsNode, CloudFormationTemplateEngine engine) {diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.javaindex 49271756e6..1585d604d1 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java@@ -735,12 +735,27 @@ public class CloudFormationService {// Provisioners work on a copy of the stored resource metadata. Keep the// last known-good identity and status when an update attempt fails so a// later retry or stack deletion still manages the original resource.- // The rollback walker must also know this resource is already restored;- // otherwise an earlier UPDATE_COMPLETE status looks like an unhandled- // mutation and incorrectly turns a safe rollback into ROLLBACK_FAILED.- previousResource.getAttributes().put(- CloudFormationResourceProvisioner.UPDATE_ROLLBACK_RESTORED_ATTR,- "true");+ // Preserve any additional resources that the failed attempt could not+ // clean up, otherwise restoring this object would orphan them.+ provisioner.mergeFailedUpdateResourceTracking(previousResource, resource);+ String rollbackFailure = resource.getAttributes().get(+ CloudFormationResourceProvisioner.UPDATE_ROLLBACK_FAILURE_ATTR);+ if (rollbackFailure == null) {+ // The rollback walker must know this resource is already restored;+ // otherwise an earlier UPDATE_COMPLETE status looks like an+ // unhandled mutation and incorrectly becomes ROLLBACK_FAILED.+ previousResource.getAttributes().put(+ CloudFormationResourceProvisioner.UPDATE_ROLLBACK_RESTORED_ATTR,+ "true");+ } else {+ // Restoration was attempted eagerly by the provisioner but did not+ // complete. Carry that failure onto the committed resource so the+ // rollback walker reports UPDATE_ROLLBACK_FAILED rather than claiming+ // the stale snapshot is live.+ previousResource.getAttributes().put(+ CloudFormationResourceProvisioner.UPDATE_ROLLBACK_FAILURE_ATTR,+ rollbackFailure);+ }stack.getResources().put(logicalId, previousResource);}break;@@ -1105,6 +1120,15 @@ public class CloudFormationService {resource.getResourceType(), "DELETE_COMPLETE","Resource creation cancelled during update rollback");removedResources.add(resource.getLogicalId());+ } else if (resource.getAttributes().containsKey(+ CloudFormationResourceProvisioner.UPDATE_ROLLBACK_FAILURE_ATTR)) {+ String reason = resource.getAttributes().remove(+ CloudFormationResourceProvisioner.UPDATE_ROLLBACK_FAILURE_ATTR);+ failures.add(resource.getLogicalId());+ resource.setStatus("UPDATE_FAILED");+ resource.setStatusReason(reason);+ addEvent(stack, resource.getLogicalId(), resource.getPhysicalId(),+ resource.getResourceType(), "UPDATE_FAILED", reason);} else if ("true".equals(resource.getAttributes().remove(CloudFormationResourceProvisioner.UPDATE_ROLLBACK_RESTORED_ATTR))|| provisioner.rollbackUpdate(resource)) {diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessor.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessor.javaindex 90e72c47c9..80c1cdd922 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessor.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessor.java@@ -210,6 +210,18 @@ class SamTransformProcessor {apiProps.set("Name", !name.isMissingNode() ? name.deepCopy() : objectMapper.getNodeFactory().textNode(logicalId));apiProps.put("ProtocolType", "HTTP");copyIfPresent(properties, "Description", apiProps);++ // Preserve inline OpenAPI route definitions so the ApiGatewayV2 provisioner can+ // materialize the routes and integrations declared by SAM DefinitionBody.+ JsonNode definitionBody = properties.path("DefinitionBody");+ if (!definitionBody.isMissingNode() && !definitionBody.isNull()) {+ apiProps.set("Body", definitionBody.deepCopy());+ } else {+ ObjectNode bodyS3Location = buildHttpApiBodyS3Location(properties.path("DefinitionUri"));+ if (bodyS3Location != null) {+ apiProps.set("BodyS3Location", bodyS3Location);+ }+ }apiDef.set("Properties", apiProps);resources.set(logicalId, apiDef);@@ -247,10 +259,135 @@ class SamTransformProcessor {if (!logicalId.equals(route.apiLogicalId())) {continue;}+ JsonNode defaultAuthorizer = defaultAuthorizerName == null+ ? objectMapper.missingNode() : authorizers.path(defaultAuthorizerName);+ if (mergeHttpApiRouteIntoDefinitionBody(apiProps.path("Body"), route,+ defaultAuthorizerName, defaultAuthorizer)) {+ expandHttpApiPermission(logicalId, route, resources);+ continue;+ }expandHttpApiRoute(logicalId, route, defaultAuthorizerLogicalId, resources);}}+ /**+ * SAM merges a Function HttpApi event into an existing OpenAPI operation instead of emitting a+ * second route with the same key. Preserve the operation's documentation while adding the+ * Lambda integration only when the body does not already provide one.+ */+ private boolean mergeHttpApiRouteIntoDefinitionBody(JsonNode definitionBody, HttpApiRoute route,+ String defaultAuthorizerName,+ JsonNode defaultAuthorizer) {+ JsonNode pathItem = definitionBody.path("paths").path(route.path());+ if (!pathItem.isObject()) {+ return false;+ }+ String operationName = "ANY".equalsIgnoreCase(route.httpMethod())+ ? "x-amazon-apigateway-any-method" : route.httpMethod();+ JsonNode operation = fieldIgnoreCase(pathItem, operationName);+ if (!operation.isObject()) {+ return false;+ }+ ObjectNode operationObject = (ObjectNode) operation;+ if (!operationObject.path("x-amazon-apigateway-integration").isObject()) {+ ObjectNode integration = objectMapper.createObjectNode();+ integration.put("type", "aws_proxy");+ integration.put("httpMethod", "POST");+ integration.put("payloadFormatVersion", "2.0");+ integration.set("uri", lambdaInvokeUri(route.functionLogicalId()));+ operationObject.set("x-amazon-apigateway-integration", integration);+ }+ applyMergedHttpApiRouteAuthorization(definitionBody, operationObject, route,+ defaultAuthorizerName, defaultAuthorizer);+ return true;+ }++ /**+ * The SAM translator mutates matching DefinitionBody operations with both the Function event's+ * integration and its effective authorization. Without the latter, merging an authenticated+ * event would silently expose the route because the API Gateway V2 body importer defaults the+ * operation to {@code NONE}.+ */+ private void applyMergedHttpApiRouteAuthorization(JsonNode definitionBody, ObjectNode operation,+ HttpApiRoute route, String defaultAuthorizerName,+ JsonNode defaultAuthorizer) {+ if (route.noAuthorizer()) {+ // SAM represents this opt-out with a synthetic NONE requirement. An empty operation-level+ // OpenAPI security array is the standard equivalent and is understood by our body importer.+ operation.set("security", objectMapper.createArrayNode());+ return;+ }+ if (defaultAuthorizerName == null || !defaultAuthorizer.isObject()+ || hasNonEmptySecurity(operation.get("security"))) {+ return;+ }++ // AWS SAM deliberately treats an absent, null, or empty operation security value as unset+ // when applying DefaultAuthorizer. A public per-event override is represented separately by+ // Authorizer: NONE and is handled above. Keep this truthiness rule aligned with+ // OpenApiEditor.set_path_default_authorizer:+ // https://github.com/aws/serverless-application-model/blob/develop/samtranslator/open_api/open_api.py+ addOpenApiJwtAuthorizer(definitionBody, defaultAuthorizerName, defaultAuthorizer);+ ObjectNode requirement = objectMapper.createObjectNode();+ JsonNode configuredScopes = defaultAuthorizer.path("AuthorizationScopes");+ requirement.set(defaultAuthorizerName, configuredScopes.isArray()+ ? configuredScopes.deepCopy() : objectMapper.createArrayNode());+ ArrayNode security = objectMapper.createArrayNode();+ security.add(requirement);+ operation.set("security", security);+ }++ private static boolean hasNonEmptySecurity(JsonNode security) {+ return security != null && !security.isNull()+ && (!security.isContainerNode() || security.size() > 0);+ }++ /**+ * Emits the same JWT security-scheme shape as+ * {@code ApiGatewayV2Authorizer.generate_openapi} in AWS SAM. The ApiGatewayV2 body provisioner+ * materializes this scheme first, then binds the operation's security requirement to it.+ */+ private void addOpenApiJwtAuthorizer(JsonNode definitionBody, String authorizerName,+ JsonNode samAuthorizer) {+ ObjectNode body = (ObjectNode) definitionBody;+ ObjectNode components = objectChild(body, "components", "DefinitionBody.components");+ ObjectNode schemes = objectChild(components, "securitySchemes",+ "DefinitionBody.components.securitySchemes");++ ObjectNode scheme = objectMapper.createObjectNode();+ scheme.put("type", "oauth2");+ ObjectNode extension = objectMapper.createObjectNode();+ extension.set("identitySource", resolveIdentitySource(authorizerName, samAuthorizer));+ extension.put("type", "jwt");++ JsonNode samJwt = samAuthorizer.path("JwtConfiguration");+ ObjectNode jwt = objectMapper.createObjectNode();+ JsonNode issuer = fieldIgnoreCase(samJwt, "issuer");+ if (!issuer.isMissingNode()) {+ jwt.set("issuer", issuer.deepCopy());+ }+ JsonNode audience = fieldIgnoreCase(samJwt, "audience");+ if (audience.isArray()) {+ jwt.set("audience", audience.deepCopy());+ }+ extension.set("jwtConfiguration", jwt);+ scheme.set("x-amazon-apigateway-authorizer", extension);+ schemes.set(authorizerName, scheme);+ }++ private ObjectNode objectChild(ObjectNode parent, String fieldName, String fieldPath) {+ JsonNode existing = parent.get(fieldName);+ if (existing == null || existing.isNull()) {+ ObjectNode created = objectMapper.createObjectNode();+ parent.set(fieldName, created);+ return created;+ }+ if (!existing.isObject()) {+ throw new AwsException("ValidationError", fieldPath + " must be an object", 400);+ }+ return (ObjectNode) existing;+ }+private ObjectNode buildHttpApiAuthorizer(String apiLogicalId, String authorizerName, JsonNode samAuthorizer) {ObjectNode authDef = objectMapper.createObjectNode();authDef.put("Type", "AWS::ApiGatewayV2::Authorizer");@@ -362,6 +499,10 @@ class SamTransformProcessor {routeDef.set("Properties", routeProps);resources.set(routeLogicalId, routeDef);+ expandHttpApiPermission(apiLogicalId, route, resources);+ }++ private void expandHttpApiPermission(String apiLogicalId, HttpApiRoute route, ObjectNode resources) {String permissionLogicalId = uniqueId(route.functionLogicalId() + "HttpApiPermission" + sanitize(apiLogicalId), resources);ObjectNode perm = objectMapper.createObjectNode();@@ -949,6 +1090,41 @@ class SamTransformProcessor {resources.set(stageLogicalId, stageDef);}+ /**+ * {@code DefinitionUri} is SAM's S3-backed OpenAPI source. ApiGatewayV2 accepts the same+ * source through {@code BodyS3Location}, with the S3 URI split into its bucket and key.+ */+ private ObjectNode buildHttpApiBodyS3Location(JsonNode definitionUri) {+ if (definitionUri == null || definitionUri.isMissingNode() || definitionUri.isNull()) {+ return null;+ }+ ObjectNode location = objectMapper.createObjectNode();+ if (definitionUri.isTextual()) {+ String uri = definitionUri.asText();+ if (!uri.startsWith("s3://")) {+ return null;+ }+ String withoutScheme = uri.substring("s3://".length());+ int slash = withoutScheme.indexOf('/');+ if (slash <= 0 || slash == withoutScheme.length() - 1) {+ return null;+ }+ location.put("Bucket", withoutScheme.substring(0, slash));+ location.put("Key", withoutScheme.substring(slash + 1));+ return location;+ }+ if (definitionUri.isObject()) {+ copyIfPresent(definitionUri, "Bucket", location);+ copyIfPresent(definitionUri, "Key", location);+ copyIfPresent(definitionUri, "Version", location);+ // An intrinsic expression (for example Ref or Fn::Sub) cannot be split until the+ // CloudFormation engine resolves it during provisioning. Preserve it as-is instead+ // of silently dropping the HttpApi definition and its routes.+ return location.has("Bucket") && location.has("Key") ? location : definitionUri.deepCopy();+ }+ return null;+ }+private void copyIfPresent(JsonNode source, String field, ObjectNode target) {JsonNode value = source.path(field);if (!value.isMissingNode() && !value.isNull()) {diff --git a/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/ApiGatewayV2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/ApiGatewayV2IntegrationTest.javaindex 0405be2589..f496908ec4 100644--- a/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/ApiGatewayV2IntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/ApiGatewayV2IntegrationTest.java@@ -1,5 +1,9 @@package io.github.hectorvent.floci.services.apigatewayv2;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.apigatewayv2.model.Authorizer;+import io.github.hectorvent.floci.services.apigatewayv2.model.Route;+import jakarta.inject.Inject;import io.quarkus.test.junit.QuarkusTest;import io.restassured.http.ContentType;import org.junit.jupiter.api.MethodOrderer;@@ -7,13 +11,22 @@ import org.junit.jupiter.api.Order;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.TestMethodOrder;+import java.util.List;+import java.util.Map;+import java.util.Set;+import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.*;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;@QuarkusTest@TestMethodOrder(MethodOrderer.OrderAnnotation.class)class ApiGatewayV2IntegrationTest {+ @Inject+ ApiGatewayV2Service apiGatewayV2Service;+private static String apiId;private static String routeId;private static String integrationId;@@ -154,6 +167,60 @@ class ApiGatewayV2IntegrationTest {.body("items.routeId", hasItem(routeId));}+ @Test @Order(23)+ void duplicateRouteKeyIsRejected() {+ given()+ .contentType(ContentType.JSON)+ .body("""+ {"routeKey":"GET /users","target":"integrations/%s"}+ """.formatted(integrationId))+ .when().post("/v2/apis/" + apiId + "/routes")+ .then()+ .statusCode(409);+ }++ @Test @Order(24)+ void restoringRouteRemovesAConflictingReplacement() {+ Route oldRoute = new Route();+ oldRoute.setRouteId("restored-route");+ oldRoute.setRouteKey("GET /users");+ oldRoute.setAuthorizationType("NONE");+ oldRoute.setAuthorizationScopes(List.of("read:users"));+ oldRoute.setTarget("integrations/" + integrationId);++ String replacementRouteId = routeId;+ apiGatewayV2Service.restoreRoute("us-east-1", apiId, oldRoute, Set.of(replacementRouteId));++ assertEquals(1, apiGatewayV2Service.getRoutes("us-east-1", apiId).stream()+ .filter(route -> "GET /users".equals(route.getRouteKey()))+ .count());+ assertEquals("restored-route",+ apiGatewayV2Service.findRouteByKey("us-east-1", apiId, "GET /users").getRouteId());+ assertEquals(List.of("read:users"),+ apiGatewayV2Service.getRoute("us-east-1", apiId, "restored-route").getAuthorizationScopes());+ assertThrows(AwsException.class,+ () -> apiGatewayV2Service.getRoute("us-east-1", apiId, replacementRouteId));+ routeId = oldRoute.getRouteId();+ }++ @Test @Order(25)+ void restoringRouteDoesNotDeleteAnIndependentConflict() {+ Route independent = apiGatewayV2Service.createRoute("us-east-1", apiId,+ Map.of("routeKey", "GET /independent"));+ Route snapshot = new Route();+ snapshot.setRouteId("rollback-snapshot");+ snapshot.setRouteKey("GET /independent");++ assertThrows(AwsException.class,+ () -> apiGatewayV2Service.restoreRoute("us-east-1", apiId, snapshot, Set.of("other-route")));+ assertEquals(independent.getRouteId(), apiGatewayV2Service+ .findRouteByKey("us-east-1", apiId, "GET /independent").getRouteId());+ assertThrows(AwsException.class,+ () -> apiGatewayV2Service.getRoute("us-east-1", apiId, snapshot.getRouteId()));++ apiGatewayV2Service.deleteRoute("us-east-1", apiId, independent.getRouteId());+ }+// ──────────────────────────── Authorizers ────────────────────────────@Test @Order(30)@@ -198,6 +265,19 @@ class ApiGatewayV2IntegrationTest {.body("items.authorizerId", hasItem(authorizerId));}+ @Test @Order(33)+ void restoreAuthorizerPreservesEnforcementConfiguration() {+ Authorizer snapshot = apiGatewayV2Service.getAuthorizer("us-east-1", apiId, authorizerId);+ apiGatewayV2Service.deleteAuthorizer("us-east-1", apiId, authorizerId);+ apiGatewayV2Service.restoreAuthorizer("us-east-1", apiId, snapshot);++ Authorizer restored = apiGatewayV2Service.getAuthorizer("us-east-1", apiId, authorizerId);+ assertEquals("JWT", restored.getAuthorizerType());+ assertEquals(List.of("$request.header.Authorization"), restored.getIdentitySource());+ assertEquals("https://example.com", restored.getJwtConfiguration().issuer());+ assertEquals(List.of("api"), restored.getJwtConfiguration().audience());+ }+// ──────────────────────────── Deployments ────────────────────────────@Test @Order(40)diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/ApiGatewayV2CfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/ApiGatewayV2CfnProvisionerTest.javanew file mode 100644index 0000000000..745ea4eac9--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/ApiGatewayV2CfnProvisionerTest.java@@ -0,0 +1,511 @@+package io.github.hectorvent.floci.services.cloudformation;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.apigatewayv2.ApiGatewayV2Service;+import io.github.hectorvent.floci.services.apigatewayv2.model.Api;+import io.github.hectorvent.floci.services.apigatewayv2.model.Authorizer;+import io.github.hectorvent.floci.services.apigatewayv2.model.Route;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.cloudformation.provisioners.CloudFormationResourceRegistry;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.Map;+import java.util.concurrent.atomic.AtomicInteger;+import java.util.function.Function;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.mockito.ArgumentMatchers.anyMap;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.ArgumentMatchers.argThat;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.doAnswer;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++class ApiGatewayV2CfnProvisionerTest {++ private static final String REGION = "us-east-1";+ private static final String API_ID = "api-123";+ private final ObjectMapper mapper = new ObjectMapper();+ private ApiGatewayV2Service apiGatewayV2Service;+ private CloudFormationResourceProvisioner provisioner;++ @BeforeEach+ void setUp() {+ apiGatewayV2Service = mock(ApiGatewayV2Service.class);+ provisioner = new CloudFormationResourceProvisioner(+ null, null, null, null, null, null, null, null, null, null,+ null, apiGatewayV2Service, null, null, null, null, mapper,+ null, null, null, null, null, null, null, null, null, null,+ null, null, null, null, null, null,+ new CloudFormationResourceRegistry(java.util.List.of()));++ Api api = new Api();+ api.setApiId(API_ID);+ api.setApiEndpoint("https://" + API_ID + ".execute-api.localhost");+ when(apiGatewayV2Service.createApi(eq(REGION), anyMap())).thenReturn(api);+ when(apiGatewayV2Service.updateApi(eq(REGION), eq(API_ID), anyMap())).thenReturn(api);+ }++ @Test+ void restoresExistingRoutesAndCleansPartialReplacementWhenRouteCreationFails() throws Exception {+ Route oldRoute = route("old-route", "GET /before");+ when(apiGatewayV2Service.createRoute(eq(REGION), eq(API_ID), anyMap())).thenAnswer(invocation -> {+ @SuppressWarnings("unchecked")+ Map<String, Object> request = invocation.getArgument(2);+ return switch ((String) request.get("routeKey")) {+ case "GET /before" -> oldRoute;+ case "GET /first" -> route("partial-route", "GET /first");+ case "GET /second" -> throw new AwsException("InternalFailure", "simulated route failure", 500);+ default -> throw new AssertionError("Unexpected route key: " + request.get("routeKey"));+ };+ });+ when(apiGatewayV2Service.getRoute(REGION, API_ID, "old-route")).thenReturn(oldRoute);++ StackResource original = provision(body("""+ {"paths":{"/before":{"get":{}}}}+ """), null, Map.of());++ StackResource replacement = provision(body("""+ {"paths":{"/first":{"get":{}},"/second":{"get":{}}}}+ """), original.getPhysicalId(), original.getAttributes());++ assertEquals("CREATE_COMPLETE", original.getStatus());+ assertEquals("CREATE_FAILED", replacement.getStatus());+ assertEquals("old-route", replacement.getAttributes().get("__FlociApiGatewayV2BodyRouteIds"));+ verify(apiGatewayV2Service).deleteRoute(REGION, API_ID, "old-route");+ verify(apiGatewayV2Service).deleteRoute(REGION, API_ID, "partial-route");+ verify(apiGatewayV2Service).restoreRoute(REGION, API_ID, oldRoute, java.util.List.of());+ }++ @Test+ void retainsPartialRoutesWhenMaterializationCleanupFails() throws Exception {+ when(apiGatewayV2Service.createRoute(eq(REGION), eq(API_ID), anyMap())).thenAnswer(invocation -> {+ @SuppressWarnings("unchecked")+ Map<String, Object> request = invocation.getArgument(2);+ return switch ((String) request.get("routeKey")) {+ case "GET /first" -> route("partial-route", "GET /first");+ case "GET /second" -> throw new AwsException("InternalFailure", "simulated route failure", 500);+ default -> throw new AssertionError("Unexpected route key: " + request.get("routeKey"));+ };+ });+ doAnswer(invocation -> {+ throw new AwsException("InternalFailure", "simulated cleanup failure", 500);+ }).when(apiGatewayV2Service).deleteRoute(REGION, API_ID, "partial-route");++ StackResource failed = provision(body("""+ {"paths":{"/first":{"get":{}},"/second":{"get":{}}}}+ """), null, Map.of());++ assertEquals("CREATE_FAILED", failed.getStatus());+ assertEquals("partial-route", failed.getAttributes().get("__FlociApiGatewayV2BodyRouteIds"));+ }++ @Test+ void restoresExistingRouteWhenReplacementCleanupKeepsAConflictingRoute() throws Exception {+ Route oldRoute = route("old-route", "GET /same");+ Route replacementRoute = route("replacement-route", "GET /same");+ AtomicInteger sameRouteCreations = new AtomicInteger();+ when(apiGatewayV2Service.createRoute(eq(REGION), eq(API_ID), anyMap())).thenAnswer(invocation -> {+ @SuppressWarnings("unchecked")+ Map<String, Object> request = invocation.getArgument(2);+ return switch ((String) request.get("routeKey")) {+ case "GET /same" -> sameRouteCreations.getAndIncrement() == 0 ? oldRoute : replacementRoute;+ case "GET /second" -> throw new AwsException("InternalFailure", "simulated route failure", 500);+ default -> throw new AssertionError("Unexpected route key: " + request.get("routeKey"));+ };+ });+ when(apiGatewayV2Service.getRoute(REGION, API_ID, "old-route")).thenReturn(oldRoute);+ doAnswer(invocation -> {+ if ("replacement-route".equals(invocation.getArgument(2))) {+ throw new AwsException("InternalFailure", "simulated cleanup failure", 500);+ }+ return null;+ }).when(apiGatewayV2Service).deleteRoute(eq(REGION), eq(API_ID), anyString());++ StackResource original = provision(body("""+ {"paths":{"/same":{"get":{}}}}+ """), null, Map.of());+ StackResource replacement = provision(body("""+ {"paths":{"/same":{"get":{}},"/second":{"get":{}}}}+ """), original.getPhysicalId(), original.getAttributes());++ assertEquals("CREATE_COMPLETE", original.getStatus());+ assertEquals("CREATE_FAILED", replacement.getStatus());+ assertEquals("old-route,replacement-route",+ replacement.getAttributes().get("__FlociApiGatewayV2BodyRouteIds"));+ verify(apiGatewayV2Service).restoreRoute(REGION, API_ID, oldRoute,+ java.util.List.of("replacement-route"));+ }++ @Test+ void mergesFailedUpdateRouteAndIntegrationOwnershipIntoCommittedMetadata() {+ StackResource previous = new StackResource();+ previous.setResourceType("AWS::ApiGatewayV2::Api");+ previous.getAttributes().put("__FlociApiGatewayV2BodyRouteIds", "old-route");+ previous.getAttributes().put("__FlociApiGatewayV2BodyIntegrationIds", "old-integration");+ previous.getAttributes().put("__FlociApiGatewayV2BodyAuthorizerIds", "old-authorizer");++ StackResource attempted = new StackResource();+ attempted.setResourceType("AWS::ApiGatewayV2::Api");+ attempted.getAttributes().put("__FlociApiGatewayV2BodyRouteIds",+ "old-route,surviving-route");+ attempted.getAttributes().put("__FlociApiGatewayV2BodyIntegrationIds",+ "old-integration,surviving-integration");+ attempted.getAttributes().put("__FlociApiGatewayV2BodyAuthorizerIds",+ "old-authorizer,surviving-authorizer");++ provisioner.mergeFailedUpdateResourceTracking(previous, attempted);++ assertEquals("old-route,surviving-route",+ previous.getAttributes().get("__FlociApiGatewayV2BodyRouteIds"));+ assertEquals("old-integration,surviving-integration",+ previous.getAttributes().get("__FlociApiGatewayV2BodyIntegrationIds"));+ assertEquals("old-authorizer,surviving-authorizer",+ previous.getAttributes().get("__FlociApiGatewayV2BodyAuthorizerIds"));+ }++ @Test+ void materializesInheritedJwtSecurityAndHonorsOperationOptOut() throws Exception {+ Authorizer authorizer = new Authorizer();+ authorizer.setAuthorizerId("body-authorizer");+ when(apiGatewayV2Service.createAuthorizer(eq(REGION), eq(API_ID), anyMap()))+ .thenReturn(authorizer);+ when(apiGatewayV2Service.createRoute(eq(REGION), eq(API_ID), anyMap())).thenAnswer(invocation -> {+ @SuppressWarnings("unchecked")+ Map<String, Object> request = invocation.getArgument(2);+ return route("route-" + request.get("routeKey"), (String) request.get("routeKey"));+ });++ StackResource resource = provision(body("""+ {+ "components":{"securitySchemes":{"JwtAuth":{+ "type":"oauth2",+ "x-amazon-apigateway-authorizer":{+ "type":"jwt",+ "identitySource":"$request.header.Authorization",+ "jwtConfiguration":{+ "issuer":"https://issuer.example.com",+ "audience":["client-id"]+ }+ }+ }}},+ "security":[{"JwtAuth":["orders/read"]}],+ "paths":{+ "/protected":{"get":{}},+ "/public":{"get":{"security":[]}}+ }+ }+ """), null, Map.of());++ assertEquals("CREATE_COMPLETE", resource.getStatus());+ assertEquals("body-authorizer",+ resource.getAttributes().get("__FlociApiGatewayV2BodyAuthorizerIds"));+ verify(apiGatewayV2Service).createAuthorizer(eq(REGION), eq(API_ID), argThat(request ->+ "JwtAuth".equals(request.get("name"))+ && "JWT".equals(request.get("authorizerType"))+ && "$request.header.Authorization".equals(request.get("identitySource"))));+ verify(apiGatewayV2Service).createRoute(eq(REGION), eq(API_ID), argThat(request ->+ "GET /protected".equals(request.get("routeKey"))+ && "JWT".equals(request.get("authorizationType"))+ && "body-authorizer".equals(request.get("authorizerId"))+ && java.util.List.of("orders/read").equals(request.get("authorizationScopes"))));+ verify(apiGatewayV2Service).createRoute(eq(REGION), eq(API_ID), argThat(request ->+ "GET /public".equals(request.get("routeKey"))+ && "NONE".equals(request.get("authorizationType"))+ && !request.containsKey("authorizerId")));+ }++ @Test+ void rejectsProtectedOperationWhenSecuritySchemeCannotBeResolved() throws Exception {+ StackResource resource = provision(body("""+ {+ "security":[{"MissingAuthorizer":[]}],+ "paths":{"/protected":{"get":{}}}+ }+ """), null, Map.of());++ assertEquals("CREATE_FAILED", resource.getStatus());+ assertEquals("Protected operation GET /protected references unsupported security scheme 'MissingAuthorizer'",+ resource.getStatusReason());+ verify(apiGatewayV2Service, never()).createRoute(eq(REGION), eq(API_ID), anyMap());+ }++ @Test+ void rejectsAndSecurityRequirementInsteadOfApplyingOnlyOneScheme() throws Exception {+ Authorizer first = new Authorizer();+ first.setAuthorizerId("first-authorizer");+ Authorizer second = new Authorizer();+ second.setAuthorizerId("second-authorizer");+ when(apiGatewayV2Service.createAuthorizer(eq(REGION), eq(API_ID), anyMap()))+ .thenReturn(first, second);++ StackResource resource = provision(body("""+ {+ "components":{"securitySchemes":{+ "First":{"x-amazon-apigateway-authorizer":{+ "type":"jwt","jwtConfiguration":{"issuer":"https://first.example.com"}+ }},+ "Second":{"x-amazon-apigateway-authorizer":{+ "type":"jwt","jwtConfiguration":{"issuer":"https://second.example.com"}+ }}+ }},+ "security":[{"First":[],"Second":[]}],+ "paths":{"/protected":{"get":{}}}+ }+ """), null, Map.of());++ assertEquals("CREATE_FAILED", resource.getStatus());+ verify(apiGatewayV2Service, never()).createRoute(eq(REGION), eq(API_ID), anyMap());+ verify(apiGatewayV2Service).deleteAuthorizer(REGION, API_ID, "first-authorizer");+ verify(apiGatewayV2Service).deleteAuthorizer(REGION, API_ID, "second-authorizer");+ }++ @Test+ void rejectsUnrepresentableSecurityOrAlternativesInsteadOfChoosingOne() throws Exception {+ StackResource resource = provision(body("""+ {+ "security":[{"First":[]},{"Second":[]}],+ "paths":{"/protected":{"get":{}}}+ }+ """), null, Map.of());++ assertEquals("CREATE_FAILED", resource.getStatus());+ verify(apiGatewayV2Service, never()).createRoute(eq(REGION), eq(API_ID), anyMap());+ }++ @Test+ void honorsAnonymousAlternativeInSecurityOrList() throws Exception {+ Authorizer authorizer = new Authorizer();+ authorizer.setAuthorizerId("optional-authorizer");+ when(apiGatewayV2Service.createAuthorizer(eq(REGION), eq(API_ID), anyMap()))+ .thenReturn(authorizer);+ when(apiGatewayV2Service.createRoute(eq(REGION), eq(API_ID), anyMap()))+ .thenReturn(route("optional-route", "GET /optional"));++ StackResource resource = provision(body("""+ {+ "components":{"securitySchemes":{"JwtAuth":{+ "x-amazon-apigateway-authorizer":{+ "type":"jwt","jwtConfiguration":{"issuer":"https://issuer.example.com"}+ }+ }}},+ "security":[{"JwtAuth":[]},{}],+ "paths":{"/optional":{"get":{}}}+ }+ """), null, Map.of());++ assertEquals("CREATE_COMPLETE", resource.getStatus());+ verify(apiGatewayV2Service).createRoute(eq(REGION), eq(API_ID), argThat(request ->+ "GET /optional".equals(request.get("routeKey"))+ && "NONE".equals(request.get("authorizationType"))));+ }++ @Test+ void materializesRequestAuthorizerSecurityAsCustomAuthorization() throws Exception {+ Authorizer authorizer = new Authorizer();+ authorizer.setAuthorizerId("request-authorizer");+ when(apiGatewayV2Service.createAuthorizer(eq(REGION), eq(API_ID), anyMap()))+ .thenReturn(authorizer);+ when(apiGatewayV2Service.createRoute(eq(REGION), eq(API_ID), anyMap()))+ .thenReturn(route("protected-route", "POST /protected"));++ StackResource resource = provision(body("""+ {+ "components":{"securitySchemes":{"RequestAuth":{+ "type":"apiKey",+ "x-amazon-apigateway-authorizer":{+ "type":"request",+ "identitySource":["$request.header.Authorization"],+ "authorizerUri":"arn:aws:apigateway:us-east-1:lambda:path/functions/auth/invocations",+ "authorizerPayloadFormatVersion":"2.0",+ "enableSimpleResponses":true+ }+ }}},+ "paths":{"/protected":{"post":{"security":[{"RequestAuth":[]}]}}}+ }+ """), null, Map.of());++ assertEquals("CREATE_COMPLETE", resource.getStatus());+ verify(apiGatewayV2Service).createAuthorizer(eq(REGION), eq(API_ID), argThat(request ->+ "REQUEST".equals(request.get("authorizerType"))+ && Boolean.TRUE.equals(request.get("enableSimpleResponses"))));+ verify(apiGatewayV2Service).createRoute(eq(REGION), eq(API_ID), argThat(request ->+ "POST /protected".equals(request.get("routeKey"))+ && "CUSTOM".equals(request.get("authorizationType"))+ && "request-authorizer".equals(request.get("authorizerId"))));+ }++ @Test+ void restoresBodyAuthorizerWhenSecuredRouteReplacementFails() throws Exception {+ Authorizer oldAuthorizer = new Authorizer();+ oldAuthorizer.setAuthorizerId("old-authorizer");+ Authorizer replacementAuthorizer = new Authorizer();+ replacementAuthorizer.setAuthorizerId("replacement-authorizer");+ when(apiGatewayV2Service.createAuthorizer(eq(REGION), eq(API_ID), anyMap()))+ .thenReturn(oldAuthorizer, replacementAuthorizer);++ Route oldRoute = route("old-route", "GET /protected");+ when(apiGatewayV2Service.createRoute(eq(REGION), eq(API_ID), anyMap()))+ .thenReturn(oldRoute)+ .thenThrow(new AwsException("InternalFailure", "simulated route failure", 500));+ when(apiGatewayV2Service.getRoute(REGION, API_ID, "old-route")).thenReturn(oldRoute);+ when(apiGatewayV2Service.getAuthorizer(REGION, API_ID, "old-authorizer"))+ .thenReturn(oldAuthorizer);++ String securedBody = """+ {+ "components":{"securitySchemes":{"JwtAuth":{+ "x-amazon-apigateway-authorizer":{+ "type":"jwt",+ "jwtConfiguration":{"issuer":"https://issuer.example.com"}+ }+ }}},+ "security":[{"JwtAuth":[]}],+ "paths":{"/protected":{"get":{}}}+ }+ """;+ StackResource original = provision(body(securedBody), null, Map.of());+ StackResource replacement = provision(body(securedBody), original.getPhysicalId(),+ original.getAttributes());++ assertEquals("CREATE_COMPLETE", original.getStatus());+ assertEquals("CREATE_FAILED", replacement.getStatus());+ assertEquals("old-authorizer",+ replacement.getAttributes().get("__FlociApiGatewayV2BodyAuthorizerIds"));+ verify(apiGatewayV2Service).deleteAuthorizer(REGION, API_ID, "old-authorizer");+ verify(apiGatewayV2Service).deleteAuthorizer(REGION, API_ID, "replacement-authorizer");+ verify(apiGatewayV2Service).restoreAuthorizer(REGION, API_ID, oldAuthorizer);+ verify(apiGatewayV2Service).restoreRoute(REGION, API_ID, oldRoute, java.util.List.of());+ }++ @Test+ void rejectsSigV4SecurityUntilHttpApiIamEnforcementIsSupported() throws Exception {+ StackResource resource = provision(body("""+ {+ "components":{"securitySchemes":{"SigV4":{+ "type":"apiKey",+ "x-amazon-apigateway-authtype":"awsSigv4"+ }}},+ "security":[{"SigV4":[]}],+ "paths":{"/iam":{"get":{}}}+ }+ """), null, Map.of());++ assertEquals("CREATE_FAILED", resource.getStatus());+ verify(apiGatewayV2Service, never()).createAuthorizer(eq(REGION), eq(API_ID), anyMap());+ verify(apiGatewayV2Service, never()).createRoute(eq(REGION), eq(API_ID), anyMap());+ }++ @Test+ void restoresExistingRoutesWhenOldRouteDeletionFails() throws Exception {+ Route oldOne = route("old-one", "GET /before-one");+ Route oldTwo = route("old-two", "GET /before-two");+ when(apiGatewayV2Service.createRoute(eq(REGION), eq(API_ID), anyMap())).thenAnswer(invocation -> {+ @SuppressWarnings("unchecked")+ Map<String, Object> request = invocation.getArgument(2);+ return switch ((String) request.get("routeKey")) {+ case "GET /before-one" -> oldOne;+ case "GET /before-two" -> oldTwo;+ case "GET /after" -> route("replacement-route", "GET /after");+ default -> throw new AssertionError("Unexpected route key: " + request.get("routeKey"));+ };+ });+ when(apiGatewayV2Service.getRoute(REGION, API_ID, "old-one")).thenReturn(oldOne);+ when(apiGatewayV2Service.getRoute(REGION, API_ID, "old-two")).thenReturn(oldTwo);+ doAnswer(invocation -> {+ if ("old-two".equals(invocation.getArgument(2))) {+ throw new AwsException("InternalFailure", "simulated delete failure", 500);+ }+ return null;+ }).when(apiGatewayV2Service).deleteRoute(eq(REGION), eq(API_ID), anyString());++ StackResource original = provision(body("""+ {"paths":{"/before-one":{"get":{}},"/before-two":{"get":{}}}}+ """), null, Map.of());++ StackResource replacement = provision(body("""+ {"paths":{"/after":{"get":{}}}}+ """), original.getPhysicalId(), original.getAttributes());++ assertEquals("CREATE_COMPLETE", original.getStatus());+ assertEquals("CREATE_FAILED", replacement.getStatus());+ assertEquals("old-one,old-two", replacement.getAttributes().get("__FlociApiGatewayV2BodyRouteIds"));+ verify(apiGatewayV2Service, never()).createRoute(eq(REGION), eq(API_ID),+ argThat(request -> "GET /after".equals(request.get("routeKey"))));+ verify(apiGatewayV2Service).restoreRoute(REGION, API_ID, oldOne, java.util.List.of());+ verify(apiGatewayV2Service).restoreRoute(REGION, API_ID, oldTwo, java.util.List.of());+ }++ @Test+ void restoresExistingRoutesWhenDefinitionRemovalFails() throws Exception {+ Route oldOne = route("old-one", "GET /before-one");+ Route oldTwo = route("old-two", "GET /before-two");+ when(apiGatewayV2Service.createRoute(eq(REGION), eq(API_ID), anyMap())).thenAnswer(invocation -> {+ @SuppressWarnings("unchecked")+ Map<String, Object> request = invocation.getArgument(2);+ return switch ((String) request.get("routeKey")) {+ case "GET /before-one" -> oldOne;+ case "GET /before-two" -> oldTwo;+ default -> throw new AssertionError("Unexpected route key: " + request.get("routeKey"));+ };+ });+ when(apiGatewayV2Service.getRoute(REGION, API_ID, "old-one")).thenReturn(oldOne);+ when(apiGatewayV2Service.getRoute(REGION, API_ID, "old-two")).thenReturn(oldTwo);+ doAnswer(invocation -> {+ if ("old-two".equals(invocation.getArgument(2))) {+ throw new AwsException("InternalFailure", "simulated delete failure", 500);+ }+ return null;+ }).when(apiGatewayV2Service).deleteRoute(eq(REGION), eq(API_ID), anyString());++ StackResource original = provision(body("""+ {"paths":{"/before-one":{"get":{}},"/before-two":{"get":{}}}}+ """), null, Map.of());++ StackResource removal = provision(propertiesWithoutBody(), original.getPhysicalId(),+ original.getAttributes());++ assertEquals("CREATE_COMPLETE", original.getStatus());+ assertEquals("CREATE_FAILED", removal.getStatus());+ assertEquals("old-one,old-two", removal.getAttributes().get("__FlociApiGatewayV2BodyRouteIds"));+ verify(apiGatewayV2Service).restoreRoute(REGION, API_ID, oldOne, java.util.List.of());+ verify(apiGatewayV2Service).restoreRoute(REGION, API_ID, oldTwo, java.util.List.of());+ }++ private StackResource provision(JsonNode properties, String existingPhysicalId,+ Map<String, String> existingAttributes) {+ return provisioner.provision("HttpApi", "AWS::ApiGatewayV2::Api", properties, engine(), REGION,+ "000000000000", "test-stack", existingPhysicalId, existingAttributes);+ }++ private JsonNode body(String body) throws Exception {+ return mapper.readTree("""+ {"Name":"test-api","ProtocolType":"HTTP","Body":%s}+ """.formatted(body));+ }++ private JsonNode propertiesWithoutBody() throws Exception {+ return mapper.readTree("""+ {"Name":"test-api","ProtocolType":"HTTP"}+ """);+ }++ private CloudFormationTemplateEngine engine() {+ return new CloudFormationTemplateEngine("000000000000", REGION, "test-stack", "stack/id",+ Map.of(), Map.of(), Map.of(), Map.of(), Map.of(), mapper,+ (Function<String, String>) name -> null);+ }++ private static Route route(String id, String routeKey) {+ Route route = new Route();+ route.setRouteId(id);+ route.setRouteKey(routeKey);+ return route;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationApiGatewayV2CleanupIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationApiGatewayV2CleanupIntegrationTest.javanew file mode 100644index 0000000000..654b70bd06--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationApiGatewayV2CleanupIntegrationTest.java@@ -0,0 +1,200 @@+package io.github.hectorvent.floci.services.cloudformation;++import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.apigatewayv2.ApiGatewayV2Service;+import io.github.hectorvent.floci.services.apigatewayv2.model.Route;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.mockito.InjectSpy;+import jakarta.inject.Inject;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.util.Arrays;+import java.util.List;+import java.util.Map;+import java.util.concurrent.atomic.AtomicReference;++import static io.restassured.RestAssured.given;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.anyMap;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.doAnswer;+import static org.mockito.Mockito.doCallRealMethod;++@QuarkusTest+class CloudFormationApiGatewayV2CleanupIntegrationTest {++ private static final String REGION = "us-east-1";+ private static final String ROUTE_IDS_ATTR = "__FlociApiGatewayV2BodyRouteIds";++ @InjectSpy+ ApiGatewayV2Service apiGatewayV2Service;++ @Inject+ CloudFormationService cloudFormationService;++ private String stackName;++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @AfterEach+ void deleteStack() {+ if (stackName != null) {+ doCallRealMethod().when(apiGatewayV2Service)+ .deleteRoute(anyString(), anyString(), anyString());+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DeleteStack")+ .formParam("StackName", stackName)+ .when()+ .post("/");+ }+ }++ @Test+ void failedUpdatePersistsOwnershipOfAReplacementThatCleanupCouldNotDelete() {+ String suffix = Long.toString(System.nanoTime(), 36);+ stackName = "http-api-cleanup-" + suffix;+ String apiName = "http-api-cleanup-" + suffix;++ createStack(httpApiTemplate(apiName, List.of("/before")));+ waitForStackStatus("CREATE_COMPLETE");+ String apiId = apiIdForName(apiName);+ String oldRouteId = apiGatewayV2Service.findRouteByKey(REGION, apiId, "GET /before").getRouteId();++ AtomicReference<String> survivingRouteId = new AtomicReference<>();+ doAnswer(invocation -> {+ @SuppressWarnings("unchecked")+ Map<String, Object> request = invocation.getArgument(2);+ if ("GET /fail".equals(request.get("routeKey"))) {+ throw new AwsException("InternalFailure", "simulated route failure", 500);+ }+ Route route = (Route) invocation.callRealMethod();+ if ("GET /survivor".equals(route.getRouteKey())) {+ survivingRouteId.set(route.getRouteId());+ }+ return route;+ }).when(apiGatewayV2Service).createRoute(eq(REGION), eq(apiId), anyMap());+ doAnswer(invocation -> {+ String routeId = invocation.getArgument(2);+ if (routeId.equals(survivingRouteId.get())) {+ throw new AwsException("InternalFailure", "simulated cleanup failure", 500);+ }+ return invocation.callRealMethod();+ }).when(apiGatewayV2Service).deleteRoute(eq(REGION), eq(apiId), anyString());++ updateStack(httpApiTemplate(apiName, List.of("/survivor", "/fail")));+ waitForStackStatus("UPDATE_ROLLBACK_COMPLETE");++ StackResource persisted = cloudFormationService.describeStacks(stackName, REGION)+ .getFirst().getResources().get("HttpApi");+ assertEquals("CREATE_COMPLETE", persisted.getStatus());+ assertTrue(Arrays.asList(persisted.getAttributes().get(ROUTE_IDS_ATTR).split(","))+ .containsAll(List.of(oldRouteId, survivingRouteId.get())));+ }++ @Test+ void failedSnapshotRestorationMarksUpdateRollbackFailed() {+ String suffix = Long.toString(System.nanoTime(), 36);+ stackName = "http-api-restore-failure-" + suffix;+ String apiName = "http-api-restore-failure-" + suffix;++ createStack(httpApiTemplate(apiName, List.of("/before")));+ waitForStackStatus("CREATE_COMPLETE");+ String apiId = apiIdForName(apiName);+ String oldRouteId = apiGatewayV2Service.findRouteByKey(REGION, apiId, "GET /before").getRouteId();++ AtomicReference<String> independentRouteId = new AtomicReference<>();+ doAnswer(invocation -> {+ @SuppressWarnings("unchecked")+ Map<String, Object> request = invocation.getArgument(2);+ if ("GET /fail".equals(request.get("routeKey"))) {+ Route independent = apiGatewayV2Service.createRoute(+ REGION, apiId, Map.of("routeKey", "GET /before"));+ independentRouteId.set(independent.getRouteId());+ throw new AwsException("InternalFailure", "simulated route failure", 500);+ }+ return invocation.callRealMethod();+ }).when(apiGatewayV2Service).createRoute(eq(REGION), eq(apiId), anyMap());++ updateStack(httpApiTemplate(apiName, List.of("/fail")));+ waitForStackStatus("UPDATE_ROLLBACK_FAILED");++ Route independent = apiGatewayV2Service.findRouteByKey(REGION, apiId, "GET /before");+ assertEquals(independentRouteId.get(), independent.getRouteId());+ assertThrows(AwsException.class,+ () -> apiGatewayV2Service.getRoute(REGION, apiId, oldRouteId));+ }++ private void createStack(String template) {+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack")+ .formParam("StackName", stackName)+ .formParam("TemplateBody", template)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ private void updateStack(String template) {+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "UpdateStack")+ .formParam("StackName", stackName)+ .formParam("TemplateBody", template)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ private void waitForStackStatus(String expected) {+ for (int attempt = 0; attempt < 100; attempt++) {+ String status = cloudFormationService.describeStacks(stackName, REGION).getFirst().getStatus();+ if (expected.equals(status)) {+ return;+ }+ try {+ Thread.sleep(25);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new AssertionError("Interrupted while waiting for stack status", e);+ }+ }+ throw new AssertionError("Stack did not reach " + expected);+ }++ private static String apiIdForName(String apiName) {+ return given()+ .when()+ .get("/v2/apis")+ .then()+ .statusCode(200)+ .extract()+ .path("items.find { it.name == '" + apiName + "' }.apiId");+ }++ private static String httpApiTemplate(String apiName, List<String> paths) {+ String pathDefinitions = paths.stream()+ .map(path -> "\"" + path + "\":{\"get\":{}}")+ .collect(java.util.stream.Collectors.joining(","));+ return """+ {"AWSTemplateFormatVersion":"2010-09-09",+ "Transform":"AWS::Serverless-2016-10-31",+ "Resources":{"HttpApi":{"Type":"AWS::Serverless::HttpApi","Properties":{+ "Name":"%s","DefinitionBody":{"openapi":"3.0.1","paths":{%s}}+ }}}}+ """.formatted(apiName, pathDefinitions);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformIntegrationTest.javaindex b3c8003764..1a0a98da98 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformIntegrationTest.java@@ -13,7 +13,10 @@ import static io.restassured.RestAssured.given;import static org.hamcrest.MatcherAssert.assertThat;import static org.hamcrest.Matchers.containsString;import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasItem;+import static org.hamcrest.Matchers.hasItems;import static org.hamcrest.Matchers.not;+import static org.hamcrest.Matchers.notNullValue;import static org.hamcrest.Matchers.nullValue;@QuarkusTest@@ -466,6 +469,272 @@ class SamTransformIntegrationTest {assertThat(resourcesXml, not(containsString("AWS::Serverless::Api")));}+ @Test+ void samHttpApi_definitionBodyCreatesApiGatewayV2Routes() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "sam-http-api-" + suffix;+ String apiName = "sam-http-api-" + suffix;+ stacksToDelete.add(stackName);++ String template = """+ AWSTemplateFormatVersion: '2010-09-09'+ Transform: AWS::Serverless-2016-10-31+ Resources:+ HttpApi:+ Type: AWS::Serverless::HttpApi+ Properties:+ Name: %s+ DefinitionBody:+ openapi: 3.0.1+ paths:+ /hello:+ get: {}+ /widgets:+ post: {}+ """.formatted(apiName);++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack")+ .formParam("StackName", stackName)+ .formParam("TemplateBody", template)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("<StackId>"));++ waitForStackStatus(stackName, "CREATE_COMPLETE");++ String apiId = given()+ .when()+ .get("/v2/apis")+ .then()+ .statusCode(200)+ .body("items.find { it.name == '" + apiName + "' }.protocolType", equalTo("HTTP"))+ .extract()+ .path("items.find { it.name == '" + apiName + "' }.apiId");++ given()+ .when()+ .get("/v2/apis/" + apiId + "/routes")+ .then()+ .statusCode(200)+ .body("items.routeKey", hasItems("GET /hello", "POST /widgets"));+ }++ @Test+ void samHttpApi_matchingDefinitionBodyAndFunctionEventCreateOneIntegratedRoute() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "sam-http-api-overlap-" + suffix;+ String apiName = "sam-http-api-overlap-" + suffix;+ String functionName = "sam-http-overlap-fn-" + suffix;+ stacksToDelete.add(stackName);++ String template = """+ AWSTemplateFormatVersion: '2010-09-09'+ Transform: AWS::Serverless-2016-10-31+ Resources:+ HttpApi:+ Type: AWS::Serverless::HttpApi+ Properties:+ Name: %s+ Auth:+ DefaultAuthorizer: JwtAuth+ Authorizers:+ JwtAuth:+ IdentitySource: '$request.header.Authorization'+ AuthorizationScopes: [read:items]+ JwtConfiguration:+ issuer: https://issuer.example.com+ audience: [items-client]+ DefinitionBody:+ openapi: 3.0.1+ info: {title: overlap, version: '1.0'}+ components: {}+ paths:+ /items:+ get:+ responses: {'200': {description: ok}}+ Handler:+ Type: AWS::Serverless::Function+ Properties:+ FunctionName: %s+ Runtime: python3.12+ Handler: index.handler+ InlineCode: 'def handler(e,c): return {}'+ Events:+ Api:+ Type: HttpApi+ Properties:+ ApiId: {Ref: HttpApi}+ Path: /items+ Method: GET+ """.formatted(apiName, functionName);++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack")+ .formParam("StackName", stackName)+ .formParam("TemplateBody", template)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ waitForStackStatus(stackName, "CREATE_COMPLETE");+ String apiId = apiIdForName(apiName);++ given()+ .when()+ .get("/v2/apis/" + apiId + "/routes")+ .then()+ .statusCode(200)+ .body("items.size()", equalTo(1))+ .body("items[0].routeKey", equalTo("GET /items"))+ .body("items[0].authorizationType", equalTo("JWT"))+ .body("items[0].authorizationScopes", hasItem("read:items"))+ .body("items[0].authorizerId", notNullValue())+ .body("items[0].target", containsString("integrations/"));++ given()+ .when()+ .get("/v2/apis/" + apiId + "/integrations")+ .then()+ .statusCode(200)+ .body("items.size()", equalTo(1))+ .body("items[0].integrationUri", containsString(functionName));+ }++ @Test+ void samHttpApi_intrinsicDefinitionUriCreatesApiGatewayV2Routes() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "sam-http-api-uri-" + suffix;+ String apiName = "sam-http-api-uri-" + suffix;+ String bucketName = "sam-http-api-spec-" + suffix;+ stacksToDelete.add(stackName);++ given()+ .when()+ .put("/" + bucketName)+ .then()+ .statusCode(200);++ given()+ .contentType("application/json")+ .body("""+ {"openapi":"3.0.1","paths":{"/from-uri":{"get":{}}}}+ """)+ .when()+ .put("/" + bucketName + "/openapi.json")+ .then()+ .statusCode(200);++ String template = """+ AWSTemplateFormatVersion: '2010-09-09'+ Transform: AWS::Serverless-2016-10-31+ Resources:+ HttpApi:+ Type: AWS::Serverless::HttpApi+ Properties:+ Name: %s+ DefinitionUri:+ Fn::Sub: s3://%s/openapi.json+ """.formatted(apiName, bucketName);++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack")+ .formParam("StackName", stackName)+ .formParam("TemplateBody", template)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ waitForStackStatus(stackName, "CREATE_COMPLETE");++ String apiId = apiIdForName(apiName);+ given()+ .when()+ .get("/v2/apis/" + apiId + "/routes")+ .then()+ .statusCode(200)+ .body("items.routeKey", hasItem("GET /from-uri"));+ }++ @Test+ void samHttpApi_definitionBodyReconcilesRoutesOnStackUpdate() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "sam-http-api-update-" + suffix;+ String apiName = "sam-http-api-update-" + suffix;+ stacksToDelete.add(stackName);++ String initialTemplate = httpApiTemplate(apiName, "/before");+ String updatedTemplate = httpApiTemplate(apiName, "/after");++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack")+ .formParam("StackName", stackName)+ .formParam("TemplateBody", initialTemplate)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ waitForStackStatus(stackName, "CREATE_COMPLETE");+ String apiId = apiIdForName(apiName);++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "UpdateStack")+ .formParam("StackName", stackName)+ .formParam("TemplateBody", updatedTemplate)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ waitForStackStatus(stackName, "UPDATE_COMPLETE");++ given()+ .when()+ .get("/v2/apis/" + apiId + "/routes")+ .then()+ .statusCode(200)+ .body("items.routeKey", hasItem("GET /after"))+ .body("items.routeKey", not(hasItem("GET /before")));+ }++ private static String httpApiTemplate(String apiName, String path) {+ return """+ AWSTemplateFormatVersion: '2010-09-09'+ Transform: AWS::Serverless-2016-10-31+ Resources:+ HttpApi:+ Type: AWS::Serverless::HttpApi+ Properties:+ Name: %s+ DefinitionBody:+ openapi: 3.0.1+ paths:+ %s:+ get: {}+ """.formatted(apiName, path);+ }++ private static String apiIdForName(String apiName) {+ return given()+ .when()+ .get("/v2/apis")+ .then()+ .statusCode(200)+ .body("items.find { it.name == '" + apiName + "' }.protocolType", equalTo("HTTP"))+ .extract()+ .path("items.find { it.name == '" + apiName + "' }.apiId");+ }+@Testvoid samFunction_withCodeUri_s3Reference() {String stackName = "sam-s3code-stack";diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessorTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessorTest.javaindex 25be1e1117..59203d5873 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessorTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessorTest.java@@ -897,4 +897,235 @@ class SamTransformProcessorTest {assertTrue(expanded.path("Transform").isMissingNode());assertTrue(expanded.path("Globals").isMissingNode());}+ @Test+ void expandSamTemplate_httpApiPreservesDefinitionBodyAsRoutes() throws Exception {+ // Regression for #1956: a route-bearing HttpApi carries its routes in the inline+ // OpenAPI DefinitionBody, which must survive as the ApiGatewayV2::Api Body — otherwise+ // the API expands with no routes.+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Resources": {+ "MyHttpApi": {+ "Type": "AWS::Serverless::HttpApi",+ "Properties": {+ "DefinitionBody": {+ "openapi": "3.0.1",+ "paths": {+ "/hello": { "get": { "x-amazon-apigateway-integration": { "type": "aws_proxy" } } }+ }+ }+ }+ }+ }+ }+ """);++ JsonNode resources = processor.expandSamTemplate(template).path("Resources");++ JsonNode api = resources.path("MyHttpApi");+ assertEquals("AWS::ApiGatewayV2::Api", api.path("Type").asText());+ JsonNode body = api.path("Properties").path("Body");+ assertFalse(body.isMissingNode(), "DefinitionBody must be preserved as the API Body");+ assertEquals("3.0.1", body.path("openapi").asText());+ assertTrue(body.path("paths").has("/hello"), "route definitions must survive the transform");+ }++ @Test+ void expandSamTemplate_httpApiEventMergesIntoMatchingDefinitionBodyOperation() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Resources": {+ "MyHttpApi": {+ "Type": "AWS::Serverless::HttpApi",+ "Properties": {+ "Auth": {+ "DefaultAuthorizer": "JwtAuth",+ "Authorizers": {+ "JwtAuth": {+ "IdentitySource": "$request.header.Authorization",+ "AuthorizationScopes": ["read:items"],+ "JwtConfiguration": {+ "Issuer": "https://issuer.example.com",+ "Audience": ["items-client"]+ }+ }+ }+ },+ "DefinitionBody": {+ "openapi": "3.0.1",+ "paths": {+ "/items": {+ "get": {+ "security": [],+ "responses": { "200": { "description": "ok" } }+ }+ }+ }+ }+ }+ },+ "MyFunction": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "Runtime": "python3.12",+ "Handler": "index.handler",+ "InlineCode": "def handler(e,c): return {}",+ "Events": {+ "Api": {+ "Type": "HttpApi",+ "Properties": {+ "ApiId": { "Ref": "MyHttpApi" },+ "Path": "/items",+ "Method": "GET"+ }+ }+ }+ }+ }+ }+ }+ """);++ JsonNode resources = processor.expandSamTemplate(template).path("Resources");+ JsonNode operation = resources.path("MyHttpApi").path("Properties").path("Body")+ .path("paths").path("/items").path("get");+ JsonNode integration = operation.path("x-amazon-apigateway-integration");+ JsonNode authorizer = resources.path("MyHttpApi").path("Properties").path("Body")+ .path("components").path("securitySchemes").path("JwtAuth");++ assertEquals("ok", operation.path("responses").path("200").path("description").asText());+ assertEquals("aws_proxy", integration.path("type").asText());+ assertEquals("POST", integration.path("httpMethod").asText());+ assertEquals("2.0", integration.path("payloadFormatVersion").asText());+ assertEquals("MyFunction", integration.path("uri").path("Fn::Sub").path(1)+ .path("FnArn").path("Fn::GetAtt").path(0).asText());+ assertEquals("oauth2", authorizer.path("type").asText());+ assertEquals("jwt", authorizer.path("x-amazon-apigateway-authorizer").path("type").asText());+ assertEquals("$request.header.Authorization", authorizer.path("x-amazon-apigateway-authorizer")+ .path("identitySource").path(0).asText());+ assertEquals("https://issuer.example.com", authorizer.path("x-amazon-apigateway-authorizer")+ .path("jwtConfiguration").path("issuer").asText());+ assertEquals("items-client", authorizer.path("x-amazon-apigateway-authorizer")+ .path("jwtConfiguration").path("audience").path(0).asText());+ assertEquals("read:items", operation.path("security").path(0).path("JwtAuth").path(0).asText());++ int routeResources = 0;+ int integrationResources = 0;+ int permissionResources = 0;+ Iterator<JsonNode> definitions = resources.elements();+ while (definitions.hasNext()) {+ String type = definitions.next().path("Type").asText();+ routeResources += "AWS::ApiGatewayV2::Route".equals(type) ? 1 : 0;+ integrationResources += "AWS::ApiGatewayV2::Integration".equals(type) ? 1 : 0;+ permissionResources += "AWS::Lambda::Permission".equals(type) ? 1 : 0;+ }+ assertEquals(0, routeResources, "matching body operations must not emit a duplicate route resource");+ assertEquals(0, integrationResources, "the body owns the merged integration");+ assertEquals(1, permissionResources, "API Gateway still needs permission to invoke the function");+ }++ @Test+ void expandSamTemplate_matchingHttpApiEventCanOptOutOfDefaultAuthorizer() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Resources": {+ "HttpApi": {+ "Type": "AWS::Serverless::HttpApi",+ "Properties": {+ "Auth": {+ "DefaultAuthorizer": "JwtAuth",+ "Authorizers": {+ "JwtAuth": {+ "IdentitySource": ["$request.header.Authorization"],+ "JwtConfiguration": {+ "issuer": "https://issuer.example.com",+ "audience": ["client-id"]+ }+ }+ }+ },+ "DefinitionBody": {+ "openapi": "3.0.1",+ "paths": { "/public": { "get": {} } }+ }+ }+ },+ "Handler": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "Runtime": "python3.12",+ "Handler": "index.handler",+ "InlineCode": "def handler(e,c): return {}",+ "Events": {+ "Public": {+ "Type": "HttpApi",+ "Properties": {+ "ApiId": { "Ref": "HttpApi" },+ "Path": "/public",+ "Method": "GET",+ "Auth": { "Authorizer": "NONE" }+ }+ }+ }+ }+ }+ }+ }+ """);++ JsonNode operation = processor.expandSamTemplate(template).path("Resources")+ .path("HttpApi").path("Properties").path("Body")+ .path("paths").path("/public").path("get");++ assertTrue(operation.path("security").isArray());+ assertTrue(operation.path("security").isEmpty(),+ "Authorizer NONE must override the API's default authorizer");+ assertTrue(operation.path("x-amazon-apigateway-integration").isObject());+ }++ @Test+ void expandSamTemplate_httpApiMapsDefinitionUriToBodyS3Location() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Resources": {+ "MyHttpApi": {+ "Type": "AWS::Serverless::HttpApi",+ "Properties": { "DefinitionUri": "s3://api-specs/openapi.yaml" }+ }+ }+ }+ """);++ JsonNode properties = processor.expandSamTemplate(template)+ .path("Resources").path("MyHttpApi").path("Properties");++ assertTrue(properties.path("Body").isMissingNode(), "DefinitionUri must not become an inline Body");+ assertEquals("api-specs", properties.path("BodyS3Location").path("Bucket").asText());+ assertEquals("openapi.yaml", properties.path("BodyS3Location").path("Key").asText());+ }+ @Test+ void expandSamTemplate_httpApiPreservesIntrinsicDefinitionUriForProvisioning() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Resources": {+ "MyHttpApi": {+ "Type": "AWS::Serverless::HttpApi",+ "Properties": {+ "DefinitionUri": { "Fn::Sub": "s3://${SpecBucket}/openapi.yaml" }+ }+ }+ }+ }+ """);++ JsonNode bodyS3Location = processor.expandSamTemplate(template)+ .path("Resources").path("MyHttpApi").path("Properties").path("BodyS3Location");++ assertEquals("s3://${SpecBucket}/openapi.yaml", bodyS3Location.path("Fn::Sub").asText());+ }}