From 205515d9b4d3f779ebbf44ab3214d76bfa6ffefd Mon Sep 17 00:00:00 2001 From: Aniket Shukla Date: Sat, 21 Nov 2026 19:42:38 +0530 Subject: [PATCH 1/3] fix(s3): emit API reasons and bucket resources in EventBridge events --- .../io/floci/aws/services/s3/S3Service.java | 17 ++- ...3EventBridgeEventShapeIntegrationTest.java | 118 ++++++++++++++++++ 2 files changed, 129 insertions(+), 6 deletions(-) create mode 100644 src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java diff --git a/src/main/java/io/floci/aws/services/s3/S3Service.java b/src/main/java/io/floci/aws/services/s3/S3Service.java index d3564924368..ba77b407239 100644 --- a/src/main/java/io/floci/aws/services/s3/S3Service.java +++ b/src/main/java/io/floci/aws/services/s3/S3Service.java @@ -7402,10 +7402,9 @@ private void fireNotifications(String bucketName, String key, String eventName, String detailType = eventName.startsWith("ObjectCreated") ? "Object Created" : eventName.startsWith("ObjectAnnotation") ? "Object Annotation" : "Object Deleted"; - Map entry = new java.util.HashMap<>(); - entry.put("Source", "aws.s3"); - entry.put("DetailType", detailType); - entry.put("Detail", buildS3EventBridgeDetail(bucketName, key, eventName, obj, region)); + Map entry = EventBridgeService.serviceEventEntry("aws.s3", detailType, + buildS3EventBridgeDetail(bucketName, key, eventName, obj, region), + S3ResourceArns.bucket(bucketPartition(bucketName), bucketName)); eventBridgeService.putEvents(List.of(entry), region); LOG.debugv("Fired S3 event {0} to EventBridge default bus", eventName); } catch (Exception e) { @@ -7450,9 +7449,15 @@ private String buildS3EventBridgeDetail(String bucketName, String key, String ev } } - /** The EventBridge {@code reason}: {@code Lifecycle Expiration} for a deletion by a lifecycle rule. */ + /** EventBridge names the creating API rather than the classic notification event. */ private static String eventBridgeReason(String eventName) { - return isLifecycleEvent(eventName) ? "Lifecycle Expiration" : eventName; + return switch (eventName) { + case "ObjectCreated:Put" -> "PutObject"; + case "ObjectCreated:Post" -> "POST Object"; + case "ObjectCreated:Copy" -> "CopyObject"; + case "ObjectCreated:CompleteMultipartUpload" -> "CompleteMultipartUpload"; + default -> isLifecycleEvent(eventName) ? "Lifecycle Expiration" : eventName; + }; } private static boolean isLifecycleEvent(String eventName) { diff --git a/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java b/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java new file mode 100644 index 00000000000..6f897ef8ae1 --- /dev/null +++ b/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java @@ -0,0 +1,118 @@ +package io.floci.aws.services.s3; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import io.floci.aws.testing.AwsTestClients; +import io.quarkus.test.junit.QuarkusTest; +import jakarta.inject.Inject; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import software.amazon.awssdk.core.sync.RequestBody; +import software.amazon.awssdk.regions.Region; +import software.amazon.awssdk.services.eventbridge.EventBridgeClient; +import software.amazon.awssdk.services.eventbridge.model.Target; +import software.amazon.awssdk.services.s3.S3Client; +import software.amazon.awssdk.services.s3.model.CompletedPart; +import software.amazon.awssdk.services.sqs.SqsClient; +import software.amazon.awssdk.services.sqs.model.Message; +import software.amazon.awssdk.services.sqs.model.QueueAttributeName; + +import java.nio.charset.StandardCharsets; +import java.util.List; +import java.util.UUID; + +import static io.restassured.RestAssured.given; +import static org.junit.jupiter.api.Assertions.*; + +@QuarkusTest +class S3EventBridgeEventShapeIntegrationTest { + + private static final String ACCOUNT = "000000000000"; + + @Inject + ObjectMapper objectMapper; + + @ParameterizedTest + @CsvSource({ + "us-east-1,aws,PutObject", + "us-east-1,aws,POST Object", + "us-east-1,aws,CopyObject", + "us-east-1,aws,CompleteMultipartUpload", + "cn-north-1,aws-cn,PutObject" + }) + void creationEventCarriesApiReasonAndBucketArn(String regionId, String partition, String reason) throws Exception { + Region region = Region.of(regionId); + String name = "s3-eb-shape-" + UUID.randomUUID(); + String bucketArn = "arn:" + partition + ":s3:::" + name; + try (S3Client s3 = AwsTestClients.create(S3Client.builder().forcePathStyle(true), ACCOUNT, region); + SqsClient sqs = AwsTestClients.create(SqsClient.builder(), ACCOUNT, region); + EventBridgeClient events = AwsTestClients.create(EventBridgeClient.builder(), ACCOUNT, region)) { + s3.createBucket(request -> { + request.bucket(name); + if (!region.equals(Region.US_EAST_1)) { + request.createBucketConfiguration(configuration -> configuration.locationConstraint(regionId)); + } + }); + String queueUrl = sqs.createQueue(request -> request.queueName(name)).queueUrl(); + String queueArn = sqs.getQueueAttributes(request -> request.queueUrl(queueUrl) + .attributeNames(QueueAttributeName.QUEUE_ARN)).attributes().get(QueueAttributeName.QUEUE_ARN); + events.putRule(request -> request.name(name).eventPattern("{\"source\":[\"aws.s3\"]}")); + try { + assertEquals(0, events.putTargets(request -> request.rule(name) + .targets(Target.builder().id("queue").arn(queueArn).build())).failedEntryCount()); + // Seed copy input before enabling notifications, so the queue receives only the operation under test. + s3.putObject(request -> request.bucket(name).key("source"), RequestBody.fromString("content")); + s3.putBucketNotificationConfiguration(request -> request.bucket(name) + .notificationConfiguration(configuration -> configuration.eventBridgeConfiguration(bridge -> {}))); + + switch (reason) { + case "PutObject" -> s3.putObject(request -> request.bucket(name).key("created"), + RequestBody.fromString("content")); + case "POST Object" -> given() + .header("Authorization", "AWS4-HMAC-SHA256 Credential=" + ACCOUNT + "/20261121/" + + regionId + "/s3/aws4_request, SignedHeaders=host, Signature=test") + .multiPart("key", "created") + .multiPart("file", "created", "content".getBytes(StandardCharsets.UTF_8), "text/plain") + .when().post("/" + name).then().statusCode(204); + case "CopyObject" -> s3.copyObject(request -> request.copySource(name + "/source") + .destinationBucket(name).destinationKey("created")); + case "CompleteMultipartUpload" -> { + String uploadId = s3.createMultipartUpload(request -> request.bucket(name).key("created")) + .uploadId(); + String etag = s3.uploadPart(request -> request.bucket(name).key("created") + .uploadId(uploadId).partNumber(1), RequestBody.fromString("content")).eTag(); + s3.completeMultipartUpload(request -> request.bucket(name).key("created").uploadId(uploadId) + .multipartUpload(upload -> upload.parts(CompletedPart.builder() + .partNumber(1).eTag(etag).build()))); + } + default -> throw new AssertionError("Unknown creation API: " + reason); + } + + List messages = sqs.receiveMessage(request -> request.queueUrl(queueUrl) + .waitTimeSeconds(2).maxNumberOfMessages(1)).messages(); + assertEquals(1, messages.size(), "Expected the S3 event through EventBridge and SQS"); + String body = messages.getFirst().body(); + JsonNode event = objectMapper.readTree(body); + String pattern = "{\"source\":[\"aws.s3\"],\"resources\":[\"" + bucketArn + + "\"],\"detail\":{\"reason\":[\"" + reason + "\"]}}"; + assertAll( + () -> assertEquals("Object Created", event.path("detail-type").asText()), + () -> assertEquals(regionId, event.path("region").asText()), + () -> assertEquals("created", event.path("detail").path("object").path("key").asText()), + () -> assertEquals(reason, event.path("detail").path("reason").asText()), + () -> assertEquals(objectMapper.valueToTree(List.of(bucketArn)), event.path("resources")), + () -> assertTrue(events.testEventPattern(request -> request.eventPattern(pattern).event(body)) + .result(), "Consumers must be able to filter on the API reason and bucket ARN")); + } finally { + events.removeTargets(request -> request.rule(name).ids("queue")); + events.deleteRule(request -> request.name(name)); + sqs.deleteQueue(request -> request.queueUrl(queueUrl)); + s3.putBucketNotificationConfiguration(request -> request.bucket(name) + .notificationConfiguration(configuration -> {})); + s3.deleteObject(request -> request.bucket(name).key("created")); + s3.deleteObject(request -> request.bucket(name).key("source")); + s3.deleteBucket(request -> request.bucket(name)); + } + } + } +} From c701c23a11b36bed1e9e53b929052e54c4346756 Mon Sep 17 00:00:00 2001 From: Aniket Shukla Date: Sat, 21 Nov 2026 19:55:23 +0530 Subject: [PATCH 2/3] test(s3): clean up EventBridge fixtures after failures --- ...3EventBridgeEventShapeIntegrationTest.java | 138 +++++++++--------- .../s3/S3EventBridgeFixtureCleanupTest.java | 95 ++++++++++++ 2 files changed, 166 insertions(+), 67 deletions(-) create mode 100644 src/test/java/io/floci/aws/services/s3/S3EventBridgeFixtureCleanupTest.java diff --git a/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java b/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java index 6f897ef8ae1..6328d69b4ba 100644 --- a/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java +++ b/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java @@ -3,8 +3,10 @@ import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import io.floci.aws.testing.AwsTestClients; +import io.floci.aws.testing.PartitionCleanup; import io.quarkus.test.junit.QuarkusTest; import jakarta.inject.Inject; +import org.junit.jupiter.api.extension.RegisterExtension; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; import software.amazon.awssdk.core.sync.RequestBody; @@ -32,6 +34,9 @@ class S3EventBridgeEventShapeIntegrationTest { @Inject ObjectMapper objectMapper; + @RegisterExtension + final PartitionCleanup cleanup = new PartitionCleanup(); + @ParameterizedTest @CsvSource({ "us-east-1,aws,PutObject", @@ -44,75 +49,74 @@ void creationEventCarriesApiReasonAndBucketArn(String regionId, String partition Region region = Region.of(regionId); String name = "s3-eb-shape-" + UUID.randomUUID(); String bucketArn = "arn:" + partition + ":s3:::" + name; - try (S3Client s3 = AwsTestClients.create(S3Client.builder().forcePathStyle(true), ACCOUNT, region); - SqsClient sqs = AwsTestClients.create(SqsClient.builder(), ACCOUNT, region); - EventBridgeClient events = AwsTestClients.create(EventBridgeClient.builder(), ACCOUNT, region)) { - s3.createBucket(request -> { - request.bucket(name); - if (!region.equals(Region.US_EAST_1)) { - request.createBucketConfiguration(configuration -> configuration.locationConstraint(regionId)); - } - }); - String queueUrl = sqs.createQueue(request -> request.queueName(name)).queueUrl(); - String queueArn = sqs.getQueueAttributes(request -> request.queueUrl(queueUrl) - .attributeNames(QueueAttributeName.QUEUE_ARN)).attributes().get(QueueAttributeName.QUEUE_ARN); - events.putRule(request -> request.name(name).eventPattern("{\"source\":[\"aws.s3\"]}")); - try { - assertEquals(0, events.putTargets(request -> request.rule(name) - .targets(Target.builder().id("queue").arn(queueArn).build())).failedEntryCount()); - // Seed copy input before enabling notifications, so the queue receives only the operation under test. - s3.putObject(request -> request.bucket(name).key("source"), RequestBody.fromString("content")); - s3.putBucketNotificationConfiguration(request -> request.bucket(name) - .notificationConfiguration(configuration -> configuration.eventBridgeConfiguration(bridge -> {}))); - - switch (reason) { - case "PutObject" -> s3.putObject(request -> request.bucket(name).key("created"), - RequestBody.fromString("content")); - case "POST Object" -> given() - .header("Authorization", "AWS4-HMAC-SHA256 Credential=" + ACCOUNT + "/20261121/" - + regionId + "/s3/aws4_request, SignedHeaders=host, Signature=test") - .multiPart("key", "created") - .multiPart("file", "created", "content".getBytes(StandardCharsets.UTF_8), "text/plain") - .when().post("/" + name).then().statusCode(204); - case "CopyObject" -> s3.copyObject(request -> request.copySource(name + "/source") - .destinationBucket(name).destinationKey("created")); - case "CompleteMultipartUpload" -> { - String uploadId = s3.createMultipartUpload(request -> request.bucket(name).key("created")) - .uploadId(); - String etag = s3.uploadPart(request -> request.bucket(name).key("created") - .uploadId(uploadId).partNumber(1), RequestBody.fromString("content")).eTag(); - s3.completeMultipartUpload(request -> request.bucket(name).key("created").uploadId(uploadId) - .multipartUpload(upload -> upload.parts(CompletedPart.builder() - .partNumber(1).eTag(etag).build()))); - } - default -> throw new AssertionError("Unknown creation API: " + reason); - } + S3Client s3 = AwsTestClients.create(S3Client.builder().forcePathStyle(true), ACCOUNT, region); + cleanup.register(s3::close); + SqsClient sqs = AwsTestClients.create(SqsClient.builder(), ACCOUNT, region); + cleanup.register(sqs::close); + EventBridgeClient events = AwsTestClients.create(EventBridgeClient.builder(), ACCOUNT, region); + cleanup.register(events::close); + s3.createBucket(request -> { + request.bucket(name); + if (!region.equals(Region.US_EAST_1)) { + request.createBucketConfiguration(configuration -> configuration.locationConstraint(regionId)); + } + }); + cleanup.register(() -> s3.deleteBucket(request -> request.bucket(name))); + String queueUrl = sqs.createQueue(request -> request.queueName(name)).queueUrl(); + cleanup.register(() -> sqs.deleteQueue(request -> request.queueUrl(queueUrl))); + String queueArn = sqs.getQueueAttributes(request -> request.queueUrl(queueUrl) + .attributeNames(QueueAttributeName.QUEUE_ARN)).attributes().get(QueueAttributeName.QUEUE_ARN); + events.putRule(request -> request.name(name).eventPattern("{\"source\":[\"aws.s3\"]}")); + cleanup.register(() -> events.deleteRule(request -> request.name(name))); + cleanup.register(() -> events.removeTargets(request -> request.rule(name).ids("queue"))); + assertEquals(0, events.putTargets(request -> request.rule(name) + .targets(Target.builder().id("queue").arn(queueArn).build())).failedEntryCount()); + // Seed copy input before enabling notifications, so the queue receives only the operation under test. + cleanup.register(() -> s3.deleteObject(request -> request.bucket(name).key("source"))); + s3.putObject(request -> request.bucket(name).key("source"), RequestBody.fromString("content")); + cleanup.register(() -> s3.putBucketNotificationConfiguration(request -> request.bucket(name) + .notificationConfiguration(configuration -> {}))); + s3.putBucketNotificationConfiguration(request -> request.bucket(name) + .notificationConfiguration(configuration -> configuration.eventBridgeConfiguration(bridge -> {}))); - List messages = sqs.receiveMessage(request -> request.queueUrl(queueUrl) - .waitTimeSeconds(2).maxNumberOfMessages(1)).messages(); - assertEquals(1, messages.size(), "Expected the S3 event through EventBridge and SQS"); - String body = messages.getFirst().body(); - JsonNode event = objectMapper.readTree(body); - String pattern = "{\"source\":[\"aws.s3\"],\"resources\":[\"" + bucketArn - + "\"],\"detail\":{\"reason\":[\"" + reason + "\"]}}"; - assertAll( - () -> assertEquals("Object Created", event.path("detail-type").asText()), - () -> assertEquals(regionId, event.path("region").asText()), - () -> assertEquals("created", event.path("detail").path("object").path("key").asText()), - () -> assertEquals(reason, event.path("detail").path("reason").asText()), - () -> assertEquals(objectMapper.valueToTree(List.of(bucketArn)), event.path("resources")), - () -> assertTrue(events.testEventPattern(request -> request.eventPattern(pattern).event(body)) - .result(), "Consumers must be able to filter on the API reason and bucket ARN")); - } finally { - events.removeTargets(request -> request.rule(name).ids("queue")); - events.deleteRule(request -> request.name(name)); - sqs.deleteQueue(request -> request.queueUrl(queueUrl)); - s3.putBucketNotificationConfiguration(request -> request.bucket(name) - .notificationConfiguration(configuration -> {})); - s3.deleteObject(request -> request.bucket(name).key("created")); - s3.deleteObject(request -> request.bucket(name).key("source")); - s3.deleteBucket(request -> request.bucket(name)); + cleanup.register(() -> s3.deleteObject(request -> request.bucket(name).key("created"))); + switch (reason) { + case "PutObject" -> s3.putObject(request -> request.bucket(name).key("created"), + RequestBody.fromString("content")); + case "POST Object" -> given() + .header("Authorization", "AWS4-HMAC-SHA256 Credential=" + ACCOUNT + "/20261121/" + + regionId + "/s3/aws4_request, SignedHeaders=host, Signature=test") + .multiPart("key", "created") + .multiPart("file", "created", "content".getBytes(StandardCharsets.UTF_8), "text/plain") + .when().post("/" + name).then().statusCode(204); + case "CopyObject" -> s3.copyObject(request -> request.copySource(name + "/source") + .destinationBucket(name).destinationKey("created")); + case "CompleteMultipartUpload" -> { + String uploadId = s3.createMultipartUpload(request -> request.bucket(name).key("created")) + .uploadId(); + String etag = s3.uploadPart(request -> request.bucket(name).key("created") + .uploadId(uploadId).partNumber(1), RequestBody.fromString("content")).eTag(); + s3.completeMultipartUpload(request -> request.bucket(name).key("created").uploadId(uploadId) + .multipartUpload(upload -> upload.parts(CompletedPart.builder() + .partNumber(1).eTag(etag).build()))); } + default -> throw new AssertionError("Unknown creation API: " + reason); } + + List messages = sqs.receiveMessage(request -> request.queueUrl(queueUrl) + .waitTimeSeconds(2).maxNumberOfMessages(1)).messages(); + assertEquals(1, messages.size(), "Expected the S3 event through EventBridge and SQS"); + String body = messages.getFirst().body(); + JsonNode event = objectMapper.readTree(body); + String pattern = "{\"source\":[\"aws.s3\"],\"resources\":[\"" + bucketArn + + "\"],\"detail\":{\"reason\":[\"" + reason + "\"]}}"; + assertAll( + () -> assertEquals("Object Created", event.path("detail-type").asText()), + () -> assertEquals(regionId, event.path("region").asText()), + () -> assertEquals("created", event.path("detail").path("object").path("key").asText()), + () -> assertEquals(reason, event.path("detail").path("reason").asText()), + () -> assertEquals(objectMapper.valueToTree(List.of(bucketArn)), event.path("resources")), + () -> assertTrue(events.testEventPattern(request -> request.eventPattern(pattern).event(body)) + .result(), "Consumers must be able to filter on the API reason and bucket ARN")); } } diff --git a/src/test/java/io/floci/aws/services/s3/S3EventBridgeFixtureCleanupTest.java b/src/test/java/io/floci/aws/services/s3/S3EventBridgeFixtureCleanupTest.java new file mode 100644 index 00000000000..1cffd3b0e79 --- /dev/null +++ b/src/test/java/io/floci/aws/services/s3/S3EventBridgeFixtureCleanupTest.java @@ -0,0 +1,95 @@ +package io.floci.aws.services.s3; + +import io.floci.aws.testing.AwsTestClients; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.mockito.MockMakers; +import org.mockito.MockedStatic; +import software.amazon.awssdk.core.sync.RequestBody; +import software.amazon.awssdk.regions.Region; +import software.amazon.awssdk.services.eventbridge.EventBridgeClient; +import software.amazon.awssdk.services.eventbridge.EventBridgeClientBuilder; +import software.amazon.awssdk.services.eventbridge.model.PutTargetsResponse; +import software.amazon.awssdk.services.s3.S3Client; +import software.amazon.awssdk.services.s3.S3ClientBuilder; +import software.amazon.awssdk.services.sqs.SqsClient; +import software.amazon.awssdk.services.sqs.SqsClientBuilder; +import software.amazon.awssdk.services.sqs.model.CreateQueueResponse; +import software.amazon.awssdk.services.sqs.model.GetQueueAttributesResponse; +import software.amazon.awssdk.services.sqs.model.QueueAttributeName; + +import java.util.Map; +import java.util.function.Consumer; + +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.*; + +class S3EventBridgeFixtureCleanupTest { + + @ParameterizedTest + @ValueSource(strings = {"queue", "attributes", "rule"}) + void setupFailureStillRemovesCreatedResources(String failureAt) throws Exception { + S3Client s3 = mock(S3Client.class); + SqsClient sqs = mock(SqsClient.class); + EventBridgeClient events = mock(EventBridgeClient.class); + IllegalStateException failure = new IllegalStateException("setup failed at " + failureAt); + when(sqs.createQueue(any(Consumer.class))).thenReturn(CreateQueueResponse.builder().queueUrl("queue-url").build()); + when(sqs.getQueueAttributes(any(Consumer.class))).thenReturn(GetQueueAttributesResponse.builder() + .attributes(Map.of(QueueAttributeName.QUEUE_ARN, "arn:aws:sqs:us-east-1:000000000000:q")).build()); + switch (failureAt) { + case "queue" -> when(sqs.createQueue(any(Consumer.class))).thenThrow(failure); + case "attributes" -> when(sqs.getQueueAttributes(any(Consumer.class))).thenThrow(failure); + case "rule" -> when(events.putRule(any(Consumer.class))).thenThrow(failure); + default -> throw new AssertionError(failureAt); + } + try (MockedStatic clients = clients(s3, sqs, events)) { + S3EventBridgeEventShapeIntegrationTest fixture = new S3EventBridgeEventShapeIntegrationTest(); + assertSame(failure, assertThrows(IllegalStateException.class, + () -> fixture.creationEventCarriesApiReasonAndBucketArn("us-east-1", "aws", "PutObject"))); + fixture.cleanup.afterEach(mock(ExtensionContext.class)); + verify(s3).deleteBucket(any(Consumer.class)); + if (!failureAt.equals("queue")) { + verify(sqs).deleteQueue(any(Consumer.class)); + } + } + } + + @Test + void failedTargetCleanupDoesNotSkipRuleQueueOrBucketDeletion() throws Exception { + S3Client s3 = mock(S3Client.class); + SqsClient sqs = mock(SqsClient.class); + EventBridgeClient events = mock(EventBridgeClient.class); + IllegalStateException failure = new IllegalStateException("seed upload failed"); + when(sqs.createQueue(any(Consumer.class))).thenReturn(CreateQueueResponse.builder().queueUrl("queue-url").build()); + when(sqs.getQueueAttributes(any(Consumer.class))).thenReturn(GetQueueAttributesResponse.builder() + .attributes(Map.of(QueueAttributeName.QUEUE_ARN, "arn:aws:sqs:us-east-1:000000000000:q")).build()); + when(events.putTargets(any(Consumer.class))).thenReturn(PutTargetsResponse.builder().failedEntryCount(0).build()); + when(s3.putObject(any(Consumer.class), any(RequestBody.class))).thenThrow(failure); + when(events.removeTargets(any(Consumer.class))).thenThrow(new IllegalStateException("target cleanup failed")); + try (MockedStatic clients = clients(s3, sqs, events)) { + S3EventBridgeEventShapeIntegrationTest fixture = new S3EventBridgeEventShapeIntegrationTest(); + assertSame(failure, assertThrows(IllegalStateException.class, + () -> fixture.creationEventCarriesApiReasonAndBucketArn("us-east-1", "aws", "PutObject"))); + fixture.cleanup.afterEach(mock(ExtensionContext.class)); + verify(events).deleteRule(any(Consumer.class)); + verify(sqs).deleteQueue(any(Consumer.class)); + verify(s3).deleteBucket(any(Consumer.class)); + } + } + + private static MockedStatic clients(S3Client s3, SqsClient sqs, EventBridgeClient events) { + MockedStatic clients = mockStatic(AwsTestClients.class, withSettings().mockMaker(MockMakers.INLINE)); + clients.when(() -> AwsTestClients.create(any(S3ClientBuilder.class), eq("000000000000"), eq(Region.US_EAST_1))) + .thenReturn(s3); + clients.when(() -> AwsTestClients.create(any(SqsClientBuilder.class), eq("000000000000"), eq(Region.US_EAST_1))) + .thenReturn(sqs); + clients.when(() -> AwsTestClients.create(any(EventBridgeClientBuilder.class), eq("000000000000"), eq(Region.US_EAST_1))) + .thenReturn(events); + return clients; + } +} From 17da6e65b0df3e15030b04744c65c1d8fe5cdedc Mon Sep 17 00:00:00 2001 From: Aniket Shukla Date: Sat, 21 Nov 2026 20:06:45 +0530 Subject: [PATCH 3/3] fix(s3): map deletion and annotation events and reuse queue fixture --- .../io/floci/aws/services/s3/S3Service.java | 13 +- ...3EventBridgeEventShapeIntegrationTest.java | 162 ++++++++++-------- .../s3/S3EventBridgeFixtureCleanupTest.java | 95 ---------- .../io/floci/aws/testing/EventRuleQueue.java | 46 +++-- .../floci/aws/testing/EventRuleQueueTest.java | 67 ++++++++ 5 files changed, 194 insertions(+), 189 deletions(-) delete mode 100644 src/test/java/io/floci/aws/services/s3/S3EventBridgeFixtureCleanupTest.java create mode 100644 src/test/java/io/floci/aws/testing/EventRuleQueueTest.java diff --git a/src/main/java/io/floci/aws/services/s3/S3Service.java b/src/main/java/io/floci/aws/services/s3/S3Service.java index ba77b407239..515ba3635a2 100644 --- a/src/main/java/io/floci/aws/services/s3/S3Service.java +++ b/src/main/java/io/floci/aws/services/s3/S3Service.java @@ -7399,9 +7399,11 @@ private void fireNotifications(String bucketName, String key, String eventName, if (config.isEventBridgeEnabled() && eventBridgeService != null) { try { - String detailType = eventName.startsWith("ObjectCreated") ? "Object Created" - : eventName.startsWith("ObjectAnnotation") ? "Object Annotation" - : "Object Deleted"; + String detailType = switch (eventName) { + case "ObjectAnnotation:Put" -> "Object Annotation Created"; + case "ObjectAnnotation:Delete" -> "Object Annotation Removed"; + default -> eventName.startsWith("ObjectCreated") ? "Object Created" : "Object Deleted"; + }; Map entry = EventBridgeService.serviceEventEntry("aws.s3", detailType, buildS3EventBridgeDetail(bucketName, key, eventName, obj, region), S3ResourceArns.bucket(bucketPartition(bucketName), bucketName)); @@ -7449,13 +7451,16 @@ private String buildS3EventBridgeDetail(String bucketName, String key, String ev } } - /** EventBridge names the creating API rather than the classic notification event. */ + /** EventBridge names the API rather than the classic notification event. */ private static String eventBridgeReason(String eventName) { return switch (eventName) { case "ObjectCreated:Put" -> "PutObject"; case "ObjectCreated:Post" -> "POST Object"; case "ObjectCreated:Copy" -> "CopyObject"; case "ObjectCreated:CompleteMultipartUpload" -> "CompleteMultipartUpload"; + case "ObjectRemoved:Delete", "ObjectRemoved:DeleteMarkerCreated" -> "DeleteObject"; + case "ObjectAnnotation:Put" -> "PutObjectAnnotation"; + case "ObjectAnnotation:Delete" -> "DeleteObjectAnnotation"; default -> isLifecycleEvent(eventName) ? "Lifecycle Expiration" : eventName; }; } diff --git a/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java b/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java index 6328d69b4ba..3da3a311598 100644 --- a/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java +++ b/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java @@ -3,21 +3,22 @@ import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import io.floci.aws.testing.AwsTestClients; +import io.floci.aws.testing.EnforcementFixtures; +import io.floci.aws.testing.EventRuleQueue; import io.floci.aws.testing.PartitionCleanup; +import io.floci.aws.testing.RestAssuredJsonUtils; import io.quarkus.test.junit.QuarkusTest; +import io.restassured.RestAssured; import jakarta.inject.Inject; +import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.extension.RegisterExtension; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; import software.amazon.awssdk.core.sync.RequestBody; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.eventbridge.EventBridgeClient; -import software.amazon.awssdk.services.eventbridge.model.Target; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.CompletedPart; -import software.amazon.awssdk.services.sqs.SqsClient; -import software.amazon.awssdk.services.sqs.model.Message; -import software.amazon.awssdk.services.sqs.model.QueueAttributeName; import java.nio.charset.StandardCharsets; import java.util.List; @@ -37,86 +38,97 @@ class S3EventBridgeEventShapeIntegrationTest { @RegisterExtension final PartitionCleanup cleanup = new PartitionCleanup(); + @BeforeAll + static void configureAwsContentTypes() { + RestAssuredJsonUtils.configureAwsContentTypes(); + } + @ParameterizedTest @CsvSource({ - "us-east-1,aws,PutObject", - "us-east-1,aws,POST Object", - "us-east-1,aws,CopyObject", - "us-east-1,aws,CompleteMultipartUpload", - "cn-north-1,aws-cn,PutObject" + "us-east-1,aws,PutObject,PutObject,Object Created", + "us-east-1,aws,POST Object,POST Object,Object Created", + "us-east-1,aws,CopyObject,CopyObject,Object Created", + "us-east-1,aws,CompleteMultipartUpload,CompleteMultipartUpload,Object Created", + "cn-north-1,aws-cn,PutObject,PutObject,Object Created", + "us-east-1,aws,DeleteObject,DeleteObject,Object Deleted", + "us-east-1,aws,DeleteMarker,DeleteObject,Object Deleted", + "us-east-1,aws,PutObjectAnnotation,PutObjectAnnotation,Object Annotation Created", + "us-east-1,aws,DeleteObjectAnnotation,DeleteObjectAnnotation,Object Annotation Removed" }) - void creationEventCarriesApiReasonAndBucketArn(String regionId, String partition, String reason) throws Exception { + void eventCarriesApiReasonAndBucketArn(String regionId, String partition, String operation, + String reason, String detailType) throws Exception { Region region = Region.of(regionId); String name = "s3-eb-shape-" + UUID.randomUUID(); String bucketArn = "arn:" + partition + ":s3:::" + name; - S3Client s3 = AwsTestClients.create(S3Client.builder().forcePathStyle(true), ACCOUNT, region); - cleanup.register(s3::close); - SqsClient sqs = AwsTestClients.create(SqsClient.builder(), ACCOUNT, region); - cleanup.register(sqs::close); - EventBridgeClient events = AwsTestClients.create(EventBridgeClient.builder(), ACCOUNT, region); - cleanup.register(events::close); - s3.createBucket(request -> { - request.bucket(name); - if (!region.equals(Region.US_EAST_1)) { - request.createBucketConfiguration(configuration -> configuration.locationConstraint(regionId)); + String authorization = EnforcementFixtures.auth(ACCOUNT, regionId, "s3"); + String pattern = "{\"source\":[\"aws.s3\"],\"detail\":{\"bucket\":{\"name\":[\"" + name + "\"]}}}"; + try (S3Client s3 = AwsTestClients.create(S3Client.builder().forcePathStyle(true), ACCOUNT, region); + EventBridgeClient events = AwsTestClients.create(EventBridgeClient.builder(), ACCOUNT, region); + EventRuleQueue queue = EventRuleQueue.route(ACCOUNT, regionId, name, pattern)) { + s3.createBucket(request -> { + request.bucket(name); + if (!region.equals(Region.US_EAST_1)) { + request.createBucketConfiguration(configuration -> configuration.locationConstraint(regionId)); + } + }); + int port = RestAssured.port; + cleanup.register(() -> EnforcementFixtures.removeBucket(port, authorization, name)); + if (operation.equals("DeleteMarker")) { + s3.putBucketVersioning(request -> request.bucket(name) + .versioningConfiguration(configuration -> configuration.status("Enabled"))); + } + // Seed inputs before enabling notifications so only the operation under test is delivered. + s3.putObject(request -> request.bucket(name).key("source"), RequestBody.fromString("content")); + if (operation.startsWith("Delete") || operation.equals("PutObjectAnnotation")) { + s3.putObject(request -> request.bucket(name).key("created"), RequestBody.fromString("content")); } - }); - cleanup.register(() -> s3.deleteBucket(request -> request.bucket(name))); - String queueUrl = sqs.createQueue(request -> request.queueName(name)).queueUrl(); - cleanup.register(() -> sqs.deleteQueue(request -> request.queueUrl(queueUrl))); - String queueArn = sqs.getQueueAttributes(request -> request.queueUrl(queueUrl) - .attributeNames(QueueAttributeName.QUEUE_ARN)).attributes().get(QueueAttributeName.QUEUE_ARN); - events.putRule(request -> request.name(name).eventPattern("{\"source\":[\"aws.s3\"]}")); - cleanup.register(() -> events.deleteRule(request -> request.name(name))); - cleanup.register(() -> events.removeTargets(request -> request.rule(name).ids("queue"))); - assertEquals(0, events.putTargets(request -> request.rule(name) - .targets(Target.builder().id("queue").arn(queueArn).build())).failedEntryCount()); - // Seed copy input before enabling notifications, so the queue receives only the operation under test. - cleanup.register(() -> s3.deleteObject(request -> request.bucket(name).key("source"))); - s3.putObject(request -> request.bucket(name).key("source"), RequestBody.fromString("content")); - cleanup.register(() -> s3.putBucketNotificationConfiguration(request -> request.bucket(name) - .notificationConfiguration(configuration -> {}))); - s3.putBucketNotificationConfiguration(request -> request.bucket(name) - .notificationConfiguration(configuration -> configuration.eventBridgeConfiguration(bridge -> {}))); + if (operation.equals("DeleteObjectAnnotation")) { + given().header("Authorization", authorization).queryParam("annotation", "") + .queryParam("annotationName", "note").body("{}").put("/" + name + "/created") + .then().statusCode(200); + } + s3.putBucketNotificationConfiguration(request -> request.bucket(name) + .notificationConfiguration(configuration -> configuration.eventBridgeConfiguration(bridge -> {}))); - cleanup.register(() -> s3.deleteObject(request -> request.bucket(name).key("created"))); - switch (reason) { - case "PutObject" -> s3.putObject(request -> request.bucket(name).key("created"), - RequestBody.fromString("content")); - case "POST Object" -> given() - .header("Authorization", "AWS4-HMAC-SHA256 Credential=" + ACCOUNT + "/20261121/" - + regionId + "/s3/aws4_request, SignedHeaders=host, Signature=test") - .multiPart("key", "created") - .multiPart("file", "created", "content".getBytes(StandardCharsets.UTF_8), "text/plain") - .when().post("/" + name).then().statusCode(204); - case "CopyObject" -> s3.copyObject(request -> request.copySource(name + "/source") - .destinationBucket(name).destinationKey("created")); - case "CompleteMultipartUpload" -> { - String uploadId = s3.createMultipartUpload(request -> request.bucket(name).key("created")) - .uploadId(); - String etag = s3.uploadPart(request -> request.bucket(name).key("created") - .uploadId(uploadId).partNumber(1), RequestBody.fromString("content")).eTag(); - s3.completeMultipartUpload(request -> request.bucket(name).key("created").uploadId(uploadId) - .multipartUpload(upload -> upload.parts(CompletedPart.builder() - .partNumber(1).eTag(etag).build()))); + switch (operation) { + case "PutObject" -> s3.putObject(request -> request.bucket(name).key("created"), + RequestBody.fromString("content")); + case "POST Object" -> given().header("Authorization", authorization) + .multiPart("key", "created") + .multiPart("file", "created", "content".getBytes(StandardCharsets.UTF_8), "text/plain") + .when().post("/" + name).then().statusCode(204); + case "CopyObject" -> s3.copyObject(request -> request.copySource(name + "/source") + .destinationBucket(name).destinationKey("created")); + case "CompleteMultipartUpload" -> { + String uploadId = s3.createMultipartUpload(request -> request.bucket(name).key("created")).uploadId(); + String etag = s3.uploadPart(request -> request.bucket(name).key("created") + .uploadId(uploadId).partNumber(1), RequestBody.fromString("content")).eTag(); + s3.completeMultipartUpload(request -> request.bucket(name).key("created").uploadId(uploadId) + .multipartUpload(upload -> upload.parts(CompletedPart.builder() + .partNumber(1).eTag(etag).build()))); + } + case "DeleteObject", "DeleteMarker" -> s3.deleteObject(request -> request.bucket(name).key("created")); + case "PutObjectAnnotation" -> given().header("Authorization", authorization).queryParam("annotation", "") + .queryParam("annotationName", "note").body("{}").put("/" + name + "/created") + .then().statusCode(200); + case "DeleteObjectAnnotation" -> given().header("Authorization", authorization).queryParam("annotation", "") + .queryParam("annotationName", "note").delete("/" + name + "/created").then().statusCode(204); + default -> throw new AssertionError("Unknown S3 API: " + operation); } - default -> throw new AssertionError("Unknown creation API: " + reason); - } - List messages = sqs.receiveMessage(request -> request.queueUrl(queueUrl) - .waitTimeSeconds(2).maxNumberOfMessages(1)).messages(); - assertEquals(1, messages.size(), "Expected the S3 event through EventBridge and SQS"); - String body = messages.getFirst().body(); - JsonNode event = objectMapper.readTree(body); - String pattern = "{\"source\":[\"aws.s3\"],\"resources\":[\"" + bucketArn - + "\"],\"detail\":{\"reason\":[\"" + reason + "\"]}}"; - assertAll( - () -> assertEquals("Object Created", event.path("detail-type").asText()), - () -> assertEquals(regionId, event.path("region").asText()), - () -> assertEquals("created", event.path("detail").path("object").path("key").asText()), - () -> assertEquals(reason, event.path("detail").path("reason").asText()), - () -> assertEquals(objectMapper.valueToTree(List.of(bucketArn)), event.path("resources")), - () -> assertTrue(events.testEventPattern(request -> request.eventPattern(pattern).event(body)) - .result(), "Consumers must be able to filter on the API reason and bucket ARN")); + List messages = queue.drain(); + assertEquals(1, messages.size(), "Expected the S3 event through EventBridge and SQS"); + JsonNode event = messages.getFirst(); + String consumerPattern = "{\"source\":[\"aws.s3\"],\"resources\":[\"" + bucketArn + + "\"],\"detail\":{\"reason\":[\"" + reason + "\"]}}"; + assertAll( + () -> assertEquals(detailType, event.path("detail-type").asText()), + () -> assertEquals(regionId, event.path("region").asText()), + () -> assertEquals("created", event.path("detail").path("object").path("key").asText()), + () -> assertEquals(reason, event.path("detail").path("reason").asText()), + () -> assertEquals(objectMapper.valueToTree(List.of(bucketArn)), event.path("resources")), + () -> assertTrue(events.testEventPattern(request -> request.eventPattern(consumerPattern) + .event(event.toString())).result(), "Consumers must be able to filter on the API reason and bucket ARN")); + } } } diff --git a/src/test/java/io/floci/aws/services/s3/S3EventBridgeFixtureCleanupTest.java b/src/test/java/io/floci/aws/services/s3/S3EventBridgeFixtureCleanupTest.java deleted file mode 100644 index 1cffd3b0e79..00000000000 --- a/src/test/java/io/floci/aws/services/s3/S3EventBridgeFixtureCleanupTest.java +++ /dev/null @@ -1,95 +0,0 @@ -package io.floci.aws.services.s3; - -import io.floci.aws.testing.AwsTestClients; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtensionContext; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.ValueSource; -import org.mockito.MockMakers; -import org.mockito.MockedStatic; -import software.amazon.awssdk.core.sync.RequestBody; -import software.amazon.awssdk.regions.Region; -import software.amazon.awssdk.services.eventbridge.EventBridgeClient; -import software.amazon.awssdk.services.eventbridge.EventBridgeClientBuilder; -import software.amazon.awssdk.services.eventbridge.model.PutTargetsResponse; -import software.amazon.awssdk.services.s3.S3Client; -import software.amazon.awssdk.services.s3.S3ClientBuilder; -import software.amazon.awssdk.services.sqs.SqsClient; -import software.amazon.awssdk.services.sqs.SqsClientBuilder; -import software.amazon.awssdk.services.sqs.model.CreateQueueResponse; -import software.amazon.awssdk.services.sqs.model.GetQueueAttributesResponse; -import software.amazon.awssdk.services.sqs.model.QueueAttributeName; - -import java.util.Map; -import java.util.function.Consumer; - -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.*; - -class S3EventBridgeFixtureCleanupTest { - - @ParameterizedTest - @ValueSource(strings = {"queue", "attributes", "rule"}) - void setupFailureStillRemovesCreatedResources(String failureAt) throws Exception { - S3Client s3 = mock(S3Client.class); - SqsClient sqs = mock(SqsClient.class); - EventBridgeClient events = mock(EventBridgeClient.class); - IllegalStateException failure = new IllegalStateException("setup failed at " + failureAt); - when(sqs.createQueue(any(Consumer.class))).thenReturn(CreateQueueResponse.builder().queueUrl("queue-url").build()); - when(sqs.getQueueAttributes(any(Consumer.class))).thenReturn(GetQueueAttributesResponse.builder() - .attributes(Map.of(QueueAttributeName.QUEUE_ARN, "arn:aws:sqs:us-east-1:000000000000:q")).build()); - switch (failureAt) { - case "queue" -> when(sqs.createQueue(any(Consumer.class))).thenThrow(failure); - case "attributes" -> when(sqs.getQueueAttributes(any(Consumer.class))).thenThrow(failure); - case "rule" -> when(events.putRule(any(Consumer.class))).thenThrow(failure); - default -> throw new AssertionError(failureAt); - } - try (MockedStatic clients = clients(s3, sqs, events)) { - S3EventBridgeEventShapeIntegrationTest fixture = new S3EventBridgeEventShapeIntegrationTest(); - assertSame(failure, assertThrows(IllegalStateException.class, - () -> fixture.creationEventCarriesApiReasonAndBucketArn("us-east-1", "aws", "PutObject"))); - fixture.cleanup.afterEach(mock(ExtensionContext.class)); - verify(s3).deleteBucket(any(Consumer.class)); - if (!failureAt.equals("queue")) { - verify(sqs).deleteQueue(any(Consumer.class)); - } - } - } - - @Test - void failedTargetCleanupDoesNotSkipRuleQueueOrBucketDeletion() throws Exception { - S3Client s3 = mock(S3Client.class); - SqsClient sqs = mock(SqsClient.class); - EventBridgeClient events = mock(EventBridgeClient.class); - IllegalStateException failure = new IllegalStateException("seed upload failed"); - when(sqs.createQueue(any(Consumer.class))).thenReturn(CreateQueueResponse.builder().queueUrl("queue-url").build()); - when(sqs.getQueueAttributes(any(Consumer.class))).thenReturn(GetQueueAttributesResponse.builder() - .attributes(Map.of(QueueAttributeName.QUEUE_ARN, "arn:aws:sqs:us-east-1:000000000000:q")).build()); - when(events.putTargets(any(Consumer.class))).thenReturn(PutTargetsResponse.builder().failedEntryCount(0).build()); - when(s3.putObject(any(Consumer.class), any(RequestBody.class))).thenThrow(failure); - when(events.removeTargets(any(Consumer.class))).thenThrow(new IllegalStateException("target cleanup failed")); - try (MockedStatic clients = clients(s3, sqs, events)) { - S3EventBridgeEventShapeIntegrationTest fixture = new S3EventBridgeEventShapeIntegrationTest(); - assertSame(failure, assertThrows(IllegalStateException.class, - () -> fixture.creationEventCarriesApiReasonAndBucketArn("us-east-1", "aws", "PutObject"))); - fixture.cleanup.afterEach(mock(ExtensionContext.class)); - verify(events).deleteRule(any(Consumer.class)); - verify(sqs).deleteQueue(any(Consumer.class)); - verify(s3).deleteBucket(any(Consumer.class)); - } - } - - private static MockedStatic clients(S3Client s3, SqsClient sqs, EventBridgeClient events) { - MockedStatic clients = mockStatic(AwsTestClients.class, withSettings().mockMaker(MockMakers.INLINE)); - clients.when(() -> AwsTestClients.create(any(S3ClientBuilder.class), eq("000000000000"), eq(Region.US_EAST_1))) - .thenReturn(s3); - clients.when(() -> AwsTestClients.create(any(SqsClientBuilder.class), eq("000000000000"), eq(Region.US_EAST_1))) - .thenReturn(sqs); - clients.when(() -> AwsTestClients.create(any(EventBridgeClientBuilder.class), eq("000000000000"), eq(Region.US_EAST_1))) - .thenReturn(events); - return clients; - } -} diff --git a/src/test/java/io/floci/aws/testing/EventRuleQueue.java b/src/test/java/io/floci/aws/testing/EventRuleQueue.java index f3de60eb32c..3bbceb41ba1 100644 --- a/src/test/java/io/floci/aws/testing/EventRuleQueue.java +++ b/src/test/java/io/floci/aws/testing/EventRuleQueue.java @@ -45,16 +45,26 @@ public static EventRuleQueue route(String region, String name, String pattern) { public static EventRuleQueue route(String account, String region, String name, String pattern) { String url = call(account, region, "sqs", "AmazonSQS.CreateQueue", SQS_CONTENT_TYPE, MAPPER.createObjectNode().put("QueueName", name)).jsonPath().getString("QueueUrl"); - ObjectNode attributes = MAPPER.createObjectNode().put("QueueUrl", url); - attributes.putArray("AttributeNames").add("QueueArn"); - String arn = call(account, region, "sqs", "AmazonSQS.GetQueueAttributes", SQS_CONTENT_TYPE, attributes) - .jsonPath().getString("Attributes.QueueArn"); - call(account, region, "events", "AWSEvents.PutRule", EVENTS_CONTENT_TYPE, - MAPPER.createObjectNode().put("Name", name).put("EventPattern", pattern)); - ObjectNode targets = MAPPER.createObjectNode().put("Rule", name); - targets.putArray("Targets").addObject().put("Id", TARGET_ID).put("Arn", arn); - call(account, region, "events", "AWSEvents.PutTargets", EVENTS_CONTENT_TYPE, targets); - return new EventRuleQueue(account, region, name, url); + EventRuleQueue queue = new EventRuleQueue(account, region, name, url); + try { + ObjectNode attributes = MAPPER.createObjectNode().put("QueueUrl", url); + attributes.putArray("AttributeNames").add("QueueArn"); + String arn = call(account, region, "sqs", "AmazonSQS.GetQueueAttributes", SQS_CONTENT_TYPE, attributes) + .jsonPath().getString("Attributes.QueueArn"); + call(account, region, "events", "AWSEvents.PutRule", EVENTS_CONTENT_TYPE, + MAPPER.createObjectNode().put("Name", name).put("EventPattern", pattern)); + ObjectNode targets = MAPPER.createObjectNode().put("Rule", name); + targets.putArray("Targets").addObject().put("Id", TARGET_ID).put("Arn", arn); + call(account, region, "events", "AWSEvents.PutTargets", EVENTS_CONTENT_TYPE, targets); + return queue; + } catch (RuntimeException | AssertionError failure) { + try { + queue.close(); + } catch (RuntimeException | AssertionError cleanupFailure) { + failure.addSuppressed(cleanupFailure); + } + throw failure; + } } /** @@ -85,11 +95,17 @@ public List drain() throws Exception { public void close() { ObjectNode targets = MAPPER.createObjectNode().put("Rule", name); targets.putArray("Ids").add(TARGET_ID); - call(account, region, "events", "AWSEvents.RemoveTargets", EVENTS_CONTENT_TYPE, targets); - call(account, region, "events", "AWSEvents.DeleteRule", EVENTS_CONTENT_TYPE, - MAPPER.createObjectNode().put("Name", name)); - call(account, region, "sqs", "AmazonSQS.DeleteQueue", SQS_CONTENT_TYPE, - MAPPER.createObjectNode().put("QueueUrl", url)); + try { + call(account, region, "events", "AWSEvents.RemoveTargets", EVENTS_CONTENT_TYPE, targets); + } finally { + try { + call(account, region, "events", "AWSEvents.DeleteRule", EVENTS_CONTENT_TYPE, + MAPPER.createObjectNode().put("Name", name)); + } finally { + call(account, region, "sqs", "AmazonSQS.DeleteQueue", SQS_CONTENT_TYPE, + MAPPER.createObjectNode().put("QueueUrl", url)); + } + } } private static Response call(String account, String region, String service, String target, diff --git a/src/test/java/io/floci/aws/testing/EventRuleQueueTest.java b/src/test/java/io/floci/aws/testing/EventRuleQueueTest.java new file mode 100644 index 00000000000..46e092db7a5 --- /dev/null +++ b/src/test/java/io/floci/aws/testing/EventRuleQueueTest.java @@ -0,0 +1,67 @@ +package io.floci.aws.testing; + +import io.restassured.RestAssured; +import io.restassured.builder.ResponseBuilder; +import io.restassured.filter.Filter; +import io.restassured.response.Response; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.atomic.AtomicBoolean; + +import static org.junit.jupiter.api.Assertions.*; + +class EventRuleQueueTest { + + @ParameterizedTest + @ValueSource(strings = {"AmazonSQS.GetQueueAttributes", "AWSEvents.PutRule", "AWSEvents.PutTargets"}) + void setupFailureStillDeletesTheCreatedQueue(String failingAction) { + List actions = new ArrayList<>(); + List original = RestAssured.filters(); + RestAssured.replaceFiltersWith((request, response, context) -> { + String action = request.getHeaders().getValue("X-Amz-Target"); + actions.add(action); + return response(action.equals(failingAction) ? 500 : 200); + }); + try { + assertThrows(AssertionError.class, () -> EventRuleQueue.route("us-east-1", "cleanup", "{}")); + assertTrue(actions.contains("AmazonSQS.DeleteQueue"), actions.toString()); + if (!failingAction.equals("AmazonSQS.GetQueueAttributes")) { + assertTrue(actions.contains("AWSEvents.DeleteRule"), actions.toString()); + } + } finally { + RestAssured.replaceFiltersWith(original); + } + } + + @Test + void failingTargetRemovalStillDeletesTheRuleAndQueue() { + List actions = new ArrayList<>(); + AtomicBoolean closing = new AtomicBoolean(); + List original = RestAssured.filters(); + RestAssured.replaceFiltersWith((request, response, context) -> { + String action = request.getHeaders().getValue("X-Amz-Target"); + actions.add(action); + return response(closing.get() && action.equals("AWSEvents.RemoveTargets") ? 500 : 200); + }); + try { + EventRuleQueue queue = EventRuleQueue.route("us-east-1", "cleanup", "{}"); + closing.set(true); + assertThrows(AssertionError.class, queue::close); + assertTrue(actions.contains("AWSEvents.DeleteRule"), actions.toString()); + assertTrue(actions.contains("AmazonSQS.DeleteQueue"), actions.toString()); + } finally { + RestAssured.replaceFiltersWith(original); + } + } + + private static Response response(int status) { + return new ResponseBuilder().setStatusCode(status).setContentType("application/json") + .setBody("{\"QueueUrl\":\"http://localhost/queue\"," + + "\"Attributes\":{\"QueueArn\":\"arn:aws:sqs:us-east-1:000000000000:q\"}," + + "\"FailedEntryCount\":0}").build(); + } +}