Light, fluffy, and always free - The AWS Local Emulator alternative
fix(kinesis): honor stream listing limits (#6145)
Aniket Shukla52c54834b0b1
diff --git a/docs/services/kinesis.md b/docs/services/kinesis.mdindex 3870e40bdb..375bb37f4d 100644--- a/docs/services/kinesis.md+++ b/docs/services/kinesis.md@@ -39,6 +39,17 @@| `UpdateShardCount` | - |<!-- floci:actions:end -->+## Stream Listing++`ListStreams` returns sorted `StreamNames`, with at most 100 names per page by default.+`Limit` accepts integers from 1 to 10000, but values above 100 still return at most 100 names.+When `HasMoreStreams` is true, pass the last returned name as `ExclusiveStartStreamName`+to continue. Truncated pages also return `NextToken`, which CLI and SDK paginators can send+back without an `ExclusiveStartStreamName`. Tokens are scoped to this operation and region,+use the same configurable lifetime as `ListShards` tokens (see the TTL setting below),+and remain usable if the cursor stream is deleted.+`StreamSummaries` are not currently modeled.+## Local Inspection EndpointsThese endpoints are Floci-local read-only helpers for the UI and tests. AWS SDK@@ -100,7 +111,7 @@ action, so that limit is intentionally unenforced here.| Variable | Default | Description ||---|---|---|| `FLOCI_SERVICES_KINESIS_ENABLED` | `true` | Enable or disable the service |-| `FLOCI_SERVICES_KINESIS_LIST_SHARDS_NEXT_TOKEN_TTL_MILLIS` | `300000` | Lifetime of a `ListShards` `NextToken` in milliseconds; AWS expires tokens after 300000 ms. Lower it to exercise `ExpiredNextTokenException` without waiting |+| `FLOCI_SERVICES_KINESIS_LIST_SHARDS_NEXT_TOKEN_TTL_MILLIS` | `300000` | Lifetime of `ListShards` and `ListStreams` `NextToken` values in milliseconds. Lower it to exercise `ExpiredNextTokenException` without waiting |## Enhanced Fan-Out (EFO)diff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 2e34c2c1ee..853bec0f63 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -1988,9 +1988,8 @@ public interface EmulatorConfig {boolean enabled();/**- * Lifetime of a ListShards NextToken, in milliseconds. AWS expires these tokens 300000- * milliseconds after they are issued; lowering it lets tests exercise the expiry path- * without waiting.+ * Lifetime of ListShards and ListStreams NextTokens, in milliseconds. Defaults to 300000;+ * lowering it lets tests exercise the expiry path without waiting.*/@WithDefault("300000")long listShardsNextTokenTtlMillis();diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandler.javaindex 96e6ae8aac..f548505bca 100644--- a/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandler.java@@ -37,17 +37,17 @@ public class KinesisJsonHandler {private final KinesisService service;private final ObjectMapper objectMapper;- private final long listShardsNextTokenTtlMillis;+ private final long nextTokenTtlMillis;@Injectpublic KinesisJsonHandler(KinesisService service, ObjectMapper objectMapper, EmulatorConfig config) {this(service, objectMapper, config.services().kinesis().listShardsNextTokenTtlMillis());}- KinesisJsonHandler(KinesisService service, ObjectMapper objectMapper, long listShardsNextTokenTtlMillis) {+ KinesisJsonHandler(KinesisService service, ObjectMapper objectMapper, long nextTokenTtlMillis) {this.service = service;this.objectMapper = objectMapper;- this.listShardsNextTokenTtlMillis = listShardsNextTokenTtlMillis;+ this.nextTokenTtlMillis = nextTokenTtlMillis;}public Response handle(String action, JsonNode request, String region) {@@ -225,14 +225,55 @@ public class KinesisJsonHandler {}private Response handleListStreams(JsonNode request, String region) {- List<String> streamNames = service.listStreams(region);+ int limit = 100;+ if (request.hasNonNull("Limit")) {+ JsonNode value = request.get("Limit");+ if (!value.isIntegralNumber() || !value.canConvertToInt() || value.intValue() < 1 || value.intValue() > 10000) {+ throw new AwsException("InvalidArgumentException", "Limit must be an integer between 1 and 10000", 400);+ }+ limit = Math.min(value.intValue(), 100);+ }+ JsonNode start = request.path("ExclusiveStartStreamName");+ String startName = start.asText(null);+ if (!start.isMissingNode() && !start.isNull()+ && (!start.isTextual() || !startName.matches("[a-zA-Z0-9_.-]{1,128}"))) {+ throw new AwsException("InvalidArgumentException", "ExclusiveStartStreamName must be a valid stream name", 400);+ }+ JsonNode token = request.path("NextToken");+ if (!token.isMissingNode() && !token.isNull() && !token.isTextual()) {+ throw invalidNextToken();+ }+ String after = token.isTextual() ? streamCursorFromToken(decodeNextToken(token.textValue()), region) : startName;+ List<String> streamNames = service.listStreams(region).stream()+ .filter(name -> after == null || name.compareTo(after) > 0)+ .toList();+ List<String> page = streamNames.stream().limit(limit).toList();ObjectNode response = objectMapper.createObjectNode();ArrayNode names = response.putArray("StreamNames");- streamNames.forEach(names::add);- response.put("HasMoreStreams", false);+ page.forEach(names::add);+ response.put("HasMoreStreams", streamNames.size() > limit);+ if (streamNames.size() > limit) {+ response.put("NextToken", encodeNextToken("ListStreams|" + region,+ Base64Url.encode(page.getLast()), System.currentTimeMillis()));+ }return Response.ok(response).build();}+ private String streamCursorFromToken(PaginationToken token, String region) {+ if (!("ListStreams|" + region).equals(token.scope())) {+ throw invalidNextToken();+ }+ try {+ String cursor = new String(Base64.getUrlDecoder().decode(token.cursor()), StandardCharsets.UTF_8);+ if (!Base64Url.encode(cursor).equals(token.cursor())) {+ throw invalidNextToken();+ }+ return cursor;+ } catch (IllegalArgumentException e) {+ throw invalidNextToken();+ }+ }+private Response handleDescribeStream(JsonNode request, String region) {String streamName = resolveStreamName(request);KinesisStream stream = service.describeStream(streamName, region);@@ -705,7 +746,7 @@ public class KinesisJsonHandler {private Response handleListShards(JsonNode request, String region) {String nextToken = request.hasNonNull("NextToken") ? request.path("NextToken").asText() : null;- ShardToken token = nextToken == null ? null : decodeShardToken(nextToken);+ PaginationToken token = nextToken == null ? null : decodeNextToken(nextToken);String resolvedStreamName = token == null? resolveStreamName(request): streamNameFromToken(request, token);@@ -727,7 +768,7 @@ public class KinesisJsonHandler {int start = token == null ? 0 : resumeShardIndex(token, snapshot);List<KinesisShard> page = paginateShards(snapshot.subList(start, snapshot.size()), maxResults);String nextCursor = start + page.size() < snapshot.size() && !page.isEmpty()- ? encodeShardToken(resolvedStreamName, page.get(page.size() - 1).getShardId(),+ ? encodeNextToken(resolvedStreamName, page.get(page.size() - 1).getShardId(),System.currentTimeMillis()): null;@@ -760,36 +801,44 @@ public class KinesisJsonHandler {}/**- * Opaque, stream-bound cursor for ListShards. It carries the stream name, the last shard id of- * the emitted page, and the issue time, so a client can resume from the token alone without- * resending the stream name and without depending on a shard's position in the live list.+ * Opaque cursor shared by ListStreams and ListShards, bound to a scope and issue time.+ * ListStreams scopes include the operation and region; ListShards scopes name the stream.*/- static String encodeShardToken(String streamName, String lastShardId, long issuedAtEpochMilli) {- String raw = streamName + "|" + lastShardId + "|" + issuedAtEpochMilli;+ static String encodeNextToken(String scope, String cursor, long issuedAtEpochMilli) {+ String raw = scope + "|" + cursor + "|" + issuedAtEpochMilli;return Base64Url.encode(raw);}- ShardToken decodeShardToken(String nextToken) {+ private PaginationToken decodeNextToken(String nextToken) {+ if (nextToken.isEmpty() || nextToken.length() > 1_048_576) {+ throw invalidNextToken();+ }String decoded;try {decoded = new String(Base64.getUrlDecoder().decode(nextToken), StandardCharsets.UTF_8);} catch (IllegalArgumentException e) {throw invalidNextToken();}- String[] parts = decoded.split("\\|", -1);- if (parts.length != 3 || parts[0].isEmpty() || parts[1].isEmpty()) {+ int timestampSeparator = decoded.lastIndexOf('|');+ int cursorSeparator = decoded.lastIndexOf('|', timestampSeparator - 1);+ if (cursorSeparator < 1) {throw invalidNextToken();}long issuedAtEpochMilli;try {- issuedAtEpochMilli = Long.parseLong(parts[2]);+ issuedAtEpochMilli = Long.parseLong(decoded.substring(timestampSeparator + 1));} catch (NumberFormatException e) {throw invalidNextToken();}- if (System.currentTimeMillis() - issuedAtEpochMilli >= listShardsNextTokenTtlMillis) {+ long now = System.currentTimeMillis();+ if (issuedAtEpochMilli > now) {+ throw invalidNextToken();+ }+ if (issuedAtEpochMilli <= now - nextTokenTtlMillis) {throw new AwsException("ExpiredNextTokenException", "The NextToken has expired.", 400);}- return new ShardToken(parts[0], parts[1], issuedAtEpochMilli);+ return new PaginationToken(decoded.substring(0, cursorSeparator),+ decoded.substring(cursorSeparator + 1, timestampSeparator), issuedAtEpochMilli);}/**@@ -798,24 +847,27 @@ public class KinesisJsonHandler {* {@code StreamARN} is tolerated when it names the same stream the token does, which keeps an* SDK that fills the ARN in for routing working, and rejected when it names a different one.*/- private String streamNameFromToken(JsonNode request, ShardToken token) {+ private String streamNameFromToken(JsonNode request, PaginationToken token) {+ if (token.scope().contains("|") || token.cursor().isEmpty()) {+ throw invalidNextToken();+ }if (request.hasNonNull("StreamName")) {throw new AwsException("InvalidArgumentException","StreamName cannot be specified together with NextToken.", 400);}if (request.hasNonNull("StreamARN")) {String arnStreamName = parseStreamNameFromArn(request.path("StreamARN").asText());- if (!token.streamName().equals(arnStreamName)) {+ if (!token.scope().equals(arnStreamName)) {throw new AwsException("InvalidArgumentException","The NextToken does not belong to the stream named by StreamARN.", 400);}}- return token.streamName();+ return token.scope();}- private static int resumeShardIndex(ShardToken token, List<KinesisShard> shards) {+ private static int resumeShardIndex(PaginationToken token, List<KinesisShard> shards) {for (int i = 0; i < shards.size(); i++) {- if (shards.get(i).getShardId().equals(token.lastShardId())) {+ if (shards.get(i).getShardId().equals(token.cursor())) {return i + 1;}}@@ -827,10 +879,9 @@ public class KinesisJsonHandler {}/**- * Decoded ListShards cursor: the stream it belongs to, the last shard id it covered, and when it- * was issued (epoch millis, for expiry).+ * Decoded scoped cursor and its issue time (epoch millis).*/- record ShardToken(String streamName, String lastShardId, long issuedAtEpochMilli) {+ private record PaginationToken(String scope, String cursor, long issuedAtEpochMilli) {}/**diff --git a/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisListStreamsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisListStreamsIntegrationTest.javanew file mode 100644index 0000000000..7de25bdce8--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisListStreamsIntegrationTest.java@@ -0,0 +1,63 @@+package io.github.hectorvent.floci.services.kinesis;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.Response;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.util.ArrayList;+import java.util.List;+import java.util.Map;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++@QuarkusTest+class KinesisListStreamsIntegrationTest {++ private final List<String> streams = new ArrayList<>();++ @BeforeAll+ static void configureContentTypes() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @AfterEach+ void deleteOwnedStreams() {+ for (String stream : streams) {+ kinesis("DeleteStream", Map.of("StreamName", stream)).then().statusCode(200);+ }+ }++ @Test+ void followsNameBasedPagesOverTheAwsJsonEndpoint() {+ String prefix = "page-" + UUID.randomUUID();+ for (String suffix : List.of("-a", "-b")) {+ String stream = prefix + suffix;+ kinesis("CreateStream", Map.of("StreamName", stream, "ShardCount", 1)).then().statusCode(200);+ streams.add(stream);+ }+ Response first = kinesis("ListStreams", Map.of("Limit", 1, "ExclusiveStartStreamName", prefix))+ .then().statusCode(200).extract().response();+ assertEquals(List.of(streams.get(0)), first.jsonPath().getList("StreamNames", String.class));+ assertTrue(first.jsonPath().getBoolean("HasMoreStreams"));+ String token = first.jsonPath().getString("NextToken");+ assertTrue(token != null && !token.isEmpty());+ Response tokenPage = kinesis("ListStreams", Map.of("Limit", 1, "NextToken", token))+ .then().statusCode(200).extract().response();+ assertEquals(List.of(streams.get(1)), tokenPage.jsonPath().getList("StreamNames", String.class));+ Response last = kinesis("ListStreams", Map.of("Limit", 1, "ExclusiveStartStreamName", streams.get(0)))+ .then().statusCode(200).extract().response();+ assertEquals(List.of(streams.get(1)), last.jsonPath().getList("StreamNames", String.class));+ }++ private Response kinesis(String action, Map<String, ?> body) {+ return given().contentType("application/x-amz-json-1.1")+ .header("Authorization", "AWS4-HMAC-SHA256 Credential=test/20261021/eu-central-2/kinesis/aws4_request")+ .header("X-Amz-Target", "Kinesis_20131202." + action).body(body).post("/");+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisListStreamsTest.java b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisListStreamsTest.javanew file mode 100644index 0000000000..1627113b01--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisListStreamsTest.java@@ -0,0 +1,102 @@+package io.github.hectorvent.floci.services.kinesis;++import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import jakarta.ws.rs.core.Response;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;++import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++class KinesisListStreamsTest {++ private static final String REGION = "us-east-1";+ private final ObjectMapper mapper = new ObjectMapper();+ private final KinesisService service = new KinesisService(new InMemoryStorage<>(), new InMemoryStorage<>(),+ new RegionResolver(REGION, "000000000000"));+ private final KinesisJsonHandler handler = new KinesisJsonHandler(service, mapper, 300_000);++ @Test+ void pagesSortedNamesUsingAnExclusiveStartName() throws Exception {+ create("zeta", REGION);+ create("alpha", REGION);+ create("mu", REGION);+ create("other-region", "eu-west-1");++ ObjectNode first = list(Map.of("Limit", 1));+ assertEquals(List.of("alpha"), names(first));+ assertTrue(first.path("HasMoreStreams").asBoolean());+ ObjectNode second = list(Map.of("Limit", 1, "ExclusiveStartStreamName", "alpha"));+ assertEquals(List.of("mu"), names(second));+ assertTrue(second.path("HasMoreStreams").asBoolean());+ ObjectNode last = list(Map.of("Limit", 1, "ExclusiveStartStreamName", "mu"));+ assertEquals(List.of("zeta"), names(last));+ assertFalse(last.path("HasMoreStreams").asBoolean());+ ObjectNode empty = list(Map.of("ExclusiveStartStreamName", "zeta"));+ assertEquals(List.of(), names(empty));+ assertFalse(empty.path("HasMoreStreams").asBoolean());+ assertEquals(List.of("alpha", "mu", "zeta"), names(list(Map.of("Limit", 3))));+ assertFalse(list(Map.of("Limit", 3)).path("HasMoreStreams").asBoolean());+ }++ @ParameterizedTest+ @ValueSource(strings = {"{}", "{\"Limit\":101}", "{\"Limit\":10000}"})+ void defaultsAndLargeLimitsStillCapEachPageAtOneHundred(String request) throws Exception {+ for (int i = 0; i < 101; i++) {+ create(String.format("stream-%03d", i), REGION);+ }+ ObjectNode first = list(mapper.readTree(request));+ assertEquals(100, names(first).size());+ assertTrue(first.path("HasMoreStreams").asBoolean());+ ObjectNode last = list(Map.of("ExclusiveStartStreamName", "stream-099"));+ assertEquals(List.of("stream-100"), names(last));+ assertFalse(last.path("HasMoreStreams").asBoolean());+ }++ @ParameterizedTest+ @ValueSource(strings = {"0", "-1", "10001", "1.5", "\"one\"", "999999999999999999999"})+ void rejectsInvalidLimitsEvenForAnEmptyRegion(String limit) throws Exception {+ ObjectNode request = (ObjectNode) mapper.readTree("{\"Limit\":" + limit + "}");+ AwsException error = assertThrows(AwsException.class, () -> list(request));+ assertEquals("InvalidArgumentException", error.getErrorCode());+ assertEquals(400, error.getHttpStatus());+ }++ @ParameterizedTest+ @ValueSource(strings = {"\"\"", "\"invalid/name\"", "123"})+ void rejectsInvalidExclusiveStartNames(String name) throws Exception {+ ObjectNode request = (ObjectNode) mapper.readTree("{\"ExclusiveStartStreamName\":" + name + "}");+ AwsException error = assertThrows(AwsException.class, () -> list(request));+ assertEquals("InvalidArgumentException", error.getErrorCode());+ assertEquals(400, error.getHttpStatus());+ }++ private void create(String name, String region) {+ try (Response response = handler.handle("CreateStream",+ mapper.valueToTree(Map.of("StreamName", name, "ShardCount", 1)), region)) {+ assertEquals(200, response.getStatus());+ }+ }++ private ObjectNode list(Object request) {+ try (Response response = handler.handle("ListStreams", mapper.valueToTree(request), REGION)) {+ assertEquals(200, response.getStatus());+ return (ObjectNode) response.getEntity();+ }+ }++ private List<String> names(ObjectNode response) {+ return mapper.convertValue(response.path("StreamNames"),+ mapper.getTypeFactory().constructCollectionType(List.class, String.class));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisListStreamsTokenTest.java b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisListStreamsTokenTest.javanew file mode 100644index 0000000000..7a5c0389a2--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisListStreamsTokenTest.java@@ -0,0 +1,166 @@+package io.github.hectorvent.floci.services.kinesis;++import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.Base64Url;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import jakarta.ws.rs.core.Response;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;++import java.util.ArrayList;+import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++class KinesisListStreamsTokenTest {++ private static final String REGION = "us-east-1";+ private final ObjectMapper mapper = new ObjectMapper();+ private final KinesisService service = new KinesisService(new InMemoryStorage<>(), new InMemoryStorage<>(),+ new RegionResolver(REGION, "000000000000"));+ private final KinesisJsonHandler handler = new KinesisJsonHandler(service, mapper, 300_000);++ @Test+ void collectsAllOneHundredFiftyStreamsUsingOnlyNextToken() {+ List<String> expected = new ArrayList<>();+ for (int i = 0; i < 150; i++) {+ String name = String.format("stream-%03d", i);+ service.createStream(name, 1, REGION);+ expected.add(name);+ }+ ObjectNode first = list(Map.of());+ List<String> seen = new ArrayList<>(names(first));+ assertEquals(100, seen.size());+ assertTrue(first.path("HasMoreStreams").asBoolean());+ assertTrue(first.hasNonNull("NextToken"));++ ObjectNode last = list(Map.of("NextToken", first.path("NextToken").asText()));+ assertEquals(50, names(last).size());+ seen.addAll(names(last));+ assertEquals(expected, seen);+ assertFalse(last.path("HasMoreStreams").asBoolean());+ assertFalse(last.has("NextToken"));+ }++ @Test+ void resumesAfterADeletedCursorAndAllowsADifferentPageSize() {+ createThreeStreams();+ ObjectNode first = list(Map.of("Limit", 1));+ assertEquals(List.of("a"), names(first));+ assertTrue(first.hasNonNull("NextToken"));+ service.deleteStream("a", REGION);++ ObjectNode last = list(Map.of("NextToken", first.path("NextToken").asText(), "Limit", 2));+ assertEquals(List.of("b", "c"), names(last));+ assertFalse(last.path("HasMoreStreams").asBoolean());+ assertFalse(last.has("NextToken"));+ assertFalse(list(Map.of("ExclusiveStartStreamName", "z")).has("NextToken"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"\"\"", "\"!\"", "\"YQ\"", "123", "{}", "[]", "false"})+ void rejectsMalformedAndNonStringTokens(String token) throws Exception {+ ObjectNode request = (ObjectNode) mapper.readTree("{\"NextToken\":" + token + "}");+ AwsException error = assertThrows(AwsException.class, () -> list(request));+ assertEquals("InvalidArgumentException", error.getErrorCode());+ assertEquals(400, error.getHttpStatus());+ }++ @Test+ void rejectsATokenFromAnotherRegionOrOperation() {+ createThreeStreams();+ ObjectNode first = list(Map.of("Limit", 1));+ assertTrue(first.hasNonNull("NextToken"));+ AwsException regionError = assertThrows(AwsException.class,+ () -> handler.handle("ListStreams", mapper.valueToTree(Map.of(+ "NextToken", first.path("NextToken").asText())), "eu-west-1"));+ assertEquals("InvalidArgumentException", regionError.getErrorCode());+ AwsException operationError = assertThrows(AwsException.class,+ () -> list(Map.of("NextToken", KinesisJsonHandler.encodeNextToken("a", "shard-0",+ System.currentTimeMillis()))));+ assertEquals("InvalidArgumentException", operationError.getErrorCode());+ AwsException reverseOperationError = assertThrows(AwsException.class,+ () -> handler.handle("ListShards", mapper.valueToTree(Map.of(+ "NextToken", first.path("NextToken").asText())), REGION));+ assertEquals("InvalidArgumentException", reverseOperationError.getErrorCode());+ }++ @Test+ void rejectsFutureTokens() {+ String token = KinesisJsonHandler.encodeNextToken("ListStreams|" + REGION,+ Base64Url.encode("a"), System.currentTimeMillis() + 60_000);+ AwsException error = assertThrows(AwsException.class, () -> list(Map.of("NextToken", token)));+ assertEquals("InvalidArgumentException", error.getErrorCode());+ assertEquals(400, error.getHttpStatus());+ }++ @ParameterizedTest+ @ValueSource(strings = {"ListStreams", "ListShards"})+ void usesConfiguredExpiryForBothListOperations(String operation) {+ service.createStream("a", 3, REGION);+ service.createStream("b", 1, REGION);+ KinesisJsonHandler expiringHandler = new KinesisJsonHandler(service, mapper, 0);+ Map<String, ?> firstRequest = "ListStreams".equals(operation)+ ? Map.of("Limit", 1) : Map.of("StreamName", "a", "MaxResults", 1);+ String token;+ try (Response first = expiringHandler.handle(operation, mapper.valueToTree(firstRequest), REGION)) {+ ObjectNode page = (ObjectNode) first.getEntity();+ assertTrue(page.hasNonNull("NextToken"));+ token = page.path("NextToken").asText();+ }++ AwsException error = assertThrows(AwsException.class,+ () -> expiringHandler.handle(operation, mapper.valueToTree(Map.of("NextToken", token)), REGION));+ assertEquals("ExpiredNextTokenException", error.getErrorCode());+ assertEquals(400, error.getHttpStatus());+ }++ @ParameterizedTest+ @ValueSource(strings = {"ListStreams", "ListShards"})+ void acceptsTokensMintedByThePreviousCodec(String operation) {+ service.createStream("a", 3, REGION);+ service.createStream("b", 1, REGION);+ String shardId = service.describeStream("a", REGION).getShards().getFirst().getShardId();+ String oldPayload = "ListStreams".equals(operation)+ ? "ListStreams|" + REGION + "|" + Base64Url.encode("a") : "a|" + shardId;+ String token = Base64Url.encode(oldPayload + "|" + System.currentTimeMillis());+ try (Response response = handler.handle(operation, mapper.valueToTree(Map.of("NextToken", token)), REGION)) {+ assertEquals(200, response.getStatus());+ ObjectNode page = (ObjectNode) response.getEntity();+ if ("ListStreams".equals(operation)) {+ assertEquals(List.of("b"), names(page));+ } else {+ assertEquals(2, page.path("Shards").size());+ assertEquals(service.describeStream("a", REGION).getShards().get(1).getShardId(),+ page.path("Shards").get(0).path("ShardId").asText());+ }+ assertFalse(page.has("NextToken"));+ }+ }++ private void createThreeStreams() {+ for (String name : List.of("a", "b", "c")) {+ service.createStream(name, 1, REGION);+ }+ }++ private ObjectNode list(Object request) {+ try (Response response = handler.handle("ListStreams", mapper.valueToTree(request), REGION)) {+ assertEquals(200, response.getStatus());+ return (ObjectNode) response.getEntity();+ }+ }++ private List<String> names(ObjectNode response) {+ return mapper.convertValue(response.path("StreamNames"),+ mapper.getTypeFactory().constructCollectionType(List.class, String.class));+ }+}