Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(redshift-serverless): add release track, managed workgroup and reservation reads (#5691)

Vũ Thế Huyd3fce1425656
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 32f9b52de6..65d6103bb0 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
@@ -13,6 +13,7 @@ import software.amazon.awssdk.services.redshiftserverless.model.GetCredentialsRe
import software.amazon.awssdk.services.redshiftserverless.model.Namespace;
import software.amazon.awssdk.services.redshiftserverless.model.NamespaceStatus;
import software.amazon.awssdk.services.redshiftserverless.model.ResourceNotFoundException;
+import software.amazon.awssdk.services.redshiftserverless.model.ServerlessTrack;
import software.amazon.awssdk.services.redshiftserverless.model.Snapshot;
import software.amazon.awssdk.services.redshiftserverless.model.Tag;
import software.amazon.awssdk.services.redshiftserverless.model.UsageLimit;
@@ -264,6 +265,29 @@ class RedshiftServerlessTest {
}
}
+ @Test
+ void releaseTracksUseAwsSdk() {
+ assumeFalse(TestFixtures.isRealAws(), "Asserts the emulator's static release tracks");
+ try (RedshiftServerlessClient client = TestFixtures.redshiftServerlessClient()) {
+ assertThat(client.listTracks(request -> {}).tracks())
+ .extracting(ServerlessTrack::trackName).containsExactly("current", "trailing");
+ assertThatThrownBy(() -> client.getTrack(request -> request.trackName("preview")))
+ .isInstanceOf(ResourceNotFoundException.class);
+ }
+ }
+
+ @Test
+ void reservationsAndManagedWorkgroupsAreEmptyUseAwsSdk() {
+ assumeFalse(TestFixtures.isRealAws(), "Asserts that the emulator offers no reservations");
+ try (RedshiftServerlessClient client = TestFixtures.redshiftServerlessClient()) {
+ assertThat(client.listManagedWorkgroups(request -> {}).managedWorkgroups()).isEmpty();
+ assertThat(client.listReservations(request -> {}).reservationsList()).isEmpty();
+ assertThat(client.listReservationOfferings(request -> {}).reservationOfferingsList()).isEmpty();
+ assertThatThrownBy(() -> client.getReservation(request -> request.reservationId("r-1")))
+ .isInstanceOf(ResourceNotFoundException.class);
+ }
+ }
+
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 c52882c359..d38199c04f 100644
--- a/docs/services/index.md
+++ b/docs/services/index.md
@@ -77,7 +77,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) | 43 |
| [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 | 25 |
+| [Redshift Serverless](redshift-serverless.md) | `POST /` + `X-Amz-Target: RedshiftServerless.*` | JSON 1.1 | 33 |
| [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 80c7e1ef9a..d9a759a7eb 100644
--- a/docs/services/redshift-serverless.md
+++ b/docs/services/redshift-serverless.md
@@ -37,6 +37,14 @@ For the upstream API shape, see the [Amazon Redshift Serverless API Reference](h
| `ListTagsForResource` | Return the tags on the namespace or workgroup named by `resourceArn` |
| `TagResource` | Merge tags into the namespace or workgroup named by `resourceArn` |
| `UntagResource` | Remove tags by key from the namespace or workgroup named by `resourceArn` |
+| `GetTrack` | Return one of the release tracks `current` and `trailing`; a track carries no `workgroupVersion` |
+| `ListTracks` | Page through the two release tracks |
+| `ListManagedWorkgroups` | Always an empty list: Floci models no Glue zero-ETL managed workgroups |
+| `ListReservations` | Always an empty list: Floci offers no reservations |
+| `ListReservationOfferings` | Always an empty list: Floci publishes no reservation offerings |
+| `GetReservation` | Always `ResourceNotFoundException`, as no reservation exists |
+| `GetReservationOffering` | Always `ResourceNotFoundException`, as no offering exists |
+| `CreateReservation` | Validates `capacity` and `offeringId`, then answers `ResourceNotFoundException` because no offering exists |
<!-- floci:actions:end -->
Namespace and workgroup state is account and Region scoped and persisted through `StorageFactory`.
diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminJsonHandler.java
new file mode 100644
index 0000000000..af13f19ddd
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminJsonHandler.java
@@ -0,0 +1,111 @@
+package io.github.hectorvent.floci.services.redshiftserverless;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import io.github.hectorvent.floci.core.common.PaginatedResult;
+import io.github.hectorvent.floci.core.common.Pagination;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.core.Response;
+
+import java.util.List;
+import java.util.function.Supplier;
+
+/**
+ * The Redshift Serverless actions that only describe or record metadata. The main
+ * {@link RedshiftServerlessJsonHandler} hands every action it does not know to this class. The
+ * request constraints (required members, patterns, lengths) are checked against the AWS model by
+ * {@link RedshiftServerlessRequestShapes} before the action reaches it.
+ */
+@ApplicationScoped
+public class RedshiftServerlessAdminJsonHandler {
+
+ private static final List<String> TRACK_NAMES = RedshiftServerlessService.TRACK_NAMES;
+
+ private final ObjectMapper objectMapper;
+
+ @Inject
+ public RedshiftServerlessAdminJsonHandler(ObjectMapper objectMapper) {
+ this.objectMapper = objectMapper;
+ }
+
+ Supplier<Response> operation(String action, JsonNode request, String region) {
+ return switch (action) {
+ case "GetTrack" -> () -> getTrack(ServerlessSupport.text(request, "trackName"));
+ case "ListTracks" -> () -> listTracks(request);
+ case "ListManagedWorkgroups" -> () -> listWithoutItems(request, "managedWorkgroups");
+ case "ListReservations" -> () -> listWithoutItems(request, "reservationsList");
+ case "ListReservationOfferings" -> () -> listWithoutItems(request, "reservationOfferingsList");
+ case "GetReservation" -> () -> getReservation(request);
+ case "GetReservationOffering" -> () -> getReservationOffering(request);
+ case "CreateReservation" -> () -> createReservation(request);
+ default -> null;
+ };
+ }
+
+ private Response getReservation(JsonNode request) {
+ throw ServerlessSupport.notFound("The reservation "
+ + ServerlessSupport.text(request, "reservationId") + " was not found.");
+ }
+
+ private Response getReservationOffering(JsonNode request) {
+ throw ServerlessSupport.notFound("The reservation offering "
+ + ServerlessSupport.text(request, "offeringId") + " was not found.");
+ }
+
+ private Response createReservation(JsonNode request) {
+ ServerlessSupport.integer(request, "capacity");
+ ServerlessSupport.text(request, "clientToken");
+ throw ServerlessSupport.notFound("The reservation offering "
+ + ServerlessSupport.text(request, "offeringId") + " was not found.");
+ }
+
+ // ── Tracks, managed workgroups and reservations ────────────────────────
+
+ /**
+ * The release tracks AWS defines. The model gives a track name only a pattern, not an enum, so an
+ * unknown name is a not-found here. Floci runs one PostgreSQL version, so a track names no workgroup version.
+ */
+ private Response getTrack(String trackName) {
+ if (!TRACK_NAMES.contains(trackName)) {
+ throw ServerlessSupport.notFound("The track " + trackName + " was not found.");
+ }
+ ObjectNode response = objectMapper.createObjectNode();
+ response.set("track", trackNode(trackName));
+ return Response.ok(response).build();
+ }
+
+ private Response listTracks(JsonNode request) {
+ PaginatedResult<String> page = Pagination.paginate(TRACK_NAMES, name -> name,
+ ServerlessSupport.maxResults(request), ServerlessSupport.text(request, "nextToken"),
+ 100, 100, "ValidationException");
+ ObjectNode response = objectMapper.createObjectNode();
+ ArrayNode items = response.putArray("tracks");
+ page.items().forEach(name -> items.add(trackNode(name)));
+ if (page.nextToken() != null) {
+ response.put("nextToken", page.nextToken());
+ }
+ return Response.ok(response).build();
+ }
+
+ private ObjectNode trackNode(String trackName) {
+ ObjectNode node = objectMapper.createObjectNode();
+ node.put("trackName", trackName);
+ node.putArray("updateTargets");
+ return node;
+ }
+
+ /**
+ * A list that is always empty, still validating the paging members the way AWS does. Floci models no
+ * Glue zero-ETL managed workgroups, publishes no reservation offerings and sells no reservations.
+ */
+ private Response listWithoutItems(JsonNode request, String listName) {
+ Pagination.paginate(List.<String>of(), name -> name, ServerlessSupport.maxResults(request),
+ ServerlessSupport.text(request, "nextToken"), 100, 100, "ValidationException");
+ ObjectNode response = objectMapper.createObjectNode();
+ response.putArray(listName);
+ return Response.ok(response).build();
+ }
+}
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 0bccc00ec7..bd8df19379 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
@@ -43,15 +43,18 @@ public class RedshiftServerlessJsonHandler {
private final ObjectMapper objectMapper;
private final RedshiftIamDbUserResolver iamDbUserResolver;
private final RedshiftServerlessUsageLimitService usageLimits;
+ private final RedshiftServerlessAdminJsonHandler admin;
@Inject
public RedshiftServerlessJsonHandler(RedshiftServerlessService service, ObjectMapper objectMapper,
RedshiftIamDbUserResolver iamDbUserResolver,
- RedshiftServerlessUsageLimitService usageLimits) {
+ RedshiftServerlessUsageLimitService usageLimits,
+ RedshiftServerlessAdminJsonHandler admin) {
this.service = service;
this.objectMapper = objectMapper;
this.iamDbUserResolver = iamDbUserResolver;
this.usageLimits = usageLimits;
+ this.admin = admin;
}
public Response handle(String action, JsonNode request, String region) {
@@ -87,7 +90,7 @@ public class RedshiftServerlessJsonHandler {
case "ListTagsForResource" -> () -> handleListTagsForResource(request, region);
case "TagResource" -> () -> handleTagResource(request, region);
case "UntagResource" -> () -> handleUntagResource(request, region);
- default -> null;
+ default -> admin.operation(action, request, region);
};
if (operation == null) {
return Response.status(400)
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 ab08667611..20e748dc66 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
@@ -88,6 +88,7 @@ public class RedshiftServerlessService implements Resettable {
public static final int DEFAULT_BASE_CAPACITY = 128;
public static final int DEFAULT_PORT = 5439;
public static final String DEFAULT_TRACK_NAME = "current";
+ public static final List<String> TRACK_NAMES = List.of("current", "trailing");
public static final String DEFAULT_IP_ADDRESS_TYPE = "ipv4";
public static final String DEFAULT_ADMIN_USERNAME = "admin";
public static final int DEFAULT_CREDENTIAL_DURATION_SECONDS = 900;
@@ -97,7 +98,6 @@ public class RedshiftServerlessService implements Resettable {
private static final int MAX_RETENTION_DAYS = 3653;
private static final Pattern SNAPSHOT_NAME = Pattern.compile("[a-z0-9-]+");
private static final Pattern WORKGROUP_NAME = Pattern.compile("[a-z0-9-]+");
- private static final Pattern TRACK_NAME = Pattern.compile("[a-zA-Z0-9_]+");
private static final Set<String> IP_ADDRESS_TYPES = Set.of("ipv4", "dualstack");
private static final Set<String> PERFORMANCE_TARGET_STATUSES = Set.of("ENABLED", "DISABLED");
@@ -993,10 +993,8 @@ public class RedshiftServerlessService implements Resettable {
if (settings.ipAddressType() != null && !IP_ADDRESS_TYPES.contains(settings.ipAddressType())) {
throw ServerlessSupport.validation("ipAddressType must be ipv4 or dualstack.");
}
- if (settings.trackName() != null
- && (settings.trackName().isEmpty() || settings.trackName().length() > 256
- || !TRACK_NAME.matcher(settings.trackName()).matches())) {
- throw ServerlessSupport.validation("trackName must be 1-256 characters of letters, numbers, and underscores.");
+ if (settings.trackName() != null && !TRACK_NAMES.contains(settings.trackName())) {
+ throw ServerlessSupport.validation("trackName must be one of " + TRACK_NAMES + ".");
}
PricePerformanceTarget target = settings.pricePerformanceTarget();
if (target != null) {
diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdministrationHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdministrationHandlerTest.java
new file mode 100644
index 0000000000..2e8cfb22ab
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdministrationHandlerTest.java
@@ -0,0 +1,120 @@
+package io.github.hectorvent.floci.services.redshiftserverless;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.github.hectorvent.floci.services.redshift.RedshiftIamDbUserResolver;
+import jakarta.ws.rs.core.Response;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.mockito.Mockito.mock;
+
+/**
+ * Covers the metadata-only Redshift Serverless actions through the handler, so both the stored
+ * behavior and the response shape the SDKs deserialize are checked.
+ */
+class RedshiftServerlessAdministrationHandlerTest {
+ private static final String REGION = "us-east-1";
+
+ private final ObjectMapper mapper = new ObjectMapper();
+ private RedshiftServerlessJsonHandler handler;
+
+ @BeforeEach
+ void setUp() {
+ handler = new RedshiftServerlessJsonHandler(mock(RedshiftServerlessService.class), mapper,
+ mock(RedshiftIamDbUserResolver.class), mock(RedshiftServerlessUsageLimitService.class),
+ new RedshiftServerlessAdminJsonHandler(mapper));
+ }
+
+ @Test
+ void tracksAreTheTwoAwsReleaseTracks() {
+ JsonNode track = ok("GetTrack", "{\"trackName\":\"trailing\"}").get("track");
+ assertEquals("trailing", track.get("trackName").textValue());
+ assertEquals(0, track.get("updateTargets").size());
+ assertEquals("ResourceNotFoundException", errorType("GetTrack", "{\"trackName\":\"nightly\"}"));
+ assertEquals("ResourceNotFoundException", errorType("GetTrack", "{\"trackName\":\"preview\"}"));
+ assertEquals("ValidationException", errorType("GetTrack", "{\"trackName\":\"not valid!\"}"));
+ assertEquals("ValidationException", errorType("GetTrack", "{}"));
+
+ assertEquals(2, ok("ListTracks", "{}").get("tracks").size());
+ JsonNode page = ok("ListTracks", "{\"maxResults\":1}");
+ assertEquals("current", page.get("tracks").get(0).get("trackName").textValue());
+ String next = page.get("nextToken").textValue();
+ JsonNode rest = ok("ListTracks", "{\"nextToken\":\"" + next + "\"}");
+ assertEquals(1, rest.get("tracks").size());
+ assertEquals("trailing", rest.get("tracks").get(0).get("trackName").textValue());
+ assertFalse(rest.has("nextToken"));
+ assertEquals("ValidationException", errorType("ListTracks", "{\"maxResults\":\"x\"}"));
+ assertEquals("ValidationException", errorType("ListTracks", "{\"maxResults\":0}"));
+ assertEquals("ValidationException", errorType("ListTracks", "{\"maxResults\":101}"));
+ assertEquals("ValidationException", errorType("ListTracks", "{\"nextToken\":\"bad-token\"}"));
+ }
+
+ @Test
+ void managedWorkgroupsAndReservationsAreEmptyBecauseFlociModelsNone() {
+ assertEquals(0, ok("ListManagedWorkgroups", "{}").get("managedWorkgroups").size());
+ assertEquals("ValidationException", errorType("ListManagedWorkgroups", "{\"sourceArn\":\"nope\"}"));
+ assertEquals(0, ok("ListManagedWorkgroups", "{\"sourceArn\":\"arn:aws:glue:us-east-1:123456789012:"
+ + "database/db\"}").get("managedWorkgroups").size());
+ assertEquals("ValidationException", errorType("ListManagedWorkgroups", "{\"maxResults\":0}"));
+ assertEquals("ValidationException", errorType("ListManagedWorkgroups", "{\"maxResults\":101}"));
+
+ assertEquals(0, ok("ListReservations", "{}").get("reservationsList").size());
+ assertEquals("ValidationException", errorType("ListReservations", "{\"maxResults\":0}"));
+ assertEquals("ValidationException", errorType("ListReservations", "{\"maxResults\":101}"));
+
+ assertEquals(0, ok("ListReservationOfferings", "{}").get("reservationOfferingsList").size());
+ assertEquals("ValidationException", errorType("ListReservationOfferings", "{\"maxResults\":0}"));
+ assertEquals("ValidationException", errorType("ListReservationOfferings", "{\"maxResults\":101}"));
+
+ assertEquals("ValidationException",
+ errorType("ListManagedWorkgroups", "{\"nextToken\":\"bad-token\"}"));
+ assertEquals("ValidationException",
+ errorType("ListReservations", "{\"nextToken\":\"bad-token\"}"));
+ assertEquals("ValidationException",
+ errorType("ListReservationOfferings", "{\"nextToken\":\"bad-token\"}"));
+
+ assertEquals("ResourceNotFoundException", errorType("GetReservation", "{\"reservationId\":\"r-1\"}"));
+ assertEquals("ValidationException", errorType("GetReservation", "{}"));
+ assertEquals("ValidationException", errorType("GetReservation", "{\"reservationId\":\"\"}"));
+ assertEquals("ResourceNotFoundException", errorType("GetReservationOffering", "{\"offeringId\":\"o-1\"}"));
+ assertEquals("ValidationException", errorType("GetReservationOffering", "{}"));
+ assertEquals("ValidationException", errorType("GetReservationOffering", "{\"offeringId\":\"\"}"));
+ assertEquals("ResourceNotFoundException",
+ errorType("CreateReservation", "{\"capacity\":128,\"offeringId\":\"o-1\"}"));
+ assertEquals("ValidationException", errorType("CreateReservation", "{\"offeringId\":\"o-1\"}"));
+ assertEquals("ValidationException",
+ errorType("CreateReservation", "{\"capacity\":\"nope\",\"offeringId\":\"o-1\"}"));
+ assertEquals("ValidationException",
+ errorType("CreateReservation", "{\"capacity\":128,\"offeringId\":\"o-1\",\"clientToken\":123}"));
+ }
+
+ @Test
+ void anUnknownActionIsStillRejected() {
+ assertEquals("UnknownOperationException", errorType("NoSuchOperation", "{}"));
+ }
+
+ private JsonNode ok(String action, String json) {
+ Response response = invoke(action, json);
+ assertEquals(200, response.getStatus(), action + " failed: " + response.getEntity());
+ return mapper.valueToTree(response.getEntity());
+ }
+
+ private String errorType(String action, String json) {
+ Response response = invoke(action, json);
+ assertEquals(400, response.getStatus(), action + " should be rejected: " + response.getEntity());
+ return mapper.valueToTree(response.getEntity()).path("__type").asText(null);
+ }
+
+ private Response invoke(String action, String json) {
+ try {
+ return handler.handle(action, mapper.readTree(json), REGION);
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+}
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 40d8a48ac8..432c73b52f 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
@@ -10,6 +10,7 @@ import org.junit.jupiter.api.Test;
import java.nio.file.Files;
import java.nio.file.Path;
+import java.util.List;
import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.equalTo;
@@ -481,6 +482,32 @@ class RedshiftServerlessIntegrationTest {
.body("__type", equalTo("ResourceNotFoundException"));
}
+ @Test
+ void releaseTracksAndEmptyListsRoundTripOverTheWire() {
+ call("ListTracks", "{}")
+ .statusCode(200)
+ .body("tracks.trackName", equalTo(List.of("current", "trailing")));
+ call("GetTrack", "{\"trackName\":\"trailing\"}")
+ .statusCode(200)
+ .body("track.trackName", equalTo("trailing"));
+ call("GetTrack", "{\"trackName\":\"preview\"}")
+ .statusCode(400)
+ .body("__type", equalTo("ResourceNotFoundException"));
+ call("GetTrack", "{}")
+ .statusCode(400)
+ .body("__type", equalTo("ValidationException"));
+
+ call("ListManagedWorkgroups", "{}").statusCode(200).body("managedWorkgroups", hasSize(0));
+ call("ListReservations", "{}").statusCode(200).body("reservationsList", hasSize(0));
+ call("ListReservationOfferings", "{}").statusCode(200).body("reservationOfferingsList", hasSize(0));
+ call("GetReservation", "{\"reservationId\":\"r-1\"}")
+ .statusCode(400)
+ .body("__type", equalTo("ResourceNotFoundException"));
+ call("CreateReservation", "{\"offeringId\":\"o-1\"}")
+ .statusCode(400)
+ .body("__type", equalTo("ValidationException"));
+ }
+
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 30777ab7ad..8691a2e509 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
@@ -86,7 +86,8 @@ class RedshiftServerlessJsonHandlerTest {
RedshiftServerlessService service =
new RedshiftServerlessService(storageFactory, regionResolver, endpoints, runtime, config);
handler = new RedshiftServerlessJsonHandler(service, mapper, iamDbUserResolver,
- new RedshiftServerlessUsageLimitService(storageFactory, regionResolver, service));
+ new RedshiftServerlessUsageLimitService(storageFactory, regionResolver, service),
+ new RedshiftServerlessAdminJsonHandler(mapper));
}
@Test
diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessServiceTest.java
index e0f5b48fa7..aef8559a63 100644
--- a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessServiceTest.java
@@ -1069,6 +1069,23 @@ class RedshiftServerlessServiceTest {
assertThrows(AwsException.class, () -> service.updateSnapshot(null, 5, REGION));
}
+ @Test
+ void creatingWorkgroupWithUnknownTrackNameIsRejected() {
+ create("tr-ns");
+ AwsException ex = assertThrows(AwsException.class, () ->
+ service.createWorkgroup("tr-wg", "tr-ns", settings(null, null, null, "nightly"), null, REGION));
+ assertEquals("ValidationException", ex.getErrorCode());
+ }
+
+ @Test
+ void updatingWorkgroupWithUnknownTrackNameIsRejected() {
+ create("upd-tr-ns");
+ createWorkgroup("upd-tr-wg", "upd-tr-ns");
+ AwsException ex = assertThrows(AwsException.class, () ->
+ service.updateWorkgroup("upd-tr-wg", settings(null, null, null, "preview"), REGION));
+ assertEquals("ValidationException", ex.getErrorCode());
+ }
+
private Namespace create(String namespaceName) {
return service.createNamespace(namespaceName, "admin", null, null, null, null, null, Map.of(), REGION);
}
diff --git a/tools/docs/services.yaml b/tools/docs/services.yaml
index 3cc24422a1..5e7712d247 100644
--- a/tools/docs/services.yaml
+++ b/tools/docs/services.yaml
@@ -323,6 +323,7 @@ services:
doc: docs/services/redshift-serverless.md
sources:
- { path: src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandler.java, mode: switch }
+ - { path: src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminJsonHandler.java, mode: switch }
- service: cognitoidentity
doc: docs/services/cognitoidentity.md
sources: