Light, fluffy, and always free - The AWS Local Emulator alternative
fix(sns): return per-entry failures from PublishBatch instead of aborting whole batch (#1008)
Ben Younesf5dba627be00
diff --git a/src/main/java/io/github/hectorvent/floci/services/sns/SnsJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/sns/SnsJsonHandler.javaindex 0a42c6fa5f..c42c035432 100644--- a/src/main/java/io/github/hectorvent/floci/services/sns/SnsJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/sns/SnsJsonHandler.java@@ -209,12 +209,14 @@ public class SnsJsonHandler {private Response handlePublishBatch(JsonNode request, String region) {String topicArn = request.path("TopicArn").asText(null);List<Map<String, Object>> entries = new ArrayList<>();+ List<String[]> entryAttributeFailures = new ArrayList<>();JsonNode entriesNode = request.path("PublishBatchRequestEntries");if (entriesNode.isArray()) {for (JsonNode entryNode : entriesNode) {+ String id = entryNode.path("Id").asText(null);Map<String, Object> entry = new HashMap<>();- entry.put("Id", entryNode.path("Id").asText(null));+ entry.put("Id", id);entry.put("Message", entryNode.path("Message").asText(null));entry.put("Subject", entryNode.path("Subject").asText(null));entry.put("MessageGroupId", entryNode.path("MessageGroupId").asText(null));@@ -222,7 +224,14 @@ public class SnsJsonHandler {JsonNode attrsNode = entryNode.path("MessageAttributes");if (attrsNode.isObject()) {- entry.put("MessageAttributes", parseMessageAttributes(attrsNode));+ try {+ entry.put("MessageAttributes", parseMessageAttributes(attrsNode));+ } catch (AwsException e) {+ // Real AWS SNS surfaces per-entry attribute errors as Failed entries+ // and keeps processing the rest of the batch, instead of aborting.+ entryAttributeFailures.add(new String[]{id, e.getErrorCode(), e.getMessage(), "true"});+ continue;+ }}entries.add(entry);@@ -240,7 +249,9 @@ public class SnsJsonHandler {successful.add(item);}ArrayNode failed = response.putArray("Failed");- for (String[] f : result.failed()) {+ List<String[]> allFailed = new ArrayList<>(result.failed());+ allFailed.addAll(entryAttributeFailures);+ for (String[] f : allFailed) {ObjectNode item = objectMapper.createObjectNode();item.put("Id", f[0]);item.put("Code", f[1]);diff --git a/src/main/java/io/github/hectorvent/floci/services/sns/SnsQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/sns/SnsQueryHandler.javaindex 7a7a57060f..8a3aea1610 100644--- a/src/main/java/io/github/hectorvent/floci/services/sns/SnsQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/sns/SnsQueryHandler.java@@ -205,6 +205,7 @@ public class SnsQueryHandler {private Response handlePublishBatch(MultivaluedMap<String, String> params, String region) {String topicArn = getParam(params, "TopicArn");List<Map<String, Object>> entries = new ArrayList<>();+ List<String[]> entryAttributeFailures = new ArrayList<>();for (int i = 1; ; i++) {String entryPrefix = "PublishBatchRequestEntries.member." + i;String id = getParam(params, entryPrefix + ".Id");@@ -220,7 +221,10 @@ public class SnsQueryHandler {try {attributes = parseMessageAttributes(params, entryPrefix + ".MessageAttributes.entry.");} catch (AwsException e) {- return xmlErrorResponse(e.getErrorCode(), e.getMessage(), e.getHttpStatus());+ // Real AWS SNS surfaces per-entry attribute errors as Failed entries+ // and keeps processing the rest of the batch, instead of aborting.+ entryAttributeFailures.add(new String[]{id, e.getErrorCode(), e.getMessage(), "true"});+ continue;}if (!attributes.isEmpty()) entry.put("MessageAttributes", attributes);entries.add(entry);@@ -233,7 +237,9 @@ public class SnsQueryHandler {xml.start("member").elem("Id", s[0]).elem("MessageId", s[1]).end("member");}xml.end("Successful").start("Failed");- for (String[] f : result.failed()) {+ List<String[]> allFailed = new ArrayList<>(result.failed());+ allFailed.addAll(entryAttributeFailures);+ for (String[] f : allFailed) {xml.start("member").elem("Id", f[0]).elem("Code", f[1]).elem("Message", f[2]).elem("SenderFault", f[3]).end("member");}diff --git a/src/test/java/io/github/hectorvent/floci/services/sns/SnsJsonHandlerPublishBatchTest.java b/src/test/java/io/github/hectorvent/floci/services/sns/SnsJsonHandlerPublishBatchTest.javanew file mode 100644index 0000000000..12e8564440--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/sns/SnsJsonHandlerPublishBatchTest.java@@ -0,0 +1,103 @@+package io.github.hectorvent.floci.services.sns;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.services.sqs.SqsService;+import io.github.hectorvent.floci.services.sqs.SqsServiceFactory;+import io.github.hectorvent.floci.services.sqs.model.Message;+import jakarta.ws.rs.core.Response;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * Tests that SnsJsonHandler.handle("PublishBatch", ...) returns AWS-compatible+ * partial-failure responses: a malformed entry must land in the Failed list+ * (with InvalidParameterValue + SenderFault=true) instead of aborting the+ * whole batch with a top-level error.+ */+class SnsJsonHandlerPublishBatchTest {++ private static final String REGION = "us-east-1";+ private static final String ACCOUNT = "000000000000";+ private static final String BASE_URL = "http://localhost:4566";++ private final ObjectMapper objectMapper = new ObjectMapper();+ private SnsService snsService;+ private SqsService sqsService;+ private SnsJsonHandler handler;++ @BeforeEach+ void setUp() {+ RegionResolver regionResolver = new RegionResolver(REGION, ACCOUNT);+ sqsService = SqsServiceFactory.createInMemory(BASE_URL, regionResolver);+ snsService = new SnsService(new InMemoryStorage<>(), new InMemoryStorage<>(),+ regionResolver, sqsService, null);+ handler = new SnsJsonHandler(snsService, objectMapper);+ }++ @Test+ void publishBatch_invalidBinaryAttribute_failsOnlyOffendingEntryAndProcessesRest() throws Exception {+ // Arrange+ sqsService.createQueue("json-partial-fail-queue", Map.of(), REGION);+ String queueArn = "arn:aws:sqs:" + REGION + ":" + ACCOUNT + ":json-partial-fail-queue";++ snsService.createTopic("json-partial-fail-topic", Map.of(), null, REGION);+ String topicArn = "arn:aws:sns:" + REGION + ":" + ACCOUNT + ":json-partial-fail-topic";+ snsService.subscribe(topicArn, "sqs", queueArn, REGION, Map.of("RawMessageDelivery", "true"));++ ObjectNode request = objectMapper.createObjectNode();+ request.put("TopicArn", topicArn);+ ArrayNode entries = request.putArray("PublishBatchRequestEntries");++ // Entry 1 — invalid base64 in BinaryValue; must NOT abort the batch+ ObjectNode bad = entries.addObject();+ bad.put("Id", "bad");+ bad.put("Message", "ignored");+ ObjectNode badAttrs = bad.putObject("MessageAttributes");+ ObjectNode badBlob = badAttrs.putObject("blob");+ badBlob.put("DataType", "Binary");+ badBlob.put("BinaryValue", "@@@-not-base64-@@@");++ // Entry 2 — valid; must be published+ ObjectNode good = entries.addObject();+ good.put("Id", "good");+ good.put("Message", "valid-message");++ // Act+ JsonNode requestNode = objectMapper.readTree(objectMapper.writeValueAsString(request));+ Response response = handler.handle("PublishBatch", requestNode, REGION);++ // Assert — partial failure (matches real AWS SNS)+ assertEquals(200, response.getStatus(),+ "PublishBatch must return 200 with per-entry failures, not abort the whole batch");++ JsonNode body = objectMapper.valueToTree(response.getEntity());+ JsonNode failed = body.path("Failed");+ JsonNode successful = body.path("Successful");++ assertTrue(failed.isArray() && failed.size() == 1, "exactly one entry must be in Failed");+ JsonNode failedEntry = failed.get(0);+ assertEquals("bad", failedEntry.path("Id").asText());+ assertEquals("InvalidParameterValue", failedEntry.path("Code").asText());+ assertTrue(failedEntry.path("SenderFault").asBoolean(), "SenderFault must be true");++ assertTrue(successful.isArray() && successful.size() == 1, "exactly one entry must be in Successful");+ assertEquals("good", successful.get(0).path("Id").asText());++ // Only the good entry should reach SQS+ List<Message> messages = sqsService.receiveMessage(+ BASE_URL + "/" + ACCOUNT + "/json-partial-fail-queue", 10, 30, 0, REGION);+ assertEquals(1, messages.size(), "only the valid entry should be delivered");+ assertEquals("valid-message", messages.get(0).getBody());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/sns/SnsQueryHandlerPublishBatchTest.java b/src/test/java/io/github/hectorvent/floci/services/sns/SnsQueryHandlerPublishBatchTest.javaindex 0b49d6d539..656799b1b0 100644--- a/src/test/java/io/github/hectorvent/floci/services/sns/SnsQueryHandlerPublishBatchTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/sns/SnsQueryHandlerPublishBatchTest.java@@ -88,6 +88,49 @@ class SnsQueryHandlerPublishBatchTest {}}+ @Test+ void publishBatch_invalidBinaryAttribute_failsOnlyOffendingEntryAndProcessesRest() {+ // Arrange+ sqsService.createQueue("partial-fail-queue", Map.of(), REGION);+ String queueArn = "arn:aws:sqs:" + REGION + ":" + ACCOUNT + ":partial-fail-queue";++ snsService.createTopic("partial-fail-topic", Map.of(), null, REGION);+ String topicArn = "arn:aws:sns:" + REGION + ":" + ACCOUNT + ":partial-fail-topic";+ snsService.subscribe(topicArn, "sqs", queueArn, REGION, Map.of("RawMessageDelivery", "true"));++ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.add("TopicArn", topicArn);++ // Entry 1: invalid base64 BinaryValue — must NOT abort the batch+ params.add("PublishBatchRequestEntries.member.1.Id", "bad");+ params.add("PublishBatchRequestEntries.member.1.Message", "ignored");+ params.add("PublishBatchRequestEntries.member.1.MessageAttributes.entry.1.Name", "blob");+ params.add("PublishBatchRequestEntries.member.1.MessageAttributes.entry.1.Value.DataType", "Binary");+ params.add("PublishBatchRequestEntries.member.1.MessageAttributes.entry.1.Value.BinaryValue", "@@@-not-base64-@@@");++ // Entry 2: valid — must be published+ putBatchEntry(params, 2, "good", "valid-message", attr("kind", "String", "ok"));++ // Act+ Response response = handler.handle("PublishBatch", params, REGION);++ // Assert — HTTP 200, partial-failure semantics (matches real AWS SNS)+ assertEquals(200, response.getStatus(),+ "PublishBatch must return 200 with per-entry failures, not abort the whole batch");+ String body = (String) response.getEntity();+ assertTrue(body.contains("<Failed>"), "response must contain Failed list");+ assertTrue(body.contains("<Id>bad</Id>"), "bad entry must appear in Failed list");+ assertTrue(body.contains("<Code>InvalidParameterValue</Code>"), "Failed entry must carry InvalidParameterValue code");+ assertTrue(body.contains("<SenderFault>true</SenderFault>"), "Failed entry must carry SenderFault=true");+ assertTrue(body.contains("<Id>good</Id>"), "good entry must appear in Successful list");++ // Good entry must have been delivered to SQS; bad entry must NOT+ List<Message> messages = sqsService.receiveMessage(+ BASE_URL + "/" + ACCOUNT + "/partial-fail-queue", 10, 30, 0, REGION);+ assertEquals(1, messages.size(), "only the valid entry should be delivered");+ assertEquals("valid-message", messages.get(0).getBody());+ }+@Testvoid publishBatch_entryWithoutMessageAttributes_doesNotPolluteOtherEntries() {// Arrange