Light, fluffy, and always free - The AWS Local Emulator alternative
feat(redshift): add ResetClusterParameterGroup (#6230)
Vũ Thế Huyd2f26250055e
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftOperationsTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftOperationsTest.javaindex cffcf75aaf..c16b570d9e 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftOperationsTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftOperationsTest.java@@ -28,6 +28,7 @@ import software.amazon.awssdk.services.redshift.model.DeleteSnapshotCopyGrantReqimport software.amazon.awssdk.services.redshift.model.DeleteTagsRequest;import software.amazon.awssdk.services.redshift.model.DescribeClusterParameterGroupsRequest;import software.amazon.awssdk.services.redshift.model.DescribeClusterParameterGroupsResponse;+import software.amazon.awssdk.services.redshift.model.DescribeClusterParametersRequest;import software.amazon.awssdk.services.redshift.model.DescribeClusterSnapshotsRequest;import software.amazon.awssdk.services.redshift.model.DescribeClusterSnapshotsResponse;import software.amazon.awssdk.services.redshift.model.DescribeClusterSubnetGroupsRequest;@@ -41,10 +42,15 @@ import software.amazon.awssdk.services.redshift.model.DescribeTagsRequest;import software.amazon.awssdk.services.redshift.model.DescribeTagsResponse;import software.amazon.awssdk.services.redshift.model.ModifyClusterIamRolesRequest;import software.amazon.awssdk.services.redshift.model.ModifyClusterIamRolesResponse;+import software.amazon.awssdk.services.redshift.model.ModifyClusterParameterGroupRequest;import software.amazon.awssdk.services.redshift.model.ModifyClusterRequest;import software.amazon.awssdk.services.redshift.model.ModifyClusterResponse;+import software.amazon.awssdk.services.redshift.model.Parameter;import software.amazon.awssdk.services.redshift.model.RebootClusterRequest;import software.amazon.awssdk.services.redshift.model.RebootClusterResponse;+import software.amazon.awssdk.services.redshift.model.RedshiftException;+import software.amazon.awssdk.services.redshift.model.ResetClusterParameterGroupRequest;+import software.amazon.awssdk.services.redshift.model.ResetClusterParameterGroupResponse;import software.amazon.awssdk.services.redshift.model.RestoreFromClusterSnapshotRequest;import software.amazon.awssdk.services.redshift.model.RestoreFromClusterSnapshotResponse;import software.amazon.awssdk.services.redshift.model.Snapshot;@@ -277,6 +283,43 @@ class RedshiftOperationsTest {assertThat(foundPg.parameterGroupFamily()).isEqualTo("redshift-1.0");assertThat(foundPg.description()).isEqualTo("Test parameter group for Redshift");+ DescribeClusterParametersRequest describeParameters = DescribeClusterParametersRequest.builder()+ .parameterGroupName(pgName).build();+ List<Parameter> defaults = client.describeClusterParameters(describeParameters).parameters();+ String cursorDefault = defaults.stream()+ .filter(parameter -> "max_cursor_result_set_size".equals(parameter.parameterName()))+ .findFirst().orElseThrow().parameterValue();+ client.modifyClusterParameterGroup(ModifyClusterParameterGroupRequest.builder()+ .parameterGroupName(pgName)+ .parameters(Parameter.builder().parameterName("max_cursor_result_set_size").parameterValue("1000").build(),+ Parameter.builder().parameterName("wlm_json_configuration").parameterValue("[{\"query_concurrency\":3}]").build())+ .build());++ assertThatThrownBy(() -> client.resetClusterParameterGroup(ResetClusterParameterGroupRequest.builder()+ .parameterGroupName(pgName).parameters(Parameter.builder().parameterValue("1000").build()).build()))+ .isInstanceOf(RedshiftException.class).hasMessageContaining("ParameterName");++ ResetClusterParameterGroupResponse reset = client.resetClusterParameterGroup(ResetClusterParameterGroupRequest.builder()+ .parameterGroupName(pgName).resetAllParameters(false)+ .parameters(Parameter.builder().parameterName("max_cursor_result_set_size").build()).build());++ assertThat(reset.parameterGroupName()).isEqualTo(pgName);+ assertThat(reset.parameterGroupStatus()).isNotBlank();+ List<Parameter> afterPartialReset = client.describeClusterParameters(describeParameters).parameters();+ assertThat(afterPartialReset).anySatisfy(parameter -> {+ assertThat(parameter.parameterName()).isEqualTo("max_cursor_result_set_size");+ assertThat(parameter.parameterValue()).isEqualTo(cursorDefault);+ assertThat(parameter.source()).isEqualTo("engine-default");+ });+ assertThat(client.describeClusterParameters(describeParameters.toBuilder().source("user").build()).parameters())+ .extracting(Parameter::parameterName).containsExactly("wlm_json_configuration");++ client.resetClusterParameterGroup(ResetClusterParameterGroupRequest.builder()+ .parameterGroupName(pgName).resetAllParameters(true).build());+ assertThat(client.describeClusterParameters(describeParameters).parameters())+ .allSatisfy(parameter -> assertThat(parameter.source()).isEqualTo("engine-default"));+ assertThat(client.describeClusterParameters(describeParameters.toBuilder().source("user").build()).parameters()).isEmpty();+// 3. Delete cluster parameter groupclient.deleteClusterParameterGroup(DeleteClusterParameterGroupRequest.builder().parameterGroupName(pgName)diff --git a/compatibility-tests/sdk-test-python/tests/test_redshift_parameter_groups.py b/compatibility-tests/sdk-test-python/tests/test_redshift_parameter_groups.pynew file mode 100644index 0000000000..e44ae9309f--- /dev/null+++ b/compatibility-tests/sdk-test-python/tests/test_redshift_parameter_groups.py@@ -0,0 +1,56 @@+"""Redshift parameter group compatibility with boto3's Query list encoding."""++from contextlib import closing++import boto3+import pytest+from botocore.exceptions import ClientError+++def test_reset_all_accepts_empty_parameter_list(aws_config, client_config, unique_name):+ name = f"pytest-redshift-pg-{unique_name}"+ with closing(boto3.client("redshift", config=client_config, **aws_config)) as client:+ client.create_cluster_parameter_group(+ ParameterGroupName=name,+ ParameterGroupFamily="redshift-1.0",+ Description="Empty Query list regression",+ )+ try:+ initial = client.describe_cluster_parameters(ParameterGroupName=name)["Parameters"]+ default_value = next(+ parameter["ParameterValue"]+ for parameter in initial+ if parameter["ParameterName"] == "max_cursor_result_set_size"+ )+ client.modify_cluster_parameter_group(+ ParameterGroupName=name,+ Parameters=[+ {"ParameterName": "max_cursor_result_set_size", "ParameterValue": "1000"}+ ],+ )++ with pytest.raises(ClientError) as failure:+ client.reset_cluster_parameter_group(+ ParameterGroupName=name, ResetAllParameters=False, Parameters=[]+ )+ assert failure.value.response["Error"]["Code"] == "InvalidParameterCombination"+ unchanged = client.describe_cluster_parameters(+ ParameterGroupName=name, Source="user"+ )["Parameters"]+ assert unchanged[0]["ParameterValue"] == "1000"++ response = client.reset_cluster_parameter_group(+ ParameterGroupName=name, ResetAllParameters=True, Parameters=[]+ )++ assert response["ParameterGroupName"] == name+ restored = client.describe_cluster_parameters(ParameterGroupName=name)["Parameters"]+ parameter = next(+ parameter+ for parameter in restored+ if parameter["ParameterName"] == "max_cursor_result_set_size"+ )+ assert parameter["ParameterValue"] == default_value+ assert parameter["Source"] == "engine-default"+ finally:+ client.delete_cluster_parameter_group(ParameterGroupName=name)diff --git a/docs/services/index.md b/docs/services/index.mdindex 1181b191f7..e932309b35 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -76,7 +76,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [Neptune](neptune.md) | `POST /` with `Action=` param + Gremlin TCP proxy | Query + WebSocket | 14 || [DocumentDB](docdb.md) | `POST /` with `Action=` param + MongoDB container | Query + MongoDB wire | 13 || [DMS](dms.md) | `POST /` + `X-Amz-Target: AmazonDMSv20160101.*` | JSON 1.1 | 20 |-| [Redshift](redshift.md) | `POST /` with `Action=` param + PostgreSQL container | Query + PostgreSQL wire (+ CFN) | 43 |+| [Redshift](redshift.md) | `POST /` with `Action=` param + PostgreSQL container | Query + PostgreSQL wire (+ CFN) | 44 || [Redshift Data API](redshift-data.md) | `POST /` + `X-Amz-Target: RedshiftData.*` | JSON 1.1 | 11 || [Redshift Serverless](redshift-serverless.md) | `POST /` + `X-Amz-Target: RedshiftServerless.*` | JSON 1.1 | 55 || [EMR](emr.md) | `POST /` + `X-Amz-Target: ElasticMapReduce.*` | JSON 1.1 | 40 |diff --git a/docs/services/redshift.md b/docs/services/redshift.mdindex 61c0e84c3c..4c876ace30 100644--- a/docs/services/redshift.md+++ b/docs/services/redshift.md@@ -30,6 +30,7 @@ For running SQL without a PostgreSQL wire connection (the way Lambda and Step Fu| `DescribeClusterParameterGroups` | List parameter groups, optionally filtered by name || `DescribeClusterParameters` | Return the parameters of a group, with any values set by `ModifyClusterParameterGroup` || `ModifyClusterParameterGroup` | Update parameter values on a group |+| `ResetClusterParameterGroup` | Reset selected parameters or all parameters to the emulated defaults || `DeleteClusterParameterGroup` | Remove a parameter group || `CreateTags` | Add or overwrite tags on a cluster, snapshot, subnet group, parameter group, snapshot copy grant or snapshot schedule || `DeleteTags` | Remove tags by key from a resource |@@ -64,6 +65,40 @@ For running SQL without a PostgreSQL wire connection (the way Lambda and Step Fu| `GetClusterCredentialsWithIAM` | Issue short-lived credentials with the DbUser derived from the caller's IAM identity |<!-- floci:actions:end -->+### Resetting parameter groups++`ResetClusterParameterGroup` resets all parameters with `ResetAllParameters=true`, or the named+parameters with `ResetAllParameters=false` and a `Parameters` list. Each list entry needs only+`ParameterName`, and at most 20 entries are accepted. When the flag is omitted, Floci resets the+supplied names, or all parameters if no names were supplied. An explicit `true` cannot be combined+with a nonempty list, and an explicit `false` requires at least one name. An empty Query list,+encoded as `Parameters=`, is treated like an omitted list. The API reference describes the omitted flag as+defaulting to `true` but also describes supplying names without the flag; Floci resolves that+ambiguity by using whether names were supplied. These combinations have not been verified against+a live AWS cluster.++Parameters report `Source=engine-default` initially, `user` after modification, and+`engine-default` after reset. `DescribeClusterParameters` accepts `Source=user` or+`Source=engine-default` to filter the result. The implicit `default.redshift-1.0` group is readable+but cannot be modified or reset.++Creating a group named `default.redshift-1.0` is rejected. Earlier Floci versions allowed such a+group to be stored: for those legacy groups, both describe operations return the stored values,+and modify/reset remain available. The read-only built-in group is used only when no stored+group exists under that name.++The default catalog remains limited to Floci's existing `max_cursor_result_set_size=0` and+`wlm_json_configuration={}` values, rather than the complete AWS engine catalog. Modifications to+other names are stored as before; resetting those names removes their overrides and omits them+from subsequent descriptions because Floci has no default to report. Resetting all parameters+restores the two catalog entries. Parameter groups remain metadata only: modifying or resetting+them does not change PostgreSQL settings, and Floci does not track the clusters' pending reboot+state. The reset response returns a descriptive `ParameterGroupStatus` message.++Sources are persisted with parameter values. For older stored groups without a source, Floci+reports `engine-default` when the value matches its catalog and `user` otherwise. The old format+cannot distinguish an explicit assignment of a default value from an unchanged default.+### Snapshot copy grants- **`KmsKeyId` defaults to an alias ARN.** Floci has no per-account AWS-managed key, sodiff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandler.javaindex 952b612540..72600d8514 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandler.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.redshift;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.AwsNamespaces;import io.github.hectorvent.floci.core.common.IamEnforcementFilter;import io.github.hectorvent.floci.core.common.PaginatedResult;import io.github.hectorvent.floci.core.common.RegionResolver;@@ -266,6 +267,13 @@ public class RedshiftQueryHandler {throw new AwsException("InvalidParameterValue", "ParameterGroupName is required", 400);}List<Parameter> parameters = service.describeClusterParameters(parameterGroupName);+ String source = params.getFirst("Source");+ if (source != null) {+ if (!"user".equals(source) && !"engine-default".equals(source)) {+ throw new AwsException("InvalidParameterValue", "Source must be user or engine-default.", 400);+ }+ parameters = parameters.stream().filter(parameter -> source.equals(parameter.getSource())).toList();+ }XmlBuilder xmlBuilder = new XmlBuilder().start("DescribeClusterParametersResponse")@@ -303,6 +311,28 @@ public class RedshiftQueryHandler {.build();return Response.ok(xml).type(MediaType.APPLICATION_XML).build();}+ case "ResetClusterParameterGroup" -> {+ List<String> parameterNames = parseParameters(params).stream().map(Parameter::getParameterName).toList();+ String rawResetAll = params.getFirst("ResetAllParameters");+ if (rawResetAll != null && !"true".equalsIgnoreCase(rawResetAll) && !"false".equalsIgnoreCase(rawResetAll)) {+ throw new AwsException("InvalidParameterValue", "ResetAllParameters must be a boolean.", 400);+ }+ boolean resetAll = rawResetAll == null ? parameterNames.isEmpty() : Boolean.parseBoolean(rawResetAll);+ String parameterGroupName = params.getFirst("ParameterGroupName");+ service.resetClusterParameterGroup(parameterGroupName, resetAll, parameterNames);+ String xml = new XmlBuilder()+ .start("ResetClusterParameterGroupResponse", AwsNamespaces.REDSHIFT)+ .start("ResetClusterParameterGroupResult")+ .elem("ParameterGroupName", parameterGroupName)+ .elem("ParameterGroupStatus", "Your parameter group has been updated.")+ .end("ResetClusterParameterGroupResult")+ .start("ResponseMetadata")+ .elem("RequestId", "test-req-id")+ .end("ResponseMetadata")+ .end("ResetClusterParameterGroupResponse")+ .build();+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();+ }case "DeleteClusterParameterGroup" -> {String parameterGroupName = params.getFirst("ParameterGroupName");service.deleteClusterParameterGroup(parameterGroupName);@@ -1203,6 +1233,7 @@ public class RedshiftQueryHandler {if (param.getDataType() != null) {builder.elem("DataType", param.getDataType());}+ builder.elem("Source", param.getSource());return builder.end("Parameter").build();}@@ -1359,21 +1390,30 @@ public class RedshiftQueryHandler {}private static List<Parameter> parseParameters(MultivaluedMap<String, String> params) {- List<Parameter> parsed = new ArrayList<>();- readParameters(params, "Parameters.member", parsed);- readParameters(params, "Parameters.Parameter", parsed);- return parsed;- }-- private static void readParameters(MultivaluedMap<String, String> params, String prefix, List<Parameter> parsed) {- for (int i = 1; ; i++) {- String name = params.getFirst(prefix + "." + i + ".ParameterName");- if (name == null) {- break;+ Map<String, Parameter> parsed = new LinkedHashMap<>();+ for (String key : params.keySet().stream().sorted().toList()) {+ if ("Parameters".equals(key)) {+ if (!"".equals(params.getFirst(key))) {+ throw new AwsException("InvalidParameterValue", "Parameters must be an indexed list or empty.", 400);+ }+ continue;+ }+ if (!key.startsWith("Parameters.")) {+ continue;+ }+ if (!key.matches("Parameters\\.(?:member|Parameter)\\.[1-9]\\d*\\.[A-Za-z]+")) {+ throw new AwsException("InvalidParameterValue", "Invalid Parameters member: " + key, 400);+ }+ String prefix = key.substring(0, key.lastIndexOf('.'));+ String name = params.getFirst(prefix + ".ParameterName");+ if (name == null || name.isBlank()) {+ throw new AwsException("InvalidParameterValue", "Each parameter must have a ParameterName.", 400);}- String value = params.getFirst(prefix + "." + i + ".ParameterValue");- parsed.add(new Parameter(name, value));+ parsed.putIfAbsent(prefix, new Parameter(name, params.getFirst(prefix + ".ParameterValue")));}+ return parsed.entrySet().stream()+ .sorted(Comparator.comparingInt(entry -> numericSuffix(entry.getKey())))+ .map(Map.Entry::getValue).toList();}private static Map<String, String> parseTags(MultivaluedMap<String, String> params) {diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftService.java b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftService.javaindex cecdad9dfb..fdd7fefe44 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftService.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/RedshiftService.java@@ -62,6 +62,7 @@ public class RedshiftService {// The group every cluster starts on until one is named.static final String DEFAULT_PARAMETER_GROUP_NAME = "default.redshift-1.0";+ private static final int MAX_RESET_PARAMETERS = 20;private final AccountAwareStorageBackend<Cluster> clusters;private final AccountAwareStorageBackend<Snapshot> snapshots;@@ -1104,6 +1105,9 @@ public class RedshiftService {// ── Parameter Group Operations ───────────────────────────────────────────public ClusterParameterGroup createClusterParameterGroup(String parameterGroupName, String parameterGroupFamily, String description) {+ if (DEFAULT_PARAMETER_GROUP_NAME.equals(parameterGroupName)) {+ throw new AwsException("InvalidParameterValue", "The default parameter group name is reserved.", 400);+ }if (parameterGroups.get(parameterGroupName).isPresent()) {throw new AwsException("ClusterParameterGroupAlreadyExists", "Cluster parameter group " + parameterGroupName + " already exists", 400);}@@ -1144,18 +1148,22 @@ public class RedshiftService {public List<Parameter> describeClusterParameters(String parameterGroupName) {ClusterParameterGroup group = parameterGroups.get(parameterGroupName)+ .or(() -> DEFAULT_PARAMETER_GROUP_NAME.equals(parameterGroupName)+ ? Optional.of(defaultParameterGroup()) : Optional.empty()).orElseThrow(() -> new AwsException("ClusterParameterGroupNotFound","Cluster parameter group " + parameterGroupName + " not found", 404));- return group.getParameters();+ return group.getParameters().stream().map(RedshiftService::copyParameterWithSource).toList();}public synchronized ClusterParameterGroup modifyClusterParameterGroup(String parameterGroupName, List<Parameter> updates) {+ requireMutableParameterGroup(parameterGroupName);ClusterParameterGroup group = parameterGroups.get(parameterGroupName).orElseThrow(() -> new AwsException("ClusterParameterGroupNotFound","Cluster parameter group " + parameterGroupName + " not found", 404));- List<Parameter> current = new ArrayList<>(group.getParameters());+ List<Parameter> current = new ArrayList<>(group.getParameters().stream()+ .map(RedshiftService::copyParameterWithSource).toList());for (Parameter update : updates) {boolean matched = false;for (int i = 0; i < current.size(); i++) {@@ -1163,6 +1171,7 @@ public class RedshiftService {if (existing.getParameterName().equals(update.getParameterName())) {// Preserve metadata (description, dataType) from existing parameter if not provided in updateexisting.setParameterValue(update.getParameterValue());+ existing.setSource("user");if (update.getDescription() != null) {existing.setDescription(update.getDescription());}@@ -1174,7 +1183,9 @@ public class RedshiftService {}}if (!matched) {- current.add(update);+ Parameter added = copyParameterWithSource(update);+ added.setSource("user");+ current.add(added);}}group.setParameters(current);@@ -1183,6 +1194,73 @@ public class RedshiftService {return group;}+ public synchronized void resetClusterParameterGroup(String parameterGroupName, boolean resetAllParameters,+ List<String> parameterNames) {+ requireMutableParameterGroup(parameterGroupName);+ if (resetAllParameters && !parameterNames.isEmpty()) {+ throw new AwsException("InvalidParameterCombination",+ "Parameters cannot be specified when ResetAllParameters is true.", 400);+ }+ if (!resetAllParameters && parameterNames.isEmpty()) {+ throw new AwsException("InvalidParameterCombination",+ "At least one parameter is required when ResetAllParameters is false.", 400);+ }+ if (parameterNames.size() > MAX_RESET_PARAMETERS) {+ throw new AwsException("InvalidParameterValue", "A maximum of 20 parameters can be reset.", 400);+ }+ ClusterParameterGroup group = parameterGroups.get(parameterGroupName)+ .orElseThrow(() -> new AwsException("ClusterParameterGroupNotFound",+ "Cluster parameter group " + parameterGroupName + " not found", 404));+ Set<String> names = new LinkedHashSet<>();+ for (String name : parameterNames) {+ if (name == null || name.isBlank() || group.getParameters().stream()+ .noneMatch(parameter -> name.equals(parameter.getParameterName()))) {+ throw new AwsException("InvalidParameterValue", "Unknown parameter: " + name, 400);+ }+ names.add(name);+ }+ List<Parameter> defaults = ClusterParameterGroup.defaultParameters();+ List<Parameter> reset = defaults;+ if (!resetAllParameters) {+ reset = new ArrayList<>();+ for (Parameter parameter : group.getParameters()) {+ if (names.contains(parameter.getParameterName())) {+ defaults.stream().filter(candidate -> candidate.getParameterName().equals(parameter.getParameterName()))+ .findFirst().ifPresent(reset::add);+ } else {+ reset.add(copyParameterWithSource(parameter));+ }+ }+ }+ group.setParameters(reset);+ parameterGroups.put(parameterGroupName, group);+ parameterGroups.flush();+ }++ private void requireMutableParameterGroup(String name) {+ if (name == null || name.isBlank()) {+ throw new AwsException("InvalidParameterValue", "ParameterGroupName is required", 400);+ }+ if (DEFAULT_PARAMETER_GROUP_NAME.equals(name) && parameterGroups.get(name).isEmpty()) {+ throw new AwsException("InvalidParameterValue", "The default parameter group cannot be modified.", 400);+ }+ }++ private static Parameter copyParameterWithSource(Parameter parameter) {+ Parameter copy = new Parameter(parameter.getParameterName(), parameter.getParameterValue(),+ parameter.getDescription(), parameter.getDataType());+ String source = parameter.getSource();+ if (source == null) {+ // Older persisted groups do not record whether a value was explicitly set to its default.+ boolean engineDefault = ClusterParameterGroup.defaultParameters().stream().anyMatch(candidate ->+ candidate.getParameterName().equals(parameter.getParameterName())+ && candidate.getParameterValue().equals(parameter.getParameterValue()));+ source = engineDefault ? "engine-default" : "user";+ }+ copy.setSource(source);+ return copy;+ }+public ClusterParameterGroup deleteClusterParameterGroup(String parameterGroupName) {Optional<ClusterParameterGroup> groupOpt = parameterGroups.get(parameterGroupName);if (groupOpt.isEmpty()) {diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/model/ClusterParameterGroup.java b/src/main/java/io/github/hectorvent/floci/services/redshift/model/ClusterParameterGroup.javaindex 01e7cb1712..7d67e06a43 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshift/model/ClusterParameterGroup.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/model/ClusterParameterGroup.java@@ -50,10 +50,16 @@ public class ClusterParameterGroup {public Map<String, String> getTags() { return tags; }public void setTags(Map<String, String> tags) { this.tags = tags; }- private List<Parameter> parameters = new ArrayList<>(List.of(- new Parameter("max_cursor_result_set_size", "0", "Maximum cursor result set size", "integer"),- new Parameter("wlm_json_configuration", "{}", "WLM configuration", "string")- ));+ private List<Parameter> parameters = defaultParameters();++ public static List<Parameter> defaultParameters() {+ List<Parameter> defaults = new ArrayList<>(List.of(+ new Parameter("max_cursor_result_set_size", "0", "Maximum cursor result set size", "integer"),+ new Parameter("wlm_json_configuration", "{}", "WLM configuration", "string")+ ));+ defaults.forEach(parameter -> parameter.setSource("engine-default"));+ return defaults;+ }public List<Parameter> getParameters() { return parameters; }public void setParameters(List<Parameter> parameters) { this.parameters = parameters; }diff --git a/src/main/java/io/github/hectorvent/floci/services/redshift/model/Parameter.java b/src/main/java/io/github/hectorvent/floci/services/redshift/model/Parameter.javaindex 927969bdfe..43141e95b3 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshift/model/Parameter.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshift/model/Parameter.java@@ -8,6 +8,7 @@ public class Parameter {private String parameterValue;private String description;private String dataType;+ private String source;public Parameter() {}@@ -54,4 +55,12 @@ public class Parameter {public void setDataType(String dataType) {this.dataType = dataType;}++ public String getSource() {+ return source;+ }++ public void setSource(String source) {+ this.source = source;+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftOperationsTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftOperationsTest.javaindex 546d443f5d..7364635a1b 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftOperationsTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftOperationsTest.java@@ -1,7 +1,12 @@package io.github.hectorvent.floci.services.redshift;+import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.redshift.container.RedshiftContainerHandle;import io.github.hectorvent.floci.services.redshift.container.RedshiftContainerManager;+import io.github.hectorvent.floci.services.redshift.model.ClusterParameterGroup;+import io.github.hectorvent.floci.services.redshift.model.Parameter;import io.quarkus.test.InjectMock;import io.quarkus.test.junit.QuarkusTest;import io.restassured.path.xml.XmlPath;@@ -15,7 +20,9 @@ import org.junit.jupiter.api.TestMethodOrder;import java.nio.file.Files;import java.nio.file.Path;+import java.util.ArrayList;import java.util.List;+import java.util.Map;import java.util.Optional;import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;@@ -53,6 +60,9 @@ public class RedshiftOperationsTest {@InjectRedshiftService service;+ @Inject+ StorageFactory storageFactory;+@Test@Order(1)void parameterGroupLifecycle() {@@ -115,6 +125,31 @@ public class RedshiftOperationsTest {.body(containsString("<ParameterName>statement_timeout</ParameterName>")).body(containsString("<ParameterValue>5000</ParameterValue>"));+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", AUTH_HEADER)+ .formParam("Action", "ResetClusterParameterGroup")+ .formParam("ParameterGroupName", "pg-test-1")+ .formParam("ResetAllParameters", "false")+ .formParam("Parameters.Parameter.1.ParameterName", "statement_timeout")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("<ResetClusterParameterGroupResult>"));++ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", AUTH_HEADER)+ .formParam("Action", "DescribeClusterParameters")+ .formParam("ParameterGroupName", "pg-test-1")+ .formParam("Source", "user")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(not(containsString("<Parameter>")));+// 4. DeleteClusterParameterGroupgiven().contentType("application/x-www-form-urlencoded")@@ -1161,4 +1196,97 @@ public class RedshiftOperationsTest {assertFault(response, 400, "InvalidParameterValue");assertEquals("Invalid Marker.", XmlPath.from(response.asString()).getString("ErrorResponse.Error.Message"));}++ @Test+ @Order(12)+ void invalidResetListsLeaveStoredOverridesUnchanged() {+ String name = "reset-validation-guard";+ service.createClusterParameterGroup(name, "redshift-1.0", "validation test");+ try {+ service.modifyClusterParameterGroup(name, List.of(new Parameter("max_cursor_result_set_size", "1000")));++ assertFault(redshift("ResetClusterParameterGroup", "ParameterGroupName", name, "Parameters", "invalid"),+ 400, "InvalidParameterValue");+ assertEquals("1000", service.describeClusterParameters(name).getFirst().getParameterValue());+ assertFault(redshift("ResetClusterParameterGroup", "ParameterGroupName", name,+ "ResetAllParameters", "false", "Parameters", ""), 400, "InvalidParameterCombination");+ assertEquals("1000", service.describeClusterParameters(name).getFirst().getParameterValue());++ for (String prefix : List.of("Parameters.Parameter", "Parameters.member")) {+ List<String> fields = new ArrayList<>(List.of("ParameterGroupName", name));+ for (int index = 1; index <= 21; index++) {+ fields.add(prefix + "." + index + ".ParameterName");+ fields.add("max_cursor_result_set_size");+ }+ assertFault(redshift("ResetClusterParameterGroup", fields.toArray(String[]::new)),+ 400, "InvalidParameterValue");+ assertEquals("1000", service.describeClusterParameters(name).getFirst().getParameterValue());+ }+ } finally {+ service.deleteClusterParameterGroup(name);+ }+ }++ @Test+ @Order(13)+ void reservedDefaultNameRejectsCreationAndPreservesLegacyGroupLifecycle() {+ String name = RedshiftService.DEFAULT_PARAMETER_GROUP_NAME;+ assertFault(redshift("CreateClusterParameterGroup", "ParameterGroupName", name,+ "ParameterGroupFamily", "redshift-1.0", "Description", "reserved"), 400, "InvalidParameterValue");+ assertFault(redshift("ResetClusterParameterGroup", "ParameterGroupName", name), 400, "InvalidParameterValue");++ AccountAwareStorageBackend<ClusterParameterGroup> backend = storageFactory.create(+ "redshift", "redshift-parameter-groups.json", new TypeReference<Map<String, ClusterParameterGroup>>() {});+ assertTrue(backend.get(name).isEmpty());+ ClusterParameterGroup legacy = new ClusterParameterGroup(name, "redshift-1.0", "legacy custom group");+ legacy.setParameters(List.of(new Parameter("max_cursor_result_set_size", "1000")));+ backend.put(name, legacy);+ backend.flush();+ try {+ redshift("DescribeClusterParameterGroups", "ParameterGroupName", name).then().statusCode(200)+ .body(containsString("<Description>legacy custom group</Description>"));+ redshift("DescribeClusterParameters", "ParameterGroupName", name).then().statusCode(200)+ .body(containsString("<ParameterValue>1000</ParameterValue>"));+ redshift("ModifyClusterParameterGroup", "ParameterGroupName", name,+ "Parameters.Parameter.1.ParameterName", "max_cursor_result_set_size",+ "Parameters.Parameter.1.ParameterValue", "2000").then().statusCode(200);+ redshift("DescribeClusterParameters", "ParameterGroupName", name).then().statusCode(200)+ .body(containsString("<ParameterValue>2000</ParameterValue>"));+ redshift("ResetClusterParameterGroup", "ParameterGroupName", name,+ "Parameters.Parameter.1.ParameterName", "max_cursor_result_set_size").then().statusCode(200);+ redshift("DescribeClusterParameters", "ParameterGroupName", name).then().statusCode(200)+ .body(containsString("<ParameterValue>0</ParameterValue>"))+ .body(containsString("<Source>engine-default</Source>"));+ redshift("DeleteClusterParameterGroup", "ParameterGroupName", name).then().statusCode(200);+ } finally {+ backend.delete(name);+ backend.flush();+ }+ redshift("DescribeClusterParameterGroups", "ParameterGroupName", name).then().statusCode(200)+ .body(not(containsString("legacy custom group")));+ assertFault(redshift("ResetClusterParameterGroup", "ParameterGroupName", name), 400, "InvalidParameterValue");+ }++ @Test+ @Order(14)+ void botocoreEmptyListResetsAllParameters() {+ String name = "reset-empty-list";+ service.createClusterParameterGroup(name, "redshift-1.0", "empty list test");+ try {+ service.modifyClusterParameterGroup(name, List.of(new Parameter("max_cursor_result_set_size", "1000")));++ redshift("ResetClusterParameterGroup", "ParameterGroupName", name,+ "ResetAllParameters", "true", "Parameters", "").then().statusCode(200);++ assertEquals("0", service.describeClusterParameters(name).getFirst().getParameterValue());+ assertEquals("engine-default", service.describeClusterParameters(name).getFirst().getSource());+ service.modifyClusterParameterGroup(name, List.of(new Parameter("max_cursor_result_set_size", "1000")));++ redshift("ResetClusterParameterGroup", "ParameterGroupName", name, "Parameters", "").then().statusCode(200);++ assertEquals("0", service.describeClusterParameters(name).getFirst().getParameterValue());+ } finally {+ service.deleteClusterParameterGroup(name);+ }+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandlerTest.javaindex 5624f7d5c4..2dce874427 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftQueryHandlerTest.java@@ -39,6 +39,222 @@ class RedshiftQueryHandlerTest {private RedshiftIamDbUserResolver iamDbUserResolver;private RegionResolver regionResolver;+ @Test+ void resetClusterParameterGroupReturnsAwsQueryResponse() {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ params.putSingle("ResetAllParameters", "true");++ Response response = handler.handle("ResetClusterParameterGroup", params);++ assertEquals(200, response.getStatus());+ String xml = (String) response.getEntity();+ assertTrue(xml.contains("<ResetClusterParameterGroupResult>"));+ assertTrue(xml.contains("<ParameterGroupName>reset-pg</ParameterGroupName>"));+ assertTrue(xml.contains("<ParameterGroupStatus>"));+ verify(service).resetClusterParameterGroup("reset-pg", true, List.of());+ }++ @Test+ void resetClusterParameterGroupDefaultsToAllWithoutNames() {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");++ handler.handle("ResetClusterParameterGroup", params);++ verify(service).resetClusterParameterGroup("reset-pg", true, List.of());+ }++ @Test+ void resetClusterParameterGroupAcceptsBothQueryMemberFormatsWithoutValues() {+ for (String prefix : List.of("Parameters.Parameter", "Parameters.member")) {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ params.putSingle("ResetAllParameters", "false");+ params.putSingle(prefix + ".1.ParameterName", "wlm_json_configuration");++ handler.handle("ResetClusterParameterGroup", params);+ }++ verify(service, times(2)).resetClusterParameterGroup("reset-pg", false, List.of("wlm_json_configuration"));+ }++ @Test+ void resetClusterParameterGroupDefaultsToSelectedNamesWhenNamesAreGiven() {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ params.putSingle("Parameters.Parameter.1.ParameterName", "wlm_json_configuration");++ handler.handle("ResetClusterParameterGroup", params);++ verify(service).resetClusterParameterGroup("reset-pg", false, List.of("wlm_json_configuration"));+ }++ @Test+ void resetClusterParameterGroupDoesNotTreatSparseNamesAsResetAll() {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ params.putSingle("Parameters.Parameter.2.ParameterName", "wlm_json_configuration");++ handler.handle("ResetClusterParameterGroup", params);++ verify(service).resetClusterParameterGroup("reset-pg", false, List.of("wlm_json_configuration"));+ }++ @Test+ void resetClusterParameterGroupRejectsInvalidBoolean() {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ params.putSingle("ResetAllParameters", "invalid");++ AwsException failure = assertThrows(AwsException.class,+ () -> handler.handle("ResetClusterParameterGroup", params));++ assertEquals("InvalidParameterValue", failure.getErrorCode());+ verify(service, never()).resetClusterParameterGroup(any(), anyBoolean(), anyList());+ }++ @Test+ void resetClusterParameterGroupAcceptsBotocoreEmptyListForResetAll() {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ params.putSingle("Parameters", "");+ params.putSingle("ResetAllParameters", "true");++ Response response = handler.handle("ResetClusterParameterGroup", params);++ assertEquals(200, response.getStatus());+ verify(service).resetClusterParameterGroup("reset-pg", true, List.of());+ }++ @Test+ void resetClusterParameterGroupTreatsEmptyListLikeOmittedList() {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ params.putSingle("Parameters", "");++ handler.handle("ResetClusterParameterGroup", params);++ verify(service).resetClusterParameterGroup("reset-pg", true, List.of());+ }++ @Test+ void resetClusterParameterGroupRejectsNonemptyBareParameters() {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ params.putSingle("Parameters", "invalid");++ AwsException failure = assertThrows(AwsException.class,+ () -> handler.handle("ResetClusterParameterGroup", params));++ assertEquals("InvalidParameterValue", failure.getErrorCode());+ verify(service, never()).resetClusterParameterGroup(any(), anyBoolean(), anyList());+ }++ @Test+ void resetClusterParameterGroupPassesAllSuppliedNamesToServiceForValidation() {+ for (String prefix : List.of("Parameters.Parameter", "Parameters.member")) {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ for (int index = 1; index <= 21; index++) {+ params.putSingle(prefix + "." + index + ".ParameterName", "max_cursor_result_set_size");+ }++ handler.handle("ResetClusterParameterGroup", params);+ }+ ArgumentCaptor<List<String>> names = ArgumentCaptor.captor();+ verify(service, times(2)).resetClusterParameterGroup(eq("reset-pg"), eq(false), names.capture());+ assertTrue(names.getAllValues().stream().allMatch(value -> value.size() == 21));+ }++ @Test+ void modifyClusterParameterGroupRejectsMembersWithoutNames() {+ for (String prefix : List.of("Parameters.Parameter", "Parameters.member")) {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ params.putSingle(prefix + ".1.ParameterValue", "1000");++ AwsException failure = assertThrows(AwsException.class,+ () -> handler.handle("ModifyClusterParameterGroup", params));++ assertEquals("InvalidParameterValue", failure.getErrorCode());+ }+ verify(service, never()).modifyClusterParameterGroup(any(), anyList());+ }++ @Test+ void modifyClusterParameterGroupReadsSparseMembersInNumericOrder() {+ for (String prefix : List.of("Parameters.Parameter", "Parameters.member")) {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ params.putSingle(prefix + ".10.ParameterName", "max_cursor_result_set_size");+ params.putSingle(prefix + ".10.ParameterValue", "2000");+ params.putSingle(prefix + ".2.ParameterName", "max_cursor_result_set_size");+ params.putSingle(prefix + ".2.ParameterValue", "1000");++ handler.handle("ModifyClusterParameterGroup", params);+ }++ ArgumentCaptor<List<Parameter>> updates = ArgumentCaptor.captor();+ verify(service, times(2)).modifyClusterParameterGroup(eq("reset-pg"), updates.capture());+ for (List<Parameter> parameters : updates.getAllValues()) {+ assertEquals(List.of("1000", "2000"), parameters.stream().map(Parameter::getParameterValue).toList());+ }+ }++ @Test+ void resetClusterParameterGroupCountsMembersRatherThanFields() {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ for (int index = 1; index <= 20; index++) {+ params.putSingle("Parameters.Parameter." + index + ".ParameterName", "max_cursor_result_set_size");+ params.putSingle("Parameters.Parameter." + index + ".ParameterValue", "ignored");+ }++ handler.handle("ResetClusterParameterGroup", params);++ ArgumentCaptor<List<String>> names = ArgumentCaptor.captor();+ verify(service).resetClusterParameterGroup(eq("reset-pg"), eq(false), names.capture());+ assertEquals(20, names.getValue().size());+ }++ @Test+ void resetClusterParameterGroupRejectsMembersWithoutNamesBeforeChoosingResetAll() {+ for (String prefix : List.of("Parameters.Parameter", "Parameters.member")) {+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ params.putSingle(prefix + ".1.ParameterValue", "1000");++ AwsException failure = assertThrows(AwsException.class,+ () -> handler.handle("ResetClusterParameterGroup", params));++ assertEquals("InvalidParameterValue", failure.getErrorCode());+ params.putSingle(prefix + ".2.ParameterName", "wlm_json_configuration");+ assertThrows(AwsException.class, () -> handler.handle("ResetClusterParameterGroup", params));+ params.putSingle(prefix + ".1.ParameterName", " ");+ assertThrows(AwsException.class, () -> handler.handle("ResetClusterParameterGroup", params));+ }+ verify(service, never()).resetClusterParameterGroup(any(), anyBoolean(), anyList());+ }++ @Test+ void describeClusterParametersFiltersAndSerializesSource() {+ Parameter overridden = new Parameter("max_cursor_result_set_size", "1000");+ overridden.setSource("user");+ Parameter engineDefault = new Parameter("wlm_json_configuration", "{}");+ engineDefault.setSource("engine-default");+ when(service.describeClusterParameters("reset-pg")).thenReturn(List.of(overridden, engineDefault));+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();+ params.putSingle("ParameterGroupName", "reset-pg");+ params.putSingle("Source", "user");++ Response response = handler.handle("DescribeClusterParameters", params);++ String xml = (String) response.getEntity();+ assertTrue(xml.contains("<Source>user</Source>"));+ assertFalse(xml.contains("wlm_json_configuration"));+ }+@BeforeEachvoid setUp() {service = mock(RedshiftService.class);diff --git a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftServiceTest.javaindex 326f010bfc..af54fc1e5c 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshift/RedshiftServiceTest.java@@ -36,6 +36,7 @@ import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.Paths;import java.util.ArrayList;+import java.util.Collections;import java.util.HashMap;import java.util.HashSet;import java.util.LinkedHashMap;@@ -1415,6 +1416,196 @@ class RedshiftServiceTest {assertEquals("integer", modified.getDataType());}+ @Test+ void resetClusterParameterGroupRestoresOnlySelectedDefaults() {+ ClusterParameterGroup group = new ClusterParameterGroup("reset-pg", "redshift-1.0", "description");+ when(parameterGroupBackend.get("reset-pg")).thenReturn(Optional.of(group));+ service.modifyClusterParameterGroup("reset-pg", List.of(+ new Parameter("max_cursor_result_set_size", "1000"),+ new Parameter("wlm_json_configuration", "custom")));++ service.resetClusterParameterGroup("reset-pg", false, List.of("max_cursor_result_set_size"));++ List<Parameter> parameters = service.describeClusterParameters("reset-pg");+ assertEquals("0", parameters.get(0).getParameterValue());+ assertEquals("engine-default", parameters.get(0).getSource());+ assertEquals("integer", parameters.get(0).getDataType());+ assertEquals("custom", parameters.get(1).getParameterValue());+ assertEquals("user", parameters.get(1).getSource());+ verify(parameterGroupBackend, times(2)).flush();+ }++ @Test+ void resetAllClusterParametersDropsOverridesOutsideDefaultCatalog() {+ ClusterParameterGroup group = new ClusterParameterGroup("reset-pg", "redshift-1.0", "description");+ group.getTags().put("owner", "analytics");+ when(parameterGroupBackend.get("reset-pg")).thenReturn(Optional.of(group));+ service.modifyClusterParameterGroup("reset-pg", List.of(+ new Parameter("max_cursor_result_set_size", "1000"), new Parameter("custom_parameter", "value")));++ service.resetClusterParameterGroup("reset-pg", true, List.of());++ List<Parameter> parameters = service.describeClusterParameters("reset-pg");+ assertEquals(2, parameters.size());+ assertEquals("0", parameters.get(0).getParameterValue());+ assertEquals("{}", parameters.get(1).getParameterValue());+ assertTrue(parameters.stream().allMatch(parameter -> "engine-default".equals(parameter.getSource())));+ assertEquals("analytics", group.getTags().get("owner"));+ assertEquals("description", group.getDescription());+ }++ @Test+ void resetClusterParametersValidatesEveryNameBeforeMutating() {+ ClusterParameterGroup group = new ClusterParameterGroup("reset-pg", "redshift-1.0", "description");+ group.getParameters().get(0).setParameterValue("1000");+ when(parameterGroupBackend.get("reset-pg")).thenReturn(Optional.of(group));++ AwsException failure = assertThrows(AwsException.class, () -> service.resetClusterParameterGroup(+ "reset-pg", false, List.of("max_cursor_result_set_size", "missing")));++ assertEquals("InvalidParameterValue", failure.getErrorCode());+ assertEquals("1000", group.getParameters().get(0).getParameterValue());+ verify(parameterGroupBackend, never()).put(anyString(), any());+ verify(parameterGroupBackend, never()).flush();+ }++ @Test+ void resetClusterParameterGroupRejectsMissingGroup() {+ AwsException failure = assertThrows(AwsException.class,+ () -> service.resetClusterParameterGroup("missing", true, List.of()));++ assertEquals("ClusterParameterGroupNotFound", failure.getErrorCode());+ assertEquals(404, failure.getHttpStatus());+ }++ @Test+ void resetClusterParameterGroupRejectsDefaultGroup() {+ AwsException failure = assertThrows(AwsException.class, () -> service.resetClusterParameterGroup(+ RedshiftService.DEFAULT_PARAMETER_GROUP_NAME, true, List.of()));++ assertEquals("InvalidParameterValue", failure.getErrorCode());+ verify(parameterGroupBackend, never()).flush();+ }++ @Test+ void createClusterParameterGroupRejectsReservedDefaultName() {+ AwsException failure = assertThrows(AwsException.class, () -> service.createClusterParameterGroup(+ RedshiftService.DEFAULT_PARAMETER_GROUP_NAME, "redshift-1.0", "custom"));++ assertEquals("InvalidParameterValue", failure.getErrorCode());+ verify(parameterGroupBackend, never()).put(anyString(), any());+ verify(parameterGroupBackend, never()).flush();+ }++ @Test+ void describeLegacyDefaultNamedGroupPreservesStoredParameters() {+ String name = RedshiftService.DEFAULT_PARAMETER_GROUP_NAME;+ ClusterParameterGroup stored = new ClusterParameterGroup(name, "redshift-1.0", "legacy custom group");+ stored.setParameters(List.of(new Parameter("max_cursor_result_set_size", "1000")));+ when(parameterGroupBackend.get(name)).thenReturn(Optional.of(stored));++ assertEquals("legacy custom group", service.describeClusterParameterGroups(name).getFirst().getDescription());+ List<Parameter> parameters = service.describeClusterParameters(name);++ assertEquals(1, parameters.size());+ assertEquals("1000", parameters.getFirst().getParameterValue());+ assertEquals("user", parameters.getFirst().getSource());+ assertEquals("1000", stored.getParameters().getFirst().getParameterValue());+ verify(parameterGroupBackend, never()).flush();+ }++ @Test+ void legacyDefaultNamedGroupCanBeModifiedAndReset() {+ String name = RedshiftService.DEFAULT_PARAMETER_GROUP_NAME;+ ClusterParameterGroup stored = new ClusterParameterGroup(name, "redshift-1.0", "legacy custom group");+ stored.setParameters(List.of(new Parameter("max_cursor_result_set_size", "1000")));+ when(parameterGroupBackend.get(name)).thenReturn(Optional.of(stored));++ service.modifyClusterParameterGroup(name, List.of(new Parameter("max_cursor_result_set_size", "2000")));+ assertEquals("2000", service.describeClusterParameters(name).getFirst().getParameterValue());+ service.resetClusterParameterGroup(name, false, List.of("max_cursor_result_set_size"));++ assertEquals("0", service.describeClusterParameters(name).getFirst().getParameterValue());+ assertEquals("engine-default", service.describeClusterParameters(name).getFirst().getSource());+ assertEquals("legacy custom group", service.describeClusterParameterGroups(name).getFirst().getDescription());+ verify(parameterGroupBackend, times(2)).put(eq(name), any());+ verify(parameterGroupBackend, times(2)).flush();+ }++ @Test+ void implicitDefaultGroupRemainsReadOnly() {+ String name = RedshiftService.DEFAULT_PARAMETER_GROUP_NAME;++ List<Parameter> parameters = service.describeClusterParameters(name);+ AwsException failure = assertThrows(AwsException.class,+ () -> service.modifyClusterParameterGroup(name, List.of(new Parameter("max_cursor_result_set_size", "2000"))));++ assertEquals("0", parameters.getFirst().getParameterValue());+ assertEquals("engine-default", parameters.getFirst().getSource());+ assertEquals("InvalidParameterValue", failure.getErrorCode());+ verify(parameterGroupBackend, never()).put(anyString(), any());+ }++ @Test+ void resetClusterParameterGroupRequiresNamesUnlessResettingAll() {+ AwsException failure = assertThrows(AwsException.class,+ () -> service.resetClusterParameterGroup("reset-pg", false, List.of()));++ assertEquals("InvalidParameterCombination", failure.getErrorCode());+ verify(parameterGroupBackend, never()).flush();+ }++ @Test+ void resetClusterParameterGroupRejectsConflictingOptions() {+ AwsException failure = assertThrows(AwsException.class, () -> service.resetClusterParameterGroup(+ "reset-pg", true, List.of("max_cursor_result_set_size")));++ assertEquals("InvalidParameterCombination", failure.getErrorCode());+ verify(parameterGroupBackend, never()).flush();+ }++ @Test+ void resetClusterParameterGroupRejectsMoreThanTwentyParameters() {+ AwsException failure = assertThrows(AwsException.class, () -> service.resetClusterParameterGroup(+ "reset-pg", false, Collections.nCopies(21, "max_cursor_result_set_size")));++ assertEquals("InvalidParameterValue", failure.getErrorCode());+ verify(parameterGroupBackend, never()).flush();+ }++ @Test+ void describeLegacyClusterParametersInfersSourceWithoutChangingStoredValues() throws Exception {+ ObjectMapper mapper = new ObjectMapper();+ ClusterParameterGroup group = mapper.readValue("""+ {"parameterGroupName":"legacy", "parameters":[+ {"parameterName":"max_cursor_result_set_size","parameterValue":"0"},+ {"parameterName":"wlm_json_configuration","parameterValue":"custom"}+ ]}+ """, ClusterParameterGroup.class);+ when(parameterGroupBackend.get("legacy")).thenReturn(Optional.of(group));++ List<Parameter> parameters = service.describeClusterParameters("legacy");++ assertEquals("engine-default", parameters.get(0).getSource());+ assertEquals("user", parameters.get(1).getSource());+ assertNull(group.getParameters().get(0).getSource());+ }++ @Test+ void resetSourceSurvivesSerialization() throws Exception {+ ClusterParameterGroup group = new ClusterParameterGroup("reset-pg", "redshift-1.0", "description");+ when(parameterGroupBackend.get("reset-pg")).thenReturn(Optional.of(group));+ service.modifyClusterParameterGroup("reset-pg", List.of(new Parameter("max_cursor_result_set_size", "0")));+ assertEquals("user", service.describeClusterParameters("reset-pg").getFirst().getSource());+ service.resetClusterParameterGroup("reset-pg", true, List.of());+ ObjectMapper mapper = new ObjectMapper();++ ClusterParameterGroup reloaded = mapper.readValue(mapper.writeValueAsString(group), ClusterParameterGroup.class);++ assertEquals("engine-default", reloaded.getParameters().getFirst().getSource());+ assertEquals("0", reloaded.getParameters().getFirst().getParameterValue());+ }+@Testvoid createAndListTagsForCluster() {Cluster cluster = new Cluster();