Light, fluffy, and always free - The AWS Local Emulator alternative
fix(sqs): match AWS queue attribute defaults and MaximumMessageSize range (#3626)
Allen Sanborn1482d45b6ed8
diff --git a/docs/configuration/advanced/application-yml.md b/docs/configuration/advanced/application-yml.mdindex 24d136d4cf..3dd8b01877 100644--- a/docs/configuration/advanced/application-yml.md+++ b/docs/configuration/advanced/application-yml.md@@ -115,7 +115,7 @@ floci:sqs:enabled: truedefault-visibility-timeout: 30 # Seconds- max-message-size: 1048576 # Bytes (1 MB)+ max-message-size: 1048576 # Bytes (1 MiB, the AWS maximum)clear-fifo-deduplication-cache-on-purge: false # When true, PurgeQueue clears SQS FIFO dedup and SNS FIFO topic dedup for topics subscribed to that queues3:diff --git a/docs/configuration/environment-variables.md b/docs/configuration/environment-variables.mdindex 616a4429cd..d31b7f6514 100644--- a/docs/configuration/environment-variables.md+++ b/docs/configuration/environment-variables.md@@ -158,7 +158,7 @@ See [Initialization Hooks](./initialization-hooks.md) for lifecycle phases and s|---|---|---|| `FLOCI_SERVICES_SQS_ENABLED` | `true` | Enable the SQS service || `FLOCI_SERVICES_SQS_DEFAULT_VISIBILITY_TIMEOUT` | `30` | Default message visibility timeout in seconds |-| `FLOCI_SERVICES_SQS_MAX_MESSAGE_SIZE` | `1048576` | Maximum message body size in bytes (1 MB) |+| `FLOCI_SERVICES_SQS_MAX_MESSAGE_SIZE` | `1048576` | Maximum message body size in bytes (1 MiB) || `FLOCI_SERVICES_SQS_CLEAR_FIFO_DEDUPLICATION_CACHE_ON_PURGE` | `false` | Reset the deduplication cache when a FIFO queue is purged |### SNSdiff --git a/docs/services/sqs.md b/docs/services/sqs.mdindex d858c3c78b..c208de3b76 100644--- a/docs/services/sqs.md+++ b/docs/services/sqs.md@@ -92,13 +92,21 @@ aws sqs set-queue-attributes \--endpoint-url $AWS_ENDPOINT_URL```+## Queue Attributes++`GetQueueAttributes` with `--attribute-names All` returns the set AWS returns for a standard queue: `QueueArn`, `CreatedTimestamp`, `LastModifiedTimestamp`, `ApproximateNumberOfMessages`, `ApproximateNumberOfMessagesNotVisible`, `ApproximateNumberOfMessagesDelayed`, `VisibilityTimeout`, `MaximumMessageSize`, `MessageRetentionPeriod`, `DelaySeconds`, `ReceiveMessageWaitTimeSeconds` and `SqsManagedSseEnabled`. `Policy`, `RedrivePolicy` and `KmsMasterKeyId` appear only once set, and FIFO queues also report `FifoQueue` and `ContentBasedDeduplication`.++`MaximumMessageSize` defaults to `1048576` bytes, the AWS default and maximum since August 2025, when AWS raised both from `262144`. `CreateQueue` and `SetQueueAttributes` reject values outside 1024 to 1048576 with `InvalidAttributeValue`; raising `FLOCI_SERVICES_SQS_MAX_MESSAGE_SIZE` above the AWS maximum raises that accepted ceiling with it. Lowering the variable below 1048576 only changes the default a new queue receives: the accepted ceiling stays at the AWS maximum, so a queue can still be set to `1048576` explicitly.++`SqsManagedSseEnabled` is `true` for a queue with no `KmsMasterKeyId`, matching AWS, and `false` once a KMS key is set. It is derived on read rather than stored, so clearing `KmsMasterKeyId` returns the queue to `true`, unless you set `SqsManagedSseEnabled` yourself, in which case your value stands. AWS does not document the cleared-key case crisply, so that behaviour is Floci's choice rather than a copied one.+## Configuration| Variable | Default | Description ||---|---|---|| `FLOCI_SERVICES_SQS_ENABLED` | `true` | Enable or disable the service || `FLOCI_SERVICES_SQS_DEFAULT_VISIBILITY_TIMEOUT` | `30` | Default message visibility timeout (seconds) |-| `FLOCI_SERVICES_SQS_MAX_MESSAGE_SIZE` | `1048576` | Maximum message size in bytes (1 MB) |+| `FLOCI_SERVICES_SQS_MAX_MESSAGE_SIZE` | `1048576` | Maximum message size in bytes (1 MiB) || `FLOCI_SERVICES_SQS_CLEAR_FIFO_DEDUPLICATION_CACHE_ON_PURGE` | `false` | When `true`, `PurgeQueue` also clears the FIFO deduplication cache for the queue and any SNS FIFO topics subscribed to it |## Examplesdiff --git a/src/main/java/io/github/hectorvent/floci/services/sns/SnsService.java b/src/main/java/io/github/hectorvent/floci/services/sns/SnsService.javaindex dd419d2d79..fc1ece88e1 100644--- a/src/main/java/io/github/hectorvent/floci/services/sns/SnsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/sns/SnsService.java@@ -1436,6 +1436,14 @@ public class SnsService implements Resettable, ResourceProvider {sub.getProtocol(), sub.getEndpoint());}} catch (Exception e) {+ // Delivery failures are per-subscriber and never reported to the publisher, which+ // matches AWS. SNS caps a publish at MAX_PUBLISH_SIZE (262144 bytes) while SQS+ // accepts up to 1048576 bytes, so for ordinary text the non-raw sqs envelope stays+ // under the queue limit. That is not a guarantee: the envelope is serialized as+ // JSON, and escaping expands every control character below 0x20 to six bytes, so a+ // publish made largely of them can serialize several times larger and cross the+ // limit. A queue configured with a smaller MaximumMessageSize crosses it more+ // easily still. Either way the message is dropped here.LOG.warnv("Failed to deliver SNS message to {0}: {1}", sub.getEndpoint(), e.getMessage());}}diff --git a/src/main/java/io/github/hectorvent/floci/services/sqs/SqsService.java b/src/main/java/io/github/hectorvent/floci/services/sqs/SqsService.javaindex 3c341ef6b7..3cee5ca85c 100644--- a/src/main/java/io/github/hectorvent/floci/services/sqs/SqsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/sqs/SqsService.java@@ -40,6 +40,10 @@ public class SqsService implements Resettable, ResourceProvider {private static final int MAX_RECEIVE_WAIT_TIME_SECONDS = 20;private static final int MAX_TERMINAL_MOVE_TASKS = 10;private static final Duration TERMINAL_MOVE_TASK_TTL = Duration.ofHours(1);+ /** AWS accepts MaximumMessageSize between 1 KiB and 1 MiB; 1 MiB is also the default.+ * Both the maximum and the default were raised from 256 KiB in August 2025. */+ private static final int MIN_MAXIMUM_MESSAGE_SIZE = 1024;+ private static final int AWS_MAXIMUM_MESSAGE_SIZE = 1048576;private final StorageBackend<String, Queue> queueStore;private final StorageBackend<String, List<Message>> messageStore;@@ -152,6 +156,9 @@ public class SqsService implements Resettable, ResourceProvider {private final int defaultVisibilityTimeout;private final int maxMessageSize;+ /** Upper bound accepted for the MaximumMessageSize attribute. Raising max-message-size above+ * the AWS limit widens this bound so the configured default stays settable explicitly. */+ private final int maxAllowedMessageSize;private final String baseUrl;private final RegionResolver regionResolver;private final boolean clearFifoDeduplicationCacheOnPurge;@@ -228,6 +235,7 @@ public class SqsService implements Resettable, ResourceProvider {this.dedupStore = dedupStore;this.defaultVisibilityTimeout = defaultVisibilityTimeout;this.maxMessageSize = maxMessageSize;+ this.maxAllowedMessageSize = Math.max(AWS_MAXIMUM_MESSAGE_SIZE, maxMessageSize);this.baseUrl = baseUrl;this.regionResolver = regionResolver;this.clearFifoDeduplicationCacheOnPurge = clearFifoDeduplicationCacheOnPurge;@@ -362,6 +370,8 @@ public class SqsService implements Resettable, ResourceProvider {attributes.put("FifoQueue", "true");}+ validateMaximumMessageSize(attributes);+String accountId = regionResolver.getAccountId();String queueUrl = baseUrl + "/" + accountId + "/" + queueName;String storageKey = regionKey(region, queueUrl);@@ -484,6 +494,26 @@ public class SqsService implements Resettable, ResourceProvider {attrs.put("ApproximateNumberOfMessagesNotVisible", String.valueOf(counts.inFlight()));attrs.put("ApproximateNumberOfMessagesDelayed", String.valueOf(counts.delayed()));+ // Derived at read time and never stored, so it cannot go stale behind a+ // KmsMasterKeyId that was later cleared. A KMS key always wins; otherwise an+ // explicit SqsManagedSseEnabled stands, and a queue with neither reports the AWS+ // default. What AWS does with a queue whose KMS key is cleared is not documented+ // crisply, so reverting to the default is a choice, not a copied behaviour.+ if (hasKmsMasterKey(attrs)) {+ attrs.put("SqsManagedSseEnabled", "false");+ } else {+ attrs.putIfAbsent("SqsManagedSseEnabled", "true");+ }+ attrs.putIfAbsent("VisibilityTimeout", String.valueOf(defaultVisibilityTimeout));+ // Report the size that SendMessage actually enforces. A queue stored before the+ // range existed can carry a value above the ceiling, and advertising it would+ // promise a payload the send path then rejects.+ attrs.put("MaximumMessageSize",+ String.valueOf(parseMaxMessageSize(attrs.get("MaximumMessageSize"))));+ attrs.putIfAbsent("DelaySeconds", "0");+ attrs.putIfAbsent("ReceiveMessageWaitTimeSeconds", "0");+ attrs.putIfAbsent("MessageRetentionPeriod", "345600");+if (attributeNames == null || attributeNames.contains("All")) {return attrs;}@@ -649,12 +679,47 @@ public class SqsService implements Resettable, ResourceProvider {return maxMessageSize;}try {- return Math.min(1048576, Math.max(1024, Integer.parseInt(value)));+ return Math.min(maxAllowedMessageSize,+ Math.max(MIN_MAXIMUM_MESSAGE_SIZE, Integer.parseInt(value.trim())));} catch (NumberFormatException ignored) {return maxMessageSize;}}+ /**+ * Reject a MaximumMessageSize outside the range AWS accepts, on CreateQueue and+ * SetQueueAttributes alike. An empty value on SetQueueAttributes resets the attribute+ * and is left to the caller.+ */+ private void validateMaximumMessageSize(Map<String, String> attributes) {+ if (attributes == null) {+ return;+ }+ String value = attributes.get("MaximumMessageSize");+ if (value == null || value.isEmpty()) {+ return;+ }+ int parsed;+ try {+ parsed = Integer.parseInt(value.trim());+ } catch (NumberFormatException ignored) {+ throw invalidMaximumMessageSize();+ }+ if (parsed < MIN_MAXIMUM_MESSAGE_SIZE || parsed > maxAllowedMessageSize) {+ throw invalidMaximumMessageSize();+ }+ }++ private AwsException invalidMaximumMessageSize() {+ return new AwsException("InvalidAttributeValue",+ "Invalid value for the parameter MaximumMessageSize.", 400);+ }++ private static boolean hasKmsMasterKey(Map<String, String> attributes) {+ String keyId = attributes.get("KmsMasterKeyId");+ return keyId != null && !keyId.isEmpty();+ }+/*** Validate that the combined payload of a {@code SendMessageBatch} call fits within* the queue's {@code MaximumMessageSize}. AWS counts the batch limit as the sum of@@ -940,6 +1005,7 @@ public class SqsService implements Resettable, ResourceProvider {Queue queue = queueStore.get(storageKey).orElseThrow(() -> new AwsException("AWS.SimpleQueueService.NonExistentQueue","The specified queue does not exist.", 400));+ validateMaximumMessageSize(attributes);if (attributes != null) {for (Map.Entry<String, String> entry : attributes.entrySet()) {if (entry.getValue() == null || entry.getValue().isEmpty()) {diff --git a/src/test/java/io/github/hectorvent/floci/config/ApplicationDefaultsTest.java b/src/test/java/io/github/hectorvent/floci/config/ApplicationDefaultsTest.javaindex d346385400..0e3694ad97 100644--- a/src/test/java/io/github/hectorvent/floci/config/ApplicationDefaultsTest.java+++ b/src/test/java/io/github/hectorvent/floci/config/ApplicationDefaultsTest.java@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.config;import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.dataformat.yaml.YAMLMapper;+import io.smallrye.config.WithDefault;import org.junit.jupiter.api.Test;import java.io.IOException;@@ -39,6 +40,22 @@ class ApplicationDefaultsTest {"production application.yml should allow 2048 MB request bodies by default");}+ @Test+ void productionConfigUsesTheAwsSqsMaximumMessageSize() throws IOException, NoSuchMethodException {+ JsonNode config = new YAMLMapper().readTree(Path.of("src/main/resources/application.yml").toFile());++ assertEquals(1048576,+ config.path("floci").path("services").path("sqs").path("max-message-size").asInt(),+ "production application.yml should use the AWS SQS maximum of 1048576 bytes");++ WithDefault fallback = EmulatorConfig.SqsServiceConfig.class+ .getMethod("maxMessageSize")+ .getAnnotation(WithDefault.class);+ assertNotNull(fallback, "maxMessageSize should declare a fallback default");+ assertEquals("1048576", fallback.value(),+ "the EmulatorConfig fallback should match the AWS SQS maximum too");+ }+@Testvoid productionConfigDoesNotSeedIamDeployerPrincipalByDefault() throws IOException {JsonNode config = new YAMLMapper().readTree(Path.of("src/main/resources/application.yml").toFile());diff --git a/src/test/java/io/github/hectorvent/floci/services/sqs/SqsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/sqs/SqsIntegrationTest.javaindex fa10100864..af34e10493 100644--- a/src/test/java/io/github/hectorvent/floci/services/sqs/SqsIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/sqs/SqsIntegrationTest.java@@ -4,7 +4,13 @@ import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;import io.quarkus.test.junit.QuarkusTest;import org.junit.jupiter.api.*;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import static io.restassured.RestAssured.given;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.hamcrest.Matchers.*;@@ -754,4 +760,95 @@ class SqsIntegrationTest {.when().post("/");}}++ @Test+ void getQueueAttributesAllReturnsTheAwsAttributeSetForAStandardQueue() {+ String attrQueueUrl = given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateQueue")+ .formParam("QueueName", "query-attribute-defaults-queue")+ .when().post("/").then().statusCode(200)+ .extract().xmlPath().getString("CreateQueueResponse.CreateQueueResult.QueueUrl");++ try {+ Map<String, String> attributes = allQueueAttributes(attrQueueUrl);++ assertEquals("1048576", attributes.get("MaximumMessageSize"),+ "MaximumMessageSize must default to the AWS value of 1048576 bytes");+ assertEquals("true", attributes.get("SqsManagedSseEnabled"),+ "A queue without a KMS key reports SSE-SQS enabled");+ assertEquals("30", attributes.get("VisibilityTimeout"));+ assertEquals("345600", attributes.get("MessageRetentionPeriod"));+ assertEquals("0", attributes.get("DelaySeconds"));+ assertEquals("0", attributes.get("ReceiveMessageWaitTimeSeconds"));+ assertTrue(attributes.containsKey("QueueArn"));+ assertTrue(attributes.containsKey("CreatedTimestamp"));+ assertTrue(attributes.containsKey("LastModifiedTimestamp"));+ assertTrue(attributes.containsKey("ApproximateNumberOfMessages"));+ assertTrue(attributes.containsKey("ApproximateNumberOfMessagesNotVisible"));+ assertTrue(attributes.containsKey("ApproximateNumberOfMessagesDelayed"));+ assertFalse(attributes.containsKey("Policy"),+ "Policy is only returned once set");+ assertFalse(attributes.containsKey("RedrivePolicy"),+ "RedrivePolicy is only returned once set");+ } finally {+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DeleteQueue")+ .formParam("QueueUrl", attrQueueUrl)+ .when().post("/");+ }+ }++ @Test+ void setQueueAttributesRejectsMaximumMessageSizeAboveTheAwsLimit() {+ String limitQueueUrl = given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateQueue")+ .formParam("QueueName", "query-max-message-size-range-queue")+ .when().post("/").then().statusCode(200)+ .extract().xmlPath().getString("CreateQueueResponse.CreateQueueResult.QueueUrl");++ try {+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "SetQueueAttributes")+ .formParam("QueueUrl", limitQueueUrl)+ .formParam("Attribute.1.Name", "MaximumMessageSize")+ .formParam("Attribute.1.Value", "1048577")+ .when().post("/").then()+ .statusCode(400)+ .body(containsString("<Code>InvalidAttributeValue</Code>"));++ assertEquals("1048576", allQueueAttributes(limitQueueUrl).get("MaximumMessageSize"),+ "A rejected SetQueueAttributes must leave the stored value untouched");+ } finally {+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DeleteQueue")+ .formParam("QueueUrl", limitQueueUrl)+ .when().post("/");+ }+ }++ private static Map<String, String> allQueueAttributes(String url) {+ var xml = given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "GetQueueAttributes")+ .formParam("QueueUrl", url)+ .formParam("AttributeName.1", "All")+ .when().post("/").then()+ .statusCode(200)+ .extract().xmlPath();++ List<String> names = xml.getList(+ "GetQueueAttributesResponse.GetQueueAttributesResult.Attribute.Name", String.class);+ List<String> values = xml.getList(+ "GetQueueAttributesResponse.GetQueueAttributesResult.Attribute.Value", String.class);+ Map<String, String> attributes = new LinkedHashMap<>();+ for (int i = 0; i < names.size(); i++) {+ attributes.put(names.get(i), values.get(i));+ }+ return attributes;+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/sqs/SqsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/sqs/SqsServiceTest.javaindex f2d30c791e..a7fc809f47 100644--- a/src/test/java/io/github/hectorvent/floci/services/sqs/SqsServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/sqs/SqsServiceTest.java@@ -65,6 +65,192 @@ class SqsServiceTest {assertEquals("60", queue.getAttributes().get("VisibilityTimeout"));}+ @Test+ void getQueueAttributes_defaultsMatchAws() {+ String region = "eu-west-1";+ Queue queue = sqsService.createQueue("defaults-queue", null, region);++ Map<String, String> attrs = sqsService.getQueueAttributes(queue.getQueueUrl(), List.of("All"), region);+ assertEquals("1048576", attrs.get("MaximumMessageSize"),+ "MaximumMessageSize must default to the AWS value of 1048576 bytes");+ assertEquals("true", attrs.get("SqsManagedSseEnabled"),+ "A queue without a KMS key reports SSE-SQS enabled");+ assertEquals("30", attrs.get("VisibilityTimeout"));+ assertEquals("345600", attrs.get("MessageRetentionPeriod"));+ assertEquals("0", attrs.get("DelaySeconds"));+ assertEquals("0", attrs.get("ReceiveMessageWaitTimeSeconds"));+ assertNotNull(attrs.get("QueueArn"));+ assertNotNull(attrs.get("CreatedTimestamp"));+ assertNotNull(attrs.get("LastModifiedTimestamp"));+ assertNotNull(attrs.get("ApproximateNumberOfMessages"));+ assertNotNull(attrs.get("ApproximateNumberOfMessagesNotVisible"));+ assertNotNull(attrs.get("ApproximateNumberOfMessagesDelayed"));+ assertFalse(attrs.containsKey("Policy"), "Policy is only returned once set");+ assertFalse(attrs.containsKey("RedrivePolicy"), "RedrivePolicy is only returned once set");+ }++ @Test+ void getQueueAttributes_sqsManagedSseDisabledWhenKmsKeyIsSet() {+ String region = "eu-west-1";+ Queue queue = sqsService.createQueue("kms-queue", null, region);+ sqsService.setQueueAttributes(queue.getQueueUrl(),+ Map.of("KmsMasterKeyId", "alias/aws/sqs"), region);++ Map<String, String> attrs = sqsService.getQueueAttributes(queue.getQueueUrl(), List.of("All"), region);+ assertEquals("false", attrs.get("SqsManagedSseEnabled"),+ "A KMS master key takes over from SSE-SQS");+ }++ @Test+ void getQueueAttributes_sqsManagedSseDisabledWhenQueueIsCreatedWithAKmsKey() {+ String region = "eu-west-1";+ Queue queue = sqsService.createQueue("kms-at-create-queue",+ Map.of("KmsMasterKeyId", "alias/aws/sqs"), region);++ assertEquals("false",+ sqsService.getQueueAttributes(queue.getQueueUrl(), List.of("All"), region)+ .get("SqsManagedSseEnabled"));+ }++ @Test+ void getQueueAttributes_sqsManagedSseReturnsToTheDefaultWhenTheKmsKeyIsCleared() {+ String region = "eu-west-1";+ Queue queue = sqsService.createQueue("kms-cleared-queue",+ Map.of("KmsMasterKeyId", "alias/aws/sqs"), region);+ assertEquals("false",+ sqsService.getQueueAttributes(queue.getQueueUrl(), List.of("All"), region)+ .get("SqsManagedSseEnabled"));++ sqsService.setQueueAttributes(queue.getQueueUrl(), Map.of("KmsMasterKeyId", ""), region);++ Map<String, String> attrs = sqsService.getQueueAttributes(queue.getQueueUrl(), List.of("All"), region);+ assertFalse(attrs.containsKey("KmsMasterKeyId"), "An empty value clears the attribute");+ assertEquals("true", attrs.get("SqsManagedSseEnabled"),+ "Nothing derived from the KMS key may outlive it");+ }++ @Test+ void getQueueAttributes_explicitSqsManagedSseFalseSurvivesAnUnrelatedUpdate() {+ String region = "eu-west-1";+ Queue queue = sqsService.createQueue("sse-off-queue",+ Map.of("SqsManagedSseEnabled", "false"), region);+ sqsService.setQueueAttributes(queue.getQueueUrl(), Map.of("DelaySeconds", "5"), region);++ Map<String, String> attrs = sqsService.getQueueAttributes(queue.getQueueUrl(), List.of("All"), region);+ assertEquals("false", attrs.get("SqsManagedSseEnabled"),+ "A value the user set is intent, not derived state, and has to survive");+ assertEquals("5", attrs.get("DelaySeconds"));+ }++ @Test+ void getQueueAttributes_selectsSqsManagedSseEnabledByName() {+ String region = "eu-west-1";+ Queue queue = sqsService.createQueue("sse-named-queue", null, region);++ Map<String, String> attrs = sqsService.getQueueAttributes(queue.getQueueUrl(),+ List.of("SqsManagedSseEnabled"), region);+ assertEquals(Map.of("SqsManagedSseEnabled", "true"), attrs);+ }++ @Test+ void createQueue_rejectsMaximumMessageSizeOutsideAwsRange() {+ for (String invalid : List.of("1048577", "1023", "0", "-1", "abc")) {+ AwsException ex = assertThrows(AwsException.class,+ () -> sqsService.createQueue("range-queue-" + invalid,+ Map.of("MaximumMessageSize", invalid), "eu-west-1"),+ "MaximumMessageSize " + invalid + " must be rejected");+ assertEquals("InvalidAttributeValue", ex.getErrorCode());+ assertTrue(ex.getMessage().contains("MaximumMessageSize"), ex.getMessage());+ }+ }++ @Test+ void createQueue_acceptsMaximumMessageSizeRangeBounds() {+ String region = "eu-west-1";+ for (String valid : List.of("1024", "1048576")) {+ Queue queue = sqsService.createQueue("bounds-queue-" + valid,+ Map.of("MaximumMessageSize", valid), region);+ assertEquals(valid,+ sqsService.getQueueAttributes(queue.getQueueUrl(), List.of("MaximumMessageSize"), region)+ .get("MaximumMessageSize"));+ }+ }++ @Test+ void createQueue_acceptsTheAwsCeilingWhenTheConfiguredMaximumIsLower() {+ String region = "eu-west-1";+ var service = new SqsService(new InMemoryStorage<>(), 30, 131072, BASE_URL, clock);++ Queue defaulted = service.createQueue("lowered-config-default-queue", null, region);+ assertEquals("131072",+ service.getQueueAttributes(defaulted.getQueueUrl(), List.of("MaximumMessageSize"), region)+ .get("MaximumMessageSize"),+ "The configured maximum is what a new queue defaults to");++ Queue raised = service.createQueue("lowered-config-raised-queue",+ Map.of("MaximumMessageSize", "1048576"), region);+ assertEquals("1048576",+ service.getQueueAttributes(raised.getQueueUrl(), List.of("MaximumMessageSize"), region)+ .get("MaximumMessageSize"),+ "Lowering the configured maximum moves the default, not the ceiling AWS accepts");+ assertDoesNotThrow(+ () -> service.sendMessage(raised.getQueueUrl(), "x".repeat(1_000_000), 0, region),+ "The accepted ceiling and the enforced ceiling have to agree");+ }++ @Test+ void getQueueAttributes_clampsAStoredMaximumMessageSizeAboveTheCeiling() {+ String region = "us-east-1";+ var store = new InMemoryStorage<String, Queue>();+ var service = new SqsService(store, 30, 1048576, BASE_URL, clock);+ Queue queue = service.createQueue("legacy-size-queue", null, region);++ // A queue persisted by a build that allowed 2 MB, which no validation path can produce.+ String storageKey = store.keys().iterator().next();+ Queue stored = store.get(storageKey).orElseThrow();+ stored.getAttributes().put("MaximumMessageSize", "2097152");+ store.put(storageKey, stored);++ assertEquals("1048576",+ service.getQueueAttributes(queue.getQueueUrl(), List.of("MaximumMessageSize"), region)+ .get("MaximumMessageSize"),+ "A stored value above the ceiling must be reported as the size actually enforced");+ AwsException ex = assertThrows(AwsException.class,+ () -> service.sendMessage(queue.getQueueUrl(), "x".repeat(1_200_000), 0, region),+ "The reported size and the enforced size have to agree");+ assertTrue(ex.getMessage().contains("1048576"), ex.getMessage());+ }++ @Test+ void setQueueAttributes_rejectsMaximumMessageSizeOutsideAwsRange() {+ String region = "eu-west-1";+ Queue queue = sqsService.createQueue("set-range-queue", null, region);++ AwsException ex = assertThrows(AwsException.class,+ () -> sqsService.setQueueAttributes(queue.getQueueUrl(),+ Map.of("MaximumMessageSize", "1048577"), region));+ assertEquals("InvalidAttributeValue", ex.getErrorCode());+ assertEquals("1048576",+ sqsService.getQueueAttributes(queue.getQueueUrl(), List.of("MaximumMessageSize"), region)+ .get("MaximumMessageSize"),+ "A rejected SetQueueAttributes must leave the stored value untouched");+ }++ @Test+ void setQueueAttributes_acceptsMaximumMessageSizeWithinAwsRange() {+ String region = "eu-west-1";+ Queue queue = sqsService.createQueue("set-valid-range-queue", null, region);+ sqsService.setQueueAttributes(queue.getQueueUrl(),+ Map.of("MaximumMessageSize", "2048"), region);++ assertEquals("2048",+ sqsService.getQueueAttributes(queue.getQueueUrl(), List.of("MaximumMessageSize"), region)+ .get("MaximumMessageSize"));+ AwsException ex = assertThrows(AwsException.class,+ () -> sqsService.sendMessage(queue.getQueueUrl(), "x".repeat(3000), 0, region));+ assertTrue(ex.getMessage().contains("2048"), ex.getMessage());+ }+@Testvoid createQueueWithTags_tagsReturnedByListQueueTags() {// Regression test for https://github.com/floci-io/floci/issues/699