Light, fluffy, and always free - The AWS Local Emulator alternative
feat(cloudformation): provision ElastiCache users and user groups (#5422)
Vũ Thế Huy86b32584f3ac
diff --git a/docs/services/cloudformation.md b/docs/services/cloudformation.mdindex bdb5a55d66..c226848d64 100644--- a/docs/services/cloudformation.md+++ b/docs/services/cloudformation.md@@ -138,7 +138,7 @@ cross-resource references.| ECS | `Cluster`, `TaskDefinition`, `Service`, `CapacityProvider`, `ClusterCapacityProviderAssociations` || EKS | `Cluster`, `Nodegroup` || RDS | `DBInstance` (starts a real container), `DBCluster` (starts a real container), `DBSubnetGroup`, `DBParameterGroup`, `DBClusterParameterGroup`, `DBProxy`, `DBProxyTargetGroup` |-| ElastiCache | `CacheCluster` (starts a real container; modifying an existing cluster in place is not supported), `SubnetGroup` |+| ElastiCache | `CacheCluster` (starts a real container; modifying an existing cluster in place is not supported), `SubnetGroup`, `User` (Tags are ignored), `UserGroup` (Tags are ignored) || Redshift | `Cluster` (single-node container; Port and non-dev DBName ignored; ManageMasterPassword unsupported), `ClusterParameterGroup`, `ClusterSubnetGroup`, `ClusterSecurityGroup` (accepted; no EC2-Classic security group model) || Redshift Serverless | `Namespace` (ManageAdminPassword is accepted and not applied; GetAtt uses the dotted Namespace.* form), `Workgroup` (starts a real container; one workgroup per namespace; capacity, VPC and price-performance settings are stored only; snapshot restore properties are ignored; GetAtt uses the dotted Workgroup.* form) || EC2 | `VPC`, `Subnet`, `SecurityGroup` (inline `SecurityGroupIngress`/`SecurityGroupEgress` supported), `SecurityGroupIngress`, `SecurityGroupEgress`, `InternetGateway`, `RouteTable`, `SubnetRouteTableAssociation`, `Route`, `NatGateway`, `EIP`, `Instance`, `LaunchTemplate`, `VPCGatewayAttachment`, `VPCEndpoint`, `NetworkAcl`, `NetworkAclEntry`, `SubnetNetworkAclAssociation`, `FlowLog` |diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ElastiCacheCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ElastiCacheCfnProvisioner.javaindex bbd5352ed0..bcea43b5c6 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ElastiCacheCfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ElastiCacheCfnProvisioner.java@@ -7,9 +7,12 @@ import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.services.cloudformation.model.StackResource;import io.github.hectorvent.floci.services.elasticache.ElastiCacheMemcachedService;import io.github.hectorvent.floci.services.elasticache.ElastiCacheService;+import io.github.hectorvent.floci.services.elasticache.UserAuthentication;import io.github.hectorvent.floci.services.elasticache.model.AuthMode;import io.github.hectorvent.floci.services.elasticache.model.CacheCluster;import io.github.hectorvent.floci.services.elasticache.model.CacheSubnetGroup;+import io.github.hectorvent.floci.services.elasticache.model.ElastiCacheUser;+import io.github.hectorvent.floci.services.elasticache.model.ElastiCacheUserGroup;import io.github.hectorvent.floci.services.elasticache.model.Endpoint;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;@@ -17,13 +20,15 @@ import org.jboss.logging.Logger;import java.util.ArrayList;import java.util.List;+import java.util.Locale;import java.util.Map;import java.util.Objects;import java.util.Set;/**- * Provisions AWS::ElastiCache::CacheCluster and SubnetGroup. A cache cluster needs the Memcached- * service as well as the Redis one, because the two engines keep their clusters in separate stores.+ * Provisions AWS::ElastiCache::CacheCluster, SubnetGroup, User and UserGroup. A cache cluster needs+ * the Memcached service as well as the Redis one, because the two engines keep their clusters in+ * separate stores.*/@ApplicationScopedpublic class ElastiCacheCfnProvisioner implements CfnResourceProvisioner {@@ -33,7 +38,11 @@ public class ElastiCacheCfnProvisioner implements CfnResourceProvisioner {private static final String CACHE_CLUSTER = "AWS::ElastiCache::CacheCluster";private static final String SUBNET_GROUP = "AWS::ElastiCache::SubnetGroup";+ private static final String USER = "AWS::ElastiCache::User";+ private static final String USER_GROUP = "AWS::ElastiCache::UserGroup";private static final String SUBNET_GROUP_UPDATE_SNAPSHOT_ATTR = "__FlociCacheSubnetGroupUpdateSnapshot";+ private static final String USER_UPDATE_SNAPSHOT_ATTR = "__FlociUserUpdateSnapshot";+ private static final String USER_GROUP_UPDATE_SNAPSHOT_ATTR = "__FlociUserGroupUpdateSnapshot";private static final List<String> UNSUPPORTED_CLUSTER_PROPERTIES = List.of("CacheSecurityGroupNames","NotificationTopicArn", "AZMode", "PreferredAvailabilityZones", "LogDeliveryConfigurations","SnapshotArns", "SnapshotName");@@ -53,16 +62,20 @@ public class ElastiCacheCfnProvisioner implements CfnResourceProvisioner {@Overridepublic Set<String> resourceTypes() {- return Set.of(CACHE_CLUSTER, SUBNET_GROUP);+ return Set.of(CACHE_CLUSTER, SUBNET_GROUP, USER, USER_GROUP);}@Overridepublic void provision(StackResource r, JsonNode props, ProvisionContext ctx) {r.getAttributes().remove(SUBNET_GROUP_UPDATE_SNAPSHOT_ATTR);+ r.getAttributes().remove(USER_UPDATE_SNAPSHOT_ATTR);+ r.getAttributes().remove(USER_GROUP_UPDATE_SNAPSHOT_ATTR);Map<String, String> attributesBefore = Map.copyOf(r.getAttributes());switch (r.getResourceType()) {case CACHE_CLUSTER -> provisionCacheCluster(r, props, ctx);case SUBNET_GROUP -> provisionSubnetGroup(r, props, ctx);+ case USER -> provisionUser(r, props, ctx);+ case USER_GROUP -> provisionUserGroup(r, props, ctx);default -> throw new IllegalStateException("ElastiCacheCfnProvisioner cannot provision " + r.getResourceType());}@@ -83,6 +96,8 @@ public class ElastiCacheCfnProvisioner implements CfnResourceProvisioner {public UpdateCleanupResult completeUpdate(StackResource resource) {if ("UPDATE_COMPLETE".equals(resource.getStatus())) {resource.getAttributes().remove(SUBNET_GROUP_UPDATE_SNAPSHOT_ATTR);+ resource.getAttributes().remove(USER_UPDATE_SNAPSHOT_ATTR);+ resource.getAttributes().remove(USER_GROUP_UPDATE_SNAPSHOT_ATTR);}return ReplacementCleanup.complete(resource, this::delete);}@@ -90,6 +105,8 @@ public class ElastiCacheCfnProvisioner implements CfnResourceProvisioner {@Overridepublic void clearUpdate(StackResource resource) {resource.getAttributes().remove(SUBNET_GROUP_UPDATE_SNAPSHOT_ATTR);+ resource.getAttributes().remove(USER_UPDATE_SNAPSHOT_ATTR);+ resource.getAttributes().remove(USER_GROUP_UPDATE_SNAPSHOT_ATTR);ReplacementCleanup.clear(resource);}@@ -109,6 +126,33 @@ public class ElastiCacheCfnProvisioner implements CfnResourceProvisioner {}}}+ if (USER.equals(resource.getResourceType())) {+ String rawSnapshot = resource.getAttributes().remove(USER_UPDATE_SNAPSHOT_ATTR);+ if (rawSnapshot != null) {+ try {+ UserSnapshot snapshot = MAPPER.readValue(rawSnapshot, UserSnapshot.class);+ elastiCacheService.modifyUser(snapshot.userId(), snapshot.authMode(),+ snapshot.passwords(), snapshot.accessString(), null, snapshot.engine());+ return true;+ } catch (Exception e) {+ LOG.errorv("Could not restore user {0} after failed update: {1}",+ resource.getPhysicalId(), e.getMessage());+ }+ }+ }+ if (USER_GROUP.equals(resource.getResourceType())) {+ String rawSnapshot = resource.getAttributes().remove(USER_GROUP_UPDATE_SNAPSHOT_ATTR);+ if (rawSnapshot != null) {+ try {+ UserGroupSnapshot snapshot = MAPPER.readValue(rawSnapshot, UserGroupSnapshot.class);+ elastiCacheService.setUserGroupMembers(snapshot.userGroupId(), snapshot.userIds(), snapshot.engine());+ return true;+ } catch (Exception e) {+ LOG.errorv("Could not restore user group {0} after failed update: {1}",+ resource.getPhysicalId(), e.getMessage());+ }+ }+ }return ReplacementCleanup.rollback(resource, this::delete);}@@ -297,6 +341,102 @@ public class ElastiCacheCfnProvisioner implements CfnResourceProvisioner {r.setPhysicalId(group.getName());}+ private void provisionUser(StackResource r, JsonNode props, ProvisionContext ctx) {+ String userId = ctx.resolveOptional(props, "UserId");+ String userName = ctx.resolveOptional(props, "UserName");+ String engine = ctx.resolveOptional(props, "Engine");+ if (userId == null || userId.isBlank() || userName == null || userName.isBlank()+ || engine == null || engine.isBlank()) {+ throw new AwsException("ValidationException", "UserId, UserName and Engine are required", 400);+ }+ String accessString = ctx.resolveOptional(props, "AccessString");+ UserAuthentication auth = resolveAuthentication(props, ctx);+ if (!ctx.resolveTags(props, "Tags").isEmpty()) {+ LOG.warnv("ElastiCache user {0}: Tags are ignored, the emulator does not tag users", userId);+ }++ ElastiCacheUser user;+ if (ctx.reusesPriorEntity(userId)) {+ ElastiCacheUser existing = elastiCacheService.getUser(userId);+ if (!userName.equals(existing.getUserName())) {+ throw new AwsException("InvalidParameterValue",+ "UserName of user " + userId + " is create-only; use a new UserId to change it", 400);+ }+ UserSnapshot snapshot = new UserSnapshot(+ existing.getUserId(),+ existing.getAuthMode(),+ existing.getPasswords(),+ existing.getAccessString(),+ existing.getEngine());+ try {+ r.getAttributes().put(USER_UPDATE_SNAPSHOT_ATTR, MAPPER.writeValueAsString(snapshot));+ } catch (JsonProcessingException e) {+ LOG.errorv("Could not snapshot user {0} before update: {1}", userId, e.getMessage());+ }+ user = elastiCacheService.modifyUser(userId,+ auth != null ? auth.mode() : null,+ auth != null ? auth.passwords() : null,+ accessString, null, engine);+ } else {+ AuthMode mode = auth != null ? auth.mode() : AuthMode.NO_AUTH;+ user = elastiCacheService.createUser(userId, userName, mode,+ auth != null ? auth.passwords() : List.of(), accessString, engine);+ }+ r.setPhysicalId(user.getUserId());+ r.getAttributes().put("Arn", user.getArn());+ r.getAttributes().put("Status", user.getStatus());+ }++ private void provisionUserGroup(StackResource r, JsonNode props, ProvisionContext ctx) {+ String groupId = ctx.resolveOptional(props, "UserGroupId");+ String engine = ctx.resolveOptional(props, "Engine");+ if (groupId == null || groupId.isBlank() || engine == null || engine.isBlank()) {+ throw new AwsException("ValidationException", "UserGroupId and Engine are required", 400);+ }+ if (!props.hasNonNull("UserIds")) {+ throw new AwsException("ValidationException", "UserIds is required", 400);+ }+ // The service stores the id in lowercase, so the prior physical id only matches in that form.+ groupId = groupId.toLowerCase(Locale.ROOT);+ List<String> userIds = ctx.resolveStringList(props, "UserIds");+ if (!ctx.resolveTags(props, "Tags").isEmpty()) {+ LOG.warnv("ElastiCache user group {0}: Tags are ignored, the emulator does not tag user groups", groupId);+ }++ ElastiCacheUserGroup group;+ if (ctx.reusesPriorEntity(groupId)) {+ ElastiCacheUserGroup existing = elastiCacheService.getUserGroup(groupId);+ UserGroupSnapshot snapshot = new UserGroupSnapshot(+ existing.getUserGroupId(),+ existing.getEngine(),+ new ArrayList<>(existing.getUserIds()));+ try {+ r.getAttributes().put(USER_GROUP_UPDATE_SNAPSHOT_ATTR, MAPPER.writeValueAsString(snapshot));+ } catch (JsonProcessingException e) {+ LOG.errorv("Could not snapshot user group {0} before update: {1}", groupId, e.getMessage());+ }+ group = elastiCacheService.setUserGroupMembers(groupId, userIds, engine);+ } else {+ group = elastiCacheService.createUserGroup(groupId, engine, userIds, ctx.region());+ }+ r.setPhysicalId(group.getUserGroupId());+ r.getAttributes().put("Arn", group.getArn());+ r.getAttributes().put("Status", group.getStatus());+ }++ private UserAuthentication resolveAuthentication(JsonNode props, ProvisionContext ctx) {+ JsonNode mode = props.has("AuthenticationMode")+ ? ctx.engine().resolveNode(props.get("AuthenticationMode")) : null;+ String type = mode != null && mode.hasNonNull("Type") ? mode.get("Type").asText() : null;+ List<String> passwords = mode != null && mode.has("Passwords")+ ? ctx.engine().resolveStringList(mode.get("Passwords")) : List.of();+ if (passwords.isEmpty()) {+ passwords = ctx.resolveStringList(props, "Passwords");+ }+ boolean noPasswordRequired = Boolean.parseBoolean(ctx.resolveOptional(props, "NoPasswordRequired"));+ return UserAuthentication.resolve(type, passwords, noPasswordRequired);+ }+@Overridepublic void delete(String resourceType, String physicalId, String region) {if (resourceType == null || physicalId == null) {@@ -312,6 +452,10 @@ public class ElastiCacheCfnProvisioner implements CfnResourceProvisioner {}, "CacheClusterNotFound");case SUBNET_GROUP -> CfnDeletes.safeDelete("ElastiCache subnet group", physicalId,() -> elastiCacheService.deleteCacheSubnetGroup(physicalId), "CacheSubnetGroupNotFoundFault");+ case USER_GROUP -> CfnDeletes.safeDelete("ElastiCache user group", physicalId,+ () -> elastiCacheService.deleteUserGroup(physicalId), "UserGroupNotFound");+ case USER -> CfnDeletes.safeDelete("ElastiCache user", physicalId,+ () -> elastiCacheService.deleteUser(physicalId), "UserNotFoundFault");default -> {}}@@ -323,4 +467,9 @@ public class ElastiCacheCfnProvisioner implements CfnResourceProvisioner {private record SubnetGroupSnapshot(String name, String description, List<String> subnetIds,Map<String, String> tags) {}++ private record UserSnapshot(String userId, AuthMode authMode, List<String> passwords,+ String accessString, String engine) {}++ private record UserGroupSnapshot(String userGroupId, String engine, List<String> userIds) {}}diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandler.javaindex 534307cb2c..8582f1b1cd 100644--- a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheQueryHandler.java@@ -33,7 +33,6 @@ import java.util.ArrayList;import java.util.Collection;import java.util.LinkedHashMap;import java.util.List;-import java.util.Locale;import java.util.Map;/**@@ -1179,57 +1178,13 @@ private Response handleCreateCacheParameterGroup(MultivaluedMap<String, String>regionResolver.getAccountId(), "user:" + u.getUserId()).toString();}- private record UserAuthentication(AuthMode mode, List<String> passwords) {}-- /**- * Resolves the authentication a CreateUser or ModifyUser request asks for. AWS accepts it- * either as an {@code AuthenticationMode} or through the top-level {@code Passwords} and- * {@code NoPasswordRequired} members, so passwords given either way mean password- * authentication. Returns null when the request names no authentication at all.- */private static UserAuthentication resolveUserAuthentication(MultivaluedMap<String, String> params) {- String type = params.getFirst("AuthenticationMode.Type");List<String> passwords = extractMemberList(params, "AuthenticationMode.Passwords.member.");if (passwords.isEmpty()) {passwords = extractMemberList(params, "Passwords.member.");}- boolean noPasswordRequired = Boolean.parseBoolean(params.getFirst("NoPasswordRequired"));-- if (type == null || type.isBlank()) {- if (noPasswordRequired && !passwords.isEmpty()) {- throw invalidCombination("NoPasswordRequired cannot be true when Passwords are provided.");- }- if (!passwords.isEmpty()) {- return new UserAuthentication(AuthMode.PASSWORD, passwords);- }- return noPasswordRequired ? new UserAuthentication(AuthMode.NO_AUTH, List.of()) : null;- }-- String normalizedType = type.toLowerCase(Locale.ROOT);- if (noPasswordRequired && !"no-password-required".equals(normalizedType)) {- throw invalidCombination("NoPasswordRequired cannot be true when AuthenticationMode.Type is " + type + ".");- }- return switch (normalizedType) {- case "password" -> {- if (passwords.isEmpty()) {- throw new AwsException("InvalidParameterValue",- "Passwords are required when AuthenticationMode.Type is password.", 400);- }- yield new UserAuthentication(AuthMode.PASSWORD, passwords);- }- case "iam", "no-password-required" -> {- if (!passwords.isEmpty()) {- throw invalidCombination("Passwords cannot be provided when AuthenticationMode.Type is " + type + ".");- }- yield new UserAuthentication("iam".equals(normalizedType) ? AuthMode.IAM : AuthMode.NO_AUTH, List.of());- }- default -> throw new AwsException("InvalidParameterValue",- "Invalid AuthenticationMode.Type " + type + ". Valid values are password, no-password-required and iam.", 400);- };- }-- private static AwsException invalidCombination(String message) {- return new AwsException("InvalidParameterCombination", message, 400);+ return UserAuthentication.resolve(params.getFirst("AuthenticationMode.Type"), passwords,+ Boolean.parseBoolean(params.getFirst("NoPasswordRequired")));}private static String memberListXml(String name, Collection<String> values) {diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheService.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheService.javaindex dc33ee5f53..d1fb908dfa 100644--- a/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheService.java+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheService.java@@ -57,6 +57,7 @@ import java.util.Optional;import java.util.Set;import java.util.concurrent.CompletableFuture;import java.util.concurrent.ConcurrentHashMap;+import java.util.function.UnaryOperator;import java.util.regex.Pattern;/**@@ -1946,18 +1947,31 @@ public class ElastiCacheService implements ResourceProvider {public ElastiCacheUserGroup modifyUserGroup(String userGroupId, List<String> userIdsToAdd,List<String> userIdsToRemove, String engine) {- String id = normalizeUserGroupId(userGroupId);- synchronized (userGroupLock) {- ElastiCacheUserGroup userGroup = getUserGroup(id);- // Validate the resulting group before changing the stored object.- String newEngine = (engine == null || engine.isBlank()) ? userGroup.getEngine() : normalizeEngine(engine);- Set<String> members = new LinkedHashSet<>(userGroup.getUserIds());+ return updateUserGroup(userGroupId, engine, current -> {+ Set<String> members = new LinkedHashSet<>(current);if (userIdsToAdd != null) {members.addAll(userIdsToAdd);}if (userIdsToRemove != null) {members.removeAll(userIdsToRemove);}+ return members;+ });+ }++ public ElastiCacheUserGroup setUserGroupMembers(String userGroupId, List<String> userIds, String engine) {+ return updateUserGroup(userGroupId, engine,+ current -> userIds == null ? new LinkedHashSet<>() : new LinkedHashSet<>(userIds));+ }++ private ElastiCacheUserGroup updateUserGroup(String userGroupId, String engine,+ UnaryOperator<Set<String>> membership) {+ String id = normalizeUserGroupId(userGroupId);+ synchronized (userGroupLock) {+ ElastiCacheUserGroup userGroup = getUserGroup(id);+ // Validate the resulting group before changing the stored object.+ String newEngine = (engine == null || engine.isBlank()) ? userGroup.getEngine() : normalizeEngine(engine);+ Set<String> members = membership.apply(userGroup.getUserIds());validateUserGroupMembers(newEngine, members);if (!newEngine.equals(userGroup.getEngine())) {for (ReplicationGroup group : replicationGroupsUsing(id)) {diff --git a/src/main/java/io/github/hectorvent/floci/services/elasticache/UserAuthentication.java b/src/main/java/io/github/hectorvent/floci/services/elasticache/UserAuthentication.javanew file mode 100644index 0000000000..def9905c1f--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/elasticache/UserAuthentication.java@@ -0,0 +1,61 @@+package io.github.hectorvent.floci.services.elasticache;++import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.elasticache.model.AuthMode;++import java.util.List;+import java.util.Locale;++/**+ * The authentication a CreateUser or ModifyUser request, or an AWS::ElastiCache::User resource,+ * asks for. AWS accepts it either as an {@code AuthenticationMode} or through the top-level+ * {@code Passwords} and {@code NoPasswordRequired} members, so passwords given either way mean+ * password authentication.+ */+public record UserAuthentication(AuthMode mode, List<String> passwords) {++ /**+ * Returns null when nothing names an authentication at all, so the caller can keep its own default.+ *+ * @param type AuthenticationMode.Type, or null when absent+ * @param passwords the passwords from AuthenticationMode or the top-level member+ * @param noPasswordRequired the top-level NoPasswordRequired member+ */+ public static UserAuthentication resolve(String type, List<String> passwords, boolean noPasswordRequired) {+ if (type == null || type.isBlank()) {+ if (noPasswordRequired && !passwords.isEmpty()) {+ throw invalidCombination("NoPasswordRequired cannot be true when Passwords are provided.");+ }+ if (!passwords.isEmpty()) {+ return new UserAuthentication(AuthMode.PASSWORD, passwords);+ }+ return noPasswordRequired ? new UserAuthentication(AuthMode.NO_AUTH, List.of()) : null;+ }++ String normalizedType = type.toLowerCase(Locale.ROOT);+ if (noPasswordRequired && !"no-password-required".equals(normalizedType)) {+ throw invalidCombination("NoPasswordRequired cannot be true when AuthenticationMode.Type is " + type + ".");+ }+ return switch (normalizedType) {+ case "password" -> {+ if (passwords.isEmpty()) {+ throw new AwsException("InvalidParameterValue",+ "Passwords are required when AuthenticationMode.Type is password.", 400);+ }+ yield new UserAuthentication(AuthMode.PASSWORD, passwords);+ }+ case "iam", "no-password-required" -> {+ if (!passwords.isEmpty()) {+ throw invalidCombination("Passwords cannot be provided when AuthenticationMode.Type is " + type + ".");+ }+ yield new UserAuthentication("iam".equals(normalizedType) ? AuthMode.IAM : AuthMode.NO_AUTH, List.of());+ }+ default -> throw new AwsException("InvalidParameterValue",+ "Invalid AuthenticationMode.Type " + type + ". Valid values are password, no-password-required and iam.", 400);+ };+ }++ private static AwsException invalidCombination(String message) {+ return new AwsException("InvalidParameterCombination", message, 400);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/ElastiCacheCfnIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/ElastiCacheCfnIntegrationTest.javaindex 99ecf01bcd..d82acba0e8 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/ElastiCacheCfnIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/ElastiCacheCfnIntegrationTest.java@@ -14,6 +14,8 @@ import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.elasticache.ElastiCacheClient;import software.amazon.awssdk.services.elasticache.model.CacheCluster;import software.amazon.awssdk.services.elasticache.model.CacheSubnetGroupNotFoundException;+import software.amazon.awssdk.services.elasticache.model.ElastiCacheException;+import software.amazon.awssdk.services.elasticache.model.UserGroupNotFoundException;import java.io.IOException;import java.net.URI;@@ -24,6 +26,7 @@ import static org.hamcrest.Matchers.containsString;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;/*** Provisions the ElastiCache resource types through CloudFormation and checks them against the@@ -46,10 +49,25 @@ class ElastiCacheCfnIntegrationTest {"Properties": {"VpcId": {"Ref": "Vpc"}, "CidrBlock": "10.71.0.0/24"}},"SubnetGroup": {"Type": "AWS::ElastiCache::SubnetGroup","Properties": {"CacheSubnetGroupName": "cfn-it-sng", "Description": "example",- "SubnetIds": [{"Ref": "Subnet"}]}}+ "SubnetIds": [{"Ref": "Subnet"}]}},+ "DefaultUser": {"Type": "AWS::ElastiCache::User",+ "Properties": {"UserId": "cfn-it-default", "UserName": "default", "Engine": "redis",+ "AccessString": "off -@all", "NoPasswordRequired": true}},+ "AppUser": {"Type": "AWS::ElastiCache::User",+ "Properties": {"UserId": "cfn-it-app", "UserName": "cfn-it-app", "Engine": "redis",+ "AccessString": "on ~* +@all",+ "AuthenticationMode": {"Type": "password",+ "Passwords": ["example-password-0123456789"]}}},+ "UserGroup": {"Type": "AWS::ElastiCache::UserGroup",+ "Properties": {"UserGroupId": "cfn-it-users", "Engine": "redis",+ "UserIds": [{"Ref": "DefaultUser"}, {"Ref": "AppUser"}]}}},"Outputs": {- "SubnetGroupRef": {"Value": {"Ref": "SubnetGroup"}}+ "SubnetGroupRef": {"Value": {"Ref": "SubnetGroup"}},+ "UserRef": {"Value": {"Ref": "AppUser"}},+ "UserArn": {"Value": {"Fn::GetAtt": ["AppUser", "Arn"]}},+ "GroupRef": {"Value": {"Ref": "UserGroup"}},+ "GroupArn": {"Value": {"Fn::GetAtt": ["UserGroup", "Arn"]}}}}""";@@ -83,7 +101,18 @@ class ElastiCacheCfnIntegrationTest {"Properties": {"VpcId": {"Ref": "Vpc"}, "CidrBlock": "10.73.0.0/24"}},"SubnetGroup": {"Type": "AWS::ElastiCache::SubnetGroup","Properties": {"CacheSubnetGroupName": "@@SNG@@", "Description": "example",- "SubnetIds": [{"Ref": "Subnet"}]}}+ "SubnetIds": [{"Ref": "Subnet"}]}},+ "DefaultUser": {"Type": "AWS::ElastiCache::User",+ "Properties": {"UserId": "cfn-it-upd-default", "UserName": "default", "Engine": "redis",+ "AccessString": "off -@all", "NoPasswordRequired": true}},+ "AppUser": {"Type": "AWS::ElastiCache::User",+ "Properties": {"UserId": "cfn-it-upd-app", "UserName": "cfn-it-upd-app", "Engine": "redis",+ "AccessString": "on ~* +@all",+ "AuthenticationMode": {"Type": "password",+ "Passwords": ["example-password-0123456789"]}}},+ "UserGroup": {"Type": "AWS::ElastiCache::UserGroup",+ "Properties": {"UserGroupId": "cfn-it-upd-users", "Engine": "redis",+ "UserIds": @@MEMBERS@@}}},"Outputs": {"SubnetGroupRef": {"Value": {"Ref": "SubnetGroup"}}@@ -106,35 +135,50 @@ class ElastiCacheCfnIntegrationTest {}@Test- void subnetGroupIsCreatedAndRemovedWithTheStack() {+ void subnetGroupUsersAndUserGroupAreCreatedAndRemovedWithTheStack() {cloudFormation(METADATA_STACK, "CreateStack", METADATA_TEMPLATE);String stacks = describeStacks(METADATA_STACK, "CREATE_COMPLETE");assertEquals("cfn-it-sng", outputValue(stacks, "SubnetGroupRef"));+ assertEquals("cfn-it-app", outputValue(stacks, "UserRef"));+ assertEquals("cfn-it-users", outputValue(stacks, "GroupRef"));+ assertTrue(outputValue(stacks, "UserArn").endsWith(":user:cfn-it-app"));+ assertTrue(outputValue(stacks, "GroupArn").endsWith(":usergroup:cfn-it-users"));try (ElastiCacheClient client = client()) {assertEquals(1, client.describeCacheSubnetGroups(r -> r.cacheSubnetGroupName("cfn-it-sng")).cacheSubnetGroups().size());+ assertEquals(2, client.describeUserGroups(r -> r.userGroupId("cfn-it-users"))+ .userGroups().getFirst().userIds().size());cloudFormation(METADATA_STACK, "DeleteStack", null);CfnStackWaits.awaitStackDeleted(METADATA_STACK);+ assertThrows(UserGroupNotFoundException.class,+ () -> client.describeUserGroups(r -> r.userGroupId("cfn-it-users")));+ assertThrows(ElastiCacheException.class, () -> client.describeUsers(r -> r.userId("cfn-it-app")));assertThrows(CacheSubnetGroupNotFoundException.class,() -> client.describeCacheSubnetGroups(r -> r.cacheSubnetGroupName("cfn-it-sng")));}}@Test- void renamedSubnetGroupIsReplaced() {+ void updateChangesGroupMembershipInPlaceAndRenamedSubnetGroupIsReplaced() {String stack = "elasticache-cfn-update-it";- cloudFormation(stack, "CreateStack", UPDATE_TEMPLATE.replace("@@SNG@@", "cfn-it-upd-sng-a"));+ String create = UPDATE_TEMPLATE.replace("@@SNG@@", "cfn-it-upd-sng-a").replace("@@MEMBERS@@",+ "[{\"Ref\": \"DefaultUser\"}]");+ cloudFormation(stack, "CreateStack", create);describeStacks(stack, "CREATE_COMPLETE");- cloudFormation(stack, "UpdateStack", UPDATE_TEMPLATE.replace("@@SNG@@", "cfn-it-upd-sng-b"));+ String update = UPDATE_TEMPLATE.replace("@@SNG@@", "cfn-it-upd-sng-b").replace("@@MEMBERS@@",+ "[{\"Ref\": \"DefaultUser\"}, {\"Ref\": \"AppUser\"}]");+ cloudFormation(stack, "UpdateStack", update);String stacks = describeStacks(stack, "UPDATE_COMPLETE");assertEquals("cfn-it-upd-sng-b", outputValue(stacks, "SubnetGroupRef"));try (ElastiCacheClient client = client()) {+ assertEquals(2, client.describeUserGroups(r -> r.userGroupId("cfn-it-upd-users"))+ .userGroups().getFirst().userIds().size());assertThrows(CacheSubnetGroupNotFoundException.class,() -> client.describeCacheSubnetGroups(r -> r.cacheSubnetGroupName("cfn-it-upd-sng-a")));assertEquals(1, client.describeCacheSubnetGroups(r -> r.cacheSubnetGroupName("cfn-it-upd-sng-b"))diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ElastiCacheCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ElastiCacheCfnProvisionerTest.javaindex 0c2fbb77f6..6bc112f2fc 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ElastiCacheCfnProvisionerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ElastiCacheCfnProvisionerTest.java@@ -12,6 +12,8 @@ import io.github.hectorvent.floci.services.elasticache.model.AuthMode;import io.github.hectorvent.floci.services.elasticache.model.CacheCluster;import io.github.hectorvent.floci.services.elasticache.model.CacheClusterStatus;import io.github.hectorvent.floci.services.elasticache.model.CacheSubnetGroup;+import io.github.hectorvent.floci.services.elasticache.model.ElastiCacheUser;+import io.github.hectorvent.floci.services.elasticache.model.ElastiCacheUserGroup;import io.github.hectorvent.floci.services.elasticache.model.Endpoint;import org.junit.jupiter.api.Test;import org.mockito.ArgumentCaptor;@@ -19,6 +21,7 @@ import org.mockito.ArgumentCaptor;import java.time.Instant;import java.util.ArrayList;import java.util.HashMap;+import java.util.LinkedHashSet;import java.util.List;import java.util.Map;@@ -253,6 +256,210 @@ class ElastiCacheCfnProvisionerTest {assertEquals("my-sng", r.getPhysicalId());}+ @Test+ void userWithPasswordAuthenticationModeSetsArnAndStatus() throws Exception {+ ElastiCacheUser user = new ElastiCacheUser("app", "app", AuthMode.PASSWORD, List.of("pw-0123456789abcd"),+ "on ~* +@all", "redis", "active", Instant.now());+ user.setArn("arn:aws:elasticache:us-east-1:000000000000:user:app");+ when(cache.createUser(eq("app"), eq("app"), eq(AuthMode.PASSWORD), eq(List.of("pw-0123456789abcd")),+ eq("on ~* +@all"), eq("redis"))).thenReturn(user);+ StackResource r = resource("AWS::ElastiCache::User", "AppUser");++ provisioner.provision(r, props("""+ {"UserId":"app","UserName":"app","Engine":"redis","AccessString":"on ~* +@all",+ "AuthenticationMode":{"Type":"password","Passwords":["pw-0123456789abcd"]}}+ """), ctx(null));++ assertEquals("app", r.getPhysicalId());+ assertEquals("arn:aws:elasticache:us-east-1:000000000000:user:app", r.getAttributes().get("Arn"));+ assertEquals("active", r.getAttributes().get("Status"));+ }++ @Test+ void userWithNoPasswordRequiredUsesNoAuth() throws Exception {+ ElastiCacheUser user = new ElastiCacheUser("d", "default", AuthMode.NO_AUTH, List.of(), "off -@all",+ "redis", "active", Instant.now());+ when(cache.createUser(eq("d"), eq("default"), eq(AuthMode.NO_AUTH), any(), eq("off -@all"), eq("redis")))+ .thenReturn(user);+ StackResource r = resource("AWS::ElastiCache::User", "Default");++ provisioner.provision(r, props("""+ {"UserId":"d","UserName":"default","Engine":"redis","AccessString":"off -@all",+ "NoPasswordRequired":true}+ """), ctx(null));++ assertEquals("d", r.getPhysicalId());+ }++ @Test+ void userRequiresUserIdUserNameAndEngine() throws Exception {+ StackResource r = resource("AWS::ElastiCache::User", "Bad");++ assertThrows(AwsException.class, () -> provisioner.provision(r, props("{\"Engine\":\"redis\"}"), ctx(null)));+ assertThrows(AwsException.class, () -> provisioner.provision(r, props("{\"UserId\":\"u\",\"UserName\":\"u\"}"), ctx(null)));+ verify(cache, never()).createUser(any(), any(), any(), any(), any(), any());+ }++ @Test+ void userRejectsPasswordModeWithoutPasswords() {+ StackResource r = resource("AWS::ElastiCache::User", "Bad");+ AwsException ex = assertThrows(AwsException.class, () -> provisioner.provision(r, props("""+ {"UserId":"u","UserName":"u","Engine":"redis",+ "AuthenticationMode":{"Type":"password"}}+ """), ctx(null)));+ assertEquals("InvalidParameterValue", ex.getErrorCode());+ verify(cache, never()).createUser(any(), any(), any(), any(), any(), any());+ }++ @Test+ void userRejectsPasswordsWithNoPasswordRequiredMode() {+ StackResource r = resource("AWS::ElastiCache::User", "Bad");+ AwsException ex = assertThrows(AwsException.class, () -> provisioner.provision(r, props("""+ {"UserId":"u","UserName":"u","Engine":"redis",+ "AuthenticationMode":{"Type":"no-password-required","Passwords":["pw"]}}+ """), ctx(null)));+ assertEquals("InvalidParameterCombination", ex.getErrorCode());+ verify(cache, never()).createUser(any(), any(), any(), any(), any(), any());+ }++ @Test+ void userRejectsPasswordsWithIamAuthenticationMode() {+ StackResource r = resource("AWS::ElastiCache::User", "Bad");+ AwsException ex = assertThrows(AwsException.class, () -> provisioner.provision(r, props("""+ {"UserId":"u","UserName":"u","Engine":"redis",+ "AuthenticationMode":{"Type":"iam","Passwords":["pw"]}}+ """), ctx(null)));+ assertEquals("InvalidParameterCombination", ex.getErrorCode());+ verify(cache, never()).createUser(any(), any(), any(), any(), any(), any());+ }++ @Test+ void userRejectsConflictingNoPasswordRequiredAndPasswords() {+ StackResource r = resource("AWS::ElastiCache::User", "Bad");+ AwsException ex = assertThrows(AwsException.class, () -> provisioner.provision(r, props("""+ {"UserId":"u","UserName":"u","Engine":"redis","NoPasswordRequired":true,"Passwords":["pw"]}+ """), ctx(null)));+ assertEquals("InvalidParameterCombination", ex.getErrorCode());+ verify(cache, never()).createUser(any(), any(), any(), any(), any(), any());+ }++ @Test+ void userRejectsConflictingNoPasswordRequiredAndAuthenticationModeType() {+ StackResource r = resource("AWS::ElastiCache::User", "Bad");+ AwsException ex = assertThrows(AwsException.class, () -> provisioner.provision(r, props("""+ {"UserId":"u","UserName":"u","Engine":"redis","NoPasswordRequired":true,+ "AuthenticationMode":{"Type":"password","Passwords":["pw"]}}+ """), ctx(null)));+ assertEquals("InvalidParameterCombination", ex.getErrorCode());+ verify(cache, never()).createUser(any(), any(), any(), any(), any(), any());+ }++ @Test+ void userRejectsInvalidAuthenticationModeType() {+ StackResource r = resource("AWS::ElastiCache::User", "Bad");+ AwsException ex = assertThrows(AwsException.class, () -> provisioner.provision(r, props("""+ {"UserId":"u","UserName":"u","Engine":"redis",+ "AuthenticationMode":{"Type":"bogus"}}+ """), ctx(null)));+ assertEquals("InvalidParameterValue", ex.getErrorCode());+ verify(cache, never()).createUser(any(), any(), any(), any(), any(), any());+ }++ @Test+ void userGroupRequiresUserIdsProperty() {+ StackResource r = resource("AWS::ElastiCache::UserGroup", "Bad");+ AwsException ex = assertThrows(AwsException.class, () -> provisioner.provision(r, props("""+ {"UserGroupId":"team","Engine":"valkey"}+ """), ctx(null)));+ assertEquals("ValidationException", ex.getErrorCode());+ verify(cache, never()).createUserGroup(any(), any(), any(), any());+ }++ @Test+ void userGroupSetsArnAndStatus() throws Exception {+ ElastiCacheUserGroup group = new ElastiCacheUserGroup();+ group.setUserGroupId("team");+ group.setArn("arn:aws:elasticache:us-east-1:000000000000:usergroup:team");+ group.setStatus("active");+ when(cache.createUserGroup("team", "redis", List.of("d", "app"), "us-east-1")).thenReturn(group);+ StackResource r = resource("AWS::ElastiCache::UserGroup", "Group");++ provisioner.provision(r, props("""+ {"UserGroupId":"team","Engine":"redis","UserIds":["d","app"]}+ """), ctx(null));++ assertEquals("team", r.getPhysicalId());+ assertEquals("arn:aws:elasticache:us-east-1:000000000000:usergroup:team", r.getAttributes().get("Arn"));+ }++ @Test+ void userGroupUpdateAppliesMembershipDelta() throws Exception {+ ElastiCacheUserGroup existing = new ElastiCacheUserGroup();+ existing.setUserGroupId("team");+ existing.setEngine("redis");+ existing.setUserIds(new LinkedHashSet<>(List.of("d", "old")));+ existing.setArn("arn");+ existing.setStatus("active");+ when(cache.getUserGroup("team")).thenReturn(existing);+ when(cache.setUserGroupMembers(eq("team"), eq(List.of("d", "new")), eq("redis"))).thenReturn(existing);+ StackResource r = resource("AWS::ElastiCache::UserGroup", "Group");++ provisioner.provision(r, props("""+ {"UserGroupId":"team","Engine":"redis","UserIds":["d","new"]}+ """), ctx("team"));++ verify(cache, never()).createUserGroup(any(), any(), any(), any());+ verify(cache).setUserGroupMembers(eq("team"), eq(List.of("d", "new")), eq("redis"));+ }++ @Test+ void userNameChangeIsRejectedBecauseItIsCreateOnly() throws Exception {+ ElastiCacheUser existing = new ElastiCacheUser("app", "old-name", AuthMode.NO_AUTH, List.of(), "on ~* +@all",+ "redis", "active", Instant.now());+ when(cache.getUser("app")).thenReturn(existing);+ StackResource r = resource("AWS::ElastiCache::User", "AppUser");++ assertThrows(AwsException.class, () -> provisioner.provision(r,+ props("{\"UserId\":\"app\",\"UserName\":\"new-name\",\"Engine\":\"redis\"}"), ctx("app")));+ verify(cache, never()).modifyUser(any(), any(), any(), any(), any(), any());+ }++ @Test+ void userGroupEngineChangeIsAppliedInPlace() throws Exception {+ ElastiCacheUserGroup existing = new ElastiCacheUserGroup();+ existing.setUserGroupId("team");+ existing.setEngine("redis");+ existing.setArn("arn");+ existing.setStatus("active");+ when(cache.getUserGroup("team")).thenReturn(existing);+ when(cache.setUserGroupMembers(eq("team"), eq(List.of()), eq("valkey"))).thenReturn(existing);+ StackResource r = resource("AWS::ElastiCache::UserGroup", "Group");++ provisioner.provision(r, props("{\"UserGroupId\":\"team\",\"Engine\":\"valkey\",\"UserIds\":[]}"), ctx("team"));++ verify(cache).setUserGroupMembers("team", List.of(), "valkey");+ verify(cache, never()).createUserGroup(any(), any(), any(), any());+ }++ @Test+ void mixedCaseUserGroupIdIsReusedOnUpdateThroughItsLowercaseForm() throws Exception {+ ElastiCacheUserGroup existing = new ElastiCacheUserGroup();+ existing.setUserGroupId("myusers");+ existing.setEngine("redis");+ existing.setArn("arn");+ existing.setStatus("active");+ when(cache.getUserGroup("myusers")).thenReturn(existing);+ when(cache.setUserGroupMembers("myusers", List.of(), "redis")).thenReturn(existing);+ StackResource r = resource("AWS::ElastiCache::UserGroup", "Group");++ provisioner.provision(r, props("{\"UserGroupId\":\"MyUsers\",\"Engine\":\"redis\",\"UserIds\":[]}"),+ ctx("myusers"));++ verify(cache, never()).createUserGroup(any(), any(), any(), any());+ verify(cache).setUserGroupMembers("myusers", List.of(), "redis");+ assertEquals("myusers", r.getPhysicalId());+ }+@Testvoid transitEncryptionDoesNotTurnOnIamAuthentication() throws Exception {when(cache.createCacheCluster(any())).thenReturn(new CacheCluster("tls", CacheClusterStatus.AVAILABLE,@@ -349,6 +556,81 @@ class ElastiCacheCfnProvisionerTest {assertNull(r.getAttributes().get("__FlociCacheSubnetGroupUpdateSnapshot"));}+ @Test+ void inPlaceUserUpdateCanBeRolledBackFromSnapshot() throws Exception {+ ElastiCacheUser existing = new ElastiCacheUser("app", "app", AuthMode.PASSWORD, List.of("pw-old"),+ "on ~* +@all", "redis", "active", Instant.now());+ when(cache.getUser("app")).thenReturn(existing);+ ElastiCacheUser modified = new ElastiCacheUser("app", "app", AuthMode.PASSWORD, List.of("pw-new"),+ "off -@all", "redis", "active", Instant.now());+ when(cache.modifyUser(eq("app"), eq(AuthMode.PASSWORD), eq(List.of("pw-new")), eq("off -@all"), any(), eq("redis")))+ .thenReturn(modified);++ StackResource r = resource("AWS::ElastiCache::User", "AppUser");+ provisioner.provision(r, props("""+ {"UserId":"app","UserName":"app","Engine":"redis","AccessString":"off -@all",+ "AuthenticationMode":{"Type":"password","Passwords":["pw-new"]}}+ """), ctx("app"));++ assertTrue(provisioner.rollbackUpdate(r));+ verify(cache).modifyUser("app", AuthMode.PASSWORD, List.of("pw-old"), "on ~* +@all", null, "redis");+ }++ @Test+ void inPlaceUserGroupUpdateCanBeRolledBackFromSnapshot() throws Exception {+ ElastiCacheUserGroup existing = new ElastiCacheUserGroup();+ existing.setUserGroupId("team");+ existing.setEngine("redis");+ existing.setUserIds(new LinkedHashSet<>(List.of("u1", "u2")));+ existing.setArn("arn");+ existing.setStatus("active");+ when(cache.getUserGroup("team")).thenReturn(existing);++ ElastiCacheUserGroup modified = new ElastiCacheUserGroup();+ modified.setUserGroupId("team");+ modified.setEngine("redis");+ modified.setUserIds(new LinkedHashSet<>(List.of("u1", "u3")));+ modified.setArn("arn");+ modified.setStatus("active");+ when(cache.setUserGroupMembers(eq("team"), eq(List.of("u1", "u3")), eq("redis"))).thenReturn(modified);++ StackResource r = resource("AWS::ElastiCache::UserGroup", "Group");+ provisioner.provision(r, props("""+ {"UserGroupId":"team","Engine":"redis","UserIds":["u1","u3"]}+ """), ctx("team"));++ assertTrue(provisioner.rollbackUpdate(r));+ verify(cache).setUserGroupMembers("team", List.of("u1", "u2"), "redis");+ }++ @Test+ void committedUserAndUserGroupUpdateClearsRollbackSnapshots() {+ StackResource rUser = resource("AWS::ElastiCache::User", "User");+ rUser.getAttributes().put("__FlociUserUpdateSnapshot", "snapshot-data");+ rUser.setStatus("UPDATE_COMPLETE");+ provisioner.completeUpdate(rUser);+ assertNull(rUser.getAttributes().get("__FlociUserUpdateSnapshot"));++ StackResource rGroup = resource("AWS::ElastiCache::UserGroup", "Group");+ rGroup.getAttributes().put("__FlociUserGroupUpdateSnapshot", "snapshot-data");+ rGroup.setStatus("UPDATE_COMPLETE");+ provisioner.completeUpdate(rGroup);+ assertNull(rGroup.getAttributes().get("__FlociUserGroupUpdateSnapshot"));+ }++ @Test+ void clearUpdateClearsUserAndUserGroupSnapshots() {+ StackResource rUser = resource("AWS::ElastiCache::User", "User");+ rUser.getAttributes().put("__FlociUserUpdateSnapshot", "snapshot-data");+ provisioner.clearUpdate(rUser);+ assertNull(rUser.getAttributes().get("__FlociUserUpdateSnapshot"));++ StackResource rGroup = resource("AWS::ElastiCache::UserGroup", "Group");+ rGroup.getAttributes().put("__FlociUserGroupUpdateSnapshot", "snapshot-data");+ provisioner.clearUpdate(rGroup);+ assertNull(rGroup.getAttributes().get("__FlociUserGroupUpdateSnapshot"));+ }+@Testvoid clusterDeletedOutsideTheStackIsRecreatedOnUpdate() throws Exception {when(cache.findCacheClusters("app-cache")).thenReturn(List.of());@@ -379,16 +661,32 @@ class ElastiCacheCfnProvisionerTest {verify(cache).deleteCacheSubnetGroup("old-sng");}+ @Test+ void renamedUserGroupReplacesAndDeletesTheOldOne() throws Exception {+ ElastiCacheUserGroup created = new ElastiCacheUserGroup();+ created.setUserGroupId("new-team");+ created.setArn("arn");+ created.setStatus("active");+ when(cache.createUserGroup("new-team", "redis", List.of(), "us-east-1")).thenReturn(created);+ StackResource r = resource("AWS::ElastiCache::UserGroup", "Group");++ provisioner.provision(r, props("{\"UserGroupId\":\"new-team\",\"Engine\":\"redis\",\"UserIds\":[]}"), ctx("old-team"));++ assertTrue(provisioner.hasReplacementUpdate(r));+ provisioner.completeUpdate(r);+ verify(cache).deleteUserGroup("old-team");+ }+@Testvoid deleteToleratesAlreadyDeletedButPropagatesOtherFailures() {- doThrow(new AwsException("CacheSubnetGroupNotFoundFault", "gone", 400))- .when(cache).deleteCacheSubnetGroup("gone");- provisioner.delete("AWS::ElastiCache::SubnetGroup", "gone", "us-east-1");+ doThrow(new AwsException("UserNotFoundFault", "gone", 404))+ .when(cache).deleteUser("gone");+ provisioner.delete("AWS::ElastiCache::User", "gone", "us-east-1");- doThrow(new AwsException("CacheSubnetGroupInUse", "busy", 400))- .when(cache).deleteCacheSubnetGroup("busy");+ doThrow(new AwsException("InvalidUserGroupState", "busy", 400))+ .when(cache).deleteUserGroup("busy");assertThrows(AwsException.class,- () -> provisioner.delete("AWS::ElastiCache::SubnetGroup", "busy", "us-east-1"));+ () -> provisioner.delete("AWS::ElastiCache::UserGroup", "busy", "us-east-1"));}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServiceTest.javaindex 237a803731..cc8688c806 100644--- a/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/elasticache/ElastiCacheServiceTest.java@@ -218,6 +218,42 @@ class ElastiCacheServiceTest {assertThrows(AwsException.class, () -> service.getUserGroup("app-group")).getErrorCode());}+ @Test+ void setUserGroupMembersReplacesCompleteMembershipAndEngine() {+ service.createUser("default-user-id", "default", AuthMode.PASSWORD,+ List.of("default-pass"), "on ~* +@all", null);+ service.createUser("app-user-id", "app", AuthMode.PASSWORD,+ List.of("app-pass"), "on ~* +@all", null);+ service.createUser("extra-user-id", "extra", AuthMode.PASSWORD,+ List.of("extra-pass"), "on ~* +@all", null);+ service.createUserGroup("set-grp", "redis", List.of("default-user-id", "app-user-id"), "us-east-1");++ ElastiCacheUserGroup updated = service.setUserGroupMembers("set-grp",+ List.of("default-user-id", "extra-user-id"), "redis");+ assertEquals(Set.of("default-user-id", "extra-user-id"), updated.getUserIds());+ assertEquals("redis", updated.getEngine());++ ElastiCacheUserGroup fetched = service.getUserGroup("set-grp");+ assertEquals(Set.of("default-user-id", "extra-user-id"), fetched.getUserIds());+ }++ @Test+ void setUserGroupMembersRejectsInvalidEngineOrMissingDefaultUserForRedis() {+ service.createUser("default-user-id", "default", AuthMode.PASSWORD,+ List.of("default-pass"), "on ~* +@all", null);+ service.createUser("app-user-id", "app", AuthMode.PASSWORD,+ List.of("app-pass"), "on ~* +@all", null);+ service.createUserGroup("val-grp", "redis", List.of("default-user-id"), "us-east-1");++ AwsException exMissing = assertThrows(AwsException.class,+ () -> service.setUserGroupMembers("val-grp", List.of("app-user-id"), "redis"));+ assertEquals("DefaultUserRequired", exMissing.getErrorCode());++ AwsException exEngine = assertThrows(AwsException.class,+ () -> service.setUserGroupMembers("val-grp", List.of("default-user-id"), "unknown"));+ assertEquals("InvalidParameterValue", exEngine.getErrorCode());+ }+@Testvoid userGroupNeedsInTransitEncryptionOnTheReplicationGroup() {service.createReplicationGroup("open", "test", AuthMode.NO_AUTH, null, "us-east-1");diff --git a/src/test/java/io/github/hectorvent/floci/services/elasticache/UserAuthenticationTest.java b/src/test/java/io/github/hectorvent/floci/services/elasticache/UserAuthenticationTest.javanew file mode 100644index 0000000000..69082d1bcd--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/elasticache/UserAuthenticationTest.java@@ -0,0 +1,60 @@+package io.github.hectorvent.floci.services.elasticache;++import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.elasticache.model.AuthMode;+import org.junit.jupiter.api.Test;++import java.util.List;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;++class UserAuthenticationTest {++ @Test+ void nothingGivenResolvesToNull() {+ assertNull(UserAuthentication.resolve(null, List.of(), false));+ }++ @Test+ void passwordsWithoutTypeMeanPasswordAuthentication() {+ UserAuthentication auth = UserAuthentication.resolve(null, List.of("p"), false);+ assertEquals(AuthMode.PASSWORD, auth.mode());+ assertEquals(List.of("p"), auth.passwords());+ }++ @Test+ void noPasswordRequiredWithoutTypeMeansNoAuth() {+ assertEquals(AuthMode.NO_AUTH, UserAuthentication.resolve(null, List.of(), true).mode());+ }++ @Test+ void typeIsMatchedCaseInsensitively() {+ assertEquals(AuthMode.IAM, UserAuthentication.resolve("IAM", List.of(), false).mode());+ assertEquals(AuthMode.NO_AUTH, UserAuthentication.resolve("No-Password-Required", List.of(), false).mode());+ }++ @Test+ void passwordTypeWithoutPasswordsIsRejected() {+ AwsException e = assertThrows(AwsException.class,+ () -> UserAuthentication.resolve("password", List.of(), false));+ assertEquals("InvalidParameterValue", e.getErrorCode());+ }++ @Test+ void conflictingInputsAreRejected() {+ assertEquals("InvalidParameterCombination", assertThrows(AwsException.class,+ () -> UserAuthentication.resolve(null, List.of("p"), true)).getErrorCode());+ assertEquals("InvalidParameterCombination", assertThrows(AwsException.class,+ () -> UserAuthentication.resolve("password", List.of("p"), true)).getErrorCode());+ assertEquals("InvalidParameterCombination", assertThrows(AwsException.class,+ () -> UserAuthentication.resolve("iam", List.of("p"), false)).getErrorCode());+ }++ @Test+ void unknownTypeIsRejected() {+ assertEquals("InvalidParameterValue", assertThrows(AwsException.class,+ () -> UserAuthentication.resolve("kerberos", List.of(), false)).getErrorCode());+ }+}diff --git a/src/test/resources/cloudformation/supported-resource-types.tsv b/src/test/resources/cloudformation/supported-resource-types.tsvindex e9e475ac0b..0ed1f75d55 100644--- a/src/test/resources/cloudformation/supported-resource-types.tsv+++ b/src/test/resources/cloudformation/supported-resource-types.tsv@@ -92,6 +92,8 @@ AWS::EKS::Cluster EksCfnProvisionerAWS::EKS::Nodegroup EksCfnProvisionerAWS::ElastiCache::CacheCluster ElastiCacheCfnProvisionerAWS::ElastiCache::SubnetGroup ElastiCacheCfnProvisioner+AWS::ElastiCache::User ElastiCacheCfnProvisioner+AWS::ElastiCache::UserGroup ElastiCacheCfnProvisionerAWS::ElasticLoadBalancingV2::Listener ElbV2CfnProvisionerAWS::ElasticLoadBalancingV2::ListenerRule ElbV2CfnProvisionerAWS::ElasticLoadBalancingV2::LoadBalancer ElbV2CfnProvisionerdiff --git a/tools/docs/cfn_resource_types.yaml b/tools/docs/cfn_resource_types.yamlindex 8284295185..9d347bc821 100644--- a/tools/docs/cfn_resource_types.yaml+++ b/tools/docs/cfn_resource_types.yaml@@ -87,7 +87,7 @@ type_order:AWS::RDS:[DBInstance, DBCluster, DBSubnetGroup, DBParameterGroup, DBClusterParameterGroup]AWS::ElastiCache:- [CacheCluster, SubnetGroup]+ [CacheCluster, SubnetGroup, User, UserGroup]AWS::Redshift:[Cluster, ClusterParameterGroup, ClusterSubnetGroup, ClusterSecurityGroup]AWS::RedshiftServerless:@@ -174,6 +174,8 @@ notes:AWS::RDS::DBInstance: starts a real containerAWS::RDS::DBCluster: starts a real containerAWS::ElastiCache::CacheCluster: 'starts a real container; modifying an existing cluster in place is not supported'+ AWS::ElastiCache::User: Tags are ignored+ AWS::ElastiCache::UserGroup: Tags are ignoredAWS::Redshift::ClusterSecurityGroup: accepted; no EC2-Classic security group modelAWS::Redshift::Cluster: single-node container; Port and non-dev DBName ignored; ManageMasterPassword unsupportedAWS::RedshiftServerless::Namespace: 'ManageAdminPassword is accepted and not applied; GetAtt uses the dotted Namespace.* form'