Light, fluffy, and always free - The AWS Local Emulator alternative
feat(rds): add option group CRUD (#2352)
Matheus Oliveira3374bfeb0492
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.javaindex 3a4a87e2a4..7782044340 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java@@ -13,15 +13,24 @@ import software.amazon.awssdk.services.rds.RdsClient;import software.amazon.awssdk.services.rds.model.ConnectionPoolConfigurationInfo;import software.amazon.awssdk.services.rds.model.CreateDbProxyResponse;import software.amazon.awssdk.services.rds.model.CreateDbSubnetGroupResponse;+import software.amazon.awssdk.services.rds.model.CreateOptionGroupResponse;import software.amazon.awssdk.services.rds.model.DBProxyTarget;import software.amazon.awssdk.services.rds.model.DescribeDbSubnetGroupsResponse;+import software.amazon.awssdk.services.rds.model.DescribeOptionGroupsResponse;import software.amazon.awssdk.services.rds.model.DescribeOrderableDbInstanceOptionsResponse;+import software.amazon.awssdk.services.rds.model.InvalidOptionGroupStateException;+import software.amazon.awssdk.services.rds.model.ModifyOptionGroupResponse;+import software.amazon.awssdk.services.rds.model.OptionConfiguration;+import software.amazon.awssdk.services.rds.model.OptionGroupNotFoundException;+import software.amazon.awssdk.services.rds.model.OptionSetting;import java.util.List;import java.util.logging.Level;import java.util.logging.Logger;import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;+import static org.assertj.core.api.Assertions.tuple;@DisplayName("RDS Control Plane")class RdsControlPlaneTest {@@ -366,6 +375,152 @@ class RdsControlPlaneTest {.build();}+ @Test+ void sdkRoundTripsOptionGroupCrudAndItsOptions() {+ String optionGroupName = TestFixtures.uniqueName("rds-og");+ try {+ CreateOptionGroupResponse created = rds.createOptionGroup(b -> b+ .optionGroupName(optionGroupName)+ .engineName("mysql")+ .majorEngineVersion("8.0")+ .optionGroupDescription("SDK option group shape"));++ assertThat(created.optionGroup().optionGroupName()).isEqualTo(optionGroupName);+ assertThat(created.optionGroup().engineName()).isEqualTo("mysql");+ assertThat(created.optionGroup().majorEngineVersion()).isEqualTo("8.0");+ assertThat(created.optionGroup().optionGroupArn())+ .endsWith(":og:" + optionGroupName);+ assertThat(created.optionGroup().allowsVpcAndNonVpcInstanceMemberships()).isTrue();+ assertThat(created.optionGroup().options()).isEmpty();++ ModifyOptionGroupResponse modified = rds.modifyOptionGroup(b -> b+ .optionGroupName(optionGroupName)+ .applyImmediately(true)+ .optionsToInclude(OptionConfiguration.builder()+ .optionName("MEMCACHED")+ .port(11211)+ .optionSettings(OptionSetting.builder()+ .name("BACKLOG_QUEUE_LIMIT")+ .value("1024")+ .build())+ .vpcSecurityGroupMemberships("sg-00000000")+ .build()));++ assertThat(modified.optionGroup().options()).singleElement().satisfies(option -> {+ assertThat(option.optionName()).isEqualTo("MEMCACHED");+ assertThat(option.port()).isEqualTo(11211);+ assertThat(option.optionSettings())+ .extracting("name", "value")+ .containsExactly(tuple("BACKLOG_QUEUE_LIMIT", "1024"));+ assertThat(option.vpcSecurityGroupMemberships())+ .extracting("vpcSecurityGroupId")+ .containsExactly("sg-00000000");+ });++ DescribeOptionGroupsResponse described = rds.describeOptionGroups(b -> b+ .optionGroupName(optionGroupName));+ assertThat(described.optionGroupsList()).singleElement().satisfies(group ->+ assertThat(group.options()).extracting("optionName")+ .containsExactly("MEMCACHED"));++ rds.modifyOptionGroup(b -> b+ .optionGroupName(optionGroupName)+ .optionsToRemove("MEMCACHED"));+ assertThat(rds.describeOptionGroups(b -> b.optionGroupName(optionGroupName))+ .optionGroupsList()).singleElement()+ .satisfies(group -> assertThat(group.options()).isEmpty());++ rds.deleteOptionGroup(b -> b.optionGroupName(optionGroupName));+ assertThatThrownBy(() -> rds.describeOptionGroups(b -> b+ .optionGroupName(optionGroupName)))+ .isInstanceOf(OptionGroupNotFoundException.class);+ } finally {+ deleteOptionGroup(rds, optionGroupName);+ }+ }++ @Test+ void sdkDescribesImplicitDefaultOptionGroups() {+ DescribeOptionGroupsResponse all = rds.describeOptionGroups();+ assertThat(all.optionGroupsList()).extracting("optionGroupName")+ .contains("default:mysql-8-0", "default:postgres-16");++ DescribeOptionGroupsResponse filtered = rds.describeOptionGroups(b -> b+ .engineName("mysql")+ .majorEngineVersion("8.0"));+ assertThat(filtered.optionGroupsList()).isNotEmpty();+ assertThat(filtered.optionGroupsList())+ .allSatisfy(group -> assertThat(group.engineName()).isEqualTo("mysql"));++ assertThatThrownBy(() -> rds.deleteOptionGroup(b -> b+ .optionGroupName("default:mysql-8-0")))+ .isInstanceOf(InvalidOptionGroupStateException.class);+ }++ @Test+ void sdkFaultsDeletingAnOptionGroupStillAttachedToAnInstance() {+ String optionGroupName = TestFixtures.uniqueName("rds-og-attached");+ String instanceName = TestFixtures.uniqueName("rds-db-og");+ try {+ rds.createOptionGroup(b -> b+ .optionGroupName(optionGroupName)+ .engineName("postgres")+ .majorEngineVersion("16")+ .optionGroupDescription("attached to an instance"));++ var instance = rds.createDBInstance(b -> b+ .dbInstanceIdentifier(instanceName)+ .engine("postgres")+ .engineVersion("16.3")+ .masterUsername("admin")+ .masterUserPassword("og-secret")+ .dbName("app")+ .dbInstanceClass("db.t3.micro")+ .allocatedStorage(20)+ .optionGroupName(optionGroupName));++ assertThat(instance.dbInstance().optionGroupMemberships())+ .singleElement()+ .satisfies(membership -> {+ assertThat(membership.optionGroupName()).isEqualTo(optionGroupName);+ assertThat(membership.status()).isEqualTo("in-sync");+ });++ assertThatThrownBy(() -> rds.deleteOptionGroup(b -> b+ .optionGroupName(optionGroupName)))+ .isInstanceOf(InvalidOptionGroupStateException.class);++ deleteDbInstance(rds, instanceName);+ rds.deleteOptionGroup(b -> b.optionGroupName(optionGroupName));+ } finally {+ deleteDbInstance(rds, instanceName);+ deleteOptionGroup(rds, optionGroupName);+ }+ }++ @Test+ void sdkReportsTheDefaultOptionGroupForAnUnattachedInstance() {+ String instanceName = TestFixtures.uniqueName("rds-db-default-og");+ try {+ var instance = createDbInstance(rds, instanceName, "default-og-secret");++ assertThat(instance.dbInstance().optionGroupMemberships())+ .singleElement()+ .satisfies(membership -> assertThat(membership.optionGroupName())+ .isEqualTo("default:postgres-16"));+ } finally {+ deleteDbInstance(rds, instanceName);+ }+ }++ private static void deleteOptionGroup(RdsClient client, String name) {+ try {+ client.deleteOptionGroup(b -> b.optionGroupName(name));+ } catch (Exception e) {+ LOG.log(Level.FINE, "RDS option group already absent during cleanup " + name, e);+ }+ }+private static void deleteProxy(RdsClient client, String name) {try {client.deleteDBProxy(b -> b.dbProxyName(name));diff --git a/docs/services/rds.md b/docs/services/rds.mdindex 99b23b7e56..1ec323a791 100644--- a/docs/services/rds.md+++ b/docs/services/rds.md@@ -37,6 +37,10 @@ RDS Data API (`rds-data`) is documented separately because it uses REST JSON rou| `DeleteDBClusterParameterGroup` | - || `ModifyDBClusterParameterGroup` | - || `DescribeDBClusterParameters` | - |+| `CreateOptionGroup` | Create an option group |+| `DescribeOptionGroups` | List option groups, including the implicit `default:` groups |+| `ModifyOptionGroup` | Add, update, or remove options in an option group |+| `DeleteOptionGroup` | Delete an option group || `DescribeDBSnapshots` | - || `DescribeDBProxies` | List DB proxies || `CreateDBProxy` | Create a DB proxy |@@ -179,6 +183,55 @@ mysql -h 127.0.0.1 -P 7002 -u root -psecret123Override the image per-instance with the `--engine-version` flag or globally via environment variables.+## Option Groups++Option groups are metadata: Floci stores the options you add, returns them on the wire, and+attaches a group to a DB instance, but it does not install the underlying engine feature in the+container.++As on AWS, every engine has an implicit `default:<engine>-<major version>` group that+`DescribeOptionGroups` returns even when you have created none. Floci ships the defaults for the+engines it can run (`postgres 13`–`18`, `mysql 8.0`/`8.4`, `mariadb 10.11`/`11.2`/`11.4`), so an+instance created without `--option-group-name` reports the matching default. Default groups can't+be modified, deleted, or tagged.++`CreateOptionGroup` accepts any `EngineName` AWS accepts — including `oracle-*`, `sqlserver-*`,+and `db2-*` — so a Terraform `aws_db_option_group` for an engine Floci cannot start still applies.+Attaching one to a DB instance requires the group's engine and major engine version to match the+instance, as on AWS: a `mysql 8.0` group can't be attached to a `mysql 8.4` instance. A mismatch+fails with `InvalidParameterCombination`.++```bash+aws rds create-option-group \+ --option-group-name my-og \+ --engine-name mysql \+ --major-engine-version 8.0 \+ --option-group-description "MySQL options" \+ --endpoint-url $AWS_ENDPOINT_URL++aws rds modify-option-group \+ --option-group-name my-og \+ --options OptionName=MEMCACHED,Port=11211 \+ --apply-immediately \+ --endpoint-url $AWS_ENDPOINT_URL++aws rds describe-option-groups \+ --engine-name mysql \+ --endpoint-url $AWS_ENDPOINT_URL+```++Deleting a group that is still attached to a DB instance fails with+`InvalidOptionGroupStateFault`, matching AWS.++Known gaps, all deliberate:++| Behavior | Status |+|---|---|+| `CopyOptionGroup`, `DescribeOptionGroupOptions` | Not implemented — separate actions, not part of option group CRUD |+| `OptionGroupQuotaExceededFault` (AWS caps an account at 20 groups) | Not enforced — capping a local emulator would only get in a test's way |+| `OptionSetting` metadata (`DataType`, `ApplyType`, `AllowedValues`, `DefaultValue`, `Description`) | Omitted — it would require the per-engine option catalog `DescribeOptionGroupOptions` serves |+| `MaxRecords` / `Marker` pagination | Every group is returned in one page, as with every other RDS list action |+## PersistenceEach DB instance and cluster gets its own named Docker volume (`floci-rds-{volumeId}`) createddiff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.javaindex 16e1d9a494..0b2625d7f4 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java@@ -5,6 +5,7 @@ import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.AwsNamespaces;import io.github.hectorvent.floci.core.common.AwsQueryResponse;import io.github.hectorvent.floci.core.common.XmlBuilder;+import io.github.hectorvent.floci.services.rds.model.DatabaseEngine;import io.github.hectorvent.floci.services.rds.model.DbCluster;import io.github.hectorvent.floci.services.rds.model.DbClusterParameterGroup;import io.github.hectorvent.floci.services.rds.model.DbEndpoint;@@ -16,6 +17,8 @@ import io.github.hectorvent.floci.services.rds.model.DbProxyAuth;import io.github.hectorvent.floci.services.rds.model.DbProxyTarget;import io.github.hectorvent.floci.services.rds.model.DbProxyTargetGroup;import io.github.hectorvent.floci.services.rds.model.DbSubnetGroup;+import io.github.hectorvent.floci.services.rds.model.OptionGroup;+import io.github.hectorvent.floci.services.rds.model.OptionGroupOption;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import jakarta.ws.rs.core.MultivaluedMap;@@ -77,6 +80,10 @@ public class RdsQueryHandler {case "DeleteDBClusterParameterGroup" -> handleDeleteDbClusterParameterGroup(params, region);case "ModifyDBClusterParameterGroup" -> handleModifyDbClusterParameterGroup(params, region);case "DescribeDBClusterParameters" -> handleDescribeDbClusterParameters(params, region);+ case "CreateOptionGroup" -> handleCreateOptionGroup(params, region);+ case "DescribeOptionGroups" -> handleDescribeOptionGroups(params, region);+ case "ModifyOptionGroup" -> handleModifyOptionGroup(params, region);+ case "DeleteOptionGroup" -> handleDeleteOptionGroup(params, region);case "DescribeDBSnapshots" -> handleDescribeDbSnapshots(params);case "DescribeDBProxies" -> handleDescribeDbProxies(params, region);case "CreateDBProxy" -> handleCreateDbProxy(params, region);@@ -121,6 +128,7 @@ public class RdsQueryHandler {int allocatedStorage = allocatedStorageStr != null ? parseIntSafe(allocatedStorageStr, 20) : 20;boolean iamEnabled = "true".equalsIgnoreCase(params.getFirst("EnableIAMDatabaseAuthentication"));String paramGroupName = params.getFirst("DBParameterGroupName");+ String optionGroupName = params.getFirst("OptionGroupName");String dbSubnetGroupName = params.getFirst("DBSubnetGroupName");String dbClusterIdentifier = params.getFirst("DBClusterIdentifier");boolean manageMasterUserPassword = "true".equalsIgnoreCase(params.getFirst("ManageMasterUserPassword"));@@ -141,7 +149,8 @@ public class RdsQueryHandler {DbInstance instance = service.createDbInstance(id, engine, engineVersion, masterUsername,masterPassword, dbName, dbInstanceClass, allocatedStorage, iamEnabled,paramGroupName, dbSubnetGroupName, dbClusterIdentifier, availabilityZone, multiAz,- manageMasterUserPassword, masterUserSecretKmsKeyId, tags, vpcSecurityGroupIds, region);+ manageMasterUserPassword, masterUserSecretKmsKeyId, tags, vpcSecurityGroupIds,+ optionGroupName, region);String result = dbInstanceXml(instance);return Response.ok(AwsQueryResponse.envelope("CreateDBInstance", AwsNamespaces.RDS, result)).build();} catch (AwsException e) {@@ -210,11 +219,12 @@ public class RdsQueryHandler {String iamStr = params.getFirst("EnableIAMDatabaseAuthentication");Boolean iamEnabled = iamStr != null ? Boolean.parseBoolean(iamStr) : null;String dbSubnetGroupName = params.getFirst("DBSubnetGroupName");+ String optionGroupName = params.getFirst("OptionGroupName");try {List<String> vpcSecurityGroupIds = vpcSecurityGroupIds(params);DbInstance instance = service.modifyDbInstance(id, newPassword, iamEnabled, dbSubnetGroupName,- vpcSecurityGroupIds, region);+ vpcSecurityGroupIds, optionGroupName, region);String result = dbInstanceXml(instance);return Response.ok(AwsQueryResponse.envelope("ModifyDBInstance", AwsNamespaces.RDS, result)).build();} catch (AwsException e) {@@ -655,6 +665,139 @@ public class RdsQueryHandler {}}+ // ── Option Groups ─────────────────────────────────────────────────────────++ private Response handleCreateOptionGroup(+ MultivaluedMap<String, String> params, String region) {+ String name = params.getFirst("OptionGroupName");+ String engineName = params.getFirst("EngineName");+ String majorEngineVersion = params.getFirst("MajorEngineVersion");+ String description = params.getFirst("OptionGroupDescription");+ Response missing = firstMissingParam(+ "OptionGroupName", name,+ "EngineName", engineName,+ "MajorEngineVersion", majorEngineVersion,+ "OptionGroupDescription", description);+ if (missing != null) {+ return missing;+ }+ OptionGroup group = service.createOptionGroup(+ name, engineName, majorEngineVersion, description, parseTags(params), region);+ return Response.ok(AwsQueryResponse.envelope(+ "CreateOptionGroup", AwsNamespaces.RDS, optionGroupXml(group))).build();+ }++ private Response handleDescribeOptionGroups(+ MultivaluedMap<String, String> params, String region) {+ Collection<OptionGroup> result = service.listOptionGroups(+ params.getFirst("OptionGroupName"),+ params.getFirst("EngineName"),+ params.getFirst("MajorEngineVersion"),+ region);+ XmlBuilder xml = new XmlBuilder().start("OptionGroupsList");+ for (OptionGroup group : result) {+ xml.start("OptionGroup").raw(optionGroupInnerXml(group)).end("OptionGroup");+ }+ xml.end("OptionGroupsList").start("Marker").end("Marker");+ return Response.ok(AwsQueryResponse.envelope(+ "DescribeOptionGroups", AwsNamespaces.RDS, xml.build())).build();+ }++ private Response handleModifyOptionGroup(+ MultivaluedMap<String, String> params, String region) {+ String name = params.getFirst("OptionGroupName");+ if (name == null || name.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue",+ "OptionGroupName is required.", AwsNamespaces.RDS, 400);+ }+ OptionGroup group = service.modifyOptionGroup(name,+ parseOptionConfigurations(params),+ memberList(params, "OptionsToRemove"),+ region);+ return Response.ok(AwsQueryResponse.envelope(+ "ModifyOptionGroup", AwsNamespaces.RDS, optionGroupXml(group))).build();+ }++ private Response handleDeleteOptionGroup(+ MultivaluedMap<String, String> params, String region) {+ String name = params.getFirst("OptionGroupName");+ if (name == null || name.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue",+ "OptionGroupName is required.", AwsNamespaces.RDS, 400);+ }+ service.deleteOptionGroup(name, region);+ return Response.ok(AwsQueryResponse.envelopeNoResult(+ "DeleteOptionGroup", AwsNamespaces.RDS)).build();+ }++ /**+ * Returns an {@code InvalidParameterValue} response for the first blank value in the given+ * name/value pairs, or {@code null} when they are all present.+ */+ private static Response firstMissingParam(String... nameValuePairs) {+ for (int i = 0; i < nameValuePairs.length; i += 2) {+ String value = nameValuePairs[i + 1];+ if (value == null || value.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue",+ nameValuePairs[i] + " is required.", AwsNamespaces.RDS, 400);+ }+ }+ return null;+ }++ /**+ * Parses {@code OptionsToInclude.OptionConfiguration.N.*} (and the legacy+ * {@code OptionsToInclude.member.N.*} encoding older SDKs emit).+ */+ private static List<OptionGroupOption> parseOptionConfigurations(+ MultivaluedMap<String, String> params) {+ List<OptionGroupOption> options = new java.util.ArrayList<>();+ for (String prefix : List.of("OptionsToInclude.OptionConfiguration",+ "OptionsToInclude.member")) {+ for (int n = 1; ; n++) {+ String base = prefix + "." + n + ".";+ String optionName = params.getFirst(base + "OptionName");+ if (optionName == null) {+ break;+ }+ OptionGroupOption option = new OptionGroupOption(optionName);+ option.setOptionVersion(params.getFirst(base + "OptionVersion"));+ String port = params.getFirst(base + "Port");+ if (port != null && !port.isBlank()) {+ try {+ option.setPort(Integer.parseInt(port.trim()));+ } catch (NumberFormatException e) {+ throw new AwsException("InvalidParameterValue",+ "Port must be an integer for option " + optionName + ".", 400);+ }+ }+ option.setOptionSettings(parseOptionSettings(params, base));+ option.setVpcSecurityGroupMemberships(+ memberList(params, base + "VpcSecurityGroupMemberships"));+ option.setDbSecurityGroupMemberships(+ memberList(params, base + "DBSecurityGroupMemberships"));+ options.add(option);+ }+ }+ return options;+ }++ private static Map<String, String> parseOptionSettings(+ MultivaluedMap<String, String> params, String optionPrefix) {+ Map<String, String> settings = new LinkedHashMap<>();+ for (String prefix : List.of("OptionSettings.OptionSetting", "OptionSettings.member")) {+ for (int n = 1; ; n++) {+ String settingName = params.getFirst(optionPrefix + prefix + "." + n + ".Name");+ if (settingName == null) {+ break;+ }+ settings.put(settingName,+ params.getFirst(optionPrefix + prefix + "." + n + ".Value"));+ }+ }+ return settings;+ }+// ── Snapshots & Proxies (not modeled — empty lists) ───────────────────────private Response handleDescribeDbSnapshots(MultivaluedMap<String, String> params) {@@ -998,6 +1141,7 @@ public class RdsQueryHandler {.elem("PreferredBackupWindow", "04:00-06:00").raw(vpcSecurityGroupsXml(i)).raw(dbParameterGroupsXml(i))+ .raw(optionGroupMembershipsXml(i)).raw(dbSubnetGroupXml(dbSubnetGroupForInstance(i))).elem("DbiResourceId", i.getDbiResourceId()).elem("DBInstanceArn", i.getDbInstanceArn());@@ -1230,6 +1374,96 @@ public class RdsQueryHandler {.build();}+ private String optionGroupXml(OptionGroup g) {+ return new XmlBuilder().start("OptionGroup").raw(optionGroupInnerXml(g)).end("OptionGroup").build();+ }++ private String optionGroupInnerXml(OptionGroup g) {+ XmlBuilder xml = new XmlBuilder()+ .elem("OptionGroupName", g.getOptionGroupName())+ .elem("OptionGroupDescription", g.getOptionGroupDescription())+ .elem("EngineName", g.getEngineName())+ .elem("MajorEngineVersion", g.getMajorEngineVersion())+ .start("Options");+ for (OptionGroupOption option : g.getOptions()) {+ xml.start("Option").raw(optionInnerXml(option)).end("Option");+ }+ return xml.end("Options")+ .elem("AllowsVpcAndNonVpcInstanceMemberships",+ g.isAllowsVpcAndNonVpcInstanceMemberships())+ .elem("OptionGroupArn", g.getOptionGroupArn())+ .build();+ }++ private String optionInnerXml(OptionGroupOption o) {+ XmlBuilder xml = new XmlBuilder()+ .elem("OptionName", o.getOptionName())+ .elem("OptionDescription", o.getOptionDescription())+ .elem("OptionVersion", o.getOptionVersion());+ if (o.getPort() != null) {+ xml.elem("Port", o.getPort().longValue());+ }+ xml.elem("Persistent", o.isPersistent())+ .elem("Permanent", o.isPermanent())+ .start("OptionSettings");+ for (Map.Entry<String, String> setting : o.getOptionSettings().entrySet()) {+ xml.start("OptionSetting")+ .elem("Name", setting.getKey())+ .elem("Value", setting.getValue())+ .elem("IsModifiable", true)+ .elem("IsCollection", false)+ .end("OptionSetting");+ }+ xml.end("OptionSettings").start("VpcSecurityGroupMemberships");+ for (String securityGroupId : o.getVpcSecurityGroupMemberships()) {+ xml.start("VpcSecurityGroupMembership")+ .elem("VpcSecurityGroupId", securityGroupId)+ .elem("Status", "active")+ .end("VpcSecurityGroupMembership");+ }+ xml.end("VpcSecurityGroupMemberships").start("DBSecurityGroupMemberships");+ for (String securityGroupName : o.getDbSecurityGroupMemberships()) {+ xml.start("DBSecurityGroup")+ .elem("DBSecurityGroupName", securityGroupName)+ .elem("Status", "authorized")+ .end("DBSecurityGroup");+ }+ return xml.end("DBSecurityGroupMemberships").build();+ }++ private static String optionGroupMembershipsXml(DbInstance instance) {+ return new XmlBuilder().start("OptionGroupMemberships")+ .start("OptionGroupMembership")+ .elem("OptionGroupName", instanceOptionGroupName(instance))+ .elem("Status", "in-sync")+ .end("OptionGroupMembership")+ .end("OptionGroupMemberships")+ .build();+ }++ private static String instanceOptionGroupName(DbInstance instance) {+ String name = instance.getOptionGroupName();+ if (name != null && !name.isBlank()) {+ return name;+ }+ String engine = instance.getEngine() != null+ ? instance.getEngine().name().toLowerCase()+ : "unknown";+ String majorVersion = optionGroupMajorVersion(instance);+ return majorVersion.isEmpty()+ ? "default:" + engine+ : RdsService.defaultOptionGroupName(engine, majorVersion);+ }++ private static String optionGroupMajorVersion(DbInstance instance) {+ String engineVersion = instance.getEngineVersion();+ if ((engineVersion == null || engineVersion.isBlank()) && instance.getEngine() != null) {+ engineVersion = defaultEngineVersion(instance.getEngine().name());+ }+ String engine = instance.getEngine() == null ? null : instance.getEngine().name();+ return RdsService.optionGroupMajorVersion(engine, engineVersion);+ }+private String clusterParamGroupXml(DbClusterParameterGroup g) {return new XmlBuilder().start("DBClusterParameterGroup").raw(clusterParamGroupInnerXml(g)).end("DBClusterParameterGroup").build();}@@ -1308,7 +1542,18 @@ public class RdsQueryHandler {return switch (baseName) {case "SubnetIds" -> quoted + "(\\.member|\\.SubnetIdentifier)?\\.\\d+";case "VpcSecurityGroupIds" -> quoted + "(\\.member|\\.VpcSecurityGroupId)?\\.\\d+";- default -> quoted + "(\\.member)?\\.\\d+";+ case "OptionsToRemove" -> quoted + "(\\.member|\\.OptionName)?\\.\\d+";+ default -> {+ // Option configurations nest their membership lists under an indexed prefix,+ // so the alternate member names have to be matched on the suffix.+ if (baseName.endsWith("VpcSecurityGroupMemberships")) {+ yield quoted + "(\\.member|\\.VpcSecurityGroupId)?\\.\\d+";+ }+ if (baseName.endsWith("DBSecurityGroupMemberships")) {+ yield quoted + "(\\.member|\\.DBSecurityGroupName)?\\.\\d+";+ }+ yield quoted + "(\\.member)?\\.\\d+";+ }};}diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.javaindex b329aa1c5e..7b6a8cc986 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java@@ -30,6 +30,8 @@ import io.github.hectorvent.floci.services.rds.model.DbProxyAuth;import io.github.hectorvent.floci.services.rds.model.DbProxyTarget;import io.github.hectorvent.floci.services.rds.model.DbProxyTargetGroup;import io.github.hectorvent.floci.services.rds.model.DbSubnetGroup;+import io.github.hectorvent.floci.services.rds.model.OptionGroup;+import io.github.hectorvent.floci.services.rds.model.OptionGroupOption;import io.github.hectorvent.floci.services.rds.proxy.RdsProxyManager;import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;import io.github.hectorvent.floci.services.secretsmanager.model.Secret;@@ -83,10 +85,39 @@ public class RdsService implements Resettable {managedDefault("postgres17"),managedDefault("postgres18"));+ /**+ * Engines AWS accepts for {@code EngineName} on an option group. Floci can only run+ * postgres, mysql and mariadb, but option groups are pure metadata, so a group for an+ * engine Floci cannot start is still valid to create and describe.+ */+ private static final Set<String> OPTION_GROUP_ENGINES = Set.of(+ "db2-ae", "db2-ce", "db2-se", "mariadb", "mysql",+ "oracle-ee", "oracle-ee-cdb", "oracle-se2", "oracle-se2-cdb", "postgres",+ "sqlserver-ee", "sqlserver-se", "sqlserver-ex", "sqlserver-web");++ /**+ * The {@code default:<engine>-<major version>} groups AWS creates implicitly. Only the+ * engines Floci can actually run are listed, so every instance Floci creates resolves to+ * a default option group that {@code DescribeOptionGroups} also returns.+ */+ private static final List<ManagedOptionGroup> MANAGED_OPTION_GROUPS = List.of(+ managedOptionGroup("mariadb", "10.11"),+ managedOptionGroup("mariadb", "11.2"),+ managedOptionGroup("mariadb", "11.4"),+ managedOptionGroup("mysql", "8.0"),+ managedOptionGroup("mysql", "8.4"),+ managedOptionGroup("postgres", "13"),+ managedOptionGroup("postgres", "14"),+ managedOptionGroup("postgres", "15"),+ managedOptionGroup("postgres", "16"),+ managedOptionGroup("postgres", "17"),+ managedOptionGroup("postgres", "18"));+private final StorageBackend<String, DbInstance> instances;private final StorageBackend<String, DbCluster> clusters;private final StorageBackend<String, DbParameterGroup> parameterGroups;private final StorageBackend<String, DbClusterParameterGroup> clusterParameterGroups;+ private final StorageBackend<String, OptionGroup> optionGroups;private final StorageBackend<String, DbSubnetGroup> subnetGroups;private final StorageBackend<String, DbProxy> proxies;private final StorageBackend<String, DbProxyTargetGroup> proxyTargetGroups;@@ -103,6 +134,14 @@ public class RdsService implements Resettable {private static final Pattern SAFE_IMAGE_TAG_PATTERN = Pattern.compile("[A-Za-z0-9._-]+");private static final Pattern DB_PROXY_NAME_PATTERN =Pattern.compile("[a-zA-Z](?:-?[a-zA-Z0-9]+)*");+ /**+ * AWS constrains a user-created option group name to 1–255 letters, numbers or hyphens,+ * starting with a letter, without a trailing or doubled hyphen. The implicit+ * {@code default:<engine>-<version>} groups are exempt — they are not user-creatable.+ */+ private static final Pattern OPTION_GROUP_NAME_PATTERN =+ Pattern.compile("[a-zA-Z][a-zA-Z0-9]*(?:-[a-zA-Z0-9]+)*");+ private static final int OPTION_GROUP_NAME_MAX_LENGTH = 255;private static final Set<String> DB_PROXY_AUTH_SCHEMES = Set.of("SECRETS");private static final Set<String> DB_PROXY_IAM_AUTH_MODES =Set.of("DISABLED", "REQUIRED", "ENABLED");@@ -136,6 +175,8 @@ public class RdsService implements Resettable {new TypeReference<Map<String, DbParameterGroup>>() {});this.clusterParameterGroups = storageFactory.create("rds", "rds-cluster-parameter-groups.json",new TypeReference<Map<String, DbClusterParameterGroup>>() {});+ this.optionGroups = storageFactory.create("rds", "rds-option-groups.json",+ new TypeReference<Map<String, OptionGroup>>() {});this.subnetGroups = storageFactory.create("rds", "rds-subnet-groups.json",new TypeReference<Map<String, DbSubnetGroup>>() {});this.proxies = storageFactory.create("rds", "rds-proxies.json",@@ -231,6 +272,28 @@ public class RdsService implements Resettable {CurrentContainerNetworkResolver currentContainerNetworkResolver,StorageBackend<String, DbProxy> proxies,StorageBackend<String, DbProxyTargetGroup> proxyTargetGroups) {+ this(containerManager, proxyManager, ec2Service, regionResolver, config,+ instances, clusters, parameterGroups, clusterParameterGroups, subnetGroups,+ secretsManagerService, dockerHostResolver, currentContainerNetworkResolver,+ proxies, proxyTargetGroups, new InMemoryStorage<>());+ }++ RdsService(RdsContainerManager containerManager,+ RdsProxyManager proxyManager,+ Ec2Service ec2Service,+ RegionResolver regionResolver,+ EmulatorConfig config,+ StorageBackend<String, DbInstance> instances,+ StorageBackend<String, DbCluster> clusters,+ StorageBackend<String, DbParameterGroup> parameterGroups,+ StorageBackend<String, DbClusterParameterGroup> clusterParameterGroups,+ StorageBackend<String, DbSubnetGroup> subnetGroups,+ SecretsManagerService secretsManagerService,+ DockerHostResolver dockerHostResolver,+ CurrentContainerNetworkResolver currentContainerNetworkResolver,+ StorageBackend<String, DbProxy> proxies,+ StorageBackend<String, DbProxyTargetGroup> proxyTargetGroups,+ StorageBackend<String, OptionGroup> optionGroups) {this.containerManager = containerManager;this.proxyManager = proxyManager;this.ec2Service = ec2Service;@@ -243,6 +306,7 @@ public class RdsService implements Resettable {this.clusters = clusters;this.parameterGroups = parameterGroups;this.clusterParameterGroups = clusterParameterGroups;+ this.optionGroups = optionGroups;this.subnetGroups = subnetGroups;this.proxies = proxies;this.proxyTargetGroups = proxyTargetGroups;@@ -371,6 +435,25 @@ public class RdsService implements Resettable {Map<String, String> tags,List<String> vpcSecurityGroupIds,String region) {+ return createDbInstance(id, engineParam, engineVersion, masterUsername, masterPassword,+ dbName, dbInstanceClass, allocatedStorage, iamEnabled, paramGroupName,+ dbSubnetGroupName, dbClusterIdentifier, availabilityZone, multiAz,+ manageMasterUserPassword, masterUserSecretKmsKeyId, tags, vpcSecurityGroupIds,+ null, region);+ }++ public DbInstance createDbInstance(String id, String engineParam, String engineVersion,+ String masterUsername, String masterPassword,+ String dbName, String dbInstanceClass,+ int allocatedStorage, boolean iamEnabled,+ String paramGroupName, String dbSubnetGroupName,+ String dbClusterIdentifier, String availabilityZone,+ boolean multiAz, boolean manageMasterUserPassword,+ String masterUserSecretKmsKeyId,+ Map<String, String> tags,+ List<String> vpcSecurityGroupIds,+ String optionGroupName,+ String region) {String effectiveRegion = effectiveRegion(region);String dbiResourceId = "db-" + java.util.UUID.randomUUID().toString().replace("-", "").substring(0, 24).toUpperCase();@@ -387,6 +470,7 @@ public class RdsService implements Resettable {}validateInstanceParameterGroup(paramGroupName, engineParam, engineVersion, effectiveRegion);+ validateInstanceOptionGroup(optionGroupName, engineParam, engineVersion, effectiveRegion);boolean mock = config.services().rds().mock();// Always reserve a unique port (even in mock) so endpoints stay distinct and usedPorts// is consistent; mock mode only skips starting the container and auth proxy.@@ -455,6 +539,7 @@ public class RdsService implements Resettable {DbInstance instance = new DbInstance(id, engine, engineVersion, masterUsername, masterPassword,dbName, dbInstanceClass, allocatedStorage, DbInstanceStatus.AVAILABLE,endpoint, iamEnabled, paramGroupName, dbClusterIdentifier, Instant.now(), proxyPort);+ instance.setOptionGroupName(optionGroupName);instance.setDbSubnetGroupName(dbSubnetGroupName);instance.setContainerId(containerId);instance.setContainerHost(containerHost);@@ -625,7 +710,18 @@ public class RdsService implements Resettable {proxies.put(dbProxyKey(effectiveRegion, resolvedProxy.getDbProxyName()), updatedProxy);});}- // Valid RDS resource types Floci does not model yet (og, pg, snapshot, ...) — taggable+ case "og" -> {+ if (managedOptionGroup(resourceId) != null) {+ throw new AwsException("InvalidOptionGroupStateFault",+ "The default option group " + resourceId + " cannot be tagged.", 400);+ }+ OptionGroup group = getOptionGroup(resourceId, effectiveRegion);+ yield new TagHandle(group.getTags(), updated -> {+ group.setTags(updated);+ putOptionGroupForRegion(resourceId, effectiveRegion, group);+ });+ }+ // Valid RDS resource types Floci does not model yet (pg, snapshot, ...) — taggable// on real AWS, so the message states the Floci limitation rather than AWS semantics.default -> throw new AwsException("InvalidParameterValue","Tagging for resource type '" + type + "' is not yet implemented by Floci: " + resourceName, 400);@@ -742,9 +838,23 @@ public class RdsService implements Resettable {public DbInstance modifyDbInstance(String id, String newPassword, Boolean iamEnabled,String dbSubnetGroupName, List<String> vpcSecurityGroupIds, String region) {+ return modifyDbInstance(id, newPassword, iamEnabled, dbSubnetGroupName,+ vpcSecurityGroupIds, null, region);+ }++ public DbInstance modifyDbInstance(+ String id, String newPassword, Boolean iamEnabled,+ String dbSubnetGroupName, List<String> vpcSecurityGroupIds,+ String optionGroupName, String region) {String effectiveRegion = effectiveRegion(region);DbInstance instance = getDbInstance(id, effectiveRegion);instance.setStatus(DbInstanceStatus.AVAILABLE);+ if (optionGroupName != null && !optionGroupName.isBlank()) {+ validateInstanceOptionGroup(optionGroupName,+ instance.getEngine() == null ? null : instance.getEngine().name().toLowerCase(),+ instance.getEngineVersion(), effectiveRegion);+ instance.setOptionGroupName(optionGroupName);+ }if (newPassword != null && !newPassword.isBlank()) {instance.setMasterPassword(newPassword);}@@ -2217,6 +2327,279 @@ public class RdsService implements Resettable {return group;}+ // ── Option Groups ─────────────────────────────────────────────────────────++ public OptionGroup createOptionGroup(+ String name, String engineName, String majorEngineVersion, String description) {+ return createOptionGroup(name, engineName, majorEngineVersion, description,+ Map.of(), regionResolver.getDefaultRegion());+ }++ public OptionGroup createOptionGroup(+ String name, String engineName, String majorEngineVersion, String description,+ Map<String, String> tags, String region) {+ String effectiveRegion = effectiveRegion(region);+ validateOptionGroupName(name);+ validateOptionGroupEngine(engineName);+ if (findOptionGroupForRegion(name, effectiveRegion) != null+ || scopedKeyExists(optionGroups, currentAccountId(),+ dbResourceKey(effectiveRegion, name))) {+ throw new AwsException("OptionGroupAlreadyExistsFault",+ "Option group " + name + " already exists.", 400);+ }+ OptionGroup group = new OptionGroup(name, engineName, majorEngineVersion, description);+ group.setRegion(effectiveRegion);+ group.setOptionGroupArn(regionResolver.buildArn("rds", effectiveRegion, "og:" + name));+ group.setTags(tags == null ? new LinkedHashMap<>() : new LinkedHashMap<>(tags));+ putOptionGroupForRegion(name, effectiveRegion, group);+ return group;+ }++ public OptionGroup getOptionGroup(String name) {+ return getOptionGroup(name, regionResolver.getDefaultRegion());+ }++ public OptionGroup getOptionGroup(String name, String region) {+ String effectiveRegion = effectiveRegion(region);+ OptionGroup group = findOptionGroupForRegion(name, effectiveRegion);+ if (group == null) {+ ManagedOptionGroup managed = managedOptionGroup(name);+ if (managed != null) {+ group = managed.toModel(effectiveRegion, regionResolver);+ }+ }+ if (group == null) {+ throw new AwsException("OptionGroupNotFoundFault",+ "Option group " + name + " not found.", 404);+ }+ return group;+ }++ public Collection<OptionGroup> listOptionGroups(+ String filterName, String engineName, String majorEngineVersion) {+ return listOptionGroups(filterName, engineName, majorEngineVersion,+ regionResolver.getDefaultRegion());+ }++ public Collection<OptionGroup> listOptionGroups(+ String filterName, String engineName, String majorEngineVersion, String region) {+ String effectiveRegion = effectiveRegion(region);+ boolean hasName = filterName != null && !filterName.isBlank();+ boolean hasEngine = engineName != null && !engineName.isBlank();+ boolean hasVersion = majorEngineVersion != null && !majorEngineVersion.isBlank();+ if (hasName && (hasEngine || hasVersion)) {+ throw new AwsException("InvalidParameterCombination",+ "OptionGroupName can't be supplied together with EngineName "+ + "or MajorEngineVersion.", 400);+ }+ if (hasVersion && !hasEngine) {+ throw new AwsException("InvalidParameterCombination",+ "MajorEngineVersion must be used with EngineName.", 400);+ }+ if (hasName) {+ return List.of(getOptionGroup(filterName, effectiveRegion));+ }++ Map<String, OptionGroup> unique = new LinkedHashMap<>();+ for (ManagedOptionGroup managed : MANAGED_OPTION_GROUPS) {+ OptionGroup group = managed.toModel(effectiveRegion, regionResolver);+ unique.put(group.getOptionGroupName(), group);+ }+ List<OptionGroup> storedGroups;+ if (optionGroups instanceof AccountAwareStorageBackend<OptionGroup> aware) {+ storedGroups = new ArrayList<>(aware.scanForAccount(currentAccountId(), k -> true));+ if (Objects.equals(currentAccountId(), defaultAccountId())) {+ storedGroups.addAll(aware.scanUnscopedLegacy(group ->+ optionGroupBelongsToRegion(group, effectiveRegion)));+ }+ } else {+ storedGroups = optionGroups.scan(k -> true);+ }+ storedGroups.stream()+ .sorted(Comparator.comparing(OptionGroup::getOptionGroupName,+ Comparator.nullsLast(Comparator.naturalOrder())))+ .filter(group -> optionGroupBelongsToRegion(group, effectiveRegion))+ .map(group -> findOptionGroupForRegion(+ group.getOptionGroupName(), effectiveRegion))+ .filter(Objects::nonNull)+ .forEach(group -> unique.put(group.getOptionGroupName(), group));++ return unique.values().stream()+ .filter(group -> !hasEngine || engineName.equalsIgnoreCase(group.getEngineName()))+ .filter(group -> !hasVersion+ || majorEngineVersion.equalsIgnoreCase(group.getMajorEngineVersion()))+ .toList();+ }++ public OptionGroup modifyOptionGroup(String name,+ List<OptionGroupOption> optionsToInclude,+ List<String> optionsToRemove) {+ return modifyOptionGroup(name, optionsToInclude, optionsToRemove,+ regionResolver.getDefaultRegion());+ }++ public OptionGroup modifyOptionGroup(String name,+ List<OptionGroupOption> optionsToInclude,+ List<String> optionsToRemove,+ String region) {+ String effectiveRegion = effectiveRegion(region);+ if (managedOptionGroup(name) != null) {+ throw new AwsException("InvalidOptionGroupStateFault",+ "The default option group " + name + " cannot be modified.", 400);+ }+ OptionGroup group = getOptionGroup(name, effectiveRegion);+ if (optionsToRemove != null && !optionsToRemove.isEmpty()) {+ group.getOptions().removeIf(option ->+ optionsToRemove.contains(option.getOptionName()));+ }+ if (optionsToInclude != null) {+ for (OptionGroupOption option : optionsToInclude) {+ mergeOption(group, option);+ }+ }+ putOptionGroupForRegion(name, effectiveRegion, group);+ return group;+ }++ public void deleteOptionGroup(String name) {+ deleteOptionGroup(name, regionResolver.getDefaultRegion());+ }++ public void deleteOptionGroup(String name, String region) {+ String effectiveRegion = effectiveRegion(region);+ if (managedOptionGroup(name) != null) {+ throw new AwsException("InvalidOptionGroupStateFault",+ "The default option group " + name + " cannot be deleted.", 400);+ }+ if (findOptionGroupForRegion(name, effectiveRegion) == null) {+ throw new AwsException("OptionGroupNotFoundFault",+ "Option group " + name + " not found.", 404);+ }+ boolean attached = listDbInstances(null, effectiveRegion).stream()+ .anyMatch(instance -> name.equals(instance.getOptionGroupName()));+ if (attached) {+ throw new AwsException("InvalidOptionGroupStateFault",+ "The option group " + name + " is still associated with a DB instance.", 400);+ }+ deleteOptionGroupForRegion(name, effectiveRegion);+ }++ /**+ * Merges an incoming {@code OptionsToInclude} entry: an option that is already present+ * has its configuration updated in place, mirroring the AWS upsert semantics.+ */+ private static void mergeOption(OptionGroup group, OptionGroupOption incoming) {+ if (incoming == null || incoming.getOptionName() == null+ || incoming.getOptionName().isBlank()) {+ throw new AwsException("InvalidParameterValue",+ "OptionName is required for every option in OptionsToInclude.", 400);+ }+ OptionGroupOption existing = group.getOptions().stream()+ .filter(option -> incoming.getOptionName().equals(option.getOptionName()))+ .findFirst()+ .orElse(null);+ if (existing == null) {+ group.getOptions().add(incoming);+ return;+ }+ existing.setOptionDescription(incoming.getOptionDescription());+ existing.setOptionVersion(incoming.getOptionVersion());+ existing.setPort(incoming.getPort());+ existing.getOptionSettings().putAll(incoming.getOptionSettings());+ existing.setVpcSecurityGroupMemberships(incoming.getVpcSecurityGroupMemberships());+ existing.setDbSecurityGroupMemberships(incoming.getDbSecurityGroupMemberships());+ }++ private static void validateOptionGroupName(String name) {+ if (name == null || name.isBlank()+ || name.length() > OPTION_GROUP_NAME_MAX_LENGTH+ || !OPTION_GROUP_NAME_PATTERN.matcher(name).matches()) {+ throw new AwsException("InvalidParameterValue",+ "OptionGroupName must be 1 to " + OPTION_GROUP_NAME_MAX_LENGTH+ + " letters, numbers or hyphens, must start with a letter, and "+ + "can't end with a hyphen or contain two consecutive hyphens.", 400);+ }+ }++ private static void validateOptionGroupEngine(String engineName) {+ if (engineName == null || engineName.isBlank()+ || !OPTION_GROUP_ENGINES.contains(engineName.toLowerCase())) {+ throw new AwsException("InvalidParameterValue",+ "EngineName " + engineName + " is not a valid option group engine.", 400);+ }+ }++ private void validateInstanceOptionGroup(+ String optionGroupName, String engineParam, String engineVersion, String region) {+ if (optionGroupName == null || optionGroupName.isBlank()) {+ return;+ }+ OptionGroup group = getOptionGroup(optionGroupName, region);+ String engine = effectiveEngineName(engineParam);+ if (!engine.equalsIgnoreCase(group.getEngineName())) {+ throw new AwsException("InvalidParameterCombination",+ invalidParameterCombinationMessage(), 400);+ }+ // An option group is scoped to one major engine version, so a group built for another+ // major version can't be attached even when the engine itself matches.+ String majorVersion = optionGroupMajorVersion(engine, engineVersion);+ if (!majorVersion.isEmpty()+ && !majorVersion.equalsIgnoreCase(group.getMajorEngineVersion())) {+ throw new AwsException("InvalidParameterCombination",+ invalidParameterCombinationMessage(), 400);+ }+ }++ /**+ * AWS keys an option group on the engine's major version, which is the leading component for+ * postgres and {@code major.minor} for the MySQL-family engines. Returns an empty string when+ * the version is unknown.+ */+ public static String optionGroupMajorVersion(String engineName, String engineVersion) {+ if (engineVersion == null || engineVersion.isBlank()) {+ return "";+ }+ String[] parts = engineVersion.trim().split("\\.");+ if ("postgres".equalsIgnoreCase(engineName) || parts.length < 2) {+ return parts[0];+ }+ return parts[0] + "." + parts[1];+ }++ private static ManagedOptionGroup managedOptionGroup(String name) {+ for (ManagedOptionGroup group : MANAGED_OPTION_GROUPS) {+ if (group.name().equals(name)) {+ return group;+ }+ }+ return null;+ }++ private static ManagedOptionGroup managedOptionGroup(+ String engineName, String majorEngineVersion) {+ return new ManagedOptionGroup(+ defaultOptionGroupName(engineName, majorEngineVersion),+ engineName,+ majorEngineVersion,+ "Default option group for " + engineName + " " + majorEngineVersion);+ }++ /** AWS names implicit option groups {@code default:<engine>-<major version>}, dots as dashes. */+ public static String defaultOptionGroupName(String engineName, String majorEngineVersion) {+ return "default:" + engineName + "-" + majorEngineVersion.replace('.', '-');+ }++ private record ManagedOptionGroup(String name, String engineName,+ String majorEngineVersion, String description) {+ private OptionGroup toModel(String region, RegionResolver regionResolver) {+ OptionGroup group = new OptionGroup(+ name, engineName, majorEngineVersion, description);+ group.setRegion(region);+ group.setOptionGroupArn(regionResolver.buildArn("rds", region, "og:" + name));+ return group;+ }+ }+// ── Password validation callbacks ─────────────────────────────────────────public boolean validateDbPassword(String instanceId, String clientUser, String password) {@@ -3899,6 +4282,73 @@ public class RdsService implements Resettable {}}+ private synchronized OptionGroup findOptionGroupForRegion(String groupName, String region) {+ String effectiveRegion = effectiveRegion(region);+ String accountId = currentAccountId();+ String key = dbResourceKey(effectiveRegion, groupName);+ java.util.function.Predicate<OptionGroup> owner = group ->+ Objects.equals(groupName, group.getOptionGroupName())+ && optionGroupBelongsToRegion(group, effectiveRegion);+ Optional<OptionGroup> resolved;+ if (optionGroups instanceof AccountAwareStorageBackend<OptionGroup> aware) {+ resolved = aware.getForAccountMigratingLegacyKeys(+ accountId, key, List.of(groupName), owner,+ Objects.equals(accountId, defaultAccountId()));+ } else {+ Optional<OptionGroup> canonicalValue = optionGroups.get(key);+ Optional<OptionGroup> canonical = canonicalValue.filter(owner);+ if (canonical.isPresent()) {+ optionGroups.get(groupName).filter(owner)+ .ifPresent(ignored -> optionGroups.delete(groupName));+ resolved = canonical;+ } else if (canonicalValue.isPresent()) {+ resolved = Optional.empty();+ } else {+ Optional<OptionGroup> legacy = optionGroups.get(groupName).filter(owner);+ if (legacy.isPresent()) {+ optionGroups.put(key, legacy.get());+ optionGroups.delete(groupName);+ }+ resolved = legacy;+ }+ }+ resolved.ifPresent(group -> {+ if (group.getRegion() == null || group.getRegion().isBlank()) {+ group.setRegion(effectiveRegion);+ putOptionGroupForRegion(groupName, effectiveRegion, group);+ }+ });+ return resolved.orElse(null);+ }++ private boolean optionGroupBelongsToRegion(OptionGroup group, String region) {+ if (group == null) {+ return false;+ }+ String storedRegion = group.getRegion();+ return storedRegion == null || storedRegion.isBlank()+ ? Objects.equals(regionResolver.getDefaultRegion(), region)+ : Objects.equals(storedRegion, region);+ }++ private void putOptionGroupForRegion(String groupName, String region, OptionGroup group) {+ String key = dbResourceKey(region, groupName);+ if (optionGroups instanceof AccountAwareStorageBackend<OptionGroup> aware) {+ aware.putForAccount(currentAccountId(), key, group);+ } else {+ optionGroups.put(key, group);+ }+ }++ private void deleteOptionGroupForRegion(String groupName, String region) {+ String key = dbResourceKey(region, groupName);+ if (optionGroups instanceof AccountAwareStorageBackend<OptionGroup> aware) {+ aware.deleteForAccount(currentAccountId(), key);+ } else {+ optionGroups.delete(key);+ }+ }+private void putSubnetGroupForScope(String accountId, String region, String groupName, DbSubnetGroup group) {String key = dbResourceKey(region, groupName);diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/model/DbInstance.java b/src/main/java/io/github/hectorvent/floci/services/rds/model/DbInstance.javaindex ded4e59a43..dd9b646b03 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/model/DbInstance.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/model/DbInstance.java@@ -23,6 +23,7 @@ public class DbInstance {private DbEndpoint endpoint;private boolean iamDatabaseAuthenticationEnabled;private String parameterGroupName;+ private String optionGroupName;private String dbSubnetGroupName;private String dbClusterIdentifier;private String vpcId;@@ -110,6 +111,9 @@ public class DbInstance {public String getParameterGroupName() { return parameterGroupName; }public void setParameterGroupName(String parameterGroupName) { this.parameterGroupName = parameterGroupName; }+ public String getOptionGroupName() { return optionGroupName; }+ public void setOptionGroupName(String optionGroupName) { this.optionGroupName = optionGroupName; }+public String getDbSubnetGroupName() { return dbSubnetGroupName; }public void setDbSubnetGroupName(String dbSubnetGroupName) { this.dbSubnetGroupName = dbSubnetGroupName; }diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/model/OptionGroup.java b/src/main/java/io/github/hectorvent/floci/services/rds/model/OptionGroup.javanew file mode 100644index 0000000000..23640aba51--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/rds/model/OptionGroup.java@@ -0,0 +1,70 @@+package io.github.hectorvent.floci.services.rds.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++/**+ * An RDS option group — the container engine-specific options are enabled through+ * (Oracle {@code S3_INTEGRATION}, SQL Server {@code SQLSERVER_BACKUP_RESTORE},+ * MariaDB {@code MARIADB_AUDIT_PLUGIN}, ...).+ */+@RegisterForReflection+public class OptionGroup {++ private String optionGroupName;+ private String optionGroupDescription;+ private String engineName;+ private String majorEngineVersion;+ private String optionGroupArn;+ private boolean allowsVpcAndNonVpcInstanceMemberships = true;+ private String region;+ private List<OptionGroupOption> options = new ArrayList<>();+ private Map<String, String> tags = new LinkedHashMap<>();++ public OptionGroup() {}++ public OptionGroup(String optionGroupName, String engineName,+ String majorEngineVersion, String optionGroupDescription) {+ this.optionGroupName = optionGroupName;+ this.engineName = engineName;+ this.majorEngineVersion = majorEngineVersion;+ this.optionGroupDescription = optionGroupDescription;+ }++ public String getOptionGroupName() { return optionGroupName; }+ public void setOptionGroupName(String optionGroupName) { this.optionGroupName = optionGroupName; }++ public String getOptionGroupDescription() { return optionGroupDescription; }+ public void setOptionGroupDescription(String optionGroupDescription) { this.optionGroupDescription = optionGroupDescription; }++ public String getEngineName() { return engineName; }+ public void setEngineName(String engineName) { this.engineName = engineName; }++ public String getMajorEngineVersion() { return majorEngineVersion; }+ public void setMajorEngineVersion(String majorEngineVersion) { this.majorEngineVersion = majorEngineVersion; }++ public String getOptionGroupArn() { return optionGroupArn; }+ public void setOptionGroupArn(String optionGroupArn) { this.optionGroupArn = optionGroupArn; }++ public boolean isAllowsVpcAndNonVpcInstanceMemberships() { return allowsVpcAndNonVpcInstanceMemberships; }+ public void setAllowsVpcAndNonVpcInstanceMemberships(boolean allowsVpcAndNonVpcInstanceMemberships) {+ this.allowsVpcAndNonVpcInstanceMemberships = allowsVpcAndNonVpcInstanceMemberships;+ }++ public String getRegion() { return region; }+ public void setRegion(String region) { this.region = region; }++ public List<OptionGroupOption> getOptions() { return options; }+ public void setOptions(List<OptionGroupOption> options) {+ this.options = options == null ? new ArrayList<>() : options;+ }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) {+ this.tags = tags == null ? new LinkedHashMap<>() : tags;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/model/OptionGroupOption.java b/src/main/java/io/github/hectorvent/floci/services/rds/model/OptionGroupOption.javanew file mode 100644index 0000000000..3262af590b--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/rds/model/OptionGroupOption.java@@ -0,0 +1,67 @@+package io.github.hectorvent.floci.services.rds.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++/**+ * A single option inside an {@link OptionGroup}, as added by {@code ModifyOptionGroup}+ * through {@code OptionsToInclude}.+ */+@RegisterForReflection+public class OptionGroupOption {++ private String optionName;+ private String optionDescription;+ private String optionVersion;+ private Integer port;+ private boolean persistent;+ private boolean permanent;+ private Map<String, String> optionSettings = new LinkedHashMap<>();+ private List<String> vpcSecurityGroupMemberships = new ArrayList<>();+ private List<String> dbSecurityGroupMemberships = new ArrayList<>();++ public OptionGroupOption() {}++ public OptionGroupOption(String optionName) {+ this.optionName = optionName;+ }++ public String getOptionName() { return optionName; }+ public void setOptionName(String optionName) { this.optionName = optionName; }++ public String getOptionDescription() { return optionDescription; }+ public void setOptionDescription(String optionDescription) { this.optionDescription = optionDescription; }++ public String getOptionVersion() { return optionVersion; }+ public void setOptionVersion(String optionVersion) { this.optionVersion = optionVersion; }++ public Integer getPort() { return port; }+ public void setPort(Integer port) { this.port = port; }++ public boolean isPersistent() { return persistent; }+ public void setPersistent(boolean persistent) { this.persistent = persistent; }++ public boolean isPermanent() { return permanent; }+ public void setPermanent(boolean permanent) { this.permanent = permanent; }++ public Map<String, String> getOptionSettings() { return optionSettings; }+ public void setOptionSettings(Map<String, String> optionSettings) {+ this.optionSettings = optionSettings == null ? new LinkedHashMap<>() : optionSettings;+ }++ public List<String> getVpcSecurityGroupMemberships() { return vpcSecurityGroupMemberships; }+ public void setVpcSecurityGroupMemberships(List<String> vpcSecurityGroupMemberships) {+ this.vpcSecurityGroupMemberships =+ vpcSecurityGroupMemberships == null ? new ArrayList<>() : vpcSecurityGroupMemberships;+ }++ public List<String> getDbSecurityGroupMemberships() { return dbSecurityGroupMemberships; }+ public void setDbSecurityGroupMemberships(List<String> dbSecurityGroupMemberships) {+ this.dbSecurityGroupMemberships =+ dbSecurityGroupMemberships == null ? new ArrayList<>() : dbSecurityGroupMemberships;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsQueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsQueryHandlerTest.javaindex cc8d8b7f1c..b9d73e8c55 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/RdsQueryHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsQueryHandlerTest.java@@ -12,11 +12,14 @@ import io.github.hectorvent.floci.services.rds.model.DbProxyAuth;import io.github.hectorvent.floci.services.rds.model.DbProxyTarget;import io.github.hectorvent.floci.services.rds.model.DbProxyTargetGroup;import io.github.hectorvent.floci.services.rds.model.DbSubnetGroup;+import io.github.hectorvent.floci.services.rds.model.OptionGroup;+import io.github.hectorvent.floci.services.rds.model.OptionGroupOption;import jakarta.ws.rs.core.MultivaluedHashMap;import jakarta.ws.rs.core.MultivaluedMap;import jakarta.ws.rs.core.Response;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;+import org.mockito.ArgumentCaptor;import java.util.List;import java.util.Map;@@ -207,7 +210,7 @@ class RdsQueryHandlerTest {when(service.listDbInstances(null, "us-west-2")).thenReturn(List.of());when(service.getDbInstance("mydb", "us-west-2")).thenReturn(instance);when(service.modifyDbInstance(- eq("mydb"), isNull(), isNull(), isNull(), anyList(), eq("us-west-2")))+ eq("mydb"), isNull(), isNull(), isNull(), anyList(), isNull(), eq("us-west-2"))).thenReturn(instance);when(service.rebootDbInstance("mydb", "us-west-2")).thenReturn(instance);when(service.listDbClusters(null, "us-west-2")).thenReturn(List.of());@@ -232,7 +235,7 @@ class RdsQueryHandlerTest {verify(service).getDbInstance("mydb", "us-west-2");verify(service).deleteDbInstance("mydb", "us-west-2");verify(service).modifyDbInstance(- eq("mydb"), isNull(), isNull(), isNull(), anyList(), eq("us-west-2"));+ eq("mydb"), isNull(), isNull(), isNull(), anyList(), isNull(), eq("us-west-2"));verify(service).rebootDbInstance("mydb", "us-west-2");verify(service).listDbClusters(null, "us-west-2");verify(service).getDbCluster("mycluster", "us-west-2");@@ -345,7 +348,7 @@ class RdsQueryHandlerTest {when(service.createDbInstance(eq("mydb"), eq("postgres"), eq("16.3"),eq(null), eq(null), eq(null), eq("db.t3.micro"),eq(20), eq(false), eq(null), eq(null), eq(null), eq(null), eq(false), eq(false), eq(null),- eq(java.util.Map.of("example:ClusterId", "cluster-a", "Name", "mydb")), eq(List.of()), isNull()))+ eq(java.util.Map.of("example:ClusterId", "cluster-a", "Name", "mydb")), eq(List.of()), isNull(), isNull())).thenReturn(instance);MultivaluedMap<String, String> p = params();@@ -359,7 +362,7 @@ class RdsQueryHandlerTest {verify(service).createDbInstance("mydb", "postgres", "16.3",null, null, null, "db.t3.micro", 20, false, null, null, null, null, false, false, null,- java.util.Map.of("example:ClusterId", "cluster-a", "Name", "mydb"), List.of(), null);+ java.util.Map.of("example:ClusterId", "cluster-a", "Name", "mydb"), List.of(), null, null);}@Test@@ -369,7 +372,7 @@ class RdsQueryHandlerTest {when(service.createDbInstance(eq("mydb"), eq("postgres"), eq("16.3"),eq(null), eq(null), eq(null), eq("db.t3.micro"),eq(20), eq(false), eq(null), eq(null), eq(null), eq(null), eq(false), eq(false), eq(null),- eq(java.util.Map.of()), eq(List.of("sg-123", "sg-456")), isNull()))+ eq(java.util.Map.of()), eq(List.of("sg-123", "sg-456")), isNull(), isNull())).thenReturn(instance);MultivaluedMap<String, String> p = params();@@ -384,7 +387,7 @@ class RdsQueryHandlerTest {assertTrue(body.contains("<VpcSecurityGroupId>sg-456</VpcSecurityGroupId>"));verify(service).createDbInstance("mydb", "postgres", "16.3",null, null, null, "db.t3.micro", 20, false, null, null, null, null, false, false, null,- java.util.Map.of(), List.of("sg-123", "sg-456"), null);+ java.util.Map.of(), List.of("sg-123", "sg-456"), null, null);}@Test@@ -400,7 +403,7 @@ class RdsQueryHandlerTest {assertTrue(((String) response.getEntity()).contains("InvalidParameterValue"));verify(service, never()).createDbInstance(any(), any(), any(), any(), any(), any(), any(),anyInt(), anyBoolean(), any(), any(), any(), any(), anyBoolean(), anyBoolean(),- any(), any(), any(), any());+ any(), any(), any(), any(), any());}@Test@@ -414,7 +417,7 @@ class RdsQueryHandlerTest {assertEquals(400, response.getStatus());assertTrue(((String) response.getEntity()).contains("InvalidParameterValue"));verify(service, never()).modifyDbInstance(- any(), any(), any(), any(), any(), any());+ any(), any(), any(), any(), any(), any(), any());}@Test@@ -500,7 +503,7 @@ class RdsQueryHandlerTest {when(service.createDbInstance(eq("mydb"), eq("postgres"), eq("16.3"),eq("admin"), eq("secret"), eq("dbname"), eq("db.t3.micro"),eq(20), eq(false), eq(null), eq(null), eq(null), eq(null), eq(false), eq(false),- eq(null), eq(java.util.Map.of()), eq(List.of()), isNull()))+ eq(null), eq(java.util.Map.of()), eq(List.of()), isNull(), isNull())).thenReturn(instance);MultivaluedMap<String, String> p = params();@@ -514,7 +517,7 @@ class RdsQueryHandlerTest {verify(service).createDbInstance("mydb", "postgres", "16.3","admin", "secret", "dbname", "db.t3.micro", 20, false, null, null, null, null, false, false,- null, java.util.Map.of(), List.of(), null);+ null, java.util.Map.of(), List.of(), null, null);}@Test@@ -526,7 +529,7 @@ class RdsQueryHandlerTest {when(service.createDbInstance(eq("mydb"), eq("postgres"), eq("16.3"),eq("admin"), eq(null), eq("dbname"), eq("db.t3.micro"),eq(20), eq(false), eq(null), eq(null), eq(null), eq(null), eq(false), eq(true),- eq("kms-key-1"), eq(java.util.Map.of()), eq(List.of()), isNull()))+ eq("kms-key-1"), eq(java.util.Map.of()), eq(List.of()), isNull(), isNull())).thenReturn(instance);MultivaluedMap<String, String> p = params();@@ -545,7 +548,7 @@ class RdsQueryHandlerTest {assertTrue(body.contains("<KmsKeyId>kms-key-1</KmsKeyId>"));verify(service).createDbInstance("mydb", "postgres", "16.3","admin", null, "dbname", "db.t3.micro", 20, false, null, null, null, null, false, true,- "kms-key-1", java.util.Map.of(), List.of(), null);+ "kms-key-1", java.util.Map.of(), List.of(), null, null);}@Test@@ -558,7 +561,7 @@ class RdsQueryHandlerTest {when(service.createDbInstance(eq("mydb"), eq("postgres"), eq("16.3"),eq("admin"), eq("secret"), eq("dbname"), eq("db.t3.micro"),eq(20), eq(false), eq(null), eq("default"), eq(null), eq("ap-northeast-1a"), eq(true),- eq(false), eq(null), eq(java.util.Map.of()), eq(List.of()), isNull()))+ eq(false), eq(null), eq(java.util.Map.of()), eq(List.of()), isNull(), isNull())).thenReturn(instance);MultivaluedMap<String, String> p = params();@@ -586,7 +589,7 @@ class RdsQueryHandlerTest {when(service.createDbInstance(eq("mydb"), eq("postgres"), eq("16.3"),eq("admin"), eq("secret"), eq("dbname"), eq("db.t3.micro"),eq(20), eq(false), eq(null), eq("missing-subnet-group"), eq(null), eq(null), eq(false),- eq(false), eq(null), eq(java.util.Map.of()), eq(List.of()), isNull()))+ eq(false), eq(null), eq(java.util.Map.of()), eq(List.of()), isNull(), isNull())).thenThrow(new AwsException("DBSubnetGroupNotFoundFault","DB subnet group missing-subnet-group not found.", 404));@@ -678,7 +681,7 @@ class RdsQueryHandlerTest {when(service.createDbInstance(eq("mydb"), eq("oracle"), eq("1.0"),eq(null), eq(null), eq(null), eq("db.t3.micro"),eq(20), eq(false), eq(null), eq(null), eq(null), eq(null), eq(false), eq(false),- eq(null), eq(java.util.Map.of()), eq(List.of()), isNull()))+ eq(null), eq(java.util.Map.of()), eq(List.of()), isNull(), isNull())).thenThrow(new AwsException("InvalidParameterValue","Unsupported engine: oracle. Supported: postgres, mysql, mariadb.", 400));@@ -1504,8 +1507,330 @@ class RdsQueryHandlerTest {assertFalse(body.contains("DBClusterNotFoundFault"));}+ // ──────────────────────────── Option groups ────────────────────────────++ @Test+ void createOptionGroup_returnsOptionGroupShape() {+ when(service.createOptionGroup("og1", "mysql", "8.0", "my og", Map.of(), null))+ .thenReturn(makeOptionGroup("og1"));++ MultivaluedMap<String, String> p = params();+ p.add("OptionGroupName", "og1");+ p.add("EngineName", "mysql");+ p.add("MajorEngineVersion", "8.0");+ p.add("OptionGroupDescription", "my og");+ Response response = handler.handle("CreateOptionGroup", p);++ assertEquals(200, response.getStatus());+ String body = (String) response.getEntity();+ assertTrue(body.contains("<CreateOptionGroupResult>"), body);+ assertTrue(body.contains("<OptionGroup>"), body);+ assertTrue(body.contains("<OptionGroupName>og1</OptionGroupName>"), body);+ assertTrue(body.contains("<EngineName>mysql</EngineName>"), body);+ assertTrue(body.contains("<MajorEngineVersion>8.0</MajorEngineVersion>"), body);+ assertTrue(body.contains("<OptionGroupDescription>my og</OptionGroupDescription>"), body);+ assertTrue(body.contains(+ "<OptionGroupArn>arn:aws:rds:us-east-1:123456789012:og:og1</OptionGroupArn>"), body);+ assertTrue(body.contains(+ "<AllowsVpcAndNonVpcInstanceMemberships>true</AllowsVpcAndNonVpcInstanceMemberships>"), body);+ assertTrue(body.contains("<Options></Options>"), body);+ }++ @Test+ void createOptionGroup_passesTags() {+ when(service.createOptionGroup(eq("og1"), eq("mysql"), eq("8.0"), eq("my og"),+ eq(Map.of("env", "dev")), isNull()))+ .thenReturn(makeOptionGroup("og1"));++ MultivaluedMap<String, String> p = params();+ p.add("OptionGroupName", "og1");+ p.add("EngineName", "mysql");+ p.add("MajorEngineVersion", "8.0");+ p.add("OptionGroupDescription", "my og");+ p.add("Tags.Tag.1.Key", "env");+ p.add("Tags.Tag.1.Value", "dev");+ Response response = handler.handle("CreateOptionGroup", p);++ assertEquals(200, response.getStatus());+ verify(service).createOptionGroup("og1", "mysql", "8.0", "my og", Map.of("env", "dev"), null);+ }++ @Test+ void createOptionGroup_requiresMandatoryParameters() {+ assertEquals(400, handler.handle("CreateOptionGroup", params()).getStatus());++ MultivaluedMap<String, String> noEngine = params();+ noEngine.add("OptionGroupName", "og1");+ assertEquals(400, handler.handle("CreateOptionGroup", noEngine).getStatus());++ MultivaluedMap<String, String> noVersion = params();+ noVersion.add("OptionGroupName", "og1");+ noVersion.add("EngineName", "mysql");+ assertEquals(400, handler.handle("CreateOptionGroup", noVersion).getStatus());++ MultivaluedMap<String, String> noDescription = params();+ noDescription.add("OptionGroupName", "og1");+ noDescription.add("EngineName", "mysql");+ noDescription.add("MajorEngineVersion", "8.0");+ assertEquals(400, handler.handle("CreateOptionGroup", noDescription).getStatus());++ verify(service, never()).createOptionGroup(any(), any(), any(), any(), any(), any());+ }++ @Test+ void describeOptionGroups_usesOptionGroupsListWrapper() {+ when(service.listOptionGroups(null, null, null, null))+ .thenReturn(List.of(makeOptionGroup("og1")));++ Response response = handler.handle("DescribeOptionGroups", params());++ assertEquals(200, response.getStatus());+ String body = (String) response.getEntity();+ assertTrue(body.contains("<OptionGroupsList>"), body);+ assertTrue(body.contains("<OptionGroupsList><OptionGroup>"), body);+ assertTrue(body.contains("</OptionGroup></OptionGroupsList>"), body);+ assertTrue(body.contains("<Marker></Marker>"), body);+ assertFalse(body.contains("<member>"), body);+ }++ @Test+ void describeOptionGroups_passesFilters() {+ when(service.listOptionGroups("og1", "mysql", "8.0", null)).thenReturn(List.of());++ MultivaluedMap<String, String> p = params();+ p.add("OptionGroupName", "og1");+ p.add("EngineName", "mysql");+ p.add("MajorEngineVersion", "8.0");+ handler.handle("DescribeOptionGroups", p);++ verify(service).listOptionGroups("og1", "mysql", "8.0", null);+ }++ @Test+ void describeOptionGroups_propagatesNotFoundFault() {+ when(service.listOptionGroups("missing", null, null, null))+ .thenThrow(new AwsException("OptionGroupNotFoundFault",+ "Option group missing not found.", 404));++ MultivaluedMap<String, String> p = params();+ p.add("OptionGroupName", "missing");+ Response response = handler.handle("DescribeOptionGroups", p);++ assertEquals(404, response.getStatus());+ assertTrue(((String) response.getEntity()).contains("OptionGroupNotFoundFault"));+ }++ @Test+ void describeOptionGroups_rendersOptionsWithSettingsAndSecurityGroups() {+ OptionGroup group = makeOptionGroup("og1");+ OptionGroupOption option = new OptionGroupOption("MEMCACHED");+ option.setOptionDescription("Innodb Memcached for MySQL");+ option.setPort(11211);+ option.setOptionSettings(new java.util.LinkedHashMap<>(+ Map.of("BACKLOG_QUEUE_LIMIT", "1024")));+ option.setVpcSecurityGroupMemberships(List.of("sg-123"));+ option.setDbSecurityGroupMemberships(List.of("default"));+ group.setOptions(new java.util.ArrayList<>(List.of(option)));+ when(service.listOptionGroups(null, null, null, null)).thenReturn(List.of(group));++ Response response = handler.handle("DescribeOptionGroups", params());++ String body = (String) response.getEntity();+ assertTrue(body.contains("<Options><Option>"), body);+ assertTrue(body.contains("<OptionName>MEMCACHED</OptionName>"), body);+ assertTrue(body.contains(+ "<OptionDescription>Innodb Memcached for MySQL</OptionDescription>"), body);+ assertTrue(body.contains("<Port>11211</Port>"), body);+ assertTrue(body.contains("<Persistent>false</Persistent>"), body);+ assertTrue(body.contains("<Permanent>false</Permanent>"), body);+ assertTrue(body.contains("<OptionSettings><OptionSetting>"+ + "<Name>BACKLOG_QUEUE_LIMIT</Name><Value>1024</Value>"), body);+ assertTrue(body.contains("<VpcSecurityGroupMemberships><VpcSecurityGroupMembership>"+ + "<VpcSecurityGroupId>sg-123</VpcSecurityGroupId>"+ + "<Status>active</Status>"), body);+ assertTrue(body.contains("<DBSecurityGroupMemberships><DBSecurityGroup>"+ + "<DBSecurityGroupName>default</DBSecurityGroupName>"+ + "<Status>authorized</Status>"), body);+ }++ @Test+ void modifyOptionGroup_parsesOptionConfigurations() {+ when(service.modifyOptionGroup(eq("og1"), anyList(), anyList(), isNull()))+ .thenReturn(makeOptionGroup("og1"));++ MultivaluedMap<String, String> p = params();+ p.add("OptionGroupName", "og1");+ p.add("ApplyImmediately", "true");+ p.add("OptionsToInclude.OptionConfiguration.1.OptionName", "MEMCACHED");+ p.add("OptionsToInclude.OptionConfiguration.1.Port", "11211");+ p.add("OptionsToInclude.OptionConfiguration.1.OptionVersion", "1.0");+ p.add("OptionsToInclude.OptionConfiguration.1.OptionSettings.OptionSetting.1.Name",+ "BACKLOG_QUEUE_LIMIT");+ p.add("OptionsToInclude.OptionConfiguration.1.OptionSettings.OptionSetting.1.Value", "1024");+ p.add("OptionsToInclude.OptionConfiguration.1.VpcSecurityGroupMemberships"+ + ".VpcSecurityGroupId.1", "sg-123");+ p.add("OptionsToInclude.OptionConfiguration.1.DBSecurityGroupMemberships"+ + ".DBSecurityGroupName.1", "default");+ Response response = handler.handle("ModifyOptionGroup", p);++ assertEquals(200, response.getStatus());+ assertTrue(((String) response.getEntity()).contains("<ModifyOptionGroupResult>"));++ @SuppressWarnings("unchecked")+ ArgumentCaptor<List<OptionGroupOption>> include = ArgumentCaptor.forClass(List.class);+ verify(service).modifyOptionGroup(eq("og1"), include.capture(), anyList(), isNull());+ assertEquals(1, include.getValue().size());+ OptionGroupOption parsed = include.getValue().getFirst();+ assertEquals("MEMCACHED", parsed.getOptionName());+ assertEquals(11211, parsed.getPort());+ assertEquals("1.0", parsed.getOptionVersion());+ assertEquals(Map.of("BACKLOG_QUEUE_LIMIT", "1024"), parsed.getOptionSettings());+ assertEquals(List.of("sg-123"), parsed.getVpcSecurityGroupMemberships());+ assertEquals(List.of("default"), parsed.getDbSecurityGroupMemberships());+ }++ @Test+ void modifyOptionGroup_acceptsLegacyMemberEncodingForOptionsToInclude() {+ when(service.modifyOptionGroup(eq("og1"), anyList(), anyList(), isNull()))+ .thenReturn(makeOptionGroup("og1"));++ MultivaluedMap<String, String> p = params();+ p.add("OptionGroupName", "og1");+ p.add("OptionsToInclude.member.1.OptionName", "MEMCACHED");+ handler.handle("ModifyOptionGroup", p);++ @SuppressWarnings("unchecked")+ ArgumentCaptor<List<OptionGroupOption>> include = ArgumentCaptor.forClass(List.class);+ verify(service).modifyOptionGroup(eq("og1"), include.capture(), anyList(), isNull());+ assertEquals(1, include.getValue().size());+ assertEquals("MEMCACHED", include.getValue().getFirst().getOptionName());+ }++ @Test+ void modifyOptionGroup_parsesOptionsToRemove() {+ when(service.modifyOptionGroup(eq("og1"), anyList(), anyList(), isNull()))+ .thenReturn(makeOptionGroup("og1"));++ MultivaluedMap<String, String> p = params();+ p.add("OptionGroupName", "og1");+ p.add("OptionsToRemove.member.1", "MEMCACHED");+ p.add("OptionsToRemove.member.2", "MARIADB_AUDIT_PLUGIN");+ handler.handle("ModifyOptionGroup", p);++ verify(service).modifyOptionGroup(eq("og1"), anyList(),+ eq(List.of("MEMCACHED", "MARIADB_AUDIT_PLUGIN")), isNull());+ }++ @Test+ void modifyOptionGroup_rejectsNonNumericPort() {+ MultivaluedMap<String, String> p = params();+ p.add("OptionGroupName", "og1");+ p.add("OptionsToInclude.OptionConfiguration.1.OptionName", "MEMCACHED");+ p.add("OptionsToInclude.OptionConfiguration.1.Port", "not-a-number");+ Response response = handler.handle("ModifyOptionGroup", p);++ assertEquals(400, response.getStatus());+ assertTrue(((String) response.getEntity()).contains("InvalidParameterValue"));+ verify(service, never()).modifyOptionGroup(any(), anyList(), anyList(), any());+ }++ @Test+ void modifyOptionGroup_requiresOptionGroupName() {+ Response response = handler.handle("ModifyOptionGroup", params());++ assertEquals(400, response.getStatus());+ verify(service, never()).modifyOptionGroup(any(), anyList(), anyList(), any());+ }++ @Test+ void deleteOptionGroup_returnsResultlessEnvelope() {+ MultivaluedMap<String, String> p = params();+ p.add("OptionGroupName", "og1");+ Response response = handler.handle("DeleteOptionGroup", p);++ assertEquals(200, response.getStatus());+ String body = (String) response.getEntity();+ assertTrue(body.contains("<DeleteOptionGroupResponse"), body);+ assertFalse(body.contains("<DeleteOptionGroupResult>"), body);+ verify(service).deleteOptionGroup("og1", null);+ }++ @Test+ void deleteOptionGroup_requiresOptionGroupName() {+ Response response = handler.handle("DeleteOptionGroup", params());++ assertEquals(400, response.getStatus());+ verify(service, never()).deleteOptionGroup(any(), any());+ }++ @Test+ void deleteOptionGroup_propagatesInvalidStateFault() {+ doThrow(new AwsException("InvalidOptionGroupStateFault",+ "The option group og1 is in use.", 400))+ .when(service).deleteOptionGroup("og1", null);++ MultivaluedMap<String, String> p = params();+ p.add("OptionGroupName", "og1");+ Response response = handler.handle("DeleteOptionGroup", p);++ assertEquals(400, response.getStatus());+ assertTrue(((String) response.getEntity()).contains("InvalidOptionGroupStateFault"));+ }++ @Test+ void describeDbInstances_includesAttachedOptionGroupMembership() {+ DbInstance instance = makeInstance("mydb");+ instance.setOptionGroupName("og1");+ when(service.listDbInstances(null, null)).thenReturn(List.of(instance));++ Response response = handler.handle("DescribeDBInstances", params());++ String body = (String) response.getEntity();+ assertTrue(body.contains("<OptionGroupMemberships><OptionGroupMembership>"+ + "<OptionGroupName>og1</OptionGroupName><Status>in-sync</Status>"), body);+ }++ @Test+ void describeDbInstances_reportsDefaultOptionGroupWhenUnattached() {+ DbInstance instance = makeInstance("mydb");+ instance.setEngineVersion("16.3");+ when(service.listDbInstances(null, null)).thenReturn(List.of(instance));++ Response response = handler.handle("DescribeDBInstances", params());++ String body = (String) response.getEntity();+ assertTrue(body.contains(+ "<OptionGroupName>default:postgres-16</OptionGroupName>"), body);+ }++ @Test+ void createDbInstance_passesOptionGroupName() {+ DbInstance instance = makeInstance("mydb");+ when(service.createDbInstance(any(), any(), any(), any(), any(), any(), any(),+ anyInt(), anyBoolean(), any(), any(), any(), any(), anyBoolean(), anyBoolean(),+ any(), any(), anyList(), any(), any()))+ .thenReturn(instance);++ MultivaluedMap<String, String> p = params();+ p.add("DBInstanceIdentifier", "mydb");+ p.add("Engine", "mysql");+ p.add("OptionGroupName", "og1");+ Response response = handler.handle("CreateDBInstance", p);++ assertEquals(200, response.getStatus());+ verify(service).createDbInstance(eq("mydb"), eq("mysql"), any(), any(), any(), any(),+ any(), anyInt(), anyBoolean(), any(), any(), any(), any(), anyBoolean(),+ anyBoolean(), any(), any(), anyList(), eq("og1"), any());+ }+// ──────────────────────────── Helpers ────────────────────────────+ private static OptionGroup makeOptionGroup(String name) {+ OptionGroup group = new OptionGroup(name, "mysql", "8.0", "my og");+ group.setOptionGroupArn("arn:aws:rds:us-east-1:123456789012:og:" + name);+ return group;+ }+private static MultivaluedMap<String, String> params() {return new MultivaluedHashMap<>();}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.javaindex ccb5741fe5..e6eaebfd29 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java@@ -24,6 +24,8 @@ import io.github.hectorvent.floci.services.rds.model.DbProxyAuth;import io.github.hectorvent.floci.services.rds.model.DbProxyTarget;import io.github.hectorvent.floci.services.rds.model.DbProxyTargetGroup;import io.github.hectorvent.floci.services.rds.model.DbSubnetGroup;+import io.github.hectorvent.floci.services.rds.model.OptionGroup;+import io.github.hectorvent.floci.services.rds.model.OptionGroupOption;import io.github.hectorvent.floci.services.rds.proxy.RdsAuthProxy;import io.github.hectorvent.floci.services.rds.proxy.RdsProxyManager;import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;@@ -559,7 +561,7 @@ class RdsServiceTest {@Testvoid tagOperationsRejectUnsupportedResourceArn() {AwsException exception = assertThrows(AwsException.class, () ->- rdsService.listTagsForResource("arn:aws:rds:us-east-1:123456789012:og:some-option-group"));+ rdsService.listTagsForResource("arn:aws:rds:us-east-1:123456789012:pg:some-parameter-group"));assertEquals("InvalidParameterValue", exception.getErrorCode());// The type is valid on real AWS; the message must present this as a Floci limitation.@@ -3726,6 +3728,479 @@ class RdsServiceTest {assertTrue(rawTargetGroups.get(targetAccount + "/app-proxy").isEmpty());}+ // ── Option Groups ─────────────────────────────────────────────────────────++ @Test+ void createOptionGroupReturnsArnAndNoOptions() {+ OptionGroup group = rdsService.createOptionGroup(+ "og1", "mysql", "8.0", "my option group");++ assertEquals("og1", group.getOptionGroupName());+ assertEquals("mysql", group.getEngineName());+ assertEquals("8.0", group.getMajorEngineVersion());+ assertEquals("my option group", group.getOptionGroupDescription());+ assertEquals("arn:aws:rds:us-east-1:123456789012:og:og1", group.getOptionGroupArn());+ assertTrue(group.isAllowsVpcAndNonVpcInstanceMemberships());+ assertTrue(group.getOptions().isEmpty());+ }++ @Test+ void createOptionGroupRejectsDuplicateName() {+ rdsService.createOptionGroup("og1", "mysql", "8.0", "first");++ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.createOptionGroup("og1", "mysql", "8.0", "second"));++ assertEquals("OptionGroupAlreadyExistsFault", exception.getErrorCode());+ assertEquals(400, exception.getHttpStatus());+ }++ @Test+ void createOptionGroupCannotShadowAManagedDefaultName() {+ // A default group's name contains ':', which the AWS name constraint forbids, so the+ // name check rejects it before the already-exists check can ever be reached.+ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.createOptionGroup(+ "default:mysql-8-0", "mysql", "8.0", "shadowing a default"));++ assertEquals("InvalidParameterValue", exception.getErrorCode());+ assertEquals("mysql", rdsService.getOptionGroup("default:mysql-8-0").getEngineName());+ }++ @Test+ void createOptionGroupRejectsUnknownEngine() {+ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.createOptionGroup("og1", "cassandra", "5.0", "nope"));++ assertEquals("InvalidParameterValue", exception.getErrorCode());+ assertEquals(400, exception.getHttpStatus());+ }++ @ParameterizedTest+ @CsvSource({+ "1og", // must start with a letter+ "-og", // must start with a letter+ "og-", // can't end with a hyphen+ "og--1", // can't contain two consecutive hyphens+ "og_1", // only letters, numbers and hyphens+ "og name" // only letters, numbers and hyphens+ })+ void createOptionGroupRejectsNamesThatViolateAwsConstraints(String name) {+ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.createOptionGroup(name, "mysql", "8.0", "bad name"));++ assertEquals("InvalidParameterValue", exception.getErrorCode());+ assertEquals(400, exception.getHttpStatus());+ }++ @Test+ void createOptionGroupRejectsNameLongerThan255Characters() {+ String name = "o" + "g".repeat(255);++ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.createOptionGroup(name, "mysql", "8.0", "too long"));++ assertEquals("InvalidParameterValue", exception.getErrorCode());+ }++ @Test+ void createOptionGroupAcceptsHyphenatedAlphanumericName() {+ OptionGroup group = rdsService.createOptionGroup(+ "my-og-1", "mysql", "8.0", "valid name");++ assertEquals("my-og-1", group.getOptionGroupName());+ }++ @Test+ void getOptionGroupThrowsOptionGroupNotFoundFaultForUnknownName() {+ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.getOptionGroup("missing"));++ assertEquals("OptionGroupNotFoundFault", exception.getErrorCode());+ assertEquals(404, exception.getHttpStatus());+ }++ @Test+ void listOptionGroupsAlwaysIncludesManagedDefaults() {+ List<String> names = rdsService.listOptionGroups(null, null, null).stream()+ .map(OptionGroup::getOptionGroupName)+ .toList();++ assertTrue(names.contains("default:mysql-8-0"), names.toString());+ assertTrue(names.contains("default:postgres-16"), names.toString());+ assertTrue(names.contains("default:mariadb-11-4"), names.toString());+ }++ @Test+ void listOptionGroupsIncludesCreatedGroupsAlongsideDefaults() {+ rdsService.createOptionGroup("og1", "mysql", "8.0", "mine");++ List<String> names = rdsService.listOptionGroups(null, null, null).stream()+ .map(OptionGroup::getOptionGroupName)+ .toList();++ assertTrue(names.contains("og1"), names.toString());+ assertTrue(names.contains("default:mysql-8-0"), names.toString());+ }++ @Test+ void listOptionGroupsFiltersByEngineName() {+ rdsService.createOptionGroup("og-oracle", "oracle-ee", "19", "oracle");++ Collection<OptionGroup> groups = rdsService.listOptionGroups(null, "oracle-ee", null);++ assertFalse(groups.isEmpty());+ assertTrue(groups.stream().allMatch(group -> "oracle-ee".equals(group.getEngineName())));+ assertTrue(groups.stream()+ .anyMatch(group -> "og-oracle".equals(group.getOptionGroupName())));+ }++ @Test+ void listOptionGroupsFiltersByMajorEngineVersion() {+ Collection<OptionGroup> groups = rdsService.listOptionGroups(null, "mysql", "8.4");++ assertEquals(1, groups.size());+ assertEquals("default:mysql-8-4", groups.iterator().next().getOptionGroupName());+ }++ @Test+ void listOptionGroupsRejectsMajorEngineVersionWithoutEngineName() {+ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.listOptionGroups(null, null, "8.0"));++ assertEquals("InvalidParameterCombination", exception.getErrorCode());+ }++ @Test+ void listOptionGroupsByUnknownNameThrowsInsteadOfReturningEmptyList() {+ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.listOptionGroups("missing", null, null));++ assertEquals("OptionGroupNotFoundFault", exception.getErrorCode());+ assertEquals(404, exception.getHttpStatus());+ }++ @Test+ void listOptionGroupsByNameResolvesManagedDefault() {+ Collection<OptionGroup> groups =+ rdsService.listOptionGroups("default:postgres-16", null, null);++ assertEquals(1, groups.size());+ OptionGroup group = groups.iterator().next();+ assertEquals("postgres", group.getEngineName());+ assertEquals("16", group.getMajorEngineVersion());+ }++ @Test+ void modifyOptionGroupAddsOptions() {+ rdsService.createOptionGroup("og1", "mariadb", "11.4", "mine");+ OptionGroupOption option = new OptionGroupOption("MARIADB_AUDIT_PLUGIN");+ option.setPort(11211);+ option.setOptionSettings(new java.util.LinkedHashMap<>(+ Map.of("SERVER_AUDIT_EVENTS", "CONNECT")));+ option.setVpcSecurityGroupMemberships(List.of("sg-123"));++ OptionGroup group = rdsService.modifyOptionGroup("og1", List.of(option), List.of());++ assertEquals(1, group.getOptions().size());+ OptionGroupOption stored = group.getOptions().getFirst();+ assertEquals("MARIADB_AUDIT_PLUGIN", stored.getOptionName());+ assertEquals(11211, stored.getPort());+ assertEquals("CONNECT", stored.getOptionSettings().get("SERVER_AUDIT_EVENTS"));+ assertEquals(List.of("sg-123"), stored.getVpcSecurityGroupMemberships());+ assertEquals(1, rdsService.getOptionGroup("og1").getOptions().size());+ }++ @Test+ void modifyOptionGroupUpdatesAnExistingOptionInPlace() {+ rdsService.createOptionGroup("og1", "mariadb", "11.4", "mine");+ OptionGroupOption first = new OptionGroupOption("MARIADB_AUDIT_PLUGIN");+ first.setOptionSettings(new java.util.LinkedHashMap<>(+ Map.of("SERVER_AUDIT_EVENTS", "CONNECT")));+ rdsService.modifyOptionGroup("og1", List.of(first), List.of());++ OptionGroupOption update = new OptionGroupOption("MARIADB_AUDIT_PLUGIN");+ update.setOptionSettings(new java.util.LinkedHashMap<>(+ Map.of("SERVER_AUDIT_EVENTS", "CONNECT,QUERY")));+ OptionGroup group = rdsService.modifyOptionGroup("og1", List.of(update), List.of());++ assertEquals(1, group.getOptions().size());+ assertEquals("CONNECT,QUERY",+ group.getOptions().getFirst().getOptionSettings().get("SERVER_AUDIT_EVENTS"));+ }++ @Test+ void modifyOptionGroupRemovesOptions() {+ rdsService.createOptionGroup("og1", "mysql", "8.0", "mine");+ rdsService.modifyOptionGroup(+ "og1", List.of(new OptionGroupOption("MEMCACHED")), List.of());++ OptionGroup group = rdsService.modifyOptionGroup("og1", List.of(), List.of("MEMCACHED"));++ assertTrue(group.getOptions().isEmpty());+ assertTrue(rdsService.getOptionGroup("og1").getOptions().isEmpty());+ }++ @Test+ void modifyOptionGroupThrowsForUnknownGroup() {+ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.modifyOptionGroup("missing", List.of(), List.of()));++ assertEquals("OptionGroupNotFoundFault", exception.getErrorCode());+ assertEquals(404, exception.getHttpStatus());+ }++ @Test+ void modifyOptionGroupRejectsManagedDefault() {+ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.modifyOptionGroup("default:mysql-8-0",+ List.of(new OptionGroupOption("MEMCACHED")), List.of()));++ assertEquals("InvalidOptionGroupStateFault", exception.getErrorCode());+ assertEquals(400, exception.getHttpStatus());+ }++ @Test+ void deleteOptionGroupRemovesTheGroup() {+ rdsService.createOptionGroup("og1", "mysql", "8.0", "mine");++ rdsService.deleteOptionGroup("og1");++ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.getOptionGroup("og1"));+ assertEquals("OptionGroupNotFoundFault", exception.getErrorCode());+ }++ @Test+ void deleteOptionGroupThrowsForUnknownGroup() {+ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.deleteOptionGroup("missing"));++ assertEquals("OptionGroupNotFoundFault", exception.getErrorCode());+ assertEquals(404, exception.getHttpStatus());+ }++ @Test+ void deleteOptionGroupRejectsManagedDefault() {+ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.deleteOptionGroup("default:mysql-8-0"));++ assertEquals("InvalidOptionGroupStateFault", exception.getErrorCode());+ assertEquals(400, exception.getHttpStatus());+ }++ @Test+ void deleteOptionGroupRejectsGroupStillAttachedToAnInstance() {+ rdsService.createOptionGroup("og1", "mysql", "8.0", "mine");+ createInstanceWithOptionGroup("mydb", "mysql", "8.0", "og1");++ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.deleteOptionGroup("og1"));++ assertEquals("InvalidOptionGroupStateFault", exception.getErrorCode());+ assertEquals(400, exception.getHttpStatus());+ }++ @Test+ void optionGroupsAreScopedByRegion() {+ rdsService.createOptionGroup("og1", "mysql", "8.0", "mine", Map.of(), "us-east-1");++ AwsException exception = assertThrows(AwsException.class,+ () -> rdsService.getOptionGroup("og1", "eu-west-1"));++ assertEquals("OptionGroupNotFoundFault", exception.getErrorCode());+ assertEquals("arn:aws:rds:us-east-1:123456789012:og:og1",+ rdsService.getOptionGroup("og1", "us-east-1").getOptionGroupArn());+ }++ @Test+ void createDbInstanceStoresAttachedOptionGroup() {+ rdsService.createOptionGroup("og1", "mysql", "8.0", "mine");++ DbInstance instance = createInstanceWithOptionGroup("mydb", "mysql", "8.0", "og1");++ assertEquals("og1", instance.getOptionGroupName());+ assertEquals("og1", rdsService.getDbInstance("mydb").getOptionGroupName());+ }++ @Test+ void createDbInstanceRejectsUnknownOptionGroup() {+ AwsException exception = assertThrows(AwsException.class,+ () -> createInstanceWithOptionGroup("mydb", "mysql", "8.0", "missing"));++ assertEquals("OptionGroupNotFoundFault", exception.getErrorCode());+ }++ @Test+ void createDbInstanceRejectsOptionGroupForAnotherEngine() {+ rdsService.createOptionGroup("og1", "mysql", "8.0", "mine");++ AwsException exception = assertThrows(AwsException.class,+ () -> createInstanceWithOptionGroup("mydb", "postgres", "16.3", "og1"));++ assertEquals("InvalidParameterCombination", exception.getErrorCode());+ }++ @Test+ void createDbInstanceRejectsOptionGroupForAnotherMajorEngineVersion() {+ rdsService.createOptionGroup("og1", "mysql", "8.0", "mine");++ AwsException exception = assertThrows(AwsException.class,+ () -> createInstanceWithOptionGroup("mydb", "mysql", "8.4.3", "og1"));++ assertEquals("InvalidParameterCombination", exception.getErrorCode());+ }++ @Test+ void createDbInstanceRejectsPostgresOptionGroupForAnotherMajorEngineVersion() {+ rdsService.createOptionGroup("og1", "postgres", "13", "mine");++ AwsException exception = assertThrows(AwsException.class,+ () -> createInstanceWithOptionGroup("mydb", "postgres", "16.3", "og1"));++ assertEquals("InvalidParameterCombination", exception.getErrorCode());+ }++ @Test+ void createDbInstanceAcceptsOptionGroupMatchingTheInstanceMajorEngineVersion() {+ rdsService.createOptionGroup("og1", "mysql", "8.0", "mine");++ DbInstance instance = createInstanceWithOptionGroup("mydb", "mysql", "8.0.36", "og1");++ assertEquals("og1", instance.getOptionGroupName());+ }++ @Test+ void createDbInstanceAcceptsPostgresOptionGroupRegardlessOfTheMinorVersion() {+ rdsService.createOptionGroup("og1", "postgres", "16", "mine");++ DbInstance instance = createInstanceWithOptionGroup("mydb", "postgres", "16.3", "og1");++ assertEquals("og1", instance.getOptionGroupName());+ }++ @Test+ void createDbInstanceAcceptsManagedDefaultOptionGroup() {+ DbInstance instance =+ createInstanceWithOptionGroup("mydb", "mysql", "8.0", "default:mysql-8-0");++ assertEquals("default:mysql-8-0", instance.getOptionGroupName());+ }++ @Test+ void optionGroupIsTaggableByArn() {+ OptionGroup group = rdsService.createOptionGroup("og1", "mysql", "8.0", "mine");++ rdsService.addTagsToResource(group.getOptionGroupArn(), Map.of("env", "dev"));++ assertEquals(Map.of("env", "dev"),+ rdsService.listTagsForResource(group.getOptionGroupArn()));+ }++ @Test+ void defaultOptionGroupCannotBeTagged() {+ AwsException exception = assertThrows(AwsException.class, () ->+ rdsService.addTagsToResource(+ "arn:aws:rds:us-east-1:123456789012:og:default:mysql-8-0",+ Map.of("env", "dev")));++ assertEquals("InvalidOptionGroupStateFault", exception.getErrorCode());+ }++ @Test+ void modifyDbInstanceAttachesOptionGroup() {+ rdsService.createOptionGroup("og1", "mysql", "8.0", "mine");+ createInstanceWithOptionGroup("mydb", "mysql", "8.0", null);++ DbInstance modified = rdsService.modifyDbInstance(+ "mydb", null, null, null, List.of(), "og1", "us-east-1");++ assertEquals("og1", modified.getOptionGroupName());+ assertEquals("og1", rdsService.getDbInstance("mydb").getOptionGroupName());+ }++ @Test+ void modifyDbInstanceRejectsOptionGroupForAnotherEngine() {+ rdsService.createOptionGroup("og1", "postgres", "16", "mine");+ createInstanceWithOptionGroup("mydb", "mysql", "8.0", null);++ AwsException exception = assertThrows(AwsException.class, () ->+ rdsService.modifyDbInstance(+ "mydb", null, null, null, List.of(), "og1", "us-east-1"));++ assertEquals("InvalidParameterCombination", exception.getErrorCode());+ }++ @Test+ void modifyDbInstanceRejectsOptionGroupForAnotherMajorEngineVersion() {+ rdsService.createOptionGroup("og1", "mysql", "8.4", "mine");+ createInstanceWithOptionGroup("mydb", "mysql", "8.0.36", null);++ AwsException exception = assertThrows(AwsException.class, () ->+ rdsService.modifyDbInstance(+ "mydb", null, null, null, List.of(), "og1", "us-east-1"));++ assertEquals("InvalidParameterCombination", exception.getErrorCode());+ }++ @Test+ void modifyDbInstanceAcceptsOptionGroupMatchingTheInstanceMajorEngineVersion() {+ rdsService.createOptionGroup("og1", "mysql", "8.0", "mine");+ createInstanceWithOptionGroup("mydb", "mysql", "8.0.36", null);++ DbInstance modified = rdsService.modifyDbInstance(+ "mydb", null, null, null, List.of(), "og1", "us-east-1");++ assertEquals("og1", modified.getOptionGroupName());+ }++ @Test+ void optionGroupsUseTheInjectedAccountAwareStorage() {+ String accountId = "123456789012";+ InMemoryStorage<String, OptionGroup> rawOptionGroups = new InMemoryStorage<>();+ RdsService service = optionGroupStoreService(regionResolver,+ new AccountAwareStorageBackend<>(rawOptionGroups, null, accountId));++ service.createOptionGroup("og1", "mysql", "8.0", "mine", Map.of(), "us-east-1");++ assertTrue(rawOptionGroups.get(accountId + "/us-east-1::og1").isPresent());+ }++ @Test+ void sameNamedOptionGroupsInDifferentAccountsAreIsolated() {+ String accountA = "111111111111";+ String accountB = "222222222222";+ InMemoryStorage<String, OptionGroup> rawOptionGroups = new InMemoryStorage<>();+ RdsService serviceA = optionGroupStoreService(+ new RegionResolver("us-east-1", accountA),+ new AccountAwareStorageBackend<>(rawOptionGroups, null, accountA));+ RdsService serviceB = optionGroupStoreService(+ new RegionResolver("us-east-1", accountB),+ new AccountAwareStorageBackend<>(rawOptionGroups, null, accountB));++ serviceA.createOptionGroup("og1", "mysql", "8.0", "account a", Map.of(), "us-east-1");+ serviceB.createOptionGroup("og1", "postgres", "16", "account b", Map.of(), "us-east-1");+ serviceA.deleteOptionGroup("og1", "us-east-1");++ assertThrows(AwsException.class, () -> serviceA.getOptionGroup("og1", "us-east-1"));+ assertEquals("postgres", serviceB.getOptionGroup("og1", "us-east-1").getEngineName());+ }++ private RdsService optionGroupStoreService(+ RegionResolver resolver, StorageBackend<String, OptionGroup> optionGroups) {+ return new RdsService(containerManager, proxyManager, ec2Service, resolver, config,+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), null, null, null,+ new InMemoryStorage<>(), new InMemoryStorage<>(), optionGroups);+ }++ private DbInstance createInstanceWithOptionGroup(+ String id, String engine, String engineVersion, String optionGroupName) {+ return rdsService.createDbInstance(id, engine, engineVersion, "admin", "password",+ "dbname", "db.t3.micro", 20, false, null, null, null, null, false, false,+ null, Map.of(), List.of(), optionGroupName, null);+ }+private RdsService newService(RdsContainerManager containerManager,RdsProxyManager proxyManager,StorageBackend<String, DbInstance> instances,diff --git a/tools/docs/services.yaml b/tools/docs/services.yamlindex 334065176c..849835257d 100644--- a/tools/docs/services.yaml+++ b/tools/docs/services.yaml@@ -78,7 +78,7 @@ services:doc: docs/services/rds.mdsources:- { path: src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java, mode: switch }- exclude_actions: [SubnetIds, VpcSecurityGroupIds]+ exclude_actions: [SubnetIds, VpcSecurityGroupIds, OptionsToRemove]- service: secretsmanagerdoc: docs/services/secrets-manager.mdsources: