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.javanew file mode 100644index 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.mdindex 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 andrespects `Path`, `Recursive`, and region selection. Unknown or missing keys and keysnot 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 Commanddiff --git a/src/main/java/io/github/hectorvent/floci/services/ssm/SsmJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/ssm/SsmJsonHandler.javaindex 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.javaindex 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.javaindex 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.javanew file mode 100644index 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.javaindex 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());+ }+@Testvoid 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.javaindex 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());+ }+@BeforeEachvoid setUp() {ssmService = new SsmService(