Light, fluffy, and always free - The AWS Local Emulator alternative
feat(secretsmanager): support Filters and pagination in BatchGetSecretValue (#1737)
Hector Venturac99dd75b87c9
diff --git a/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerJsonHandler.javaindex d31ebaa673..fa088cc7bd 100644--- a/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerJsonHandler.java@@ -1,6 +1,7 @@package io.github.hectorvent.floci.services.secretsmanager;import io.github.hectorvent.floci.core.common.AwsErrorResponse;+import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.services.secretsmanager.model.Secret;import io.github.hectorvent.floci.services.secretsmanager.model.SecretVersion;import com.fasterxml.jackson.databind.JsonNode;@@ -64,13 +65,61 @@ public class SecretsManagerJsonHandler {.build();}- List<String> secretIdList = new ArrayList<>();+ if (request.has("SecretIdList") && request.has("Filters")) {+ return Response.status(400)+ .entity(new AwsErrorResponse("InvalidParameterException", "You cannot specify both SecretIdList and Filters."))+ .build();+ }++ List<SecretsManagerService.BatchSecretValue> values;+ String nextToken = null;+if (request.has("SecretIdList")) {+ List<String> secretIdList = new ArrayList<>();request.path("SecretIdList").forEach(id -> secretIdList.add(id.asText()));- }+ try {+ values = service.batchGetSecretValue(secretIdList, region);+ } catch (AwsException e) {+ return Response.status(e.getHttpStatus())+ .entity(new AwsErrorResponse(e.jsonType(), e.getMessage()))+ .build();+ }+ } else {+ // Validate paging inputs before the service scans and filters the whole store.+ int maxResults = request.has("MaxResults") ? request.path("MaxResults").asInt() : 20;+ if (maxResults < 1 || maxResults > 20) {+ return Response.status(400)+ .entity(new AwsErrorResponse("InvalidParameterException", "MaxResults must be between 1 and 20."))+ .build();+ }- // Filters are not fully implemented yet, but for now we only support SecretIdList- List<SecretsManagerService.BatchSecretValue> values = service.batchGetSecretValue(secretIdList, region);+ int startIndex = 0;+ if (request.has("NextToken")) {+ try {+ startIndex = Integer.parseInt(request.path("NextToken").asText());+ if (startIndex < 0) {+ throw new NumberFormatException("negative NextToken");+ }+ } catch (NumberFormatException e) {+ return Response.status(400)+ .entity(new AwsErrorResponse("InvalidNextTokenException", "The NextToken value is invalid."))+ .build();+ }+ }++ List<SecretsManagerService.BatchSecretValue> allFilteredValues =+ service.batchGetSecretValueByFilters(parseFilters(request), region);++ if (startIndex > allFilteredValues.size()) {+ values = List.of();+ } else {+ int endIndex = Math.min(startIndex + maxResults, allFilteredValues.size());+ values = allFilteredValues.subList(startIndex, endIndex);+ if (endIndex < allFilteredValues.size()) {+ nextToken = String.valueOf(endIndex);+ }+ }+ }ObjectNode response = objectMapper.createObjectNode();ArrayNode secretValues = objectMapper.createArrayNode();@@ -96,6 +145,10 @@ public class SecretsManagerJsonHandler {secretValues.add(node);}response.set("SecretValues", secretValues);+ if (nextToken != null) {+ response.put("NextToken", nextToken);+ }+ response.set("Errors", objectMapper.createArrayNode());return Response.ok(response).build();}@@ -269,8 +322,23 @@ public class SecretsManagerJsonHandler {return Response.ok(response).build();}+ /** Parses the request's {@code Filters} array, shared by BatchGetSecretValue and ListSecrets. */+ private List<SecretsManagerService.Filter> parseFilters(JsonNode request) {+ List<SecretsManagerService.Filter> filters = new ArrayList<>();+ JsonNode filtersNode = request.path("Filters");+ if (filtersNode.isArray()) {+ for (JsonNode f : filtersNode) {+ String key = f.path("Key").asText();+ List<String> filterValues = new ArrayList<>();+ f.path("Values").forEach(v -> filterValues.add(v.asText()));+ filters.add(new SecretsManagerService.Filter(key, filterValues));+ }+ }+ return filters;+ }+private Response handleListSecrets(JsonNode request, String region) {- List<Secret> secrets = new ArrayList<>(service.listSecrets(region));+ List<Secret> secrets = new ArrayList<>(service.listSecrets(region, parseFilters(request)));// AWS lists secrets by CreatedDate when SortBy is absent; sort on it (name as a// tiebreaker) for AWS-matching, stable pagination across calls.secrets.sort(Comparator.comparing(Secret::getCreatedDate, Comparator.nullsLast(Comparator.naturalOrder()))diff --git a/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerService.java b/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerService.javaindex 4777d3128c..04a3897001 100644--- a/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerService.java+++ b/src/main/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerService.java@@ -23,6 +23,7 @@ import java.util.concurrent.Executors;import java.time.Instant;import java.util.ArrayList;+import java.util.Comparator;import java.util.HashMap;import java.util.List;import java.util.Map;@@ -292,6 +293,108 @@ public class SecretsManagerService {.orElse(false));}+ public List<Secret> listSecrets(String region, List<Filter> filters) {+ List<Secret> allSecrets = listSecrets(region);+ if (filters == null || filters.isEmpty()) {+ return allSecrets;+ }+ List<Secret> result = new ArrayList<>();+ for (Secret secret : allSecrets) {+ if (matchesFilters(secret, filters, region)) {+ result.add(secret);+ }+ }+ return result;+ }++ public List<BatchSecretValue> batchGetSecretValueByFilters(List<Filter> filters, String region) {+ List<BatchSecretValue> result = new ArrayList<>();+ List<Secret> allSecrets = listSecrets(region);+ for (Secret secret : allSecrets) {+ if (matchesFilters(secret, filters, region)) {+ SecretVersion version = findVersionByStage(secret, AWSCURRENT);+ if (version != null) {+ result.add(new BatchSecretValue(+ secret.getArn(),+ secret.getName(),+ version.getSecretString(),+ version.getSecretBinary(),+ version.getVersionId(),+ version.getVersionStages(),+ version.getCreatedDate()+ ));+ }+ }+ }+ // Stable order (created date, then name) so offset-based pagination in the handler+ // never skips or duplicates entries across calls — same contract as ListSecrets.+ result.sort(Comparator.comparing(BatchSecretValue::createdDate,+ Comparator.nullsLast(Comparator.naturalOrder()))+ .thenComparing(BatchSecretValue::name, Comparator.nullsLast(Comparator.naturalOrder())));+ return result;+ }++ private boolean matchesFilters(Secret secret, List<Filter> filters, String region) {+ if (filters == null || filters.isEmpty()) {+ return true;+ }+ for (Filter filter : filters) {+ if (!matchesFilter(secret, filter, region)) {+ return false;+ }+ }+ return true;+ }++ private boolean matchesFilter(Secret secret, Filter filter, String region) {+ String key = filter.key();+ List<String> values = filter.values();+ if (values == null || values.isEmpty()) {+ return true;+ }++ for (String val : values) {+ if (matchesValue(secret, key, val, region)) {+ return true;+ }+ }+ return false;+ }++ private boolean matchesValue(Secret secret, String key, String filterVal, String region) {+ boolean negate = filterVal.startsWith("!");+ String targetVal = negate ? filterVal.substring(1) : filterVal;++ boolean matched = matchesTarget(secret, key, targetVal, region);+ return negate ? !matched : matched;+ }++ private boolean matchesTarget(Secret secret, String key, String targetVal, String region) {+ return switch (key) {+ case "name" -> secret.getName() != null && secret.getName().startsWith(targetVal);+ case "description" -> secret.getDescription() != null && secret.getDescription().toLowerCase().startsWith(targetVal.toLowerCase());+ case "tag-key" -> secret.getTags() != null && secret.getTags().stream().anyMatch(t -> t.key() != null && t.key().startsWith(targetVal));+ case "tag-value" -> secret.getTags() != null && secret.getTags().stream().anyMatch(t -> t.value() != null && t.value().startsWith(targetVal));+ // Floci does not model cross-region replication, so every secret's primary region+ // IS the region it lives in — comparing the request region is equivalent to a+ // per-secret attribute here (all match when the prefix fits, none otherwise).+ case "primary-region" -> region != null && region.startsWith(targetVal);+ // owning-service is a valid Filter.Key enum value but is currently deferred (always returning false)+ case "owning-service" -> false;+ case "all" -> {+ String lowerVal = targetVal.toLowerCase();+ boolean nameMatch = secret.getName() != null && secret.getName().toLowerCase().startsWith(lowerVal);+ boolean descMatch = secret.getDescription() != null && secret.getDescription().toLowerCase().startsWith(lowerVal);+ boolean tagKeyMatch = secret.getTags() != null && secret.getTags().stream().anyMatch(t -> t.key() != null && t.key().toLowerCase().startsWith(lowerVal));+ boolean tagValueMatch = secret.getTags() != null && secret.getTags().stream().anyMatch(t -> t.value() != null && t.value().toLowerCase().startsWith(lowerVal));+ yield nameMatch || descMatch || tagKeyMatch || tagValueMatch;+ }+ default -> false;+ };+ }++ public record Filter(String key, List<String> values) {}+public Secret deleteSecret(String secretId, Integer recoveryWindowInDays, boolean forceDelete, String region) {Secret secret = resolveSecret(secretId, region);String storageKey = regionKey(region, secret.getName());diff --git a/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerJsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerJsonHandlerTest.javaindex 4196052ba0..87a13e006c 100644--- a/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerJsonHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/secretsmanager/SecretsManagerJsonHandlerTest.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.secretsmanager;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.core.common.AwsErrorResponse;import jakarta.ws.rs.core.Response;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;@@ -246,6 +247,146 @@ class SecretsManagerJsonHandlerTest {ObjectNode batchReq = MAPPER.createObjectNode();Response response = handler.handle("BatchGetSecretValue", batchReq, REGION);assertThat(response.getStatus(), is(400));+ assertThat(((AwsErrorResponse) response.getEntity()).message(), containsString("You must specify either SecretIdList or Filters"));+ }++ @Test+ void batchGetSecretValueMutuallyExclusiveParameters() {+ ObjectNode batchReq = MAPPER.createObjectNode();+ batchReq.putArray("SecretIdList").add("secret1");+ batchReq.putArray("Filters").addObject().put("Key", "name").putArray("Values").add("secret1");+ Response response = handler.handle("BatchGetSecretValue", batchReq, REGION);+ assertThat(response.getStatus(), is(400));+ assertThat(((AwsErrorResponse) response.getEntity()).message(), containsString("You cannot specify both SecretIdList and Filters"));+ }++ @Test+ void batchGetSecretValueWithFilters() {+ // Create matching/non-matching secrets+ ObjectNode createReq1 = MAPPER.createObjectNode();+ createReq1.put("Name", "prod-db-url");+ createReq1.put("Description", "Production Database URL");+ createReq1.put("SecretString", "postgres://prod");+ createReq1.putArray("Tags").addObject().put("Key", "Env").put("Value", "Production");+ handler.handle("CreateSecret", createReq1, REGION);++ ObjectNode createReq2 = MAPPER.createObjectNode();+ createReq2.put("Name", "dev-db-url");+ createReq2.put("Description", "Development Database URL");+ createReq2.put("SecretString", "postgres://dev");+ createReq2.putArray("Tags").addObject().put("Key", "Env").put("Value", "Development");+ handler.handle("CreateSecret", createReq2, REGION);++ // Filter by name (begins with)+ ObjectNode filterReq = MAPPER.createObjectNode();+ filterReq.putArray("Filters").addObject().put("Key", "name").putArray("Values").add("prod");+ Response response = handler.handle("BatchGetSecretValue", filterReq, REGION);+ assertThat(response.getStatus(), is(200));+ ObjectNode body = (ObjectNode) response.getEntity();+ assertThat(body.get("SecretValues").size(), is(1));+ assertThat(body.get("SecretValues").get(0).get("Name").asText(), is("prod-db-url"));++ // Filter by description (case-insensitive)+ filterReq = MAPPER.createObjectNode();+ filterReq.putArray("Filters").addObject().put("Key", "description").putArray("Values").add("production");+ response = handler.handle("BatchGetSecretValue", filterReq, REGION);+ assertThat(response.getStatus(), is(200));+ body = (ObjectNode) response.getEntity();+ assertThat(body.get("SecretValues").size(), is(1));+ assertThat(body.get("SecretValues").get(0).get("Name").asText(), is("prod-db-url"));++ // Filter by tag-key+ filterReq = MAPPER.createObjectNode();+ filterReq.putArray("Filters").addObject().put("Key", "tag-key").putArray("Values").add("Env");+ response = handler.handle("BatchGetSecretValue", filterReq, REGION);+ assertThat(response.getStatus(), is(200));+ body = (ObjectNode) response.getEntity();+ assertThat(body.get("SecretValues").size(), is(2));++ // Filter by tag-value negation+ filterReq = MAPPER.createObjectNode();+ filterReq.putArray("Filters").addObject().put("Key", "tag-value").putArray("Values").add("!Production");+ response = handler.handle("BatchGetSecretValue", filterReq, REGION);+ assertThat(response.getStatus(), is(200));+ body = (ObjectNode) response.getEntity();+ assertThat(body.get("SecretValues").size(), is(1));+ assertThat(body.get("SecretValues").get(0).get("Name").asText(), is("dev-db-url"));+ }++ @Test+ void batchGetSecretValueWithFiltersPagination() {+ for (int i = 0; i < 5; i++) {+ ObjectNode createReq = MAPPER.createObjectNode();+ createReq.put("Name", "paged-secret-" + i);+ createReq.put("SecretString", "val-" + i);+ handler.handle("CreateSecret", createReq, REGION);+ }++ // Fetch page 1 (MaxResults = 2)+ ObjectNode filterReq = MAPPER.createObjectNode();+ filterReq.putArray("Filters").addObject().put("Key", "name").putArray("Values").add("paged-");+ filterReq.put("MaxResults", 2);+ Response response = handler.handle("BatchGetSecretValue", filterReq, REGION);+ assertThat(response.getStatus(), is(200));+ ObjectNode body = (ObjectNode) response.getEntity();+ assertThat(body.get("SecretValues").size(), is(2));+ assertThat(body.has("NextToken"), is(true));+ String nextToken = body.get("NextToken").asText();++ // Fetch page 2+ filterReq = MAPPER.createObjectNode();+ filterReq.putArray("Filters").addObject().put("Key", "name").putArray("Values").add("paged-");+ filterReq.put("MaxResults", 2);+ filterReq.put("NextToken", nextToken);+ response = handler.handle("BatchGetSecretValue", filterReq, REGION);+ assertThat(response.getStatus(), is(200));+ body = (ObjectNode) response.getEntity();+ assertThat(body.get("SecretValues").size(), is(2));+ assertThat(body.has("NextToken"), is(true));+ nextToken = body.get("NextToken").asText();++ // Fetch page 3 (remaining 1)+ filterReq = MAPPER.createObjectNode();+ filterReq.putArray("Filters").addObject().put("Key", "name").putArray("Values").add("paged-");+ filterReq.put("MaxResults", 2);+ filterReq.put("NextToken", nextToken);+ response = handler.handle("BatchGetSecretValue", filterReq, REGION);+ assertThat(response.getStatus(), is(200));+ body = (ObjectNode) response.getEntity();+ assertThat(body.get("SecretValues").size(), is(1));+ assertThat(body.has("NextToken"), is(false));+ }++ @Test+ void batchGetSecretValueRejectsNegativeNextToken() {+ // A negative offset is an invalid token, not a valid query with no results.+ ObjectNode filterReq = MAPPER.createObjectNode();+ filterReq.putArray("Filters").addObject().put("Key", "name").putArray("Values").add("any");+ filterReq.put("NextToken", "-1");+ Response response = handler.handle("BatchGetSecretValue", filterReq, REGION);+ assertThat(response.getStatus(), is(400));+ assertThat(((AwsErrorResponse) response.getEntity()).type(), containsString("InvalidNextTokenException"));+ }++ @Test+ void listSecretsWithFilters() {+ ObjectNode createReq1 = MAPPER.createObjectNode();+ createReq1.put("Name", "test-secret-a");+ createReq1.put("SecretString", "valA");+ handler.handle("CreateSecret", createReq1, REGION);++ ObjectNode createReq2 = MAPPER.createObjectNode();+ createReq2.put("Name", "test-secret-b");+ createReq2.put("SecretString", "valB");+ handler.handle("CreateSecret", createReq2, REGION);++ ObjectNode listReq = MAPPER.createObjectNode();+ listReq.putArray("Filters").addObject().put("Key", "name").putArray("Values").add("test-secret-a");+ Response response = handler.handle("ListSecrets", listReq, REGION);+ assertThat(response.getStatus(), is(200));+ ObjectNode body = (ObjectNode) response.getEntity();+ assertThat(body.get("SecretList").size(), is(1));+ assertThat(body.get("SecretList").get(0).get("Name").asText(), is("test-secret-a"));}@Test