Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

feat(redshift-serverless): add usage limit actions (#5378)

Vũ Thế Huy141fd747ee67
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftServerlessTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftServerlessTest.java
index 3a55df883f..d7e13e5fdf 100644
--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftServerlessTest.java
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftServerlessTest.java
@@ -15,6 +15,10 @@ import software.amazon.awssdk.services.redshiftserverless.model.NamespaceStatus;
import software.amazon.awssdk.services.redshiftserverless.model.ResourceNotFoundException;
import software.amazon.awssdk.services.redshiftserverless.model.Snapshot;
import software.amazon.awssdk.services.redshiftserverless.model.Tag;
+import software.amazon.awssdk.services.redshiftserverless.model.UsageLimit;
+import software.amazon.awssdk.services.redshiftserverless.model.UsageLimitBreachAction;
+import software.amazon.awssdk.services.redshiftserverless.model.UsageLimitPeriod;
+import software.amazon.awssdk.services.redshiftserverless.model.UsageLimitUsageType;
import software.amazon.awssdk.services.redshiftserverless.model.Workgroup;
import software.amazon.awssdk.services.redshiftserverless.model.WorkgroupStatus;
@@ -202,6 +206,60 @@ class RedshiftServerlessTest {
}
}
+ @Test
+ void usageLimitLifecycleUsesAwsSdk() {
+ assumeFalse(TestFixtures.isRealAws(), "Creates a workgroup and asserts emulator-local behavior");
+
+ try (RedshiftServerlessClient client = TestFixtures.redshiftServerlessClient()) {
+ String namespaceName = "floci-compat-limit-ns";
+ String workgroupName = "floci-compat-limit-wg";
+ try {
+ client.createNamespace(request -> request.namespaceName(namespaceName).adminUsername("admin")
+ .adminUserPassword("Secret123!"));
+ String workgroupArn = client.createWorkgroup(request -> request
+ .workgroupName(workgroupName).namespaceName(namespaceName)).workgroup().workgroupArn();
+
+ UsageLimit created = client.createUsageLimit(request -> request
+ .resourceArn(workgroupArn)
+ .usageType(UsageLimitUsageType.SERVERLESS_COMPUTE)
+ .amount(60L)).usageLimit();
+ assertThat(created.amount()).isEqualTo(60L);
+ assertThat(created.period()).isEqualTo(UsageLimitPeriod.MONTHLY);
+ assertThat(created.breachAction()).isEqualTo(UsageLimitBreachAction.LOG);
+ assertThat(created.resourceArn()).isEqualTo(workgroupArn);
+ assertThat(created.usageLimitArn()).contains(":usagelimit/");
+
+ UsageLimit second = client.createUsageLimit(request -> request
+ .resourceArn(workgroupArn)
+ .usageType(UsageLimitUsageType.SERVERLESS_COMPUTE)
+ .period(UsageLimitPeriod.DAILY)
+ .amount(10L)).usageLimit();
+ assertThat(second.period()).isEqualTo(UsageLimitPeriod.DAILY);
+
+ UsageLimit updated = client.updateUsageLimit(request -> request
+ .usageLimitId(created.usageLimitId())
+ .amount(90L)
+ .breachAction(UsageLimitBreachAction.DEACTIVATE)).usageLimit();
+ assertThat(updated.amount()).isEqualTo(90L);
+ assertThat(updated.breachAction()).isEqualTo(UsageLimitBreachAction.DEACTIVATE);
+
+ assertThat(client.getUsageLimit(request -> request.usageLimitId(created.usageLimitId()))
+ .usageLimit().amount()).isEqualTo(90L);
+ assertThat(client.listUsageLimits(request -> request.resourceArn(workgroupArn)).usageLimits())
+ .extracting(UsageLimit::usageLimitId)
+ .containsExactlyInAnyOrder(created.usageLimitId(), second.usageLimitId());
+
+ client.deleteUsageLimit(request -> request.usageLimitId(second.usageLimitId()));
+ client.deleteUsageLimit(request -> request.usageLimitId(created.usageLimitId()));
+ assertThatThrownBy(() -> client.getUsageLimit(request -> request.usageLimitId(created.usageLimitId())))
+ .isInstanceOf(ResourceNotFoundException.class);
+ } finally {
+ deleteWorkgroupBestEffort(client, workgroupName);
+ deleteBestEffort(client, namespaceName);
+ }
+ }
+ }
+
private static void deleteSnapshotBestEffort(RedshiftServerlessClient client, String snapshotName) {
try {
client.deleteSnapshot(request -> request.snapshotName(snapshotName));
diff --git a/docs/services/index.md b/docs/services/index.md
index e63c4382e1..750246c56d 100644
--- a/docs/services/index.md
+++ b/docs/services/index.md
@@ -76,7 +76,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac
| [DMS](dms.md) | `POST /` + `X-Amz-Target: AmazonDMSv20160101.*` | JSON 1.1 | 20 |
| [Redshift](redshift.md) | `POST /` with `Action=` param + PostgreSQL container | Query + PostgreSQL wire (+ CFN) | 35 |
| [Redshift Data API](redshift-data.md) | `POST /` + `X-Amz-Target: RedshiftData.*` | JSON 1.1 | 11 |
-| [Redshift Serverless](redshift-serverless.md) | `POST /` + `X-Amz-Target: RedshiftServerless.*` | JSON 1.1 | 19 |
+| [Redshift Serverless](redshift-serverless.md) | `POST /` + `X-Amz-Target: RedshiftServerless.*` | JSON 1.1 | 24 |
| [EMR](emr.md) | `POST /` + `X-Amz-Target: ElasticMapReduce.*` | JSON 1.1 | 37 |
| [EMR Serverless](emr-serverless.md) | `/applications/*`, `/tags/*` | REST JSON | 10 |
| [Data Firehose](firehose.md) | `POST /` + `X-Amz-Target: Firehose_20150804.*` | JSON 1.1 | 12 |
diff --git a/docs/services/redshift-serverless.md b/docs/services/redshift-serverless.md
index 4422b36c0c..8c0a384a75 100644
--- a/docs/services/redshift-serverless.md
+++ b/docs/services/redshift-serverless.md
@@ -27,6 +27,11 @@ For the upstream API shape, see the [Amazon Redshift Serverless API Reference](h
| `ListSnapshots` | Page through the snapshots in the Region, filtered by `namespaceName`, `namespaceArn`, `ownerAccount` and a `startTime`/`endTime` window |
| `DeleteSnapshot` | Remove a snapshot and return it |
| `RestoreFromSnapshot` | Restore into an existing namespace and workgroup, replaying the snapshot's dump into the workgroup's database; neither is created |
+| `CreateUsageLimit` | Set a usage limit on a workgroup, defaulting `period` to `monthly` and `breachAction` to `log` |
+| `GetUsageLimit` | Return a usage limit by `usageLimitId` |
+| `ListUsageLimits` | Page through the usage limits in the Region, filtered by `resourceArn` and `usageType` |
+| `UpdateUsageLimit` | Change the `amount` or `breachAction` of a usage limit and return it |
+| `DeleteUsageLimit` | Remove a usage limit and return it |
| `GetCredentials` | Mint a temporary database user and password for a workgroup, valid on its endpoint until `expiration` |
| `ListTagsForResource` | Return the tags on the namespace or workgroup named by `resourceArn` |
| `TagResource` | Merge tags into the namespace or workgroup named by `resourceArn` |
@@ -37,7 +42,7 @@ Namespace and workgroup state is account and Region scoped and persisted through
## Compatibility Notes
-- **A workgroup runs a real PostgreSQL container.** `CreateWorkgroup` starts the container (this needs Docker and uses `floci.services.redshift.image-version`) and an authenticating proxy on the `endpoint`, whose port comes from the same pool as provisioned Redshift clusters (`floci.services.redshift.proxy-base-port` to `proxy-max-port`). Connect with any PostgreSQL client or JDBC driver using the namespace admin user and password, to the namespace `dbName`. The Redshift Data API accepts `WorkgroupName` ([details](redshift-data.md)). Only the operations in the Supported Actions table are served. The rest of the Redshift Serverless API is not emulated and answers `UnknownOperationException`: snapshot copy configurations, snapshot restore access policies, recovery points, table restore and restore status, usage limits, endpoint access, resource policies, custom domain associations, scheduled actions, reservations and reservation offerings, tracks, managed workgroups, the Identity Center token, and lakehouse configuration.
+- **A workgroup runs a real PostgreSQL container.** `CreateWorkgroup` starts the container (this needs Docker and uses `floci.services.redshift.image-version`) and an authenticating proxy on the `endpoint`, whose port comes from the same pool as provisioned Redshift clusters (`floci.services.redshift.proxy-base-port` to `proxy-max-port`). Connect with any PostgreSQL client or JDBC driver using the namespace admin user and password, to the namespace `dbName`. The Redshift Data API accepts `WorkgroupName` ([details](redshift-data.md)). Only the operations in the Supported Actions table are served. The rest of the Redshift Serverless API is not emulated and answers `UnknownOperationException`: snapshot copy configurations, snapshot restore access policies, recovery points, table restore and restore status, endpoint access, resource policies, custom domain associations, scheduled actions, reservations and reservation offerings, tracks, managed workgroups, the Identity Center token, and lakehouse configuration.
- **Admin credentials come from the namespace.** The backend role is the namespace `adminUsername` (default `admin`) and the password is the `adminUserPassword` the namespace was created with. A namespace created without a password gets a generated one that is kept internally and never returned, so such a workgroup is reachable through `GetCredentials` and the Data API only. `manageAdminPassword` still creates no secret. Changing `adminUserPassword` with `UpdateNamespace` takes effect for new connections and is refused with `ValidationException` if the backend rejects it (AWS password rules: 8 to 64 characters with upper case, lower case and a digit, and none of `' " / @`). Changing `adminUsername` on a running workgroup does not rename the backend role; the new name is accepted at the proxy, which opens the backend as the original role.
- **`GetCredentials` returns a master-equivalent password.** `dbUser` is derived from the signing identity (`IAM:<user>` or `IAMR:<role>`, falling back to `IAMR:floci` when the caller cannot be resolved), `dbPassword` is random, and `expiration` and `nextRefreshTime` are epoch seconds (the same instant). `durationSeconds` defaults to 900 and must be 900 to 3600. `dbName`, when given, must be the namespace `dbName`. `customDomainName` is not supported. A returned credential stays valid until it expires or the workgroup is deleted.
- **The runtime survives a restart when its container does.** On startup Floci re-attaches to the container and restarts the proxy on the same port, so the endpoint is stable. If the container is gone the workgroup comes back with an empty database; if neither can be started, the workgroup stays `AVAILABLE`, the Data API reports that its runtime is not available, and the failure is logged. Containers have no Docker volume, as for provisioned clusters.
@@ -54,6 +59,7 @@ Namespace and workgroup state is account and Region scoped and persisted through
- **`UpdateNamespace` applies only the fields present in the request.** An omitted field keeps its stored value; an explicitly empty `iamRoles` or `logExports` array clears it.
- **A namespace has at most one workgroup, and a workgroup belongs to exactly one namespace.** A second `CreateWorkgroup` for a namespace returns `ConflictException`, and so does `DeleteNamespace` while the namespace still has a workgroup. AWS documents the one-to-one relationship; the `DeleteNamespace` refusal is the one rule here that is inferred rather than documented, because the API reference lists `ConflictException` for that call without naming its trigger.
- **Workgroup defaults follow AWS.** `baseCapacity` defaults to 128 RPUs, `port` to 5439, `ipAddressType` to `ipv4`, `trackName` to `current`, `pricePerformanceTarget` to `{"status":"DISABLED"}`, and `enhancedVpcRouting`, `publiclyAccessible` and `extraComputeForAutomaticOptimization` to `false`. `status` is `AVAILABLE` as soon as the call returns; `DeleteWorkgroup` returns the workgroup with `DELETING` and removes it in the same call.
+- **Usage limits are stored and echoed, not enforced.** Floci does not meter RPU consumption, so no `breachAction` ever fires and `period` never resets a counter. A limit belongs to a workgroup: `resourceArn` must be a workgroup ARN (`ResourceNotFoundException` otherwise), and `amount` must be a positive integer. Deleting a workgroup removes its limits, and a workgroup recreated under the same name does not inherit them. `UpdateUsageLimit` changes only `amount` and `breachAction`. `CreateUsageLimit` takes no tags in the API model, so usage limits are not taggable here.
- **Capacity, network and security settings are stored and echoed, not enforced.** `baseCapacity`, `maxCapacity`, `subnetIds`, `securityGroupIds`, `enhancedVpcRouting`, `publiclyAccessible` and `configParameters` have no effect on the emulator. `configParameters` returns only what the caller supplied: AWS also adds a set of default parameters that the API reference does not enumerate, and Terraform treats the attribute as computed, so the difference does not produce a plan diff.
- **`port` is validated and echoed.** It must be in 5431-5455 or 8191-8215. The `endpoint.port` is the port Floci allocated, which is what a client connects to.
- **`UpdateWorkgroup` applies only the fields present.** AWS documents that several parameters cannot be changed in one request; Floci accepts any combination. A `trackName` different from the current one is recorded as `pendingTrackName` and `trackName` is unchanged, as AWS switches tracks on the next release. `workgroupName` and `namespaceName` cannot be changed.
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandler.java
index 6d7e61f4ec..40e81e6cd4 100644
--- a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandler.java
@@ -14,6 +14,7 @@ import io.github.hectorvent.floci.services.redshiftserverless.model.ConfigParame
import io.github.hectorvent.floci.services.redshiftserverless.model.Namespace;
import io.github.hectorvent.floci.services.redshiftserverless.model.PricePerformanceTarget;
import io.github.hectorvent.floci.services.redshiftserverless.model.RedshiftServerlessSnapshot;
+import io.github.hectorvent.floci.services.redshiftserverless.model.UsageLimit;
import io.github.hectorvent.floci.services.redshiftserverless.model.Workgroup;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
@@ -52,13 +53,16 @@ public class RedshiftServerlessJsonHandler {
private final RedshiftServerlessService service;
private final ObjectMapper objectMapper;
private final RedshiftIamDbUserResolver iamDbUserResolver;
+ private final RedshiftServerlessUsageLimitService usageLimits;
@Inject
public RedshiftServerlessJsonHandler(RedshiftServerlessService service, ObjectMapper objectMapper,
- RedshiftIamDbUserResolver iamDbUserResolver) {
+ RedshiftIamDbUserResolver iamDbUserResolver,
+ RedshiftServerlessUsageLimitService usageLimits) {
this.service = service;
this.objectMapper = objectMapper;
this.iamDbUserResolver = iamDbUserResolver;
+ this.usageLimits = usageLimits;
}
public Response handle(String action, JsonNode request, String region) {
@@ -84,6 +88,11 @@ public class RedshiftServerlessJsonHandler {
case "ListSnapshots" -> handleListSnapshots(request, region);
case "DeleteSnapshot" -> handleDeleteSnapshot(request, region);
case "RestoreFromSnapshot" -> handleRestoreFromSnapshot(request, region);
+ case "CreateUsageLimit" -> handleCreateUsageLimit(request, region);
+ case "GetUsageLimit" -> handleGetUsageLimit(request, region);
+ case "ListUsageLimits" -> handleListUsageLimits(request, region);
+ case "UpdateUsageLimit" -> handleUpdateUsageLimit(request, region);
+ case "DeleteUsageLimit" -> handleDeleteUsageLimit(request, region);
case "GetCredentials" -> handleGetCredentials(request, region, authorizationHeader);
case "ListTagsForResource" -> handleListTagsForResource(request, region);
case "TagResource" -> handleTagResource(request, region);
@@ -260,6 +269,64 @@ public class RedshiftServerlessJsonHandler {
return snapshotArn == null ? snapshotName : service.snapshotNameFromArn(snapshotArn, region);
}
+ private Response handleCreateUsageLimit(JsonNode request, String region) {
+ return usageLimitResponse(usageLimits.createUsageLimit(
+ optionalText(request, "resourceArn"),
+ optionalText(request, "usageType"),
+ parseLong(request, "amount"),
+ optionalText(request, "period"),
+ optionalText(request, "breachAction"),
+ region));
+ }
+
+ private Response handleGetUsageLimit(JsonNode request, String region) {
+ return usageLimitResponse(usageLimits.getUsageLimit(optionalText(request, "usageLimitId"), region));
+ }
+
+ private Response handleListUsageLimits(JsonNode request, String region) {
+ PaginatedResult<UsageLimit> page = usageLimits.listUsageLimits(
+ optionalText(request, "resourceArn"), optionalText(request, "usageType"), region,
+ parseMaxResults(request), optionalText(request, "nextToken"));
+ ObjectNode response = objectMapper.createObjectNode();
+ ArrayNode items = response.putArray("usageLimits");
+ page.items().forEach(limit -> items.add(usageLimitNode(limit)));
+ if (page.nextToken() != null) {
+ response.put("nextToken", page.nextToken());
+ }
+ return Response.ok(response).build();
+ }
+
+ private Response handleUpdateUsageLimit(JsonNode request, String region) {
+ return usageLimitResponse(usageLimits.updateUsageLimit(
+ optionalText(request, "usageLimitId"),
+ parseLong(request, "amount"),
+ optionalText(request, "breachAction"),
+ region));
+ }
+
+ private Response handleDeleteUsageLimit(JsonNode request, String region) {
+ return usageLimitResponse(usageLimits.deleteUsageLimit(optionalText(request, "usageLimitId"), region));
+ }
+
+ private Response usageLimitResponse(UsageLimit limit) {
+ ObjectNode response = objectMapper.createObjectNode();
+ response.set("usageLimit", usageLimitNode(limit));
+ return Response.ok(response).build();
+ }
+
+ /** {@code UsageLimit} has no timestamp member, so the creation date the store keeps is not emitted. */
+ private ObjectNode usageLimitNode(UsageLimit limit) {
+ ObjectNode node = objectMapper.createObjectNode();
+ node.put("usageLimitId", limit.getUsageLimitId());
+ node.put("usageLimitArn", limit.getUsageLimitArn());
+ node.put("resourceArn", limit.getResourceArn());
+ node.put("usageType", limit.getUsageType());
+ node.put("amount", limit.getAmount());
+ node.put("period", limit.getPeriod());
+ node.put("breachAction", limit.getBreachAction());
+ return node;
+ }
+
private Response handleListTagsForResource(JsonNode request, String region) {
Map<String, String> tags = service.listTagsForResource(text(request, "resourceArn"), region);
ObjectNode response = objectMapper.createObjectNode();
@@ -489,12 +556,35 @@ public class RedshiftServerlessJsonHandler {
return Instant.ofEpochMilli(Math.round(node.asDouble() * 1000));
}
+ /** A string member: null when missing or null, a validation error when present with any other type. */
+ private String optionalText(JsonNode request, String field) {
+ JsonNode node = request.path(field);
+ if (node.isMissingNode() || node.isNull()) {
+ return null;
+ }
+ if (!node.isTextual()) {
+ throw validation(field + " must be a string.");
+ }
+ return node.textValue();
+ }
+
+ private Long parseLong(JsonNode request, String field) {
+ JsonNode node = request.path(field);
+ if (node.isMissingNode() || node.isNull()) {
+ return null;
+ }
+ if (!node.isIntegralNumber() || !node.canConvertToLong()) {
+ throw validation(field + " must be an integer.");
+ }
+ return node.asLong();
+ }
+
private Integer parseMaxResults(JsonNode request) {
JsonNode node = request.path("maxResults");
if (node.isMissingNode() || node.isNull()) {
return null;
}
- if (!node.isNumber()) {
+ if (!node.isIntegralNumber() || !node.canConvertToInt()) {
throw validation("maxResults must be an integer.");
}
return node.asInt();
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessService.java b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessService.java
index 78069ad157..ca0334cf8e 100644
--- a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessService.java
@@ -38,6 +38,7 @@ import java.util.UUID;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.regex.Pattern;
+import java.util.stream.Collectors;
@ApplicationScoped
public class RedshiftServerlessService implements Resettable {
@@ -615,6 +616,17 @@ public class RedshiftServerlessService implements Resettable {
.findFirst();
}
+ public Optional<Workgroup> findWorkgroupByArn(String resourceArn, String region) {
+ return workgroupByArn(resourceArn, region);
+ }
+
+ /** ARNs of every workgroup in the Region, for callers that test many resources against them at once. */
+ public Set<String> workgroupArns(String region) {
+ return workgroups.scan(key -> key.startsWith(region + "::")).stream()
+ .map(Workgroup::getWorkgroupArn)
+ .collect(Collectors.toSet());
+ }
+
private Optional<Workgroup> workgroupByArn(String resourceArn, String region) {
return workgroups.scan(key -> key.startsWith(region + "::")).stream()
.filter(workgroup -> resourceArn.equals(workgroup.getWorkgroupArn()))
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessUsageLimitService.java b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessUsageLimitService.java
new file mode 100644
index 0000000000..22e341cca2
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessUsageLimitService.java
@@ -0,0 +1,193 @@
+package io.github.hectorvent.floci.services.redshiftserverless;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.PaginatedResult;
+import io.github.hectorvent.floci.core.common.Pagination;
+import io.github.hectorvent.floci.core.common.RegionResolver;
+import io.github.hectorvent.floci.core.common.Resettable;
+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.redshiftserverless.model.UsageLimit;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * Redshift Serverless usage limits. They are stored and echoed, not enforced: Floci does not meter
+ * RPU consumption, so no {@code breachAction} ever fires.
+ *
+ * <p>A limit belongs to a workgroup but is kept in its own store, so deleting a workgroup, from the
+ * API or from CloudFormation, needs no hook here. Each read instead checks that the workgroup still
+ * exists and drops the limit otherwise. A workgroup ARN carries a generated id, so a workgroup
+ * recreated under the same name has a new ARN and never matches a limit left by its predecessor.
+ */
+@ApplicationScoped
+public class RedshiftServerlessUsageLimitService implements Resettable {
+
+ private static final Set<String> USAGE_TYPES = Set.of("serverless-compute", "cross-region-datasharing");
+ private static final Set<String> PERIODS = Set.of("daily", "weekly", "monthly");
+ private static final Set<String> BREACH_ACTIONS = Set.of("log", "emit-metric", "deactivate");
+ private static final String DEFAULT_PERIOD = "monthly";
+ private static final String DEFAULT_BREACH_ACTION = "log";
+ private static final int PAGE_SIZE = 100;
+
+ private final AccountAwareStorageBackend<UsageLimit> usageLimits;
+ private final RegionResolver regionResolver;
+ private final RedshiftServerlessService serverless;
+
+ @Inject
+ public RedshiftServerlessUsageLimitService(StorageFactory storageFactory, RegionResolver regionResolver,
+ RedshiftServerlessService serverless) {
+ this.usageLimits = storageFactory.create("redshiftserverless", "redshiftserverless-usagelimits.json",
+ new TypeReference<Map<String, UsageLimit>>() {});
+ this.regionResolver = regionResolver;
+ this.serverless = serverless;
+ }
+
+ public synchronized UsageLimit createUsageLimit(String resourceArn, String usageType, Long amount,
+ String period, String breachAction, String region) {
+ requireText(resourceArn, "resourceArn");
+ requireText(usageType, "usageType");
+ requireOneOf(usageType, USAGE_TYPES, "usageType");
+ if (amount == null) {
+ throw validation("amount is required.");
+ }
+ requirePositive(amount);
+ String resolvedPeriod = period == null ? DEFAULT_PERIOD : requireOneOf(period, PERIODS, "period");
+ String resolvedAction = breachAction == null
+ ? DEFAULT_BREACH_ACTION : requireOneOf(breachAction, BREACH_ACTIONS, "breachAction");
+ serverless.findWorkgroupByArn(resourceArn, region)
+ .orElseThrow(() -> notFound("The resource " + resourceArn + " was not found."));
+
+ UsageLimit limit = new UsageLimit();
+ limit.setUsageLimitId(UUID.randomUUID().toString());
+ limit.setUsageLimitArn(regionResolver.buildArn("redshift-serverless", region,
+ "usagelimit/" + limit.getUsageLimitId()));
+ limit.setResourceArn(resourceArn);
+ limit.setUsageType(usageType);
+ limit.setAmount(amount);
+ limit.setPeriod(resolvedPeriod);
+ limit.setBreachAction(resolvedAction);
+ usageLimits.put(storageKey(region, limit.getUsageLimitId()), limit);
+ return new UsageLimit(limit);
+ }
+
+ public synchronized UsageLimit getUsageLimit(String usageLimitId, String region) {
+ return new UsageLimit(require(usageLimitId, region));
+ }
+
+ public synchronized PaginatedResult<UsageLimit> listUsageLimits(String resourceArn, String usageType,
+ String region, Integer maxResults,
+ String nextToken) {
+ if (usageType != null) {
+ requireOneOf(usageType, USAGE_TYPES, "usageType");
+ }
+ List<UsageLimit> matching = live(region).stream()
+ .filter(limit -> resourceArn == null || resourceArn.equals(limit.getResourceArn()))
+ .filter(limit -> usageType == null || usageType.equals(limit.getUsageType()))
+ .sorted(Comparator.comparing(UsageLimit::getUsageLimitId))
+ .map(UsageLimit::new)
+ .toList();
+ return Pagination.paginate(matching, UsageLimit::getUsageLimitId, maxResults, nextToken,
+ PAGE_SIZE, PAGE_SIZE, "InvalidPaginationException");
+ }
+
+ public synchronized UsageLimit updateUsageLimit(String usageLimitId, Long amount, String breachAction,
+ String region) {
+ UsageLimit current = require(usageLimitId, region);
+ if (amount != null) {
+ requirePositive(amount);
+ }
+ if (breachAction != null) {
+ requireOneOf(breachAction, BREACH_ACTIONS, "breachAction");
+ }
+ UsageLimit updated = new UsageLimit(current);
+ if (amount != null) {
+ updated.setAmount(amount);
+ }
+ if (breachAction != null) {
+ updated.setBreachAction(breachAction);
+ }
+ usageLimits.put(storageKey(region, usageLimitId), updated);
+ return new UsageLimit(updated);
+ }
+
+ public synchronized UsageLimit deleteUsageLimit(String usageLimitId, String region) {
+ UsageLimit existing = require(usageLimitId, region);
+ usageLimits.delete(storageKey(region, usageLimitId));
+ return new UsageLimit(existing);
+ }
+
+ @Override
+ public void clear() {
+ usageLimits.clear();
+ }
+
+ private UsageLimit require(String usageLimitId, String region) {
+ requireText(usageLimitId, "usageLimitId");
+ UsageLimit limit = usageLimits.get(storageKey(region, usageLimitId)).orElse(null);
+ if (limit != null && !isLive(limit, region)) {
+ usageLimits.delete(storageKey(region, usageLimitId));
+ limit = null;
+ }
+ if (limit == null) {
+ throw notFound("The usage limit " + usageLimitId + " was not found.");
+ }
+ return limit;
+ }
+
+ /** The region's limits whose workgroup is still there; any other is deleted as it is found. */
+ private List<UsageLimit> live(String region) {
+ Set<String> workgroupArns = serverless.workgroupArns(region);
+ return usageLimits.scan(key -> key.startsWith(region + "::")).stream()
+ .filter(limit -> {
+ if (workgroupArns.contains(limit.getResourceArn())) {
+ return true;
+ }
+ usageLimits.delete(storageKey(region, limit.getUsageLimitId()));
+ return false;
+ })
+ .toList();
+ }
+
+ private boolean isLive(UsageLimit limit, String region) {
+ return serverless.findWorkgroupByArn(limit.getResourceArn(), region).isPresent();
+ }
+
+ private static String storageKey(String region, String usageLimitId) {
+ return region + "::" + usageLimitId;
+ }
+
+ private static void requireText(String value, String field) {
+ if (value == null || value.isBlank()) {
+ throw validation(field + " is required.");
+ }
+ }
+
+ private static String requireOneOf(String value, Set<String> allowed, String field) {
+ if (!allowed.contains(value)) {
+ throw validation(field + " must be one of " + allowed.stream().sorted().toList() + ".");
+ }
+ return value;
+ }
+
+ private static void requirePositive(long amount) {
+ if (amount < 1) {
+ throw validation("amount must be a positive number.");
+ }
+ }
+
+ private static AwsException notFound(String message) {
+ return new AwsException("ResourceNotFoundException", message, 400);
+ }
+
+ private static AwsException validation(String message) {
+ return new AwsException("ValidationException", message, 400);
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/model/UsageLimit.java b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/model/UsageLimit.java
new file mode 100644
index 0000000000..2845477e25
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/model/UsageLimit.java
@@ -0,0 +1,90 @@
+package io.github.hectorvent.floci.services.redshiftserverless.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+/**
+ * A Redshift Serverless usage limit. Floci stores and echoes it but does not meter usage, so
+ * {@code breachAction} never fires.
+ */
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class UsageLimit {
+
+ private String usageLimitId;
+ private String usageLimitArn;
+ private String resourceArn;
+ private String usageType;
+ private long amount;
+ private String period;
+ private String breachAction;
+
+ public UsageLimit() {
+ }
+
+ public UsageLimit(UsageLimit other) {
+ this.usageLimitId = other.usageLimitId;
+ this.usageLimitArn = other.usageLimitArn;
+ this.resourceArn = other.resourceArn;
+ this.usageType = other.usageType;
+ this.amount = other.amount;
+ this.period = other.period;
+ this.breachAction = other.breachAction;
+ }
+
+ public String getUsageLimitId() {
+ return usageLimitId;
+ }
+
+ public void setUsageLimitId(String usageLimitId) {
+ this.usageLimitId = usageLimitId;
+ }
+
+ public String getUsageLimitArn() {
+ return usageLimitArn;
+ }
+
+ public void setUsageLimitArn(String usageLimitArn) {
+ this.usageLimitArn = usageLimitArn;
+ }
+
+ public String getResourceArn() {
+ return resourceArn;
+ }
+
+ public void setResourceArn(String resourceArn) {
+ this.resourceArn = resourceArn;
+ }
+
+ public String getUsageType() {
+ return usageType;
+ }
+
+ public void setUsageType(String usageType) {
+ this.usageType = usageType;
+ }
+
+ public long getAmount() {
+ return amount;
+ }
+
+ public void setAmount(long amount) {
+ this.amount = amount;
+ }
+
+ public String getPeriod() {
+ return period;
+ }
+
+ public void setPeriod(String period) {
+ this.period = period;
+ }
+
+ public String getBreachAction() {
+ return breachAction;
+ }
+
+ public void setBreachAction(String breachAction) {
+ this.breachAction = breachAction;
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessIntegrationTest.java
index 4ee4d750d1..49d07f0300 100644
--- a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessIntegrationTest.java
@@ -363,6 +363,116 @@ class RedshiftServerlessIntegrationTest {
call("DeleteNamespace", "{\"namespaceName\":\"wg-err-ns\"}").statusCode(200);
}
+ @Test
+ void usageLimitLifecycleFollowsTheApiModel() {
+ call("CreateNamespace", "{\"namespaceName\":\"limit-ns\",\"adminUserPassword\":\"Secret123!\"}")
+ .statusCode(200);
+ String workgroupArn = call("CreateWorkgroup", "{\"workgroupName\":\"limit-wg\",\"namespaceName\":\"limit-ns\"}")
+ .statusCode(200)
+ .extract().path("workgroup.workgroupArn");
+
+ String limitId = call("CreateUsageLimit", "{\"resourceArn\":\"" + workgroupArn
+ + "\",\"usageType\":\"serverless-compute\",\"amount\":120,\"period\":\"daily\"}")
+ .statusCode(200)
+ .body("usageLimit.amount", equalTo(120))
+ .body("usageLimit.period", equalTo("daily"))
+ .body("usageLimit.breachAction", equalTo("log"))
+ .body("usageLimit.usageLimitArn", matchesPattern(
+ "arn:aws:redshift-serverless:us-east-1:\\d{12}:usagelimit/.+"))
+ .extract().path("usageLimit.usageLimitId");
+
+ String secondLimitId = call("CreateUsageLimit", "{\"resourceArn\":\"" + workgroupArn
+ + "\",\"usageType\":\"serverless-compute\",\"amount\":200,\"period\":\"monthly\"}")
+ .statusCode(200)
+ .extract().path("usageLimit.usageLimitId");
+
+ call("UpdateUsageLimit", "{\"usageLimitId\":\"" + limitId + "\",\"amount\":240,\"breachAction\":\"deactivate\"}")
+ .statusCode(200)
+ .body("usageLimit.amount", equalTo(240))
+ .body("usageLimit.breachAction", equalTo("deactivate"))
+ .body("usageLimit.period", equalTo("daily"));
+
+ call("ListUsageLimits", "{\"resourceArn\":\"" + workgroupArn + "\"}")
+ .statusCode(200)
+ .body("usageLimits", hasSize(2));
+
+ call("DeleteUsageLimit", "{\"usageLimitId\":\"" + secondLimitId + "\"}").statusCode(200);
+
+ call("ListUsageLimits", "{\"resourceArn\":\"" + workgroupArn + "\"}")
+ .statusCode(200)
+ .body("usageLimits", hasSize(1))
+ .body("usageLimits[0].usageLimitId", equalTo(limitId));
+
+ call("DeleteWorkgroup", "{\"workgroupName\":\"limit-wg\"}").statusCode(200);
+ call("GetUsageLimit", "{\"usageLimitId\":\"" + limitId + "\"}")
+ .statusCode(400)
+ .body("__type", equalTo("ResourceNotFoundException"));
+ }
+
+ @Test
+ void listUsageLimitsPaginatesAndRejectsAnOutOfRangePageSize() {
+ call("CreateNamespace", "{\"namespaceName\":\"page-limit-ns\",\"adminUserPassword\":\"Secret123!\"}")
+ .statusCode(200);
+ String workgroupArn = call("CreateWorkgroup",
+ "{\"workgroupName\":\"page-limit-wg\",\"namespaceName\":\"page-limit-ns\"}")
+ .statusCode(200)
+ .extract().path("workgroup.workgroupArn");
+ call("CreateUsageLimit", "{\"resourceArn\":\"" + workgroupArn
+ + "\",\"usageType\":\"serverless-compute\",\"amount\":1}").statusCode(200);
+ call("CreateUsageLimit", "{\"resourceArn\":\"" + workgroupArn
+ + "\",\"usageType\":\"cross-region-datasharing\",\"amount\":2}").statusCode(200);
+
+ String nextToken = call("ListUsageLimits", "{\"resourceArn\":\"" + workgroupArn + "\",\"maxResults\":1}")
+ .statusCode(200)
+ .body("usageLimits", hasSize(1))
+ .body("nextToken", notNullValue())
+ .extract().path("nextToken");
+ call("ListUsageLimits", "{\"resourceArn\":\"" + workgroupArn + "\",\"maxResults\":1,\"nextToken\":\""
+ + nextToken + "\"}")
+ .statusCode(200)
+ .body("usageLimits", hasSize(1))
+ .body("nextToken", nullValue());
+
+ call("ListUsageLimits", "{\"maxResults\":0}")
+ .statusCode(400)
+ .body("__type", equalTo("InvalidPaginationException"));
+ }
+
+ @Test
+ void aWorkgroupRecreatedUnderTheSameNameDoesNotInheritUsageLimits() {
+ call("CreateNamespace", "{\"namespaceName\":\"again-limit-ns\",\"adminUserPassword\":\"Secret123!\"}")
+ .statusCode(200);
+ String firstArn = call("CreateWorkgroup",
+ "{\"workgroupName\":\"again-limit-wg\",\"namespaceName\":\"again-limit-ns\"}")
+ .statusCode(200)
+ .extract().path("workgroup.workgroupArn");
+ String oldLimitId = call("CreateUsageLimit", "{\"resourceArn\":\"" + firstArn
+ + "\",\"usageType\":\"serverless-compute\",\"amount\":1}")
+ .statusCode(200)
+ .extract().path("usageLimit.usageLimitId");
+
+ call("DeleteWorkgroup", "{\"workgroupName\":\"again-limit-wg\"}").statusCode(200);
+ String secondArn = call("CreateWorkgroup",
+ "{\"workgroupName\":\"again-limit-wg\",\"namespaceName\":\"again-limit-ns\"}")
+ .statusCode(200)
+ .extract().path("workgroup.workgroupArn");
+
+ call("GetUsageLimit", "{\"usageLimitId\":\"" + oldLimitId + "\"}").statusCode(400);
+ call("ListUsageLimits", "{\"resourceArn\":\"" + secondArn + "\"}")
+ .statusCode(200)
+ .body("usageLimits", hasSize(0));
+ call("CreateUsageLimit", "{\"resourceArn\":\"" + secondArn
+ + "\",\"usageType\":\"serverless-compute\",\"amount\":1}").statusCode(200);
+ }
+
+ @Test
+ void createUsageLimitRejectsAnUnknownWorkgroup() {
+ call("CreateUsageLimit", "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:000000000000:workgroup/none"
+ + "\",\"usageType\":\"serverless-compute\",\"amount\":1}")
+ .statusCode(400)
+ .body("__type", equalTo("ResourceNotFoundException"));
+ }
+
private static io.restassured.response.ValidatableResponse call(String action, String body) {
return given()
.header("X-Amz-Target", TARGET_PREFIX + action)
diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandlerTest.java
index da0d2dbfc3..80aff1a594 100644
--- a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandlerTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandlerTest.java
@@ -77,9 +77,97 @@ class RedshiftServerlessJsonHandlerTest {
when(iamDbUserResolver.resolveDbUser("AUTH")).thenReturn("IAM:alice");
EmulatorConfig config = mock(EmulatorConfig.class, org.mockito.Mockito.RETURNS_DEEP_STUBS);
when(config.storage().persistentPath()).thenReturn(System.getProperty("java.io.tmpdir"));
- handler = new RedshiftServerlessJsonHandler(
- new RedshiftServerlessService(storageFactory, regionResolver, endpoints, runtime, config), mapper,
- iamDbUserResolver);
+ when(storageFactory.create(eq("redshiftserverless"), eq("redshiftserverless-usagelimits.json"),
+ any(TypeReference.class))).thenReturn((AccountAwareStorageBackend)
+ AccountAwareStorageBackend.inMemory(ACCOUNT_ID));
+ RedshiftServerlessService service =
+ new RedshiftServerlessService(storageFactory, regionResolver, endpoints, runtime, config);
+ handler = new RedshiftServerlessJsonHandler(service, mapper, iamDbUserResolver,
+ new RedshiftServerlessUsageLimitService(storageFactory, regionResolver, service));
+ }
+
+ @Test
+ void usageLimitShapeFollowsTheApiModel() {
+ create("limit-ns");
+ String workgroupArn = body(handler.handle("CreateWorkgroup",
+ parse("{\"workgroupName\":\"limit-wg\",\"namespaceName\":\"limit-ns\"}"), REGION))
+ .get("workgroup").get("workgroupArn").textValue();
+
+ JsonNode created = body(handler.handle("CreateUsageLimit", parse("{\"resourceArn\":\"" + workgroupArn
+ + "\",\"usageType\":\"serverless-compute\",\"amount\":60}"), REGION)).get("usageLimit");
+
+ assertTrue(created.get("amount").isIntegralNumber());
+ assertEquals(60, created.get("amount").longValue());
+ assertEquals("monthly", created.get("period").textValue());
+ assertEquals("log", created.get("breachAction").textValue());
+ assertEquals(workgroupArn, created.get("resourceArn").textValue());
+ assertTrue(created.get("usageLimitArn").textValue().contains(":usagelimit/"));
+ assertEquals(7, created.size());
+
+ String id = created.get("usageLimitId").textValue();
+ JsonNode updated = body(handler.handle("UpdateUsageLimit",
+ parse("{\"usageLimitId\":\"" + id + "\",\"amount\":90,\"breachAction\":\"deactivate\"}"), REGION))
+ .get("usageLimit");
+ assertEquals(90, updated.get("amount").longValue());
+ assertEquals("deactivate", updated.get("breachAction").textValue());
+
+ JsonNode listed = body(handler.handle("ListUsageLimits",
+ parse("{\"resourceArn\":\"" + workgroupArn + "\"}"), REGION));
+ assertEquals(1, listed.get("usageLimits").size());
+ assertFalse(listed.has("nextToken"));
+
+ assertEquals(id, body(handler.handle("DeleteUsageLimit", parse("{\"usageLimitId\":\"" + id + "\"}"),
+ REGION)).get("usageLimit").get("usageLimitId").textValue());
+ assertEquals(400, handler.handle("GetUsageLimit", parse("{\"usageLimitId\":\"" + id + "\"}"),
+ REGION).getStatus());
+ }
+
+ @Test
+ void usageLimitMembersOfTheWrongTypeAreRejectedNotIgnored() {
+ create("typed-ns");
+ String workgroupArn = body(handler.handle("CreateWorkgroup",
+ parse("{\"workgroupName\":\"typed-wg\",\"namespaceName\":\"typed-ns\"}"), REGION))
+ .get("workgroup").get("workgroupArn").textValue();
+ String base = "\"resourceArn\":\"" + workgroupArn + "\",\"usageType\":\"serverless-compute\",\"amount\":5";
+ assertEquals(400, handler.handle("CreateUsageLimit", parse("{" + base + ",\"period\":3}"), REGION).getStatus());
+ assertEquals(400, handler.handle("CreateUsageLimit", parse("{" + base + ",\"breachAction\":true}"),
+ REGION).getStatus());
+ assertEquals(400, handler.handle("CreateUsageLimit", parse(
+ "{\"resourceArn\":7,\"usageType\":\"serverless-compute\",\"amount\":5}"), REGION).getStatus());
+ // Nothing was stored by the rejected creates.
+ assertEquals(0, body(handler.handle("ListUsageLimits", parse("{}"), REGION)).get("usageLimits").size());
+
+ String id = body(handler.handle("CreateUsageLimit", parse("{" + base + "}"), REGION))
+ .get("usageLimit").get("usageLimitId").textValue();
+ assertEquals(400, handler.handle("UpdateUsageLimit",
+ parse("{\"usageLimitId\":\"" + id + "\",\"breachAction\":1}"), REGION).getStatus());
+ assertEquals(400, handler.handle("ListUsageLimits", parse("{\"resourceArn\":7}"), REGION).getStatus());
+ assertEquals(400, handler.handle("ListUsageLimits", parse("{\"usageType\":7}"), REGION).getStatus());
+ assertEquals(400, handler.handle("ListUsageLimits", parse("{\"nextToken\":7}"), REGION).getStatus());
+ assertEquals(400, handler.handle("GetUsageLimit", parse("{\"usageLimitId\":7}"), REGION).getStatus());
+ assertEquals("log", body(handler.handle("GetUsageLimit", parse("{\"usageLimitId\":\"" + id + "\"}"),
+ REGION)).get("usageLimit").get("breachAction").textValue());
+ }
+
+ @Test
+ void maxResultsMustBeAnIntegerThatFitsAnInt() {
+ assertEquals(400, handler.handle("ListUsageLimits", parse("{\"maxResults\":1.5}"), REGION).getStatus());
+ assertEquals(400, handler.handle("ListUsageLimits", parse("{\"maxResults\":3000000000}"), REGION).getStatus());
+ assertEquals(400, handler.handle("ListUsageLimits", parse("{\"maxResults\":\"1\"}"), REGION).getStatus());
+ assertEquals(200, handler.handle("ListUsageLimits", parse("{\"maxResults\":1}"), REGION).getStatus());
+ }
+
+ @Test
+ void usageLimitAmountMustBeAnInteger() {
+ assertEquals(400, handler.handle("CreateUsageLimit", parse(
+ "{\"resourceArn\":\"arn\",\"usageType\":\"serverless-compute\",\"amount\":\"60\"}"),
+ REGION).getStatus());
+ assertEquals(400, handler.handle("CreateUsageLimit", parse(
+ "{\"resourceArn\":\"arn\",\"usageType\":\"serverless-compute\",\"amount\":1.5}"),
+ REGION).getStatus());
+ assertEquals(400, handler.handle("CreateUsageLimit", parse(
+ "{\"resourceArn\":\"arn\",\"usageType\":\"serverless-compute\",\"amount\":18446744073709551621}"),
+ REGION).getStatus());
}
@Test
diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessUsageLimitServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessUsageLimitServiceTest.java
new file mode 100644
index 0000000000..c6e1598ce4
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessUsageLimitServiceTest.java
@@ -0,0 +1,268 @@
+package io.github.hectorvent.floci.services.redshiftserverless;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.PaginatedResult;
+import io.github.hectorvent.floci.core.common.RegionResolver;
+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;
+import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.redshiftserverless.model.UsageLimit;
+import io.github.hectorvent.floci.services.redshiftserverless.model.Workgroup;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class RedshiftServerlessUsageLimitServiceTest {
+ private static final String REGION = "us-east-1";
+ private static final String ACCOUNT_ID = "123456789012";
+ private static final String WORKGROUP_ARN =
+ "arn:aws:redshift-serverless:us-east-1:" + ACCOUNT_ID + ":workgroup/wg-1";
+
+ private final Set<String> liveArns = new HashSet<>();
+ private RedshiftServerlessService serverless;
+ private RedshiftServerlessUsageLimitService service;
+
+ @BeforeEach
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ void setUp() {
+ StorageFactory storageFactory = mock(StorageFactory.class);
+ when(storageFactory.create(eq("redshiftserverless"), eq("redshiftserverless-usagelimits.json"),
+ any(TypeReference.class))).thenReturn((AccountAwareStorageBackend)
+ AccountAwareStorageBackend.inMemory(ACCOUNT_ID));
+ RegionResolver regionResolver = mock(RegionResolver.class);
+ when(regionResolver.buildArn(eq("redshift-serverless"), any(String.class), any(String.class)))
+ .thenAnswer(invocation -> "arn:aws:redshift-serverless:"
+ + invocation.getArgument(1, String.class) + ":" + ACCOUNT_ID + ":"
+ + invocation.getArgument(2, String.class));
+ serverless = mock(RedshiftServerlessService.class);
+ when(serverless.workgroupArns(REGION)).thenAnswer(invocation -> new HashSet<>(liveArns));
+ liveWorkgroup(WORKGROUP_ARN);
+ service = new RedshiftServerlessUsageLimitService(storageFactory, regionResolver, serverless);
+ }
+
+ private void liveWorkgroup(String arn) {
+ Workgroup workgroup = new Workgroup();
+ workgroup.setWorkgroupArn(arn);
+ liveArns.add(arn);
+ when(serverless.findWorkgroupByArn(arn, REGION)).thenReturn(Optional.of(workgroup));
+ }
+
+ private void removeWorkgroup(String arn) {
+ liveArns.remove(arn);
+ when(serverless.findWorkgroupByArn(arn, REGION)).thenReturn(Optional.empty());
+ }
+
+ private UsageLimit create(long amount) {
+ return service.createUsageLimit(WORKGROUP_ARN, "serverless-compute", amount, null, null, REGION);
+ }
+
+ private static String errorCode(Runnable call) {
+ return assertThrows(AwsException.class, call::run).getErrorCode();
+ }
+
+ private static void assertResourceNotFound(Runnable call) {
+ AwsException exception = assertThrows(AwsException.class, call::run);
+ assertEquals("ResourceNotFoundException", exception.getErrorCode());
+ assertEquals(400, exception.getHttpStatus());
+ }
+
+ @Test
+ void createAppliesAwsDefaultsAndBuildsTheArn() {
+ UsageLimit limit = create(100);
+
+ assertEquals("monthly", limit.getPeriod());
+ assertEquals("log", limit.getBreachAction());
+ assertEquals(100, limit.getAmount());
+ assertEquals(WORKGROUP_ARN, limit.getResourceArn());
+ assertEquals(limit.getUsageLimitId(), UUID.fromString(limit.getUsageLimitId()).toString());
+ assertEquals("arn:aws:redshift-serverless:us-east-1:" + ACCOUNT_ID + ":usagelimit/" + limit.getUsageLimitId(),
+ limit.getUsageLimitArn());
+ }
+
+ @Test
+ void createKeepsAnExplicitPeriodAndBreachAction() {
+ UsageLimit limit = service.createUsageLimit(WORKGROUP_ARN, "cross-region-datasharing", 5L,
+ "weekly", "deactivate", REGION);
+
+ assertEquals("weekly", limit.getPeriod());
+ assertEquals("deactivate", limit.getBreachAction());
+ assertEquals("cross-region-datasharing", limit.getUsageType());
+ }
+
+ @Test
+ void createRejectsInvalidInput() {
+ assertEquals("ValidationException", errorCode(() -> create(0)));
+ assertEquals("ValidationException", errorCode(() -> create(-1)));
+ assertEquals("ValidationException", errorCode(() ->
+ service.createUsageLimit(WORKGROUP_ARN, "serverless-compute", null, null, null, REGION)));
+ assertEquals("ValidationException", errorCode(() ->
+ service.createUsageLimit(WORKGROUP_ARN, "other", 1L, null, null, REGION)));
+ assertEquals("ValidationException", errorCode(() ->
+ service.createUsageLimit(WORKGROUP_ARN, null, 1L, null, null, REGION)));
+ assertEquals("ValidationException", errorCode(() ->
+ service.createUsageLimit(WORKGROUP_ARN, "serverless-compute", 1L, "hourly", null, REGION)));
+ assertEquals("ValidationException", errorCode(() ->
+ service.createUsageLimit(WORKGROUP_ARN, "serverless-compute", 1L, null, "block", REGION)));
+ assertEquals("ValidationException", errorCode(() ->
+ service.createUsageLimit(" ", "serverless-compute", 1L, null, null, REGION)));
+ }
+
+ @Test
+ void createRejectsAnUnknownWorkgroup() {
+ String missing = "arn:aws:redshift-serverless:us-east-1:" + ACCOUNT_ID + ":workgroup/absent";
+ removeWorkgroup(missing);
+
+ assertResourceNotFound(() ->
+ service.createUsageLimit(missing, "serverless-compute", 1L, null, null, REGION));
+ }
+
+ @Test
+ void createAllowsMultipleLimitsOnTheSameWorkgroup() {
+ UsageLimit first = service.createUsageLimit(WORKGROUP_ARN, "serverless-compute", 100L,
+ "daily", "log", REGION);
+ UsageLimit second = service.createUsageLimit(WORKGROUP_ARN, "serverless-compute", 500L,
+ "monthly", "deactivate", REGION);
+
+ assertEquals("daily", first.getPeriod());
+ assertEquals("monthly", second.getPeriod());
+ assertEquals(2, service.listUsageLimits(WORKGROUP_ARN, "serverless-compute", REGION, null, null)
+ .items().size());
+ }
+
+ @Test
+ void getAndDeleteRejectAnUnknownId() {
+ assertResourceNotFound(() -> service.getUsageLimit("absent", REGION));
+ assertResourceNotFound(() -> service.deleteUsageLimit("absent", REGION));
+ assertEquals("ValidationException", errorCode(() -> service.getUsageLimit(null, REGION)));
+ }
+
+ @Test
+ void deleteRemovesTheLimitAndReturnsIt() {
+ UsageLimit limit = create(1);
+
+ UsageLimit deleted = service.deleteUsageLimit(limit.getUsageLimitId(), REGION);
+
+ assertEquals(limit.getUsageLimitId(), deleted.getUsageLimitId());
+ assertResourceNotFound(() -> service.getUsageLimit(limit.getUsageLimitId(), REGION));
+ create(3);
+ }
+
+ @Test
+ void updateChangesOnlyTheSuppliedFields() {
+ UsageLimit limit = service.createUsageLimit(WORKGROUP_ARN, "serverless-compute", 10L,
+ "daily", "emit-metric", REGION);
+
+ UsageLimit amountOnly = service.updateUsageLimit(limit.getUsageLimitId(), 20L, null, REGION);
+ assertEquals(20, amountOnly.getAmount());
+ assertEquals("emit-metric", amountOnly.getBreachAction());
+ assertEquals("daily", amountOnly.getPeriod());
+
+ UsageLimit actionOnly = service.updateUsageLimit(limit.getUsageLimitId(), null, "deactivate", REGION);
+ assertEquals(20, actionOnly.getAmount());
+ assertEquals("deactivate", actionOnly.getBreachAction());
+ assertEquals("deactivate", service.getUsageLimit(limit.getUsageLimitId(), REGION).getBreachAction());
+ }
+
+ @Test
+ void updateRejectsInvalidInputAndUnknownId() {
+ UsageLimit limit = create(10);
+
+ assertEquals("ValidationException", errorCode(() ->
+ service.updateUsageLimit(limit.getUsageLimitId(), 0L, null, REGION)));
+ assertEquals("ValidationException", errorCode(() ->
+ service.updateUsageLimit(limit.getUsageLimitId(), null, "block", REGION)));
+ assertResourceNotFound(() ->
+ service.updateUsageLimit("absent", 1L, null, REGION));
+ assertEquals(10, service.getUsageLimit(limit.getUsageLimitId(), REGION).getAmount());
+ }
+
+ @Test
+ void listFiltersByResourceAndUsageType() {
+ String otherArn = "arn:aws:redshift-serverless:us-east-1:" + ACCOUNT_ID + ":workgroup/wg-2";
+ liveWorkgroup(otherArn);
+ create(1);
+ service.createUsageLimit(WORKGROUP_ARN, "cross-region-datasharing", 2L, null, null, REGION);
+ service.createUsageLimit(otherArn, "serverless-compute", 3L, null, null, REGION);
+
+ assertEquals(3, service.listUsageLimits(null, null, REGION, null, null).items().size());
+ assertEquals(2, service.listUsageLimits(WORKGROUP_ARN, null, REGION, null, null).items().size());
+ assertEquals(2, service.listUsageLimits(null, "serverless-compute", REGION, null, null).items().size());
+ assertEquals(1, service.listUsageLimits(otherArn, "serverless-compute", REGION, null, null).items().size());
+ assertEquals("ValidationException", errorCode(() ->
+ service.listUsageLimits(null, "other", REGION, null, null)));
+ }
+
+ @Test
+ void listPaginates() {
+ String second = "arn:aws:redshift-serverless:us-east-1:" + ACCOUNT_ID + ":workgroup/wg-2";
+ liveWorkgroup(second);
+ create(1);
+ service.createUsageLimit(second, "serverless-compute", 2L, null, null, REGION);
+
+ PaginatedResult<UsageLimit> first = service.listUsageLimits(null, null, REGION, 1, null);
+ assertEquals(1, first.items().size());
+ assertTrue(first.nextToken() != null);
+
+ PaginatedResult<UsageLimit> rest = service.listUsageLimits(null, null, REGION, 1, first.nextToken());
+ assertEquals(1, rest.items().size());
+ assertTrue(rest.nextToken() == null);
+ assertEquals("InvalidPaginationException", errorCode(() ->
+ service.listUsageLimits(null, null, REGION, 101, null)));
+ }
+
+ @Test
+ void listStillPagesAfterTheLimitBehindTheTokenIsDeleted() {
+ String second = "arn:aws:redshift-serverless:us-east-1:" + ACCOUNT_ID + ":workgroup/wg-2";
+ liveWorkgroup(second);
+ create(1);
+ service.createUsageLimit(second, "serverless-compute", 2L, null, null, REGION);
+
+ PaginatedResult<UsageLimit> first = service.listUsageLimits(null, null, REGION, 1, null);
+ service.deleteUsageLimit(first.items().get(0).getUsageLimitId(), REGION);
+
+ PaginatedResult<UsageLimit> rest = service.listUsageLimits(null, null, REGION, 1, first.nextToken());
+ assertEquals(1, rest.items().size());
+ assertTrue(rest.nextToken() == null);
+ }
+
+ @Test
+ void getRemovesTheRecordOfADeletedWorkgroup() {
+ UsageLimit limit = create(1);
+ removeWorkgroup(WORKGROUP_ARN);
+ assertResourceNotFound(() -> service.getUsageLimit(limit.getUsageLimitId(), REGION));
+
+ // The same ARN is live again, which only a record that survived the Get could answer for.
+ liveWorkgroup(WORKGROUP_ARN);
+ assertResourceNotFound(() -> service.getUsageLimit(limit.getUsageLimitId(), REGION));
+ }
+
+ @Test
+ void aLimitDisappearsWithItsWorkgroup() {
+ UsageLimit limit = create(1);
+ removeWorkgroup(WORKGROUP_ARN);
+
+ assertResourceNotFound(() -> service.getUsageLimit(limit.getUsageLimitId(), REGION));
+ assertTrue(service.listUsageLimits(null, null, REGION, null, null).items().isEmpty());
+ }
+
+ @Test
+ void clearRemovesEveryLimit() {
+ create(1);
+
+ service.clear();
+
+ assertTrue(service.listUsageLimits(null, null, REGION, null, null).items().isEmpty());
+ }
+}