Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(ssm): match parameter path label filters (#6560)

Jimmy Liu Jiabcae24f5fca0
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SsmPathLabelTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SsmPathLabelTest.java
new file mode 100644
index 0000000000..95e4b263f9
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SsmPathLabelTest.java
@@ -0,0 +1,71 @@
+package com.floci.test;
+
+import org.junit.jupiter.api.Test;
+import software.amazon.awssdk.services.ssm.SsmClient;
+import software.amazon.awssdk.services.ssm.model.GetParametersByPathRequest;
+import software.amazon.awssdk.services.ssm.model.Parameter;
+import software.amazon.awssdk.services.ssm.model.ParameterStringFilter;
+import software.amazon.awssdk.services.ssm.model.ParameterType;
+
+import java.util.List;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class SsmPathLabelTest {
+
+ @Test
+ void pathLabelsSelectHistoricalValuesAndFollowLabelChanges() {
+ String path = "/sdk-test/path-label-" + UUID.randomUUID();
+ String name = path + "/config";
+ String other = path + "/unlabeled";
+ try (SsmClient ssm = TestFixtures.ssmClient()) {
+ try {
+ ssm.putParameter(r -> r.name(name).type(ParameterType.STRING).value("released"));
+ ssm.labelParameterVersion(r -> r.name(name).parameterVersion(1L).labels("release"));
+ ssm.putParameter(r -> r.name(name).type(ParameterType.STRING).value("next").overwrite(true));
+ ssm.putParameter(r -> r.name(other).type(ParameterType.STRING).value("other"));
+
+ List<Parameter> released = parameters(ssm, path, "release");
+ assertThat(released).extracting(Parameter::name).containsExactly(name);
+ assertThat(released).extracting(Parameter::version).containsExactly(1L);
+ assertThat(released).extracting(Parameter::value).containsExactly("released");
+ assertThat(parameters(ssm, path, "missing")).isEmpty();
+
+ ssm.labelParameterVersion(r -> r.name(name).parameterVersion(2L).labels("release"));
+ assertThat(parameters(ssm, path, "release")).extracting(Parameter::value).containsExactly("next");
+ ssm.unlabelParameterVersion(r -> r.name(name).parameterVersion(2L).labels("release"));
+ assertThat(parameters(ssm, path, "release")).isEmpty();
+ } finally {
+ ssm.deleteParameters(r -> r.names(name, other));
+ }
+ }
+ }
+
+ @Test
+ void paginatorDoesNotSkipVersionsThatShareAParameterName() {
+ String path = "/sdk-test/path-label-" + UUID.randomUUID();
+ String name = path + "/config";
+ try (SsmClient ssm = TestFixtures.ssmClient()) {
+ try {
+ ssm.putParameter(r -> r.name(name).type(ParameterType.STRING).value("first"));
+ ssm.labelParameterVersion(r -> r.name(name).parameterVersion(1L).labels("release", "stable"));
+ ssm.putParameter(r -> r.name(name).type(ParameterType.STRING).value("second").overwrite(true));
+ ssm.labelParameterVersion(r -> r.name(name).parameterVersion(2L).labels("preview"));
+
+ List<Parameter> versions = parameters(ssm, path, "release", "stable", "preview");
+ assertThat(versions).extracting(Parameter::name).containsExactly(name, name);
+ assertThat(versions).extracting(Parameter::version).containsExactly(1L, 2L);
+ assertThat(versions).extracting(Parameter::value).containsExactly("first", "second");
+ } finally {
+ ssm.deleteParameter(r -> r.name(name));
+ }
+ }
+ }
+
+ private List<Parameter> parameters(SsmClient ssm, String path, String... labels) {
+ return ssm.getParametersByPathPaginator(GetParametersByPathRequest.builder().path(path).maxResults(1)
+ .parameterFilters(ParameterStringFilter.builder().key("Label").option("Equals").values(labels).build())
+ .build()).stream().flatMap(page -> page.parameters().stream()).toList();
+ }
+}
diff --git a/docs/services/ssm.md b/docs/services/ssm.md
index 176ddafd04..6952932bac 100644
--- a/docs/services/ssm.md
+++ b/docs/services/ssm.md
@@ -33,7 +33,13 @@
filters combine with AND. Filtering also applies to public AMI parameters and
respects `Path`, `Recursive`, and region selection. Unknown or missing keys and keys
not allowed for this action are rejected with `InvalidFilterKey`.
-`Label` filters accept only `Equals`, but label matching and pagination are not currently modeled.
+`Label` filters accept only `Equals` and return the stored versions carrying the requested
+labels, including older versions. Moving or removing a label changes subsequent results.
+The same OR/AND rules apply to label filters, and a version matching several requested
+labels appears only once. Type and KeyId filters match the labeled version's metadata.
+Public AMI parameters have no stored labels and are excluded from label queries.
+`MaxResults` and `NextToken` paginate the matching versions in name/version order; queries
+without a label filter continue to return the latest version of each parameter.
### Run Command
diff --git a/src/main/java/io/github/hectorvent/floci/services/ssm/SsmJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/ssm/SsmJsonHandler.java
index 4d9b696ffc..2bc67ba963 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ssm/SsmJsonHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ssm/SsmJsonHandler.java
@@ -234,13 +234,19 @@ public class SsmJsonHandler {
String path = request.path("Path").asText();
boolean recursive = request.path("Recursive").asBoolean(false);
- List<Parameter> params = ssmService.getParametersByPath(path, recursive, parameterFilters(request), region);
+ List<ParameterStringFilter> filters = parameterFilters(request);
+ List<Parameter> params = ssmService.getParametersByPath(path, recursive, filters, region);
+ boolean labeledVersions = filters.stream().anyMatch(filter -> "Label".equals(filter.key()));
+ // A label query can return several versions of one name. The separator keeps name order,
+ // and the padded version lets the cursor resume inside that parameter's history.
+ Function<Parameter, String> cursor = labeledVersions
+ ? p -> p.getName() + "\0" + String.format("%019d", p.getVersion()) : Parameter::getName;
ObjectNode response = objectMapper.createObjectNode();
ArrayNode parametersArray = objectMapper.createArrayNode();
- PaginatedResult<Parameter> page = page(pageRequest, params, Parameter::getName, ALL_ITEMS,
+ PaginatedResult<Parameter> page = page(pageRequest, params, cursor, ALL_ITEMS,
GET_PARAMETERS_BY_PATH_TOKEN + ssmService.accountId() + ":" + region + ":" + recursive + ":"
- + (path.endsWith("/") ? path : path + "/"));
+ + (path.endsWith("/") ? path : path + "/") + (labeledVersions ? ":labels" : ""));
for (Parameter p : page.items()) {
parametersArray.add(parameterToNode(p));
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ssm/SsmService.java b/src/main/java/io/github/hectorvent/floci/services/ssm/SsmService.java
index d940ffceb1..e50d954d5a 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ssm/SsmService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ssm/SsmService.java
@@ -532,17 +532,25 @@ public class SsmService implements ResourceProvider {
: h.getLabels() != null && h.getLabels().contains(selector))
.max(Comparator.comparingLong(ParameterHistory::getVersion))
.map(h -> {
- Parameter parameter = new Parameter(baseName, h.getValue(), h.getType());
- parameter.setVersion(h.getVersion());
- parameter.setDescription(h.getDescription());
- parameter.setLastModifiedDate(h.getLastModifiedDate());
- parameter.setArn(current.get().getArn());
- parameter.setDataType(current.get().getDataType());
+ Parameter parameter = historicalParameter(current.get(), h);
parameter.setSelector(":" + selector);
return parameter;
});
}
+ private static Parameter historicalParameter(Parameter current, ParameterHistory history) {
+ Parameter parameter = new Parameter(current.getName(), history.getValue(), history.getType());
+ parameter.setVersion(history.getVersion());
+ parameter.setDescription(history.getDescription());
+ parameter.setLastModifiedDate(history.getLastModifiedDate());
+ // Older stored history has no KeyId; only the current version can recover it reliably.
+ parameter.setKeyId(history.getKeyId() != null ? history.getKeyId()
+ : history.getVersion() == current.getVersion() ? current.getKeyId() : null);
+ parameter.setArn(current.getArn());
+ parameter.setDataType(current.getDataType());
+ return parameter;
+ }
+
/**
* AWS publishes read-only AMI id parameters under {@code /aws/service/} in every account
* with no setup, so a read of one of those names is answered from the EC2 image catalog.
@@ -566,8 +574,19 @@ public class SsmService implements ResourceProvider {
List<ParameterStringFilter> filters, String region) {
filters.forEach(SsmService::validateGetParametersByPathFilter);
List<ParameterStringFilter> matchingFilters = filters.stream().filter(filter -> !"Label".equals(filter.key())).toList();
+ List<ParameterStringFilter> labelFilters = filters.stream().filter(filter -> "Label".equals(filter.key())).toList();
+ if (labelFilters.isEmpty()) {
+ return getParametersByPath(path, recursive, region).stream()
+ .filter(parameter -> matchingFilters.stream().allMatch(filter -> matchesParameterFilter(parameter, filter)))
+ .toList();
+ }
+ // Labels belong to versions, so matching only the latest parameter would lose older releases.
return getParametersByPath(path, recursive, region).stream()
- .filter(parameter -> matchingFilters.stream().allMatch(filter -> matchesParameterFilter(parameter, filter)))
+ .flatMap(parameter -> historyStore.get(regionKey(region, parameter.getName())).orElse(List.of()).stream()
+ .filter(history -> history.getLabels() != null && labelFilters.stream().allMatch(filter ->
+ filter.values().stream().anyMatch(history.getLabels()::contains)))
+ .map(history -> historicalParameter(parameter, history))
+ .filter(history -> matchingFilters.stream().allMatch(filter -> matchesParameterFilter(history, filter))))
.toList();
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ssm/model/ParameterHistory.java b/src/main/java/io/github/hectorvent/floci/services/ssm/model/ParameterHistory.java
index 2e77fe13d8..bdd0cd654c 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ssm/model/ParameterHistory.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ssm/model/ParameterHistory.java
@@ -24,6 +24,9 @@ public class ParameterHistory {
@JsonProperty("Type")
private String type;
+ @JsonProperty("KeyId")
+ private String keyId;
+
@JsonProperty("LastModifiedDate")
private Instant lastModifiedDate;
@@ -40,6 +43,7 @@ public class ParameterHistory {
this.version = parameter.getVersion();
this.value = parameter.getValue();
this.type = parameter.getType();
+ this.keyId = parameter.getKeyId();
this.lastModifiedDate = parameter.getLastModifiedDate();
this.description = parameter.getDescription();
}
@@ -49,6 +53,7 @@ public class ParameterHistory {
this.version = other.version;
this.value = other.value;
this.type = other.type;
+ this.keyId = other.keyId;
this.lastModifiedDate = other.lastModifiedDate;
this.description = other.description;
this.labels = other.labels != null ? new ArrayList<>(other.labels) : new ArrayList<>();
@@ -66,6 +71,9 @@ public class ParameterHistory {
public String getType() { return type; }
public void setType(String type) { this.type = type; }
+ public String getKeyId() { return keyId; }
+ public void setKeyId(String keyId) { this.keyId = keyId; }
+
public Instant getLastModifiedDate() { return lastModifiedDate; }
public void setLastModifiedDate(Instant lastModifiedDate) { this.lastModifiedDate = lastModifiedDate; }
diff --git a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmPathLabelFilterIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmPathLabelFilterIntegrationTest.java
new file mode 100644
index 0000000000..fb8440d437
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmPathLabelFilterIntegrationTest.java
@@ -0,0 +1,251 @@
+package io.github.hectorvent.floci.services.ssm;
+
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.path.json.JsonPath;
+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.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+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.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@QuarkusTest
+class SsmPathLabelFilterIntegrationTest {
+
+ private static final String ACCOUNT = "000000006500";
+ private static final String REGION = "eu-west-3";
+ private final String path = "/label-filter-" + UUID.randomUUID();
+ private final Set<OwnedParameter> owned = new LinkedHashSet<>();
+
+ @BeforeAll
+ static void configureContentTypes() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ @AfterEach
+ void deleteOwnedParameters() {
+ for (OwnedParameter parameter : owned) {
+ ok(parameter.account(), parameter.region(), "DeleteParameter", Map.of("Name", parameter.name()));
+ }
+ }
+
+ @Test
+ void returnsOnlyLabeledParametersAndPreservesUnfilteredReads() {
+ put("config", "released");
+ put("unlabeled", "other");
+ label("config", 1, "release");
+
+ assertNames(byLabel("release"), "config");
+ assertNames(byLabel("missing"));
+ assertNames(byLabel("Release"));
+ assertNames(ok("GetParametersByPath", Map.of("Path", path)), "config", "unlabeled");
+ }
+
+ @Test
+ void returnsTheLabeledVersionInsteadOfTheLatestValue() {
+ put("config", "released");
+ label("config", 1, "release");
+ JsonPath original = ok("GetParameter", Map.of("Name", path + "/config:release"));
+ put("config", "not-released");
+
+ JsonPath result = byLabel("release");
+ assertEquals(List.of("released"), result.getList("Parameters.Value"));
+ assertEquals(List.of(1L), result.getList("Parameters.Version", Long.class));
+ assertEquals(original.getString("Parameter.ARN"), result.getString("Parameters[0].ARN"));
+ assertEquals(original.getDouble("Parameter.LastModifiedDate"),
+ result.getDouble("Parameters[0].LastModifiedDate"));
+ assertNull(result.getString("Parameters[0].Selector"));
+ assertEquals("not-released", ok("GetParameter", Map.of("Name", path + "/config"))
+ .getString("Parameter.Value"));
+ }
+
+ @Test
+ void followsMovedAndRemovedLabels() {
+ put("config", "old");
+ label("config", 1, "release");
+ put("config", "new");
+ label("config", 2, "release");
+ assertEquals(List.of(2L), byLabel("release").getList("Parameters.Version", Long.class));
+
+ ok("UnlabelParameterVersion", Map.of("Name", path + "/config", "ParameterVersion", 2,
+ "Labels", List.of("release")));
+ assertNames(byLabel("release"));
+ }
+
+ @Test
+ void combinesLabelValuesAndFiltersWithoutDuplicatingAVersion() {
+ put("config", "first");
+ label("config", 1, "release", "stable");
+ put("config", "second");
+ label("config", 2, "preview");
+
+ assertEquals(List.of(1L, 2L), byLabel("release", "stable", "preview")
+ .getList("Parameters.Version", Long.class));
+ JsonPath intersection = query(false, List.of(filter("Label", "release", "preview"), filter("Label", "stable")));
+ assertEquals(List.of(1L), intersection.getList("Parameters.Version", Long.class));
+ assertNames(query(false, List.of(filter("Label", "release"), filter("Label", "preview"))));
+ }
+
+ @Test
+ void combinesLabelsWithTheExistingTypeAndKeyIdFilters() {
+ put("text", "text");
+ label("text", 1, "release");
+ put(ACCOUNT, REGION, "secret", "secret", "SecureString", "alias/release-key");
+ label("secret", 1, "release");
+ put(ACCOUNT, REGION, "unlabeled", "secret", "SecureString", "alias/release-key");
+
+ assertNames(query(false, List.of(filter("Label", "release"), filter("Type", "SecureString"))), "secret");
+ assertNames(query(false, List.of(filter("Label", "release"), filter("KeyId", "alias/release-key"))), "secret");
+ assertNames(query(false, List.of(filter("Label", "release"), filter("Type", "String"),
+ filter("KeyId", "alias/release-key"))));
+ }
+
+ @Test
+ void usesTheLabeledVersionsTypeWhenCombiningFilters() {
+ put("config", "old-text");
+ label("config", 1, "release");
+ put(ACCOUNT, REGION, "config", "new-secret", "SecureString", "alias/release-key");
+
+ JsonPath oldType = query(false, List.of(filter("Label", "release"), filter("Type", "String")));
+ assertEquals(List.of("old-text"), oldType.getList("Parameters.Value", String.class));
+ assertEquals(List.of("String"), oldType.getList("Parameters.Type", String.class));
+ assertNames(query(false, List.of(filter("Label", "release"), filter("Type", "SecureString"))));
+ assertNames(query(false, List.of(filter("Type", "SecureString"))), "config");
+ }
+
+ @Test
+ void usesTheLabeledVersionsKeyIdWhenCombiningFilters() {
+ put(ACCOUNT, REGION, "config", "old-secret", "SecureString", "alias/old-key");
+ label("config", 1, "release");
+ put(ACCOUNT, REGION, "config", "new-secret", "SecureString", "alias/new-key");
+
+ JsonPath oldKey = query(false, List.of(filter("Label", "release"), filter("KeyId", "alias/old-key")));
+ assertEquals(List.of("old-secret"), oldKey.getList("Parameters.Value", String.class));
+ assertNames(query(false, List.of(filter("Label", "release"), filter("KeyId", "alias/new-key"))));
+ assertNames(query(false, List.of(filter("KeyId", "alias/new-key"))), "config");
+ }
+
+ @Test
+ void pagesDifferentLabeledVersionsOfTheSameParameter() {
+ for (int version = 1; version <= 10; version++) {
+ put("config", "value-" + version);
+ }
+ label("config", 9, "release");
+ label("config", 10, "preview");
+ put("unlabeled", "other");
+ List<Long> versions = new ArrayList<>();
+ String token = null;
+ int pages = 0;
+ do {
+ Map<String, Object> request = new HashMap<>(Map.of("Path", path, "MaxResults", 1,
+ "ParameterFilters", List.of(filter("Label", "release", "preview"))));
+ if (token != null) {
+ request.put("NextToken", token);
+ }
+ JsonPath result = ok("GetParametersByPath", request);
+ assertNames(result, "config");
+ versions.addAll(result.getList("Parameters.Version", Long.class));
+ token = result.getString("NextToken");
+ assertTrue(++pages <= 2, "Pagination must make progress");
+ } while (token != null);
+ assertEquals(List.of(9L, 10L), versions);
+ }
+
+ @Test
+ void resumesAfterTheCursorVersionLosesItsLabel() {
+ put("config", "first");
+ label("config", 1, "release");
+ put("config", "second");
+ label("config", 2, "preview");
+ List<Map<String, Object>> filters = List.of(filter("Label", "release", "preview"));
+ String token = ok("GetParametersByPath", Map.of("Path", path, "MaxResults", 1,
+ "ParameterFilters", filters)).getString("NextToken");
+ assertTrue(token != null, "The second labeled version needs a continuation token");
+ ok("UnlabelParameterVersion", Map.of("Name", path + "/config", "ParameterVersion", 1,
+ "Labels", List.of("release")));
+
+ JsonPath next = ok("GetParametersByPath", Map.of("Path", path, "MaxResults", 1,
+ "ParameterFilters", filters, "NextToken", token));
+ assertEquals(List.of(2L), next.getList("Parameters.Version", Long.class));
+ assertNull(next.getString("NextToken"));
+ }
+
+ @Test
+ void keepsPathRegionAndAccountIsolation() {
+ put("direct", "local");
+ label("direct", 1, "release");
+ put("nested/config", "nested");
+ label("nested/config", 1, "release");
+ for (String[] scope : List.of(new String[]{ACCOUNT, "ap-southeast-2"},
+ new String[]{"000000006501", REGION})) {
+ put(scope[0], scope[1], "foreign", "other", "String", null);
+ ok(scope[0], scope[1], "LabelParameterVersion", Map.of("Name", path + "/foreign",
+ "ParameterVersion", 1, "Labels", List.of("release")));
+ }
+ assertNames(byLabel("release"), "direct");
+ assertNames(query(true, List.of(filter("Label", "release"))), "direct", "nested/config");
+ }
+
+ private JsonPath byLabel(String... labels) {
+ return query(false, List.of(filter("Label", labels)));
+ }
+
+ private JsonPath query(boolean recursive, List<Map<String, Object>> filters) {
+ return ok("GetParametersByPath", Map.of("Path", path, "Recursive", recursive, "ParameterFilters", filters));
+ }
+
+ private static Map<String, Object> filter(String key, String... values) {
+ return Map.of("Key", key, "Values", List.of(values));
+ }
+
+ private void label(String suffix, long version, String... labels) {
+ ok("LabelParameterVersion", Map.of("Name", path + "/" + suffix, "ParameterVersion", version,
+ "Labels", List.of(labels)));
+ }
+
+ private void put(String suffix, String value) {
+ put(ACCOUNT, REGION, suffix, value, "String", null);
+ }
+
+ private void put(String account, String region, String suffix, String value, String type, String keyId) {
+ String name = path + "/" + suffix;
+ Map<String, Object> request = new HashMap<>(Map.of("Name", name, "Value", value, "Type", type,
+ "Overwrite", true));
+ if (keyId != null) {
+ request.put("KeyId", keyId);
+ }
+ ok(account, region, "PutParameter", request);
+ owned.add(new OwnedParameter(account, region, name));
+ }
+
+ private void assertNames(JsonPath response, String... suffixes) {
+ assertEquals(List.of(suffixes).stream().map(suffix -> path + "/" + suffix).sorted().toList(),
+ response.getList("Parameters.Name", String.class).stream().sorted().toList());
+ }
+
+ private JsonPath ok(String action, Map<String, ?> request) {
+ return ok(ACCOUNT, REGION, action, request);
+ }
+
+ private JsonPath ok(String account, String region, String action, Map<String, ?> request) {
+ return given().contentType("application/x-amz-json-1.1")
+ .header("Authorization", "AWS4-HMAC-SHA256 Credential=" + account + "/20261025/" + region
+ + "/ssm/aws4_request, SignedHeaders=host, Signature=abc")
+ .header("X-Amz-Target", "AmazonSSM." + action).body(request).post("/")
+ .then().statusCode(200).extract().jsonPath();
+ }
+
+ private record OwnedParameter(String account, String region, String name) {
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServicePublicAmiParameterTest.java b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServicePublicAmiParameterTest.java
index 7f5ba9a47e..8cef842597 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServicePublicAmiParameterTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServicePublicAmiParameterTest.java
@@ -125,6 +125,12 @@ class SsmServicePublicAmiParameterTest {
List.of(new ParameterStringFilter("KeyId", null, List.of("alias/aws/ssm"))), REGION).isEmpty());
}
+ @Test
+ void excludesPublicParametersFromLabelFilteredPaths() {
+ assertTrue(ssmService.getParametersByPath("/aws/service", true,
+ List.of(new ParameterStringFilter("Label", null, List.of("release"))), REGION).isEmpty());
+ }
+
@Test
void resolvesEksOptimizedAmiParametersAcrossArchitecturesAndVersions() {
String x86Param = "/aws/service/eks/optimized-ami/1.31/amazon-linux-2023/x86_64/standard/recommended/image_id";
diff --git a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServiceTest.java
index f9a3e55c36..28b0d36cd3 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ssm/SsmServiceTest.java
@@ -50,6 +50,25 @@ class SsmServiceTest {
private final List<Map<String, Object>> events = new ArrayList<>();
private SsmService ssmService;
+ @Test
+ void labeledCurrentVersionUsesKeyIdFromLegacyHistory() {
+ InMemoryStorage<String, Parameter> parameters = new InMemoryStorage<>();
+ InMemoryStorage<String, List<ParameterHistory>> history = new InMemoryStorage<>();
+ SsmService service = new SsmService(parameters, history, 5);
+ Parameter current = new Parameter("/legacy/key", "secret", "SecureString");
+ current.setVersion(1);
+ current.setKeyId("alias/legacy-key");
+ parameters.put("us-east-1::/legacy/key", current);
+ ParameterHistory oldRecord = new ParameterHistory(current);
+ oldRecord.setKeyId(null);
+ oldRecord.setLabels(List.of("release"));
+ history.put("us-east-1::/legacy/key", List.of(oldRecord));
+
+ assertEquals(1, service.getParametersByPath("/legacy", false, List.of(
+ new ParameterStringFilter("Label", null, List.of("release")),
+ new ParameterStringFilter("KeyId", null, List.of("alias/legacy-key"))), "us-east-1").size());
+ }
+
@BeforeEach
void setUp() {
ssmService = new SsmService(