Light, fluffy, and always free - The AWS Local Emulator alternative
feat(rds): manage event notification subscriptions (#4332)
lex0009dcbabe2b5c
diff --git a/docs/services/rds.md b/docs/services/rds.mdindex 357335851c..1e6a724761 100644--- a/docs/services/rds.md+++ b/docs/services/rds.md@@ -29,6 +29,10 @@ RDS Data API (`rds-data`) is documented separately because it uses REST JSON rou| `PromoteReadReplicaDBCluster` | Refused with `InvalidDBClusterStateFault`: no cluster is created as a replica of an instance || `DescribeOrderableDBInstanceOptions` | List deterministic instance class options || `DescribeEvents` | - |+| `CreateEventSubscription` | Create an event notification subscription (stored, nothing is published) |+| `DescribeEventSubscriptions` | List subscriptions, or the one the request names |+| `ModifyEventSubscription` | Update the members the request names |+| `DeleteEventSubscription` | Delete a subscription || `CreateDBSubnetGroup` | Create a DB subnet group; tags given here are readable through `ListTagsForResource` || `DescribeDBSubnetGroups` | List DB subnet groups || `ModifyDBSubnetGroup` | Update DB subnet group description and subnet list |@@ -135,6 +139,16 @@ checked against the instance's other window. Modifications apply immediately —`arn:aws:rds:<region>:<account>:cluster-snapshot:<name>`. RDS reserved instances aren'tmodeled (there's no reserved-instance API), so tagging doesn't apply to them.+## Event notification subscriptions++The four subscription actions manage the resource itself. **Nothing is published to the topic.**+A subscription is stored and reported back so a client can manage it. No RDS event reaches SNS+through it, so an SNS subscriber sees nothing.++`SnsTopicArn` is required and is not resolved against the SNS service. `SourceType` is checked+against the model's valid values, and a request naming `SourceIds` must also name the `SourceType`+they belong to, as the model requires. An omitted `Enabled` activates the subscription.+## Configuration| Variable | Default | Description |diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.javaindex 5b739a38fa..2807553467 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java@@ -14,6 +14,7 @@ import io.github.hectorvent.floci.services.rds.model.DbEndpoint;import io.github.hectorvent.floci.services.docdb.DocDbQueryHandler;import io.github.hectorvent.floci.services.neptune.NeptuneQueryHandler;import io.github.hectorvent.floci.services.rds.model.DbInstance;+import io.github.hectorvent.floci.services.rds.model.EventSubscription;import io.github.hectorvent.floci.services.rds.model.DbInstanceScalingChanges;import io.github.hectorvent.floci.services.rds.model.DbInstanceSettings;import io.github.hectorvent.floci.services.rds.model.LogExportChanges;@@ -90,6 +91,10 @@ public class RdsQueryHandler {case "PromoteReadReplicaDBCluster" -> handlePromoteReadReplicaDbCluster(params, region);case "DescribeOrderableDBInstanceOptions" -> handleDescribeOrderableDbInstanceOptions(params);case "DescribeEvents" -> handleDescribeEvents(params, region);+ case "CreateEventSubscription" -> handleCreateEventSubscription(params, region);+ case "DescribeEventSubscriptions" -> handleDescribeEventSubscriptions(params, region);+ case "ModifyEventSubscription" -> handleModifyEventSubscription(params, region);+ case "DeleteEventSubscription" -> handleDeleteEventSubscription(params, region);case "CreateDBSubnetGroup" -> handleCreateDbSubnetGroup(params, region);case "DescribeDBSubnetGroups" -> handleDescribeDbSubnetGroups(params, region);case "ModifyDBSubnetGroup" -> handleModifyDbSubnetGroup(params, region);@@ -277,6 +282,81 @@ public class RdsQueryHandler {}}+ // ── Event notification subscriptions ────────────────────────────────────++ private Response handleCreateEventSubscription(MultivaluedMap<String, String> params, String region) {+ EventSubscription subscription = service.createEventSubscription(region,+ params.getFirst("SubscriptionName"),+ params.getFirst("SnsTopicArn"),+ params.getFirst("SourceType"),+ memberList(params, "SourceIds"),+ memberList(params, "EventCategories"),+ optionalBoolean(params.getFirst("Enabled")),+ parseTags(params));+ return Response.ok(AwsQueryResponse.envelope("CreateEventSubscription", AwsNamespaces.RDS,+ new XmlBuilder().raw(eventSubscriptionXml(subscription)).build())).build();+ }++ private Response handleModifyEventSubscription(MultivaluedMap<String, String> params, String region) {+ EventSubscription subscription = service.modifyEventSubscription(region,+ params.getFirst("SubscriptionName"),+ params.getFirst("SnsTopicArn"),+ params.getFirst("SourceType"),+ memberList(params, "EventCategories"),+ optionalBoolean(params.getFirst("Enabled")));+ return Response.ok(AwsQueryResponse.envelope("ModifyEventSubscription", AwsNamespaces.RDS,+ new XmlBuilder().raw(eventSubscriptionXml(subscription)).build())).build();+ }++ private Response handleDeleteEventSubscription(MultivaluedMap<String, String> params, String region) {+ EventSubscription subscription = service.deleteEventSubscription(region,+ params.getFirst("SubscriptionName"));+ return Response.ok(AwsQueryResponse.envelope("DeleteEventSubscription", AwsNamespaces.RDS,+ new XmlBuilder().raw(eventSubscriptionXml(subscription)).build())).build();+ }++ private Response handleDescribeEventSubscriptions(MultivaluedMap<String, String> params, String region) {+ RdsService.EventSubscriptionPage page = service.describeEventSubscriptions(region,+ params.getFirst("SubscriptionName"),+ optionalInt(params.getFirst("MaxRecords")),+ params.getFirst("Marker"));+ XmlBuilder xml = new XmlBuilder().start("EventSubscriptionsList");+ for (EventSubscription subscription : page.subscriptions()) {+ xml.raw(eventSubscriptionXml(subscription));+ }+ xml.end("EventSubscriptionsList");+ if (page.marker() != null) {+ xml.elem("Marker", page.marker());+ }+ return Response.ok(AwsQueryResponse.envelope("DescribeEventSubscriptions", AwsNamespaces.RDS,+ xml.build())).build();+ }++ private static String eventSubscriptionXml(EventSubscription s) {+ XmlBuilder xml = new XmlBuilder().start("EventSubscription")+ .elem("CustomerAwsId", s.getCustomerAwsId())+ .elem("CustSubscriptionId", s.getCustSubscriptionId())+ .elem("SnsTopicArn", s.getSnsTopicArn())+ .elem("Status", s.getStatus())+ .elem("SubscriptionCreationTime", s.getSubscriptionCreationTime())+ .elem("Enabled", String.valueOf(s.isEnabled()))+ .elem("EventSubscriptionArn", s.getEventSubscriptionArn());+ if (s.getSourceType() != null) {+ xml.elem("SourceType", s.getSourceType());+ }+ xml.start("SourceIdsList");+ for (String id : s.getSourceIdsList()) {+ xml.elem("SourceId", id);+ }+ xml.end("SourceIdsList");+ xml.start("EventCategoriesList");+ for (String category : s.getEventCategoriesList()) {+ xml.elem("EventCategory", category);+ }+ xml.end("EventCategoriesList");+ return xml.end("EventSubscription").build();+ }+private Response handleDescribeEvents(MultivaluedMap<String, String> params, String region) {String sourceIdentifier = params.getFirst("SourceIdentifier");String sourceType = params.getFirst("SourceType");diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.javaindex 7424bbbcce..65dbbfe465 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java@@ -35,6 +35,7 @@ import io.github.hectorvent.floci.services.rds.model.DbClusterParameterGroup;import io.github.hectorvent.floci.services.rds.model.DbClusterSnapshot;import io.github.hectorvent.floci.services.rds.model.DbEndpoint;import io.github.hectorvent.floci.services.rds.model.DbInstance;+import io.github.hectorvent.floci.services.rds.model.EventSubscription;import io.github.hectorvent.floci.services.kms.KmsService;import io.github.hectorvent.floci.services.kms.model.KmsKey;import io.github.hectorvent.floci.services.rds.model.DbInstanceScalingChanges;@@ -167,6 +168,7 @@ public class RdsService implements Resettable, ResourceProvider {private final StorageBackend<String, GlobalCluster> globalClusters;private final StorageBackend<String, String> snapshotData;private StorageBackend<String, RdsEvent> events = new InMemoryStorage<>();+ private final StorageBackend<String, EventSubscription> eventSubscriptions;private final RdsContainerManager containerManager;private final RdsProxyManager proxyManager;// CreateDBCluster/CreateDBInstance register the new resource only after the@@ -237,6 +239,8 @@ public class RdsService implements Resettable, ResourceProvider {this.metricsService = metricsService;this.instances = storageFactory.create("rds", "rds-instances.json",new TypeReference<Map<String, DbInstance>>() {});+ this.eventSubscriptions = storageFactory.create("rds", "rds-event-subscriptions.json",+ new TypeReference<Map<String, EventSubscription>>() {});this.clusters = storageFactory.create("rds", "rds-clusters.json",new TypeReference<Map<String, DbCluster>>() {});this.parameterGroups = storageFactory.create("rds", "rds-parameter-groups.json",@@ -397,6 +401,7 @@ public class RdsService implements Resettable, ResourceProvider {this.snapshots = new io.github.hectorvent.floci.core.storage.InMemoryStorage<>();this.clusterSnapshots = new InMemoryStorage<>();this.snapshotData = new io.github.hectorvent.floci.core.storage.InMemoryStorage<>();+ this.eventSubscriptions = new InMemoryStorage<>();}public void restorePersistedRuntime() {@@ -1960,6 +1965,16 @@ public class RdsService implements Resettable, ResourceProvider {putSnapshotForScope(currentAccountId(), effectiveRegion, resourceId, snapshot);});}+ case "es" -> {+ EventSubscription subscription = eventSubscriptions+ .get(eventSubscriptionKey(effectiveRegion, resourceId))+ .orElseThrow(() -> new AwsException("SubscriptionNotFound",+ "Subscription " + resourceId + " not found.", 404));+ yield new TagHandle(subscription.getTags(), updated -> {+ subscription.setTags(updated);+ eventSubscriptions.put(eventSubscriptionKey(effectiveRegion, resourceId), subscription);+ });+ }case "db-proxy" -> {DbProxy proxy = proxies.scan(k -> true).stream().filter(candidate -> effectiveRegion.equals(regionFromArn(candidate.getDbProxyArn())))@@ -8473,4 +8488,159 @@ public class RdsService implements Resettable, ResourceProvider {new SupportedResourceType("rds:db", "rds", true),new SupportedResourceType("rds:cluster", "rds", true));}+ // ── Event notification subscriptions ────────────────────────────────────++ /** The model's SourceType valid values. */+ private static final Set<String> EVENT_SOURCE_TYPES = Set.of(+ "db-instance", "db-cluster", "db-parameter-group", "db-security-group", "db-snapshot",+ "db-cluster-snapshot", "db-proxy", "zero-etl", "custom-engine-version",+ "blue-green-deployment");+ private static final int MAX_SUBSCRIPTION_NAME = 255;+ /** The model documents MaxRecords as minimum 20, maximum 100, default 100. */+ private static final int MIN_MAX_RECORDS = 20;+ private static final int MAX_MAX_RECORDS = 100;+ private static final int DEFAULT_MAX_RECORDS = 100;++ /**+ * Nothing is published to the topic. The subscription is stored and reported back so a client+ * can manage it, and no RDS event reaches SNS through it.+ */+ public synchronized EventSubscription createEventSubscription(String region, String subscriptionName,+ String snsTopicArn, String sourceType,+ List<String> sourceIds,+ List<String> eventCategories, Boolean enabled,+ Map<String, String> tags) {+ if (subscriptionName == null || subscriptionName.isBlank()) {+ throw new AwsException("InvalidParameterValue", "SubscriptionName is required.", 400);+ }+ if (subscriptionName.length() >= MAX_SUBSCRIPTION_NAME) {+ throw new AwsException("InvalidParameterValue",+ "SubscriptionName must be less than " + MAX_SUBSCRIPTION_NAME + " characters.", 400);+ }+ if (snsTopicArn == null || snsTopicArn.isBlank()) {+ throw new AwsException("SNSTopicArnNotFound",+ "SnsTopicArn is required and must name an existing topic.", 404);+ }+ if (sourceType != null && !EVENT_SOURCE_TYPES.contains(sourceType)) {+ throw new AwsException("InvalidParameterValue",+ "SourceType must be one of " + EVENT_SOURCE_TYPES + ".", 400);+ }+ // CreateEventSubscriptionMessage.SourceIds carries the coupling in its own member+ // documentation, not in the operation's: "Constraints: If SourceIds are supplied,+ // SourceType must also be provided." The operation docs walk through both specified,+ // SourceType alone, and neither, and never mention SourceIds alone, so the member doc is+ // the only place it is stated.+ if (sourceIds != null && !sourceIds.isEmpty() && (sourceType == null || sourceType.isBlank())) {+ throw new AwsException("InvalidParameterCombination",+ "SourceType must be provided when SourceIds are supplied.", 400);+ }+ String key = eventSubscriptionKey(region, subscriptionName);+ if (eventSubscriptions.get(key).isPresent()) {+ throw new AwsException("SubscriptionAlreadyExist",+ "Subscription " + subscriptionName + " already exists.", 400);+ }+ String accountId = regionResolver.getAccountId();+ EventSubscription subscription = new EventSubscription();+ subscription.setCustomerAwsId(accountId);+ subscription.setCustSubscriptionId(subscriptionName);+ subscription.setSnsTopicArn(snsTopicArn);+ subscription.setStatus("active");+ subscription.setSubscriptionCreationTime(Instant.now().toString());+ subscription.setSourceType(sourceType);+ subscription.setSourceIdsList(sourceIds == null ? new ArrayList<>() : new ArrayList<>(sourceIds));+ subscription.setEventCategoriesList(+ eventCategories == null ? new ArrayList<>() : new ArrayList<>(eventCategories));+ // The model documents the subscription as created but inactive when Enabled is false, and+ // says nothing about a default, so an omitted Enabled activates it as the console does.+ subscription.setEnabled(enabled == null || enabled);+ subscription.setEventSubscriptionArn(AwsArnUtils.Arn.of("rds", region, accountId,+ "es:" + subscriptionName).toString());+ subscription.setTags(tags == null ? new LinkedHashMap<>() : new LinkedHashMap<>(tags));+ eventSubscriptions.put(key, subscription);+ return subscription;+ }++ /** ModifyEventSubscription applies only the members the request names. */+ public synchronized EventSubscription modifyEventSubscription(String region, String subscriptionName,+ String snsTopicArn, String sourceType,+ List<String> eventCategories, Boolean enabled) {+ EventSubscription subscription = requireEventSubscription(region, subscriptionName);+ // Validated before anything is applied. The store hands back the live instance, so setting+ // the topic first would leave it written when a later member is rejected, and a describe+ // would report a change the request was answered 400 for.+ if (sourceType != null && !sourceType.isBlank() && !EVENT_SOURCE_TYPES.contains(sourceType)) {+ throw new AwsException("InvalidParameterValue",+ "SourceType must be one of " + EVENT_SOURCE_TYPES + ".", 400);+ }+ if (snsTopicArn != null && !snsTopicArn.isBlank()) {+ subscription.setSnsTopicArn(snsTopicArn);+ }+ if (sourceType != null && !sourceType.isBlank()) {+ subscription.setSourceType(sourceType);+ }+ if (eventCategories != null && !eventCategories.isEmpty()) {+ subscription.setEventCategoriesList(new ArrayList<>(eventCategories));+ }+ if (enabled != null) {+ subscription.setEnabled(enabled);+ }+ eventSubscriptions.put(eventSubscriptionKey(region, subscriptionName), subscription);+ return subscription;+ }++ public synchronized EventSubscription deleteEventSubscription(String region, String subscriptionName) {+ EventSubscription subscription = requireEventSubscription(region, subscriptionName);+ eventSubscriptions.delete(eventSubscriptionKey(region, subscriptionName));+ return subscription;+ }++ /** Every subscription in the region, or the one the request names. */+ /** One page of subscriptions, plus the marker to continue from, or null at the end. */+ public record EventSubscriptionPage(List<EventSubscription> subscriptions, String marker) {}++ public synchronized EventSubscriptionPage describeEventSubscriptions(+ String region, String subscriptionName, Integer maxRecords, String marker) {+ // Ahead of the named-subscription shortcut, so a bad page size is rejected whether or not+ // the request also names a subscription. Request validation does not depend on which branch+ // serves the read.+ if (maxRecords != null && (maxRecords < MIN_MAX_RECORDS || maxRecords > MAX_MAX_RECORDS)) {+ throw new AwsException("InvalidParameterValue",+ "MaxRecords must be between " + MIN_MAX_RECORDS + " and " + MAX_MAX_RECORDS + ".", 400);+ }+ if (subscriptionName != null && !subscriptionName.isBlank()) {+ return new EventSubscriptionPage(+ List.of(requireEventSubscription(region, subscriptionName)), null);+ }+ String prefix = eventSubscriptionKey(region, "");+ List<EventSubscription> all = eventSubscriptions.scan(k -> k.startsWith(prefix)).stream()+ .sorted(Comparator.comparing(EventSubscription::getCustSubscriptionId))+ .toList();+ // The marker is the last name of the previous page and the next page starts after it.+ // Resuming at the first name strictly greater than the marker rather than at the marker's+ // own index means a subscription deleted between calls does not restart the walk, which an+ // exact-match lookup would do by silently leaving the offset at zero.+ int from = 0;+ if (marker != null && !marker.isBlank()) {+ while (from < all.size() && all.get(from).getCustSubscriptionId().compareTo(marker) <= 0) {+ from++;+ }+ }+ int limit = maxRecords == null ? DEFAULT_MAX_RECORDS : maxRecords;+ int to = Math.min(all.size(), from + limit);+ List<EventSubscription> page = all.subList(Math.min(from, all.size()), to);+ String next = to < all.size() && !page.isEmpty()+ ? page.get(page.size() - 1).getCustSubscriptionId() : null;+ return new EventSubscriptionPage(page, next);+ }++ private EventSubscription requireEventSubscription(String region, String subscriptionName) {+ return eventSubscriptions.get(eventSubscriptionKey(region, subscriptionName))+ .orElseThrow(() -> new AwsException("SubscriptionNotFound",+ "Subscription " + subscriptionName + " not found.", 404));+ }++ private static String eventSubscriptionKey(String region, String subscriptionName) {+ return "es::" + region + "::" + subscriptionName;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/model/EventSubscription.java b/src/main/java/io/github/hectorvent/floci/services/rds/model/EventSubscription.javanew file mode 100644index 0000000000..aad0585cd7--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/rds/model/EventSubscription.java@@ -0,0 +1,54 @@+package io.github.hectorvent.floci.services.rds.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++/** An RDS event notification subscription, as DescribeEventSubscriptions reports it. */+@RegisterForReflection+public class EventSubscription {++ private String customerAwsId;+ private String custSubscriptionId;+ private String snsTopicArn;+ private String status;+ private String subscriptionCreationTime;+ private String sourceType;+ private List<String> sourceIdsList = new ArrayList<>();+ private List<String> eventCategoriesList = new ArrayList<>();+ private boolean enabled;+ private String eventSubscriptionArn;+ private Map<String, String> tags = new LinkedHashMap<>();++ public String getCustomerAwsId() { return customerAwsId; }+ public void setCustomerAwsId(String customerAwsId) { this.customerAwsId = customerAwsId; }+ public String getCustSubscriptionId() { return custSubscriptionId; }+ public void setCustSubscriptionId(String custSubscriptionId) { this.custSubscriptionId = custSubscriptionId; }+ public String getSnsTopicArn() { return snsTopicArn; }+ public void setSnsTopicArn(String snsTopicArn) { this.snsTopicArn = snsTopicArn; }+ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }+ public String getSubscriptionCreationTime() { return subscriptionCreationTime; }+ public void setSubscriptionCreationTime(String subscriptionCreationTime) {+ this.subscriptionCreationTime = subscriptionCreationTime;+ }+ public String getSourceType() { return sourceType; }+ public void setSourceType(String sourceType) { this.sourceType = sourceType; }+ public List<String> getSourceIdsList() { return sourceIdsList; }+ public void setSourceIdsList(List<String> sourceIdsList) { this.sourceIdsList = sourceIdsList; }+ public List<String> getEventCategoriesList() { return eventCategoriesList; }+ public void setEventCategoriesList(List<String> eventCategoriesList) {+ this.eventCategoriesList = eventCategoriesList;+ }+ public boolean isEnabled() { return enabled; }+ public void setEnabled(boolean enabled) { this.enabled = enabled; }+ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) { this.tags = tags; }+ public String getEventSubscriptionArn() { return eventSubscriptionArn; }+ public void setEventSubscriptionArn(String eventSubscriptionArn) {+ this.eventSubscriptionArn = eventSubscriptionArn;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsEventSubscriptionIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsEventSubscriptionIntegrationTest.javanew file mode 100644index 0000000000..6bd1cccd26--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsEventSubscriptionIntegrationTest.java@@ -0,0 +1,231 @@+package io.github.hectorvent.floci.services.rds;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.Test;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.not;+import static org.junit.jupiter.api.Assertions.assertNotNull;++/** Create, Describe, Modify and Delete for an RDS event notification subscription. */+@QuarkusTest+class RdsEventSubscriptionIntegrationTest {++ private static final String TOPIC = "arn:aws:sns:us-east-1:000000000000:rds-events";++ private static ValidatableResponse rds(String action, String... formParams) {+ RequestSpecification request = given()+ .header("Authorization", "AWS4-HMAC-SHA256 Credential=test/20260615/us-east-1/rds/aws4_request, "+ + "SignedHeaders=content-type;host, Signature=test")+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", action)+ .formParam("Version", "2014-10-31");+ for (int i = 0; i < formParams.length; i += 2) {+ request = request.formParam(formParams[i], formParams[i + 1]);+ }+ return request.when().post("/").then();+ }++ private static String name(String prefix) {+ return prefix + "-" + Long.toString(System.nanoTime(), 36);+ }++ @Test+ void createDescribeModifyAndDelete() {+ String subscription = name("sub");+ rds("CreateEventSubscription",+ "SubscriptionName", subscription,+ "SnsTopicArn", TOPIC,+ "SourceType", "db-instance",+ "SourceIds.member.1", "db-one",+ "EventCategories.member.1", "availability")+ .statusCode(200)+ .body("CreateEventSubscriptionResponse.CreateEventSubscriptionResult.EventSubscription.CustSubscriptionId",+ equalTo(subscription))+ .body("CreateEventSubscriptionResponse.CreateEventSubscriptionResult.EventSubscription.Status",+ equalTo("active"))+ .body("CreateEventSubscriptionResponse.CreateEventSubscriptionResult.EventSubscription.Enabled",+ equalTo("true"))+ .body("CreateEventSubscriptionResponse.CreateEventSubscriptionResult.EventSubscription.SourceIdsList.SourceId",+ equalTo("db-one"))+ .body("CreateEventSubscriptionResponse.CreateEventSubscriptionResult.EventSubscription.EventSubscriptionArn",+ containsString(":es:" + subscription));++ rds("DescribeEventSubscriptions", "SubscriptionName", subscription)+ .statusCode(200)+ .body(containsString("<CustSubscriptionId>" + subscription + "</CustSubscriptionId>"));++ rds("ModifyEventSubscription", "SubscriptionName", subscription, "Enabled", "false")+ .statusCode(200)+ .body("ModifyEventSubscriptionResponse.ModifyEventSubscriptionResult.EventSubscription.Enabled",+ equalTo("false"))+ // SourceType was not named, so it survives the modify.+ .body("ModifyEventSubscriptionResponse.ModifyEventSubscriptionResult.EventSubscription.SourceType",+ equalTo("db-instance"));++ rds("DeleteEventSubscription", "SubscriptionName", subscription).statusCode(200);+ rds("DescribeEventSubscriptions", "SubscriptionName", subscription).statusCode(404);+ }++ @Test+ void aRejectedModifyChangesNothing() {+ String subscription = name("atomic");+ rds("CreateEventSubscription", "SubscriptionName", subscription, "SnsTopicArn", TOPIC,+ "SourceType", "db-instance").statusCode(200);++ // Valid SnsTopicArn, invalid SourceType. The topic must not survive the 400.+ rds("ModifyEventSubscription", "SubscriptionName", subscription,+ "SnsTopicArn", "arn:aws:sns:us-east-1:000000000000:other", "SourceType", "db-widget")+ .statusCode(400);++ rds("DescribeEventSubscriptions", "SubscriptionName", subscription)+ .statusCode(200)+ .body(containsString("<SnsTopicArn>" + TOPIC + "</SnsTopicArn>"))+ .body(not(containsString("rds-events-other")));+ }++ @Test+ void tagsGivenAtCreateAreReadableThroughListTagsForResource() {+ String subscription = name("tagged");+ String arn = rds("CreateEventSubscription", "SubscriptionName", subscription,+ "SnsTopicArn", TOPIC, "Tags.Tag.1.Key", "team", "Tags.Tag.1.Value", "platform")+ .statusCode(200)+ .extract().path("CreateEventSubscriptionResponse.CreateEventSubscriptionResult"+ + ".EventSubscription.EventSubscriptionArn");++ rds("ListTagsForResource", "ResourceName", arn)+ .statusCode(200)+ .body(containsString("<Key>team</Key>"))+ .body(containsString("<Value>platform</Value>"));+ }++ @Test+ void describeHonoursMaxRecordsAndMarker() {+ // The model bounds MaxRecords at 20, so a meaningful page needs more than 20 rows.+ String prefix = "page-" + Long.toString(System.nanoTime(), 36);+ for (int i = 0; i < 21; i++) {+ rds("CreateEventSubscription", "SubscriptionName", String.format("%s-%02d", prefix, i),+ "SnsTopicArn", TOPIC).statusCode(200);+ }++ String marker = rds("DescribeEventSubscriptions", "MaxRecords", "20")+ .statusCode(200)+ .extract().path("DescribeEventSubscriptionsResponse"+ + ".DescribeEventSubscriptionsResult.Marker");+ assertNotNull(marker, "a bounded page short of the end carries a Marker");++ rds("DescribeEventSubscriptions", "MaxRecords", "20", "Marker", marker)+ .statusCode(200)+ .body(not(containsString("<CustSubscriptionId>" + marker + "</CustSubscriptionId>")));+ }++ @Test+ void anOutOfRangeMaxRecordsIsRefused() {+ // 0 used to build an empty page and then read its last element.+ rds("DescribeEventSubscriptions", "MaxRecords", "0").statusCode(400)+ .body(containsString("InvalidParameterValue"));+ rds("DescribeEventSubscriptions", "MaxRecords", "-5").statusCode(400);+ rds("DescribeEventSubscriptions", "MaxRecords", "19").statusCode(400);+ rds("DescribeEventSubscriptions", "MaxRecords", "101").statusCode(400);+ rds("DescribeEventSubscriptions", "MaxRecords", "20").statusCode(200);+ }++ @Test+ void anOutOfRangeMaxRecordsIsRefusedEvenWhenASubscriptionIsNamed() {+ String subscription = name("named");+ rds("CreateEventSubscription", "SubscriptionName", subscription, "SnsTopicArn", TOPIC)+ .statusCode(200);++ // The named-subscription read used to return before the page size was looked at.+ rds("DescribeEventSubscriptions", "SubscriptionName", subscription, "MaxRecords", "0")+ .statusCode(400)+ .body(containsString("InvalidParameterValue"));+ rds("DescribeEventSubscriptions", "SubscriptionName", subscription, "MaxRecords", "20")+ .statusCode(200);+ }++ @Test+ void aMarkerWhoseSubscriptionIsGoneDoesNotRestartTheWalk() {+ String prefix = "gone-" + Long.toString(System.nanoTime(), 36);+ for (int i = 0; i < 21; i++) {+ rds("CreateEventSubscription", "SubscriptionName", String.format("%s-%02d", prefix, i),+ "SnsTopicArn", TOPIC).statusCode(200);+ }+ String marker = rds("DescribeEventSubscriptions", "MaxRecords", "20")+ .statusCode(200)+ .extract().path("DescribeEventSubscriptionsResponse"+ + ".DescribeEventSubscriptionsResult.Marker");+ assertNotNull(marker);++ rds("DeleteEventSubscription", "SubscriptionName", marker).statusCode(200);++ // Resuming from a name that no longer exists must not hand back the first page again.+ rds("DescribeEventSubscriptions", "MaxRecords", "20", "Marker", marker)+ .statusCode(200)+ .body(not(containsString("<CustSubscriptionId>" + prefix + "-00</CustSubscriptionId>")));+ }++ @Test+ void sourceIdsWithoutASourceTypeIsRefused() {+ rds("CreateEventSubscription",+ "SubscriptionName", name("nosrctype"),+ "SnsTopicArn", TOPIC,+ "SourceIds.member.1", "db-one")+ .statusCode(400)+ .body(containsString("InvalidParameterCombination"));+ }++ @Test+ void anUnmodelledSourceTypeIsRefused() {+ rds("CreateEventSubscription",+ "SubscriptionName", name("badtype"),+ "SnsTopicArn", TOPIC,+ "SourceType", "db-widget")+ .statusCode(400)+ .body(containsString("InvalidParameterValue"));+ }++ @Test+ void aMissingTopicArnIsRefusedAndASecondCreateClashes() {+ rds("CreateEventSubscription", "SubscriptionName", name("notopic"))+ .statusCode(404)+ .body(containsString("SNSTopicArnNotFound"));++ String subscription = name("dup");+ rds("CreateEventSubscription", "SubscriptionName", subscription, "SnsTopicArn", TOPIC)+ .statusCode(200);+ rds("CreateEventSubscription", "SubscriptionName", subscription, "SnsTopicArn", TOPIC)+ .statusCode(400)+ .body(containsString("SubscriptionAlreadyExist"));+ }++ @Test+ void describeWithNoNameListsThemAndAnUnknownNameIsNotFound() {+ String subscription = name("listed");+ rds("CreateEventSubscription", "SubscriptionName", subscription, "SnsTopicArn", TOPIC)+ .statusCode(200);++ rds("DescribeEventSubscriptions")+ .statusCode(200)+ .body(containsString("<CustSubscriptionId>" + subscription + "</CustSubscriptionId>"));++ rds("DescribeEventSubscriptions", "SubscriptionName", "no-such-subscription")+ .statusCode(404)+ .body(containsString("SubscriptionNotFound"));+ }++ @Test+ void anInactiveSubscriptionIsCreatedButNotActive() {+ String subscription = name("off");+ rds("CreateEventSubscription",+ "SubscriptionName", subscription, "SnsTopicArn", TOPIC, "Enabled", "false")+ .statusCode(200)+ .body("CreateEventSubscriptionResponse.CreateEventSubscriptionResult.EventSubscription.Enabled",+ equalTo("false"))+ .body(not(containsString("<Enabled>true</Enabled>")));+ }+}