Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cloudformation): delete AWS::IAM::User on stack deletion (#3076)
Vũ Thế Huy7b5c6e272db9
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationIamUserTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationIamUserTest.javanew file mode 100644index 0000000000..67cff63f5c--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationIamUserTest.java@@ -0,0 +1,171 @@+package com.floci.test;++import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.cloudformation.CloudFormationClient;+import software.amazon.awssdk.services.cloudformation.model.CloudFormationException;+import software.amazon.awssdk.services.cloudformation.model.CreateStackRequest;+import software.amazon.awssdk.services.cloudformation.model.DeleteStackRequest;+import software.amazon.awssdk.services.cloudformation.model.DescribeStacksRequest;+import software.amazon.awssdk.services.cloudformation.model.Output;+import software.amazon.awssdk.services.cloudformation.model.Stack;+import software.amazon.awssdk.services.iam.IamClient;+import software.amazon.awssdk.services.iam.model.DeleteUserRequest;+import software.amazon.awssdk.services.iam.model.GetUserRequest;+import software.amazon.awssdk.services.iam.model.GetUserResponse;+import software.amazon.awssdk.services.iam.model.NoSuchEntityException;+import software.amazon.awssdk.services.iam.model.User;++import java.util.List;+import java.util.Map;+import java.util.logging.Level;+import java.util.logging.Logger;+import java.util.stream.Collectors;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++@DisplayName("CloudFormation AWS::IAM::User")+class CloudFormationIamUserTest {++ private static final Logger LOG = Logger.getLogger(CloudFormationIamUserTest.class.getName());++ private static CloudFormationClient cloudFormation;+ private static IamClient iam;+ private static String stackName;+ private static String userName;++ @BeforeAll+ static void setup() {+ cloudFormation = TestFixtures.cloudFormationClient();+ iam = TestFixtures.iamClient();+ stackName = TestFixtures.uniqueName("compat-cfn-iam-user");+ userName = TestFixtures.uniqueName("compat-user");+ }++ @AfterAll+ static void cleanup() {+ if (cloudFormation != null) {+ try {+ cloudFormation.deleteStack(+ DeleteStackRequest.builder().stackName(stackName).build());+ } catch (Exception e) {+ LOG.log(Level.WARNING, "Failed to delete CloudFormation IAM user test stack: " + stackName, e);+ }+ cloudFormation.close();+ }+ if (iam != null) {+ try {+ iam.deleteUser(DeleteUserRequest.builder().userName(userName).build());+ } catch (Exception e) {+ LOG.log(Level.WARNING, "Failed to delete IAM user directly during cleanup: " + userName, e);+ }+ iam.close();+ }+ }++ @Test+ void createsValidatesUpdatesAndDeletesIamUserThroughAwsSdk() throws InterruptedException {+ cloudFormation.createStack(CreateStackRequest.builder()+ .stackName(stackName)+ .templateBody(template(userName, "/initial/"))+ .build());+ assertThat(waitForTerminal(stackName, 30)).isEqualTo("CREATE_COMPLETE");++ Stack createdStack = cloudFormation.describeStacks(+ DescribeStacksRequest.builder().stackName(stackName).build())+ .stacks().get(0);+ Map<String, String> outputs = createdStack.outputs().stream()+ .collect(Collectors.toMap(Output::outputKey, Output::outputValue));++ assertThat(outputs).containsEntry("UserRef", userName);+ String userArn = outputs.get("UserArn");+ assertThat(userArn).startsWith("arn:aws:iam::").endsWith(":user/initial/" + userName);++ GetUserResponse userResponse = iam.getUser(GetUserRequest.builder().userName(userName).build());+ User user = userResponse.user();+ assertThat(user.userName()).isEqualTo(userName);+ assertThat(user.path()).isEqualTo("/initial/");+ assertThat(user.arn()).isEqualTo(userArn);+ String userId = user.userId();+ assertThat(userId).startsWith("AIDA");++ // Update path on existing user+ cloudFormation.updateStack(r -> r+ .stackName(stackName)+ .templateBody(template(userName, "/updated/")));+ assertThat(waitForTerminal(stackName, 30)).isEqualTo("UPDATE_COMPLETE");++ GetUserResponse updatedUserResponse = iam.getUser(GetUserRequest.builder().userName(userName).build());+ assertThat(updatedUserResponse.user().path()).isEqualTo("/updated/");+ assertThat(updatedUserResponse.user().userId()).isEqualTo(userId);++ // Delete stack and verify user is removed+ cloudFormation.deleteStack(DeleteStackRequest.builder().stackName(stackName).build());+ waitForDeleted(stackName, 30);++ assertThatThrownBy(() -> iam.getUser(GetUserRequest.builder().userName(userName).build()))+ .isInstanceOf(NoSuchEntityException.class);+ }++ private static String template(String name, String path) {+ return """+ {+ "Resources": {+ "AppUser": {+ "Type": "AWS::IAM::User",+ "Properties": {+ "UserName": "%s",+ "Path": "%s"+ }+ }+ },+ "Outputs": {+ "UserRef": {"Value": {"Ref": "AppUser"}},+ "UserArn": {"Value": {"Fn::GetAtt": ["AppUser", "Arn"]}}+ }+ }+ """.formatted(name, path);+ }++ private static String waitForTerminal(String name, int maxSeconds) throws InterruptedException {+ long deadline = System.currentTimeMillis() + maxSeconds * 1000L;+ while (System.currentTimeMillis() < deadline) {+ List<Stack> stacks = cloudFormation.describeStacks(+ DescribeStacksRequest.builder().stackName(name).build()).stacks();+ if (!stacks.isEmpty()) {+ String status = stacks.get(0).stackStatusAsString();+ if (!status.endsWith("_IN_PROGRESS")) {+ return status;+ }+ }+ Thread.sleep(500);+ }+ throw new AssertionError(+ "Stack " + name + " did not reach a terminal state within " + maxSeconds + "s");+ }++ private static void waitForDeleted(String name, int maxSeconds) throws InterruptedException {+ long deadline = System.currentTimeMillis() + maxSeconds * 1000L;+ while (System.currentTimeMillis() < deadline) {+ try {+ List<Stack> stacks = cloudFormation.describeStacks(+ DescribeStacksRequest.builder().stackName(name).build()).stacks();+ if (stacks.isEmpty()+ || "DELETE_COMPLETE".equals(stacks.get(0).stackStatusAsString())) {+ return;+ }+ } catch (CloudFormationException e) {+ if (e.getMessage() != null && e.getMessage().contains("does not exist")) {+ return;+ }+ throw e;+ }+ Thread.sleep(500);+ }+ throw new AssertionError(+ "Stack " + name + " was not deleted within " + maxSeconds + "s");+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.javaindex b1da5d2020..cec665961f 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java@@ -239,7 +239,6 @@ public class CloudFormationResourceProvisioner {"AWS::IAM::InstanceProfile","AWS::IAM::ManagedPolicy","AWS::IAM::Policy",- "AWS::IAM::User","AWS::Lambda::Function","AWS::Lambda::LayerVersion","AWS::RDS::DBCluster",@@ -399,7 +398,6 @@ public class CloudFormationResourceProvisioner {case "AWS::Lambda::Function" -> provisionLambda(resource, properties, engine, region, accountId, stackName);case "AWS::Lambda::LayerVersion" ->provisionLambdaLayerVersion(resource, properties, engine, region, stackName);- case "AWS::IAM::User" -> provisionIamUser(resource, properties, engine, stackName);case "AWS::IAM::AccessKey" -> provisionIamAccessKey(resource, properties, engine);case "AWS::IAM::Policy" -> provisionIamInlinePolicy(resource, properties, engine, stackName);case "AWS::IAM::ManagedPolicy" ->@@ -4772,17 +4770,6 @@ public class CloudFormationResourceProvisioner {// ── Helpers ───────────────────────────────────────────────────────────────- private void provisionIamUser(StackResource r, JsonNode props, CloudFormationTemplateEngine engine,- String stackName) {- String userName = resolveOptional(props, "UserName", engine);- if (userName == null || userName.isBlank()) {- userName = generatePhysicalName(stackName, r.getLogicalId(), 64, false);- }- var user = iamService.createUser(userName, "/");- r.setPhysicalId(userName);- r.getAttributes().put("Arn", user.getArn());- }-private void provisionIamAccessKey(StackResource r, JsonNode props, CloudFormationTemplateEngine engine) {String userName = resolveOptional(props, "UserName", engine);if (userName != null) {diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamUserCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamUserCfnProvisioner.javanew file mode 100644index 0000000000..39edba43e6--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamUserCfnProvisioner.java@@ -0,0 +1,320 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.databind.JsonNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.iam.IamService;+import io.github.hectorvent.floci.services.iam.model.AccessKey;+import io.github.hectorvent.floci.services.iam.model.IamUser;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.util.ArrayList;+import java.util.Collection;+import java.util.Collections;+import java.util.HashMap;+import java.util.HashSet;+import java.util.LinkedHashSet;+import java.util.List;+import java.util.Map;+import java.util.Set;++/**+ * CloudFormation provisioning for {@code AWS::IAM::User}, moved out of the+ * {@code CloudFormationResourceProvisioner} switch.+ */+@ApplicationScoped+public class IamUserCfnProvisioner implements CfnResourceProvisioner {++ private static final Logger LOG = Logger.getLogger(IamUserCfnProvisioner.class);++ private static final String INLINE_NAMES_ATTR = "__FlociInlinePolicyNames";+ private static final String MANAGED_ARNS_ATTR = "__FlociManagedPolicyArns";+ private static final String GROUPS_ATTR = "__FlociGroups";+ private static final String USER_ID_ATTR = "__FlociUserId";++ private final IamService iamService;++ @Inject+ public IamUserCfnProvisioner(IamService iamService) {+ this.iamService = iamService;+ }++ @Override+ public Set<String> resourceTypes() {+ return Set.of("AWS::IAM::User");+ }++ @Override+ public void provision(StackResource r, JsonNode props, ProvisionContext ctx) {+ String userName = ctx.stablePhysicalName(ctx.resolveOptional(props, "UserName"),+ r.getLogicalId(), 64, false);+ final String resolvedUserName = userName;+ if (ctx.isUpdate() && !ctx.priorPhysicalId().equals(resolvedUserName)) {+ throw new AwsException("ValidationError",+ "Updating UserName requires resource replacement, which is not supported.", 400);+ }++ String path = ctx.resolveOptional(props, "Path");+ if (path == null) {+ path = "/";+ }+ final String resolvedPath = path;++ List<String> managedPolicyArns = ctx.resolveStringList(props, "ManagedPolicyArns");+ List<String> groups = ctx.resolveStringList(props, "Groups");++ IamUser user;+ boolean createdUser = false;+ String priorPath = null;+ String priorUserId = null;+ try {+ user = iamService.createUser(resolvedUserName, resolvedPath);+ createdUser = true;+ r.getAttributes().put(CfnRollback.ROLLBACK_OWNED_ATTR, "true");+ } catch (AwsException e) {+ if (!ctx.reusesPriorEntity(resolvedUserName) || !"EntityAlreadyExists".equals(e.getErrorCode())) {+ throw e;+ }+ user = iamService.getUser(resolvedUserName);+ String existingUserId = r.getAttributes().get(USER_ID_ATTR);+ if (existingUserId == null || existingUserId.isBlank()+ || !existingUserId.equals(user.getUserId())) {+ r.getAttributes().remove(CfnRollback.ROLLBACK_OWNED_ATTR);+ throw e;+ }+ priorPath = user.getPath();+ priorUserId = existingUserId;+ if (!resolvedPath.equals(user.getPath())) {+ iamService.updateUser(resolvedUserName, null, resolvedPath, existingUserId);+ user = iamService.getUser(resolvedUserName);+ }+ }++ r.setPhysicalId(resolvedUserName);+ r.getAttributes().put("Arn", user.getArn());+ r.getAttributes().put(USER_ID_ATTR, user.getUserId());++ Set<String> previousInlineNames = readTrackedSet(r, INLINE_NAMES_ATTR);+ Set<String> previousManagedArns = readTrackedSet(r, MANAGED_ARNS_ATTR);+ Set<String> previousGroups = readTrackedSet(r, GROUPS_ATTR);++ Set<String> originalGroups = new HashSet<>(user.getGroupNames());+ Set<String> originalPolicyArns = new HashSet<>(user.getAttachedPolicyArns());+ Map<String, String> originalInlinePolicies = new HashMap<>(user.getInlinePolicies());++ LinkedHashSet<String> groupsAddedByThisAttempt = new LinkedHashSet<>();+ LinkedHashSet<String> groupsRemovedByThisAttempt = new LinkedHashSet<>();+ LinkedHashSet<String> attachedByThisAttempt = new LinkedHashSet<>();+ LinkedHashSet<String> detachedByThisAttempt = new LinkedHashSet<>();+ LinkedHashSet<String> inlineWrittenByThisAttempt = new LinkedHashSet<>();+ LinkedHashSet<String> inlineRemovedByThisAttempt = new LinkedHashSet<>();++ final String pathToRestore = priorPath;+ final String userIdToRestore = priorUserId;++ try {+ for (String groupName : groups) {+ iamService.addUserToGroup(groupName, resolvedUserName);+ if (!originalGroups.contains(groupName)) {+ groupsAddedByThisAttempt.add(groupName);+ }+ }++ for (String policyArn : managedPolicyArns) {+ iamService.attachUserPolicy(resolvedUserName, policyArn);+ if (!originalPolicyArns.contains(policyArn)) {+ attachedByThisAttempt.add(policyArn);+ }+ }++ if (props != null && props.has("Policies")) {+ for (JsonNode policy : props.get("Policies")) {+ String declaredName = ctx.resolveOptional(policy, "PolicyName");+ if (declaredName == null || declaredName.isBlank()) {+ throw new AwsException("ValidationError",+ "An inline policy on user " + resolvedUserName + " has no PolicyName.", 400);+ }+ final String policyName = declaredName;+ JsonNode document = policy.get("PolicyDocument");+ if (document == null || document.isNull()) {+ throw new AwsException("ValidationError",+ "Inline policy '" + policyName + "' on user " + resolvedUserName+ + " has no PolicyDocument.", 400);+ }+ iamService.putUserPolicy(resolvedUserName, policyName,+ ctx.engine().resolveJsonAttribute(document));+ inlineWrittenByThisAttempt.add(policyName);+ }+ }++ for (String stale : previousInlineNames) {+ if (!inlineWrittenByThisAttempt.contains(stale)+ && originalInlinePolicies.containsKey(stale)) {+ iamService.deleteUserPolicy(resolvedUserName, stale);+ inlineRemovedByThisAttempt.add(stale);+ }+ }+ for (String stale : previousManagedArns) {+ if (!managedPolicyArns.contains(stale) && originalPolicyArns.contains(stale)) {+ iamService.detachUserPolicy(resolvedUserName, stale);+ detachedByThisAttempt.add(stale);+ }+ }+ for (String stale : previousGroups) {+ if (!groups.contains(stale) && originalGroups.contains(stale)) {+ iamService.removeUserFromGroup(stale, resolvedUserName);+ groupsRemovedByThisAttempt.add(stale);+ }+ }+ } catch (RuntimeException failure) {+ boolean cleanupSucceeded = true;++ for (String groupName : groupsRemovedByThisAttempt) {+ if (!CfnRollback.attemptIamCleanup(failure,+ "re-add user " + resolvedUserName + " to group " + groupName,+ () -> iamService.addUserToGroup(groupName, resolvedUserName))) {+ cleanupSucceeded = false;+ }+ }+ for (String policyName : inlineRemovedByThisAttempt) {+ String prior = originalInlinePolicies.get(policyName);+ if (prior == null) {+ continue;+ }+ if (!CfnRollback.attemptIamCleanup(failure,+ "restore inline policy " + policyName + " on user " + resolvedUserName,+ () -> iamService.putUserPolicy(resolvedUserName, policyName, prior))) {+ cleanupSucceeded = false;+ }+ }+ for (String policyArn : detachedByThisAttempt) {+ if (!CfnRollback.attemptIamCleanup(failure,+ "reattach policy " + policyArn + " to user " + resolvedUserName,+ () -> iamService.attachUserPolicy(resolvedUserName, policyArn))) {+ cleanupSucceeded = false;+ }+ }++ List<String> inlineRollback = new ArrayList<>(inlineWrittenByThisAttempt);+ Collections.reverse(inlineRollback);+ for (String policyName : inlineRollback) {+ String prior = originalInlinePolicies.get(policyName);+ String cleanupDescription = (prior == null ? "remove" : "restore")+ + " inline policy " + policyName + " on user " + resolvedUserName;+ if (!CfnRollback.attemptIamCleanup(failure, cleanupDescription, () -> {+ if (prior == null) {+ iamService.deleteUserPolicy(resolvedUserName, policyName);+ } else {+ iamService.putUserPolicy(resolvedUserName, policyName, prior);+ }+ })) {+ cleanupSucceeded = false;+ }+ }++ List<String> rollbackArns = new ArrayList<>(attachedByThisAttempt);+ Collections.reverse(rollbackArns);+ for (String policyArn : rollbackArns) {+ String cleanupDescription = "detach policy " + policyArn + " from user " + resolvedUserName;+ if (!CfnRollback.attemptIamCleanup(failure, cleanupDescription,+ () -> iamService.detachUserPolicy(resolvedUserName, policyArn))) {+ cleanupSucceeded = false;+ }+ }++ List<String> rollbackGroups = new ArrayList<>(groupsAddedByThisAttempt);+ Collections.reverse(rollbackGroups);+ for (String groupName : rollbackGroups) {+ String cleanupDescription = "remove user " + resolvedUserName + " from group " + groupName;+ if (!CfnRollback.attemptIamCleanup(failure, cleanupDescription,+ () -> iamService.removeUserFromGroup(groupName, resolvedUserName))) {+ cleanupSucceeded = false;+ }+ }++ if (pathToRestore != null) {+ if (!CfnRollback.attemptIamCleanup(failure, "restore prior path on user " + resolvedUserName,+ () -> iamService.updateUser(resolvedUserName, null, pathToRestore, userIdToRestore))) {+ cleanupSucceeded = false;+ }+ }++ if (createdUser) {+ if (!CfnRollback.attemptIamCleanup(failure, "delete user " + resolvedUserName,+ () -> iamService.deleteUser(resolvedUserName))) {+ cleanupSucceeded = false;+ }+ if (cleanupSucceeded) {+ r.getAttributes().remove(CfnRollback.ROLLBACK_OWNED_ATTR);+ }+ }+ throw failure;+ }++ writeTrackedSet(r, INLINE_NAMES_ATTR, inlineWrittenByThisAttempt);+ writeTrackedSet(r, MANAGED_ARNS_ATTR, managedPolicyArns);+ writeTrackedSet(r, GROUPS_ATTR, groups);+ }++ private static Set<String> readTrackedSet(StackResource r, String attribute) {+ String raw = r.getAttributes().get(attribute);+ if (raw == null || raw.isEmpty()) {+ return Set.of();+ }+ return new LinkedHashSet<>(List.of(raw.split("\n")));+ }++ private static void writeTrackedSet(StackResource r, String attribute, Collection<String> values) {+ if (values.isEmpty()) {+ r.getAttributes().remove(attribute);+ return;+ }+ r.getAttributes().put(attribute, String.join("\n", values));+ }++ @Override+ public void delete(String resourceType, String physicalId, String region) {+ IamUser user;+ try {+ user = iamService.getUser(physicalId);+ } catch (AwsException e) {+ if (!"NoSuchEntity".equals(e.getErrorCode())) {+ throw e;+ }+ LOG.debugv("IAM user already gone, treating as deleted: {0}", physicalId);+ return;+ }++ for (String policyArn : new ArrayList<>(user.getAttachedPolicyArns())) {+ CfnDeletes.safeDelete("attached policy " + policyArn + " on user", physicalId,+ () -> iamService.detachUserPolicy(physicalId, policyArn), "NoSuchEntity");+ }++ for (String policyName : new ArrayList<>(user.getInlinePolicies().keySet())) {+ CfnDeletes.safeDelete("inline policy " + policyName + " on user", physicalId,+ () -> iamService.deleteUserPolicy(physicalId, policyName), "NoSuchEntity");+ }++ for (String groupName : new ArrayList<>(user.getGroupNames())) {+ CfnDeletes.safeDelete("user " + physicalId + " membership in group " + groupName, physicalId,+ () -> iamService.removeUserFromGroup(groupName, physicalId), "NoSuchEntity");+ }++ try {+ for (AccessKey key : iamService.listAccessKeys(physicalId)) {+ CfnDeletes.safeDelete("access key " + key.getAccessKeyId() + " on user", physicalId,+ () -> iamService.deleteAccessKey(physicalId, key.getAccessKeyId()), "NoSuchEntity");+ }+ } catch (AwsException e) {+ if (!"NoSuchEntity".equals(e.getErrorCode())) {+ throw e;+ }+ LOG.debugv("IAM user access keys already gone, treating as deleted: {0}", physicalId);+ }++ CfnDeletes.safeDelete("IAM user", physicalId,+ () -> iamService.deleteUser(physicalId), "NoSuchEntity");+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamService.javaindex 1b80a32ef2..e9c797c6d8 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java@@ -395,7 +395,21 @@ public class IamService implements SessionAccountLookup, ResourceProvider {}public void updateUser(String userName, String newUserName, String newPath) {+ updateUser(userName, newUserName, newPath, null);+ }++ /**+ * Same as {@link #updateUser(String, String, String)}, but verifies {@code expectedUserId}+ * against the resolved user's immutable ID before applying the update, atomically with the+ * name-based lookup.+ */+ public void updateUser(String userName, String newUserName, String newPath, String expectedUserId) {IamUser user = getUser(userName);+ if (expectedUserId != null && !expectedUserId.equals(user.getUserId())) {+ throw new AwsException("EntityAlreadyExists",+ "User " + userName + " was replaced by a different user of the same name; "+ + "refusing to apply an update meant for the original user.", 409);+ }if (newUserName != null && !newUserName.equals(userName)) {if (users.get(newUserName).isPresent()) {throw new AwsException("EntityAlreadyExists",diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.javaindex 64c583470b..697f5570e8 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java@@ -39,6 +39,7 @@ import io.github.hectorvent.floci.services.cloudformation.provisioners.EcsCapaciimport io.github.hectorvent.floci.services.cloudformation.provisioners.EcsCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.FirehoseCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.IamRoleCfnProvisioner;+import io.github.hectorvent.floci.services.cloudformation.provisioners.IamUserCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.IotDomainConfigurationCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.KinesisCfnProvisioner;@@ -233,6 +234,7 @@ final class CfnProvisionerFixture {}if (iamService != null) {discovered.add(new IamRoleCfnProvisioner(iamService));+ discovered.add(new IamUserCfnProvisioner(iamService));}if (ecsService != null) {discovered.add(new EcsCapacityCfnProvisioner(ecsService));diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIamUserIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIamUserIntegrationTest.javanew file mode 100644index 0000000000..4a8f05aaab--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIamUserIntegrationTest.java@@ -0,0 +1,361 @@+package io.github.hectorvent.floci.services.cloudformation;++import io.github.hectorvent.floci.core.common.XmlParser;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.Response;+import org.junit.jupiter.api.Test;++import static io.restassured.RestAssured.given;+import static org.hamcrest.MatcherAssert.assertThat;+import static org.hamcrest.Matchers.containsString;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.junit.jupiter.api.Assertions.fail;++/**+ * Verifies CloudFormation provisioning and deprovisioning lifecycle for {@code AWS::IAM::User}+ * (regression test for issue #2490).+ */+@QuarkusTest+class CloudFormationIamUserIntegrationTest {++ private static final String CFN_AUTH =+ "AWS4-HMAC-SHA256 Credential=111122223333/20260205/us-east-1/cloudformation/aws4_request";+ private static final String IAM_AUTH =+ "AWS4-HMAC-SHA256 Credential=111122223333/20260205/us-east-1/iam/aws4_request";++ @Test+ void deleteStackDeletesIamUserAndAllowsRecreation() throws InterruptedException {+ String suffix = Long.toString(System.nanoTime(), 36);+ String userName = "probe-user-" + suffix;+ String stackName = "cfn-user-stack-" + suffix;++ String template = """+ {+ "Resources": {+ "ProbeUser": {+ "Type": "AWS::IAM::User",+ "Properties": {+ "UserName": "%s"+ }+ }+ },+ "Outputs": {+ "UserRef": {"Value": {"Ref": "ProbeUser"}},+ "UserArn": {"Value": {"Fn::GetAtt": ["ProbeUser", "Arn"]}}+ }+ }+ """.formatted(userName);++ String stackId = createStack(stackName, template);+ awaitStackStatus(stackId, "CREATE_COMPLETE");++ String stackXml = describeStacks(stackId);+ assertEquals(userName, outputValue(stackXml, "UserRef"));+ String expectedArn = "arn:aws:iam::111122223333:user/" + userName;+ assertEquals(expectedArn, outputValue(stackXml, "UserArn"));++ // Verify IAM user exists and Arn matches+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", IAM_AUTH)+ .formParam("Action", "GetUser")+ .formParam("UserName", userName)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("<UserName>" + userName + "</UserName>"))+ .body(containsString("<Arn>" + expectedArn + "</Arn>"));++ // Delete the stack+ deleteStack(stackName);+ awaitStackStatus(stackId, "DELETE_COMPLETE");++ // Verify IAM user is gone (NoSuchEntity / 404)+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", IAM_AUTH)+ .formParam("Action", "GetUser")+ .formParam("UserName", userName)+ .when()+ .post("/")+ .then()+ .statusCode(404)+ .body(containsString("NoSuchEntity"));++ // Redeploying with the same explicit UserName succeeds rather than failing with EntityAlreadyExists+ String newStackName = "cfn-user-stack-recreate-" + suffix;+ String newStackId = createStack(newStackName, template);+ awaitStackStatus(newStackId, "CREATE_COMPLETE");++ deleteStack(newStackName);+ awaitStackStatus(newStackId, "DELETE_COMPLETE");+ }++ @Test+ void deleteStackDeletesUserWithGeneratedName() throws InterruptedException {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "cfn-genuser-stack-" + suffix;++ String template = """+ {+ "Resources": {+ "GenUser": {+ "Type": "AWS::IAM::User"+ }+ },+ "Outputs": {+ "UserRef": {"Value": {"Ref": "GenUser"}},+ "UserArn": {"Value": {"Fn::GetAtt": ["GenUser", "Arn"]}}+ }+ }+ """;++ String stackId = createStack(stackName, template);+ awaitStackStatus(stackId, "CREATE_COMPLETE");++ String stackXml = describeStacks(stackId);+ String generatedUserName = outputValue(stackXml, "UserRef");+ assertNotNull(generatedUserName);+ assertEquals("arn:aws:iam::111122223333:user/" + generatedUserName, outputValue(stackXml, "UserArn"));++ // Verify generated user exists+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", IAM_AUTH)+ .formParam("Action", "GetUser")+ .formParam("UserName", generatedUserName)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("<UserName>" + generatedUserName + "</UserName>"))+ .body(containsString("<Arn>arn:aws:iam::111122223333:user/" + generatedUserName + "</Arn>"));++ deleteStack(stackName);+ awaitStackStatus(stackId, "DELETE_COMPLETE");++ // Verify generated user is deleted+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", IAM_AUTH)+ .formParam("Action", "GetUser")+ .formParam("UserName", generatedUserName)+ .when()+ .post("/")+ .then()+ .statusCode(404)+ .body(containsString("NoSuchEntity"));+ }++ @Test+ void updateStackReconcilesGroupsPoliciesAndPath() throws InterruptedException {+ String suffix = Long.toString(System.nanoTime(), 36);+ String userName = "update-user-" + suffix;+ String stackName = "cfn-update-user-stack-" + suffix;++ // Pre-create two groups+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", IAM_AUTH)+ .formParam("Action", "CreateGroup")+ .formParam("GroupName", "group-a-" + suffix)+ .when().post("/").then().statusCode(200);++ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", IAM_AUTH)+ .formParam("Action", "CreateGroup")+ .formParam("GroupName", "group-b-" + suffix)+ .when().post("/").then().statusCode(200);++ String template1 = """+ {+ "Resources": {+ "TestUser": {+ "Type": "AWS::IAM::User",+ "Properties": {+ "UserName": "%s",+ "Path": "/initial/",+ "Groups": ["group-a-%s", "group-b-%s"],+ "ManagedPolicyArns": [+ "arn:aws:iam::aws:policy/ReadOnlyAccess",+ "arn:aws:iam::aws:policy/PowerUserAccess"+ ],+ "Policies": [+ {+ "PolicyName": "keep-policy",+ "PolicyDocument": {"Version": "2012-10-17", "Statement": []}+ },+ {+ "PolicyName": "drop-policy",+ "PolicyDocument": {"Version": "2012-10-17", "Statement": []}+ }+ ]+ }+ }+ }+ }+ """.formatted(userName, suffix, suffix);++ String stackId = createStack(stackName, template1);+ awaitStackStatus(stackId, "CREATE_COMPLETE");++ // Verify initial state+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", IAM_AUTH)+ .formParam("Action", "GetUser")+ .formParam("UserName", userName)+ .when().post("/").then().statusCode(200)+ .body(containsString("<Path>/initial/</Path>"));++ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", IAM_AUTH)+ .formParam("Action", "ListAttachedUserPolicies")+ .formParam("UserName", userName)+ .when().post("/").then().statusCode(200)+ .body(containsString("ReadOnlyAccess"))+ .body(containsString("PowerUserAccess"));++ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", IAM_AUTH)+ .formParam("Action", "ListUserPolicies")+ .formParam("UserName", userName)+ .when().post("/").then().statusCode(200)+ .body(containsString("<member>keep-policy</member>"))+ .body(containsString("<member>drop-policy</member>"));++ // Update stack: change path to /updated/, drop group-b, drop PowerUserAccess, drop drop-policy+ String template2 = """+ {+ "Resources": {+ "TestUser": {+ "Type": "AWS::IAM::User",+ "Properties": {+ "UserName": "%s",+ "Path": "/updated/",+ "Groups": ["group-a-%s"],+ "ManagedPolicyArns": [+ "arn:aws:iam::aws:policy/ReadOnlyAccess"+ ],+ "Policies": [+ {+ "PolicyName": "keep-policy",+ "PolicyDocument": {"Version": "2012-10-17", "Statement": []}+ }+ ]+ }+ }+ }+ }+ """.formatted(userName, suffix);++ updateStack(stackName, template2);+ awaitStackStatus(stackId, "UPDATE_COMPLETE");++ // Verify updated path+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", IAM_AUTH)+ .formParam("Action", "GetUser")+ .formParam("UserName", userName)+ .when().post("/").then().statusCode(200)+ .body(containsString("<Path>/updated/</Path>"));++ // Verify managed policy PowerUserAccess was detached+ String attachedPolicies = given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", IAM_AUTH)+ .formParam("Action", "ListAttachedUserPolicies")+ .formParam("UserName", userName)+ .when().post("/").then().statusCode(200).extract().asString();+ assertThat(attachedPolicies, containsString("ReadOnlyAccess"));+ assertThat(attachedPolicies, org.hamcrest.Matchers.not(containsString("PowerUserAccess")));++ // Verify drop-policy was deleted+ String inlinePolicies = given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", IAM_AUTH)+ .formParam("Action", "ListUserPolicies")+ .formParam("UserName", userName)+ .when().post("/").then().statusCode(200).extract().asString();+ assertThat(inlinePolicies, containsString("<member>keep-policy</member>"));+ assertThat(inlinePolicies, org.hamcrest.Matchers.not(containsString("<member>drop-policy</member>")));++ // Verify group-b was removed+ String userGroups = given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", IAM_AUTH)+ .formParam("Action", "ListGroupsForUser")+ .formParam("UserName", userName)+ .when().post("/").then().statusCode(200).extract().asString();+ assertThat(userGroups, containsString("group-a-" + suffix));+ assertThat(userGroups, org.hamcrest.Matchers.not(containsString("group-b-" + suffix)));++ deleteStack(stackName);+ awaitStackStatus(stackId, "DELETE_COMPLETE");+ }++ private static String createStack(String stackName, String template) {+ return cfnQuery("CreateStack", stackName, template)+ .then()+ .statusCode(200)+ .extract()+ .xmlPath()+ .getString("CreateStackResponse.CreateStackResult.StackId");+ }++ private static void updateStack(String stackName, String template) {+ cfnQuery("UpdateStack", stackName, template)+ .then()+ .statusCode(200);+ }++ private static void deleteStack(String stackName) {+ cfnQuery("DeleteStack", stackName)+ .then()+ .statusCode(200);+ }++ private static void awaitStackStatus(String stackId, String status) throws InterruptedException {+ String xml = "";+ long deadline = System.currentTimeMillis() + 10_000;+ while (System.currentTimeMillis() < deadline) {+ xml = describeStacks(stackId);+ if (xml.contains("<StackStatus>" + status + "</StackStatus>")) {+ return;+ }+ Thread.sleep(50);+ }+ fail("stack " + stackId + " never reached " + status + ": " + xml);+ }++ private static String describeStacks(String stackId) {+ return cfnQuery("DescribeStacks", stackId).then().statusCode(200).extract().asString();+ }++ private static Response cfnQuery(String action, String stackName) {+ return cfnQuery(action, stackName, null);+ }++ private static Response cfnQuery(String action, String stackName, String template) {+ var req = given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", action)+ .formParam("StackName", stackName);+ if (template != null) {+ req.formParam("TemplateBody", template);+ }+ return req.when().post("/");+ }++ private static String outputValue(String xml, String key) {+ return XmlParser.extractPairs(xml, "Outputs", "OutputKey", "OutputValue").get(key);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamUserCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamUserCfnProvisionerTest.javanew file mode 100644index 0000000000..e759f0e192--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamUserCfnProvisionerTest.java@@ -0,0 +1,330 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudformation.CloudFormationTemplateEngine;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.iam.IamService;+import io.github.hectorvent.floci.services.iam.model.AccessKey;+import io.github.hectorvent.floci.services.iam.model.IamUser;+import org.junit.jupiter.api.Test;++import java.util.HashMap;+import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.doThrow;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++class IamUserCfnProvisionerTest {++ private static final String ACCOUNT_ID = "000000000000";++ private final IamService iam = mock(IamService.class);+ private final IamUserCfnProvisioner provisioner = new IamUserCfnProvisioner(iam);+ private final ObjectMapper mapper = new ObjectMapper();++ private ProvisionContext ctx() {+ CloudFormationTemplateEngine engine = mock(CloudFormationTemplateEngine.class);++ when(engine.resolve(any())).thenAnswer(inv -> {+ JsonNode node = inv.getArgument(0);+ return node == null ? null : node.asText();+ });++ when(engine.resolveNode(any())).thenAnswer(inv -> inv.getArgument(0));++ // resolveStringList delegates to the real engine method; for the literal arrays these+ // tests use it just walks the array and calls resolve(...) per element, stubbed above.+ when(engine.resolveStringList(any())).thenCallRealMethod();++ when(engine.resolveJsonAttribute(any())).thenAnswer(inv -> {+ JsonNode node = inv.getArgument(0);+ return node != null && node.isTextual() ? node.asText() : node.toString();+ });++ return new ProvisionContext(engine, "us-east-1", ACCOUNT_ID, "test-stack");+ }++ private ProvisionContext updateCtx(String priorPhysicalId) {+ ProvisionContext base = ctx();+ return new ProvisionContext(base.engine(), base.region(), base.accountId(), base.stackName(), priorPhysicalId);+ }++ private StackResource resource() {+ StackResource r = new StackResource();+ r.setLogicalId("AppUser");+ r.setResourceType("AWS::IAM::User");+ r.setAttributes(new HashMap<>());+ return r;+ }++ private JsonNode props(String json) {+ try {+ return mapper.readTree(json);+ } catch (Exception e) {+ throw new RuntimeException(e);+ }+ }++ private IamUser stubCreate(String userName, String path) {+ IamUser user = new IamUser("AIDA" + userName, userName, path,+ "arn:aws:iam::" + ACCOUNT_ID + ":user" + path + userName);+ when(iam.createUser(eq(userName), eq(path))).thenReturn(user);+ return user;+ }++ @Test+ void declaresIamUserResourceType() {+ assertEquals(java.util.Set.of("AWS::IAM::User"), provisioner.resourceTypes());+ }++ @Test+ void provisionCreatesUserWithExplicitUserNameAndDefaultPath() {+ stubCreate("custom-user", "/");+ StackResource r = resource();++ provisioner.provision(r, props("""+ {+ "UserName": "custom-user"+ }+ """), ctx());++ assertEquals("custom-user", r.getPhysicalId());+ assertEquals("arn:aws:iam::" + ACCOUNT_ID + ":user/custom-user", r.getAttributes().get("Arn"));+ verify(iam).createUser("custom-user", "/");+ }++ @Test+ void provisionCreatesUserWithCustomPath() {+ stubCreate("custom-user", "/engineering/");+ StackResource r = resource();++ provisioner.provision(r, props("""+ {+ "UserName": "custom-user",+ "Path": "/engineering/"+ }+ """), ctx());++ assertEquals("custom-user", r.getPhysicalId());+ assertEquals("arn:aws:iam::" + ACCOUNT_ID + ":user/engineering/custom-user", r.getAttributes().get("Arn"));+ verify(iam).createUser("custom-user", "/engineering/");+ }++ @Test+ void provisionGeneratesPhysicalNameWhenUserNameIsOmitted() {+ when(iam.createUser(any(), eq("/"))).thenAnswer(inv -> {+ String name = inv.getArgument(0);+ return new IamUser("AIDA" + name, name, "/", "arn:aws:iam::" + ACCOUNT_ID + ":user/" + name);+ });+ StackResource r = resource();++ provisioner.provision(r, mapper.createObjectNode(), ctx());++ assertNotNull(r.getPhysicalId());+ assertTrue(r.getPhysicalId().contains("test-stack"));+ assertEquals("arn:aws:iam::" + ACCOUNT_ID + ":user/" + r.getPhysicalId(), r.getAttributes().get("Arn"));+ }++ @Test+ void provisionAttachesManagedPoliciesAndInlinePoliciesAndGroups() {+ IamUser user = stubCreate("app-user", "/");+ StackResource r = resource();++ provisioner.provision(r, props("""+ {+ "UserName": "app-user",+ "Groups": ["developers", "qa"],+ "ManagedPolicyArns": [+ "arn:aws:iam::aws:policy/ReadOnlyAccess",+ "arn:aws:iam::aws:policy/PowerUserAccess"+ ],+ "Policies": [+ {+ "PolicyName": "s3-access",+ "PolicyDocument": {"Version": "2012-10-17", "Statement": []}+ }+ ]+ }+ """), ctx());++ verify(iam).addUserToGroup("developers", "app-user");+ verify(iam).addUserToGroup("qa", "app-user");+ verify(iam).attachUserPolicy("app-user", "arn:aws:iam::aws:policy/ReadOnlyAccess");+ verify(iam).attachUserPolicy("app-user", "arn:aws:iam::aws:policy/PowerUserAccess");+ verify(iam).putUserPolicy(eq("app-user"), eq("s3-access"), any());+ }++ @Test+ void updatingUserNameRequiresReplacement() {+ StackResource r = resource();+ r.setPhysicalId("old-user");++ AwsException failure = assertThrows(AwsException.class, () ->+ provisioner.provision(r, props("""+ {+ "UserName": "new-user"+ }+ """), updateCtx("old-user")));++ assertEquals("ValidationError", failure.getErrorCode());+ assertTrue(failure.getMessage().contains("resource replacement"));+ verify(iam, never()).createUser(any(), any());+ }++ @Test+ void deleteDetachesPoliciesRemovesGroupsAndDeletesUser() {+ IamUser user = new IamUser("AIDAuser", "my-user", "/", "arn:aws:iam::" + ACCOUNT_ID + ":user/my-user");+ user.getAttachedPolicyArns().add("arn:aws:iam::aws:policy/ReadOnlyAccess");+ user.getInlinePolicies().put("inline-1", "{}");+ user.getGroupNames().add("dev-group");+ when(iam.getUser("my-user")).thenReturn(user);++ AccessKey key = new AccessKey("AKIA123", "secret", "my-user");+ when(iam.listAccessKeys("my-user")).thenReturn(List.of(key));++ provisioner.delete("AWS::IAM::User", "my-user", "us-east-1");++ verify(iam).detachUserPolicy("my-user", "arn:aws:iam::aws:policy/ReadOnlyAccess");+ verify(iam).deleteUserPolicy("my-user", "inline-1");+ verify(iam).removeUserFromGroup("dev-group", "my-user");+ verify(iam).deleteAccessKey("my-user", "AKIA123");+ verify(iam).deleteUser("my-user");+ }++ @Test+ void deleteToleratesAlreadyDeletedUser() {+ when(iam.getUser("already-gone"))+ .thenThrow(new AwsException("NoSuchEntity", "User does not exist", 404));++ provisioner.delete("AWS::IAM::User", "already-gone", "us-east-1");++ verify(iam, never()).deleteUser(any());+ }++ @Test+ void updateReconcilesRemovedGroupsManagedPoliciesAndInlinePolicies() {+ IamUser existing = new IamUser("AIDAuser", "my-user", "/", "arn:aws:iam::" + ACCOUNT_ID + ":user/my-user");+ existing.getGroupNames().add("keep-group");+ existing.getGroupNames().add("drop-group");+ existing.getAttachedPolicyArns().add("arn:aws:iam::aws:policy/Keep");+ existing.getAttachedPolicyArns().add("arn:aws:iam::aws:policy/Drop");+ existing.getInlinePolicies().put("keep-inline", "{}");+ existing.getInlinePolicies().put("drop-inline", "{}");++ when(iam.createUser(eq("my-user"), eq("/"))).thenThrow(new AwsException("EntityAlreadyExists", "exists", 409));+ when(iam.getUser("my-user")).thenReturn(existing);++ StackResource r = resource();+ r.setPhysicalId("my-user");+ r.getAttributes().put("__FlociUserId", "AIDAuser");+ r.getAttributes().put("__FlociGroups", "keep-group\ndrop-group");+ r.getAttributes().put("__FlociManagedPolicyArns", "arn:aws:iam::aws:policy/Keep\narn:aws:iam::aws:policy/Drop");+ r.getAttributes().put("__FlociInlinePolicyNames", "keep-inline\ndrop-inline");++ provisioner.provision(r, props("""+ {+ "UserName": "my-user",+ "Groups": ["keep-group"],+ "ManagedPolicyArns": ["arn:aws:iam::aws:policy/Keep"],+ "Policies": [+ {+ "PolicyName": "keep-inline",+ "PolicyDocument": {"Version": "2012-10-17", "Statement": []}+ }+ ]+ }+ """), updateCtx("my-user"));++ verify(iam).removeUserFromGroup("drop-group", "my-user");+ verify(iam).detachUserPolicy("my-user", "arn:aws:iam::aws:policy/Drop");+ verify(iam).deleteUserPolicy("my-user", "drop-inline");+ verify(iam, never()).removeUserFromGroup("keep-group", "my-user");+ verify(iam, never()).detachUserPolicy("my-user", "arn:aws:iam::aws:policy/Keep");+ verify(iam, never()).deleteUserPolicy("my-user", "keep-inline");+ }++ @Test+ void updateReconcilesPathChange() {+ IamUser existing = new IamUser("AIDAuser", "my-user", "/", "arn:aws:iam::" + ACCOUNT_ID + ":user/my-user");+ when(iam.createUser(eq("my-user"), eq("/new-path/"))).thenThrow(new AwsException("EntityAlreadyExists", "exists", 409));+ when(iam.getUser("my-user")).thenReturn(existing);++ StackResource r = resource();+ r.setPhysicalId("my-user");+ r.getAttributes().put("__FlociUserId", "AIDAuser");++ provisioner.provision(r, props("""+ {+ "UserName": "my-user",+ "Path": "/new-path/"+ }+ """), updateCtx("my-user"));++ verify(iam).updateUser("my-user", null, "/new-path/", "AIDAuser");+ }++ @Test+ void updateRefusesToAdoptReplacementUserWithDifferentUserId() {+ IamUser replacement = new IamUser("AIDAnew-user", "my-user", "/", "arn:aws:iam::" + ACCOUNT_ID + ":user/my-user");+ when(iam.createUser(eq("my-user"), eq("/"))).thenThrow(new AwsException("EntityAlreadyExists", "exists", 409));+ when(iam.getUser("my-user")).thenReturn(replacement);++ StackResource r = resource();+ r.setPhysicalId("my-user");+ r.getAttributes().put("__FlociUserId", "AIDAold-user");++ AwsException failure = assertThrows(AwsException.class, () ->+ provisioner.provision(r, props("""+ {+ "UserName": "my-user"+ }+ """), updateCtx("my-user")));++ assertEquals("EntityAlreadyExists", failure.getErrorCode());+ verify(iam, never()).addUserToGroup(any(), any());+ verify(iam, never()).attachUserPolicy(any(), any());+ }++ @Test+ void failedUpdateRestoresPriorInlinePolicyAndDetachesNewManagedPolicy() {+ IamUser existing = new IamUser("AIDAuser", "my-user", "/", "arn:aws:iam::" + ACCOUNT_ID + ":user/my-user");+ String priorDocument = "{\"Version\":\"2012-10-17\",\"Statement\":[\"prior\"]}";+ existing.getInlinePolicies().put("first", priorDocument);+ when(iam.createUser(eq("my-user"), eq("/"))).thenThrow(new AwsException("EntityAlreadyExists", "exists", 409));+ when(iam.getUser("my-user")).thenReturn(existing);+ doThrow(new AwsException("MalformedPolicyDocument", "bad policy", 400))+ .when(iam).putUserPolicy(eq("my-user"), eq("second"), any());++ StackResource r = resource();+ r.setPhysicalId("my-user");+ r.getAttributes().put("__FlociUserId", "AIDAuser");++ assertThrows(AwsException.class, () -> provisioner.provision(r, props("""+ {+ "UserName": "my-user",+ "ManagedPolicyArns": ["arn:aws:iam::aws:policy/NewPolicy"],+ "Policies": [+ {"PolicyName": "first", "PolicyDocument": {"Version": "2012-10-17", "Statement": []}},+ {"PolicyName": "second", "PolicyDocument": {"Version": "2012-10-17", "Statement": []}}+ ]+ }+ """), updateCtx("my-user")));++ verify(iam).attachUserPolicy("my-user", "arn:aws:iam::aws:policy/NewPolicy");+ verify(iam).detachUserPolicy("my-user", "arn:aws:iam::aws:policy/NewPolicy");+ verify(iam).putUserPolicy("my-user", "first", priorDocument);+ verify(iam, never()).deleteUser("my-user");+ }+}diff --git a/src/test/resources/cloudformation/supported-resource-types.tsv b/src/test/resources/cloudformation/supported-resource-types.tsvindex d2054a9986..e26b3d7aa4 100644--- a/src/test/resources/cloudformation/supported-resource-types.tsv+++ b/src/test/resources/cloudformation/supported-resource-types.tsv@@ -73,7 +73,7 @@ AWS::IAM::InstanceProfile LEGACY_SWITCHAWS::IAM::ManagedPolicy LEGACY_SWITCHAWS::IAM::Policy LEGACY_SWITCHAWS::IAM::Role IamRoleCfnProvisioner-AWS::IAM::User LEGACY_SWITCH+AWS::IAM::User IamUserCfnProvisionerAWS::IoT::DomainConfiguration IotDomainConfigurationCfnProvisionerAWS::IoT::Policy IotCfnProvisionerAWS::IoT::Thing IotCfnProvisioner