Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cloudformation): treat delete of an already-removed DynamoDB table or Lambda function as idempotent (#1803)
Alex Banna5cb26ff1170d
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 e57b41ed09..952a1e651e 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@@ -455,8 +455,8 @@ public class CloudFormationResourceProvisioner {case "AWS::S3::Bucket" -> s3Service.deleteBucket(physicalId);case "AWS::SNS::Topic" -> snsService.deleteTopic(physicalId, region);case "AWS::SNS::Subscription" -> snsService.unsubscribe(physicalId, region);- case "AWS::DynamoDB::Table" -> dynamoDbService.deleteTable(physicalId, region);- case "AWS::Lambda::Function" -> lambdaService.deleteFunction(region, physicalId);+ case "AWS::DynamoDB::Table" -> deleteDynamoTableSafe(physicalId, region);+ case "AWS::Lambda::Function" -> deleteLambdaFunctionSafe(physicalId, region);case "AWS::IAM::Role" -> deleteRoleSafe(physicalId);// AWS::IAM::Policy is inline: it is removed together with its owning principal (see// deleteRoleSafe), or precisely via the StackResource-aware delete path. Nothing to do@@ -4261,6 +4261,28 @@ public class CloudFormationResourceProvisioner {}}+ private void deleteDynamoTableSafe(String tableName, String region) {+ try {+ dynamoDbService.deleteTable(tableName, region);+ } catch (AwsException e) {+ if (!"ResourceNotFoundException".equals(e.getErrorCode())) {+ throw e;+ }+ LOG.debugv("DynamoDB table already gone, treating as deleted: {0}", tableName);+ }+ }++ private void deleteLambdaFunctionSafe(String functionName, String region) {+ try {+ lambdaService.deleteFunction(region, functionName);+ } catch (AwsException e) {+ if (!"ResourceNotFoundException".equals(e.getErrorCode())) {+ throw e;+ }+ LOG.debugv("Lambda function already gone, treating as deleted: {0}", functionName);+ }+ }+private void deleteManagedPolicy(StackResource resource) {String policyArn = resource.getPhysicalId();for (String roleName : managedPolicyRoleTargets(resource)) {diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationDeleteIdempotencyIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationDeleteIdempotencyIntegrationTest.javanew file mode 100644index 0000000000..05d15fb1cf--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationDeleteIdempotencyIntegrationTest.java@@ -0,0 +1,124 @@+package io.github.hectorvent.floci.services.cloudformation;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.junit.jupiter.api.Assertions.fail;++/**+ * Verifies deleting a stack whose underlying resource was already removed out-of-band completes+ * (DELETE_COMPLETE) rather than failing. AWS CloudFormation treats deleting an absent resource as an+ * idempotent no-op — this matters because a rolled-back stack has already deleted some of its+ * resources, so tearing that stack down re-issues DeleteTable/DeleteFunction against resources that+ * no longer exist. Without the {@code *Safe} wrappers those "not found" errors flipped the stack to+ * DELETE_FAILED, wedging the stack name against a later create.+ *+ * <p>Exercised end-to-end through the DynamoDB path (metadata-only, so Docker-free). Hermetic unit+ * coverage verifies both the DynamoDB and Lambda wrappers, including propagation of other errors.+ */+@QuarkusTest+class CloudFormationDeleteIdempotencyIntegrationTest {++ private static final String CFN_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/cloudformation/aws4_request";+ private static final String DDB_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/dynamodb/aws4_request";+ private static final String DDB_CT = "application/x-amz-json-1.0";++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ void deletingStackWhoseTableWasRemovedOutOfBandStillCompletes() throws InterruptedException {+ String suffix = Long.toString(System.nanoTime(), 36);+ String tableName = "idem-delete-table-" + suffix;+ String stackName = "idem-delete-stack-" + suffix;++ String template = """+ {+ "Resources": {+ "T": {+ "Type": "AWS::DynamoDB::Table",+ "Properties": {+ "TableName": "%s",+ "AttributeDefinitions": [{"AttributeName":"pk","AttributeType":"S"}],+ "KeySchema": [{"AttributeName":"pk","KeyType":"HASH"}],+ "BillingMode": "PAY_PER_REQUEST"+ }+ }+ }+ }+ """.formatted(tableName);++ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "CreateStack")+ .formParam("StackName", stackName)+ .formParam("TemplateBody", template)+ .when().post("/").then().statusCode(200);++ // CloudFormationQueryHandler awaits executeChangeSet before CreateStack returns, so this+ // one-shot assertion verifies the handler's synchronous completion contract.+ assertStackStatus(stackName, "CREATE_COMPLETE");++ // Remove the table out-of-band — mimics a rollback having already deleted it.+ given()+ .contentType(DDB_CT)+ .header("Authorization", DDB_AUTH)+ .header("X-Amz-Target", "DynamoDB_20120810.DeleteTable")+ .body("{\"TableName\":\"" + tableName + "\"}")+ .when().post("/").then().statusCode(200);++ // Deleting the stack must still succeed (was DELETE_FAILED: "Requested resource not found").+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "DeleteStack")+ .formParam("StackName", stackName)+ .when().post("/").then().statusCode(200);++ // DeleteStack runs asynchronously: poll until the stack is gone (a successful delete removes it+ // entirely). A failed delete would instead leave it queryable as DELETE_FAILED — fail fast on that.+ awaitStackDeleted(stackName);+ }++ private void awaitStackDeleted(String stackName) throws InterruptedException {+ for (int i = 0; i < 100; i++) {+ String body = given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "DescribeStacks")+ .formParam("StackName", stackName)+ .when().post("/").then().extract().asString();++ if (body.contains("does not exist")) {+ return;+ }+ if (body.contains("<StackStatus>DELETE_FAILED</StackStatus>")) {+ fail("stack delete failed instead of treating the already-removed table as deleted: " + body);+ }+ Thread.sleep(50);+ }+ fail("stack " + stackName + " was not deleted within the timeout");+ }++ private void assertStackStatus(String stackName, String status) {+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "DescribeStacks")+ .formParam("StackName", stackName)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("<StackStatus>" + status + "</StackStatus>"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationDeleteIdempotencyTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationDeleteIdempotencyTest.javanew file mode 100644index 0000000000..02e71fef3c--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationDeleteIdempotencyTest.java@@ -0,0 +1,87 @@+package io.github.hectorvent.floci.services.cloudformation;++import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudformation.provisioners.CloudFormationResourceRegistry;+import io.github.hectorvent.floci.services.dynamodb.DynamoDbService;+import io.github.hectorvent.floci.services.lambda.LambdaService;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.List;++import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;+import static org.junit.jupiter.api.Assertions.assertSame;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.mockito.Mockito.doThrow;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.verify;++class CloudFormationDeleteIdempotencyTest {++ private static final String REGION = "us-east-1";++ private DynamoDbService dynamoDbService;+ private LambdaService lambdaService;+ private CloudFormationResourceProvisioner provisioner;++ @BeforeEach+ void setUp() {+ dynamoDbService = mock(DynamoDbService.class);+ lambdaService = mock(LambdaService.class);+ provisioner = new CloudFormationResourceProvisioner(+ null, null, null, dynamoDbService, lambdaService,+ null, null, null, null, null,+ null, null, null, null, null, null,+ new ObjectMapper(),+ null, null, null, null, null, null, null,+ null, null, null, null, null, null, null,+ new CloudFormationResourceRegistry(List.of()));+ }++ @Test+ void missingDynamoDbTableIsAlreadyDeleted() {+ doThrow(awsError("ResourceNotFoundException"))+ .when(dynamoDbService).deleteTable("missing-table", REGION);++ assertDoesNotThrow(() -> provisioner.delete("AWS::DynamoDB::Table", "missing-table", REGION));++ verify(dynamoDbService).deleteTable("missing-table", REGION);+ }++ @Test+ void missingLambdaFunctionIsAlreadyDeleted() {+ doThrow(awsError("ResourceNotFoundException"))+ .when(lambdaService).deleteFunction(REGION, "missing-function");++ assertDoesNotThrow(() -> provisioner.delete("AWS::Lambda::Function", "missing-function", REGION));++ verify(lambdaService).deleteFunction(REGION, "missing-function");+ }++ @Test+ void dynamoDbDeleteFailureStillPropagates() {+ AwsException expected = awsError("InternalServerError");+ doThrow(expected).when(dynamoDbService).deleteTable("table", REGION);++ AwsException actual = assertThrows(AwsException.class,+ () -> provisioner.delete("AWS::DynamoDB::Table", "table", REGION));++ assertSame(expected, actual);+ }++ @Test+ void lambdaDeleteFailureStillPropagates() {+ AwsException expected = awsError("ServiceException");+ doThrow(expected).when(lambdaService).deleteFunction(REGION, "function");++ AwsException actual = assertThrows(AwsException.class,+ () -> provisioner.delete("AWS::Lambda::Function", "function", REGION));++ assertSame(expected, actual);+ }++ private static AwsException awsError(String errorCode) {+ return new AwsException(errorCode, "delete failed", 500);+ }+}