Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cloudformation): keep unchanged VPCs and security groups on stack update (#3033)
Jerald Lindbergdde11aeb6a59
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 85710990bd..c6bbd28923 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@@ -41,10 +41,16 @@ import io.github.hectorvent.floci.services.autoscaling.model.AutoScalingGroup;import io.github.hectorvent.floci.services.autoscaling.model.LaunchConfiguration;import io.github.hectorvent.floci.services.autoscaling.model.MixedInstancesPolicy;import io.github.hectorvent.floci.services.cloudwatch.metrics.model.MetricAlarm;+import io.github.hectorvent.floci.services.ec2.model.IpPermission;+import io.github.hectorvent.floci.services.ec2.model.IpRange;+import io.github.hectorvent.floci.services.ec2.model.Ipv6Range;+import io.github.hectorvent.floci.services.ec2.model.PrefixListId;+import io.github.hectorvent.floci.services.ec2.model.SecurityGroup;import io.github.hectorvent.floci.services.ec2.Ec2Service;import io.github.hectorvent.floci.services.kinesis.KinesisService;import io.github.hectorvent.floci.services.kinesis.model.KinesisStream;import io.github.hectorvent.floci.services.ec2.model.Tag;+import io.github.hectorvent.floci.services.ec2.model.UserIdGroupPair;import io.github.hectorvent.floci.services.firehose.FirehoseService;import io.github.hectorvent.floci.services.firehose.model.DeliveryStreamDescription;import io.github.hectorvent.floci.services.rds.RdsService;@@ -702,7 +708,13 @@ public class CloudFormationResourceProvisioner {description = "Managed by CloudFormation";}String vpcId = resolveOptional(props, "VpcId", engine);- var sg = ec2Service.createSecurityGroup(region, groupName, description, vpcId);+ // provision() re-runs for every resource on every update. Re-creating an unchanged group+ // would mint a new group id (and collide on the name whenever the VPC id is stable), so+ // reuse the group this resource already points at.+ var reconciled = existingSecurityGroupToReconcile(r.getPhysicalId(), groupName, description, vpcId, region);+ final SecurityGroup sg = reconciled != null+ ? reconciled+ : ec2Service.createSecurityGroup(region, groupName, description, vpcId);// Ref on AWS::EC2::SecurityGroup returns the group id for VPC security groups.r.setPhysicalId(sg.getGroupId());r.getAttributes().put("GroupId", sg.getGroupId());@@ -713,17 +725,24 @@ public class CloudFormationResourceProvisioner {// Inline rule properties — previously dropped, leaving the group empty. The mapping is// shared with the standalone SecurityGroupIngress/Egress resource types, which live in// Ec2SecurityGroupRuleCfnProvisioner; this arm joins them when it is extracted.+ // Authorize appends without a duplicate check, so re-running this on a reused group would+ // stack another copy of every inline rule on each update. Only authorize what the group+ // does not already carry.+ //+ // Deliberately additive: a rule dropped from the template is not revoked here. Revoking+ // the difference would mean revoking permissions this resource cannot prove it owns - a+ // group can also carry rules from standalone AWS::EC2::SecurityGroupIngress/Egress+ // resources, and clearing them on an unrelated update would close ports another stack+ // resource is responsible for. Removing a rule the template no longer declares needs the+ // provisioner to record what it authorized; noted as a follow-up.+ var peerGroupId = peerGroupIdResolver(region, sg.getVpcId());if (props != null && props.has("SecurityGroupIngress")) {- for (JsonNode rule : props.get("SecurityGroupIngress")) {- ec2Service.authorizeSecurityGroupIngress(region, sg.getGroupId(),- List.of(Ec2SecurityGroupRuleCfnProvisioner.toIpPermission(rule, engine)));- }+ authorizeMissing(props.get("SecurityGroupIngress"), sg.getIpPermissions(), engine, peerGroupId,+ perms -> ec2Service.authorizeSecurityGroupIngress(region, sg.getGroupId(), perms));}if (props != null && props.has("SecurityGroupEgress")) {- for (JsonNode rule : props.get("SecurityGroupEgress")) {- ec2Service.authorizeSecurityGroupEgress(region, sg.getGroupId(),- List.of(Ec2SecurityGroupRuleCfnProvisioner.toIpPermission(rule, engine)));- }+ authorizeMissing(props.get("SecurityGroupEgress"), sg.getIpPermissionsEgress(), engine, peerGroupId,+ perms -> ec2Service.authorizeSecurityGroupEgress(region, sg.getGroupId(), perms));}}@@ -1207,6 +1226,120 @@ public class CloudFormationResourceProvisioner {r.getAttributes().put("DBClusterParameterGroupName", group.getDbClusterParameterGroupName());}+ /** The VPC a security group would land in for this template value: the default when omitted. */+ private String effectiveVpcId(String vpcId, String region) {+ return vpcId != null && !vpcId.isEmpty() ? vpcId : String.valueOf(ec2Service.resolveDefaultVpcId(region));+ }++ /**+ * Authorizes each declared rule that the group does not already carry, one call per rule so a+ * rejected rule cannot take its siblings down with it.+ */+ private void authorizeMissing(JsonNode declared, List<IpPermission> existing,+ CloudFormationTemplateEngine engine,+ java.util.function.UnaryOperator<String> peerGroupId,+ java.util.function.Consumer<List<IpPermission>> authorize) {+ Set<String> present = existing.stream()+ .map(p -> permissionKey(p, peerGroupId))+ .collect(java.util.stream.Collectors.toSet());+ for (JsonNode rule : declared) {+ IpPermission perm = Ec2SecurityGroupRuleCfnProvisioner.toIpPermission(rule, engine);+ if (present.add(permissionKey(perm, peerGroupId))) {+ authorize.accept(List.of(perm));+ }+ }+ }++ /**+ * Resolves a peer group's name to its id, the same lookup {@code Ec2Service} performs when it+ * stores an authorized rule. Group names are unique per VPC rather than per region, so the+ * search is confined to the group being authorized. A name matching nothing there stays a+ * name, which is also what the service does.+ */+ private java.util.function.UnaryOperator<String> peerGroupIdResolver(String region, String vpcId) {+ return groupName -> ec2Service.describeSecurityGroups(region, List.of(), List.of(groupName), Map.of())+ .stream()+ .filter(peer -> Objects.equals(vpcId, peer.getVpcId()))+ .map(SecurityGroup::getGroupId)+ .filter(Objects::nonNull)+ .findFirst()+ .orElse(groupName);+ }++ /**+ * Identity of a permission for duplicate detection. {@link IpPermission} and the range types+ * it holds define no {@code equals}, so compare a canonical rendering instead. Descriptions+ * are left out: AWS treats a rule differing only by description as the same rule.+ */+ private static String permissionKey(IpPermission p, java.util.function.UnaryOperator<String> peerGroupId) {+ return String.join("|",+ String.valueOf(p.getIpProtocol()),+ String.valueOf(p.getFromPort()),+ String.valueOf(p.getToPort()),+ p.getIpRanges().stream().map(IpRange::getCidrIp).filter(Objects::nonNull).sorted()+ .collect(java.util.stream.Collectors.joining(",")),+ p.getIpv6Ranges().stream().map(Ipv6Range::getCidrIpv6).filter(Objects::nonNull).sorted()+ .collect(java.util.stream.Collectors.joining(",")),+ p.getUserIdGroupPairs().stream()+ .map(g -> peerIdentity(g, peerGroupId))+ .filter(Objects::nonNull).sorted()+ .collect(java.util.stream.Collectors.joining(",")),+ p.getPrefixListIds().stream().map(PrefixListId::getPrefixListId)+ .filter(Objects::nonNull).sorted()+ .collect(java.util.stream.Collectors.joining(",")));+ }++ /**+ * How a peer group is identified when two permissions are compared: its id whenever one can be+ * had. A stored pair already carries one, because authorize resolves the name as it records the+ * rule, while a pair straight from the template carries only the name it was declared with.+ * Keying a resolved id against an unresolved name never matches, which re-authorized a rule+ * naming its peer through {@code SourceSecurityGroupName} on every single update.+ */+ private static String peerIdentity(UserIdGroupPair pair,+ java.util.function.UnaryOperator<String> peerGroupId) {+ if (pair.getGroupId() != null) {+ return pair.getGroupId();+ }+ return pair.getGroupName() == null ? null : peerGroupId.apply(pair.getGroupName());+ }++ /**+ * The security group this stack resource already points at, when an UpdateStack re-invocation+ * left it unchanged. Unlike most resources the physical id here is the group <em>id</em>, not+ * the name, so the rename check compares the stored group's name against the template's.+ *+ * <p>Returns {@code null} for a fresh create, a group deleted out of band, or any change AWS+ * treats as a replacement: GroupName, GroupDescription and VpcId are all immutable on a+ * security group, so a template that changes one wants a new group, not an edit to this one.+ * The caller then creates.+ */+ private SecurityGroup existingSecurityGroupToReconcile(String priorPhysicalId, String groupName,+ String description, String vpcId, String region) {+ if (priorPhysicalId == null || priorPhysicalId.isBlank()) {+ return null;+ }+ try {+ return ec2Service.describeSecurityGroups(region, List.of(priorPhysicalId), List.of(), Map.of())+ .stream()+ .filter(existing -> groupName == null || groupName.equals(existing.getGroupName()))+ .filter(existing -> description == null || description.equals(existing.getDescription()))+ // Compare the VpcId the template would actually get, not the raw property.+ // createSecurityGroup resolves an omitted VpcId to the region's default VPC,+ // so the stored group always has one: comparing against a null property would+ // either force a replacement on every update, or - the bug - let a template+ // that drops VpcId keep a group sitting in the explicit VPC it named before.+ .filter(existing -> effectiveVpcId(vpcId, region).equals(existing.getVpcId()))+ .findFirst()+ .orElse(null);+ } catch (AwsException notFound) {+ // Expected when the group was deleted out of band since the prior update.+ LOG.debugv(notFound, "No existing security group {0} found on file, falling back to create",+ priorPhysicalId);+ return null;+ }+ }+/*** Looks up {@code name} via {@code lookup} when this is an update re-invocation for the same* physical resource (i.e. {@code priorPhysicalId} is set and unchanged), returning {@code null}diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2VpcCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2VpcCfnProvisioner.javaindex 7448ad68c0..d428c560b9 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2VpcCfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2VpcCfnProvisioner.java@@ -1,10 +1,13 @@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.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ec2.model.Vpc;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;+import org.jboss.logging.Logger;import java.util.List;import java.util.Map;@@ -17,6 +20,8 @@ import java.util.Set;@ApplicationScopedpublic class Ec2VpcCfnProvisioner implements CfnResourceProvisioner {+ private static final Logger LOG = Logger.getLogger(Ec2VpcCfnProvisioner.class);+private final Ec2Service ec2Service;@Inject@@ -32,7 +37,8 @@ public class Ec2VpcCfnProvisioner implements CfnResourceProvisioner {@Overridepublic void provision(StackResource r, JsonNode props, ProvisionContext ctx) {String cidr = ctx.resolveOptional(props, "CidrBlock");- var vpc = ec2Service.createVpc(ctx.region(), cidr, false);+ Vpc reconciled = existingVpcToReconcile(ctx.isUpdate() ? ctx.priorPhysicalId() : null, cidr, ctx.region());+ final Vpc vpc = reconciled != null ? reconciled : ec2Service.createVpc(ctx.region(), cidr, false);r.setPhysicalId(vpc.getVpcId());r.getAttributes().put("VpcId", vpc.getVpcId());if (vpc.getCidrBlock() != null) {@@ -46,6 +52,42 @@ public class Ec2VpcCfnProvisioner implements CfnResourceProvisioner {.ifPresent(sg -> r.getAttributes().put("DefaultSecurityGroup", sg.getGroupId()));}+ /**+ * The VPC this stack resource already points at, when an UpdateStack re-invocation left it+ * unchanged. {@code provision()} re-runs for every resource on every update, so creating+ * unconditionally would mint a fresh VPC id and silently orphan every subnet, route table and+ * security group that referenced the old one.+ *+ * <p>Returns {@code null} for a fresh create, for a CidrBlock change (which AWS treats as a+ * replacement), or when the VPC is gone from the backend - the caller then creates.+ *+ * <p>The prior id is the one the context captured, not the one on the {@link StackResource}:+ * {@code provision} assigns the new id onto that resource as it runs, so a resource-derived+ * check flips from create to update mid-method.+ */+ private Vpc existingVpcToReconcile(String priorPhysicalId, String cidr, String region) {+ if (priorPhysicalId == null || priorPhysicalId.isBlank()) {+ return null;+ }+ Vpc existing;+ try {+ existing = ec2Service.describeVpcs(region, List.of(priorPhysicalId), Map.of())+ .stream().findFirst().orElse(null);+ } catch (AwsException notFound) {+ // Expected when the VPC was deleted out of band since the prior update.+ LOG.debugv(notFound, "No existing VPC {0} found on file, falling back to create", priorPhysicalId);+ return null;+ }+ if (existing == null) {+ return null;+ }+ // A changed CidrBlock is a replacement on AWS, so let the caller create a new VPC.+ if (cidr != null && !cidr.isBlank() && !cidr.equals(existing.getCidrBlock())) {+ return null;+ }+ return existing;+ }+// No delete override: the switch this replaces had no AWS::EC2::VPC delete arm,// so stack teardown leaves the VPC alone. Adding one here would change teardown// behavior beyond the scope of this extraction.diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnUnchangedResourceUpdateIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnUnchangedResourceUpdateIntegrationTest.javanew file mode 100644index 0000000000..a37a942177--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnUnchangedResourceUpdateIntegrationTest.java@@ -0,0 +1,351 @@+package io.github.hectorvent.floci.services.cloudformation;++import io.github.hectorvent.floci.core.common.XmlParser;+import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.Test;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.not;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;++/**+ * UpdateStack must leave an unchanged resource alone, whatever its type.+ *+ * <p>{@code provision()} re-runs for every resource on every update, changed or not, so a+ * provisioner that calls create unconditionally either collides with itself (rolling the stack+ * back) or quietly mints a new physical id, orphaning everything that referenced the old one.+ * Each case here builds a stack holding one resource plus a throwaway queue, updates only the+ * queue, and asserts both that the stack reached UPDATE_COMPLETE and that the untouched resource+ * kept its physical id.+ *+ * <p>Regression cover for "CloudFormation update recreates unchanged named resources"+ * (floci-io/floci#2134).+ */+@QuarkusTest+class CfnUnchangedResourceUpdateIntegrationTest {++ private static final String CFN_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260808/us-west-2/cloudformation/aws4_request";++ private static String stackWith(String namedResourceJson, String queueName) {+ return """+ {+ "Resources": {+ %s,+ "ChurnQueue": {+ "Type": "AWS::SQS::Queue",+ "Properties": {"QueueName": "%s"}+ }+ }+ }+ """.formatted(namedResourceJson, queueName);+ }++ /**+ * Pulls the PhysicalResourceId of one logical resource out of a DescribeStackResources body.+ * The member ordering is not guaranteed, so pick the member by its LogicalResourceId rather+ * than by position.+ */+ private static String physicalIdOf(String describeBody, String logicalId) {+ return XmlParser.extractGroups(describeBody, "member").stream()+ .filter(member -> logicalId.equals(member.get("LogicalResourceId")))+ .map(member -> member.get("PhysicalResourceId"))+ .findFirst()+ .orElse(null);+ }++ private String namedPhysicalId(String stackName) {+ String body = given()+ .contentType("application/x-www-form-urlencoded").header("Authorization", CFN_AUTH)+ .formParam("Action", "DescribeStackResources").formParam("StackName", stackName)+ .when().post("/").then().statusCode(200)+ .extract().body().asString();+ return physicalIdOf(body, "Named");+ }++ /**+ * Creates the stack, updates it with only the churn queue renamed, then asserts both that the+ * update completed and that the untouched resource kept its physical id. The second assertion+ * is the load-bearing one: a provisioner that re-creates the resource under a fresh id can+ * still report UPDATE_COMPLETE while silently orphaning whatever referenced the old id.+ */+ private void assertUnchangedResourceSurvivesUpdate(String label, String namedResourceJson) {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "probe-" + label + "-" + suffix;+ String body = namedResourceJson.replace("SUFFIX", suffix);++ given().contentType("application/x-www-form-urlencoded").header("Authorization", CFN_AUTH)+ .formParam("Action", "CreateStack").formParam("StackName", stackName)+ .formParam("TemplateBody", stackWith(body, "probe-q-a-" + suffix))+ .when().post("/").then().statusCode(200);++ given().contentType("application/x-www-form-urlencoded").header("Authorization", CFN_AUTH)+ .formParam("Action", "DescribeStacks").formParam("StackName", stackName)+ .when().post("/").then().statusCode(200)+ .body(containsString("<StackStatus>CREATE_COMPLETE</StackStatus>"));++ String before = namedPhysicalId(stackName);+ assertNotNull(before, "no PhysicalResourceId for Named after create");++ given().contentType("application/x-www-form-urlencoded").header("Authorization", CFN_AUTH)+ .formParam("Action", "UpdateStack").formParam("StackName", stackName)+ .formParam("TemplateBody", stackWith(body, "probe-q-b-" + suffix))+ .when().post("/").then().statusCode(200);++ given().contentType("application/x-www-form-urlencoded").header("Authorization", CFN_AUTH)+ .formParam("Action", "DescribeStacks").formParam("StackName", stackName)+ .when().post("/").then().statusCode(200)+ .body(containsString("<StackStatus>UPDATE_COMPLETE</StackStatus>"))+ .body(not(containsString("ROLLBACK")));++ assertEquals(before, namedPhysicalId(stackName),+ label + ": unchanged resource was re-created under a new physical id");+ }++ private static final String EC2_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260808/us-west-2/ec2/aws4_request";++ /** Runs create-then-update and hands back the Named physical id before and after. */+ private String[] createThenUpdate(String label, String createBody, String updateBody) {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "probe-" + label + "-" + suffix;++ given().contentType("application/x-www-form-urlencoded").header("Authorization", CFN_AUTH)+ .formParam("Action", "CreateStack").formParam("StackName", stackName)+ .formParam("TemplateBody", stackWith(createBody.replace("SUFFIX", suffix), "probe-q-a-" + suffix))+ .when().post("/").then().statusCode(200);++ String before = namedPhysicalId(stackName);+ assertNotNull(before, "no PhysicalResourceId for Named after create");++ given().contentType("application/x-www-form-urlencoded").header("Authorization", CFN_AUTH)+ .formParam("Action", "UpdateStack").formParam("StackName", stackName)+ .formParam("TemplateBody", stackWith(updateBody.replace("SUFFIX", suffix), "probe-q-b-" + suffix))+ .when().post("/").then().statusCode(200);++ given().contentType("application/x-www-form-urlencoded").header("Authorization", CFN_AUTH)+ .formParam("Action", "DescribeStacks").formParam("StackName", stackName)+ .when().post("/").then().statusCode(200)+ .body(containsString("<StackStatus>UPDATE_COMPLETE</StackStatus>"))+ .body(not(containsString("ROLLBACK")));++ return new String[] {before, namedPhysicalId(stackName)};+ }++ private static final String SG_WITH_INGRESS = """+ "Named": {+ "Type": "AWS::EC2::SecurityGroup",+ "Properties": {+ "GroupName": "probe-sg-SUFFIX",+ "GroupDescription": "probe DESCRIPTION",+ "SecurityGroupIngress": [+ {"IpProtocol": "tcp", "FromPort": 22, "ToPort": 22, "CidrIp": "10.0.0.0/8"}+ ]+ }+ }""";++ /**+ * A group can carry rules from standalone AWS::EC2::SecurityGroupIngress resources as well as+ * its own inline ones. Reconciling the inline set by clearing the group first would revoke+ * those too, so a stack update unrelated to them would silently close their ports.+ */+ @Test+ void anUpdateLeavesRulesOwnedByStandaloneResourcesAlone() {+ String body = """+ "Named": {+ "Type": "AWS::EC2::SecurityGroup",+ "Properties": {+ "GroupName": "probe-sg-mixed-SUFFIX",+ "GroupDescription": "probe mixed",+ "SecurityGroupIngress": [+ {"IpProtocol": "tcp", "FromPort": 22, "ToPort": 22, "CidrIp": "10.0.0.0/8"}+ ]+ }+ },+ "ExtraRule": {+ "Type": "AWS::EC2::SecurityGroupIngress",+ "Properties": {+ "GroupId": {"Ref": "Named"},+ "IpProtocol": "tcp",+ "FromPort": 8080,+ "ToPort": 8080,+ "CidrIp": "10.9.0.0/16"+ }+ }""";+ String[] ids = createThenUpdate("sg-mixed", body, body);+ assertEquals(ids[0], ids[1], "unchanged security group was re-created under a new physical id");++ String described = given()+ .contentType("application/x-www-form-urlencoded").header("Authorization", EC2_AUTH)+ .formParam("Action", "DescribeSecurityGroups").formParam("GroupId.1", ids[1])+ .when().post("/").then().statusCode(200)+ .extract().body().asString();++ assertEquals(1, described.split("<fromPort>22</fromPort>", -1).length - 1,+ "inline rule should appear exactly once after an update");+ assertEquals(1, described.split("<fromPort>8080</fromPort>", -1).length - 1,+ "the standalone resource's rule was revoked by the inline reconciliation");+ }++ /**+ * AuthorizeSecurityGroupIngress appends without a duplicate check, so re-running provision on a+ * reused group stacks another copy of every inline rule on each update. Retaining the group id+ * is not enough on its own: the group has to still describe the rules the template declares,+ * once each.+ */+ @Test+ void securityGroupInlineRulesAreNotDuplicatedByAnUpdate() {+ String body = SG_WITH_INGRESS.replace("DESCRIPTION", "stable");+ String[] ids = createThenUpdate("sg-rules", body, body);+ assertEquals(ids[0], ids[1], "unchanged security group was re-created under a new physical id");++ String described = given()+ .contentType("application/x-www-form-urlencoded").header("Authorization", EC2_AUTH)+ .formParam("Action", "DescribeSecurityGroups").formParam("GroupId.1", ids[1])+ .when().post("/").then().statusCode(200)+ .extract().body().asString();++ int occurrences = described.split("<fromPort>22</fromPort>", -1).length - 1;+ assertEquals(1, occurrences,+ "inline ingress rule appears " + occurrences + " times after one update; "+ + "provision re-authorized it on the reused group");+ }++ /**+ * A rule naming its peer through SourceSecurityGroupName is the case the CidrIp rules above+ * cannot reach. Ec2Service resolves the name to a group id as it records the rule, while the+ * declaration the template hands back on the next update still carries only the name, so+ * comparing the two forms directly finds no match and re-authorizes the rule every time.+ *+ * <p>DependsOn is load-bearing: the peer has to exist when the rule is first authorized, or+ * the stored pair keeps the unresolved name and both sides agree for the wrong reason.+ */+ @Test+ void aRuleNamingItsPeerByNameIsNotDuplicatedByAnUpdate() {+ String body = """+ "Peer": {+ "Type": "AWS::EC2::SecurityGroup",+ "Properties": {+ "GroupName": "probe-sg-peer-SUFFIX",+ "GroupDescription": "probe peer"+ }+ },+ "Named": {+ "Type": "AWS::EC2::SecurityGroup",+ "DependsOn": "Peer",+ "Properties": {+ "GroupName": "probe-sg-byname-SUFFIX",+ "GroupDescription": "probe by name",+ "SecurityGroupIngress": [+ {"IpProtocol": "tcp", "FromPort": 5432, "ToPort": 5432,+ "SourceSecurityGroupName": "probe-sg-peer-SUFFIX"}+ ]+ }+ }""";+ String[] ids = createThenUpdate("sg-byname", body, body);+ assertEquals(ids[0], ids[1], "unchanged security group was re-created under a new physical id");++ String described = given()+ .contentType("application/x-www-form-urlencoded").header("Authorization", EC2_AUTH)+ .formParam("Action", "DescribeSecurityGroups").formParam("GroupId.1", ids[1])+ .when().post("/").then().statusCode(200)+ .extract().body().asString();++ int occurrences = described.split("<fromPort>5432</fromPort>", -1).length - 1;+ assertEquals(1, occurrences,+ "name-based ingress rule appears " + occurrences + " times after one update; "+ + "the stored peer is keyed by id and the declared one by name");+ }++ @Test+ void logGroup() {+ assertUnchangedResourceSurvivesUpdate("loggroup", """+ "Named": {+ "Type": "AWS::Logs::LogGroup",+ "Properties": {"LogGroupName": "/probe/log-SUFFIX"}+ }""");+ }++ @Test+ void snsTopic() {+ assertUnchangedResourceSurvivesUpdate("sns", """+ "Named": {+ "Type": "AWS::SNS::Topic",+ "Properties": {"TopicName": "probe-topic-SUFFIX"}+ }""");+ }++ @Test+ void sqsQueue() {+ assertUnchangedResourceSurvivesUpdate("sqs", """+ "Named": {+ "Type": "AWS::SQS::Queue",+ "Properties": {"QueueName": "probe-queue-SUFFIX"}+ }""");+ }++ @Test+ void ecrRepository() {+ assertUnchangedResourceSurvivesUpdate("ecr", """+ "Named": {+ "Type": "AWS::ECR::Repository",+ "Properties": {"RepositoryName": "probe-repo-SUFFIX"}+ }""");+ }++ @Test+ void kmsAlias() {+ assertUnchangedResourceSurvivesUpdate("kms", """+ "Key": {"Type": "AWS::KMS::Key", "Properties": {}},+ "Named": {+ "Type": "AWS::KMS::Alias",+ "Properties": {"AliasName": "alias/probe-SUFFIX", "TargetKeyId": {"Ref": "Key"}}+ }""");+ }++ @Test+ void kinesisStream() {+ assertUnchangedResourceSurvivesUpdate("kinesis", """+ "Named": {+ "Type": "AWS::Kinesis::Stream",+ "Properties": {"Name": "probe-stream-SUFFIX", "ShardCount": 1}+ }""");+ }++ @Test+ void securityGroup() {+ assertUnchangedResourceSurvivesUpdate("sg", """+ "Vpc": {+ "Type": "AWS::EC2::VPC",+ "Properties": {"CidrBlock": "10.99.0.0/16"}+ },+ "Named": {+ "Type": "AWS::EC2::SecurityGroup",+ "Properties": {+ "GroupName": "probe-sg-SUFFIX",+ "GroupDescription": "probe",+ "VpcId": {"Ref": "Vpc"}+ }+ }""");+ }++ @Test+ void vpc() {+ assertUnchangedResourceSurvivesUpdate("vpc", """+ "Named": {+ "Type": "AWS::EC2::VPC",+ "Properties": {"CidrBlock": "10.98.0.0/16"}+ }""");+ }++ @Test+ void s3Bucket() {+ assertUnchangedResourceSurvivesUpdate("s3", """+ "Named": {+ "Type": "AWS::S3::Bucket",+ "Properties": {"BucketName": "probe-bucket-SUFFIX"}+ }""");+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2VpcCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2VpcCfnProvisionerTest.javanew file mode 100644index 0000000000..7090728bcc--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2VpcCfnProvisionerTest.java@@ -0,0 +1,155 @@+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.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ec2.model.SecurityGroup;+import io.github.hectorvent.floci.services.ec2.model.Vpc;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyBoolean;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/** {@code AWS::EC2::VPC}. */+class Ec2VpcCfnProvisionerTest {++ private static final ObjectMapper MAPPER = new ObjectMapper();+ private static final String REGION = "us-east-1";++ private Ec2Service ec2;+ private Ec2VpcCfnProvisioner provisioner;+ private CloudFormationTemplateEngine engine;++ @BeforeEach+ void setUp() {+ ec2 = mock(Ec2Service.class);+ provisioner = new Ec2VpcCfnProvisioner(ec2);+ engine = mock(CloudFormationTemplateEngine.class);+ when(engine.resolve(any())).thenAnswer(i -> {+ JsonNode node = i.getArgument(0);+ return node == null || node.isMissingNode() || node.isNull() ? null : node.asText();+ });+ when(engine.resolveNode(any())).thenAnswer(i -> i.getArgument(0));+ when(ec2.describeSecurityGroups(anyString(), any(), any(), any())).thenReturn(List.of());+ }++ private static JsonNode props(String json) {+ try {+ return MAPPER.readTree(json);+ } catch (Exception e) {+ throw new IllegalArgumentException(e);+ }+ }++ private static Vpc vpc(String id, String cidr) {+ Vpc v = new Vpc();+ v.setVpcId(id);+ v.setCidrBlock(cidr);+ return v;+ }++ /**+ * Provisions the way the engine does: an update arrives with the prior id on both the context+ * and the resource, so a provisioner reading the wrong one still looks correct here. The+ * create-path cases below are what separate them.+ */+ private StackResource provision(String priorPhysicalId, String json) {+ return provision(priorPhysicalId, priorPhysicalId, json);+ }++ private StackResource provision(String contextPriorId, String resourcePhysicalId, String json) {+ StackResource r = new StackResource();+ r.setLogicalId("Vpc");+ r.setResourceType("AWS::EC2::VPC");+ r.setPhysicalId(resourcePhysicalId);+ ProvisionContext ctx =+ new ProvisionContext(engine, REGION, "000000000000", "my-stack", contextPriorId);+ provisioner.provision(r, props(json), ctx);+ return r;+ }++ @Test+ void refIsTheVpcIdAndGetAttExposesTheDocumentedAttributes() {+ when(ec2.createVpc(anyString(), anyString(), anyBoolean())).thenReturn(vpc("vpc-new", "10.0.0.0/16"));+ SecurityGroup def = new SecurityGroup();+ def.setGroupId("sg-default");+ def.setVpcId("vpc-new");+ when(ec2.describeSecurityGroups(REGION, List.of(), List.of("default"), Map.of()))+ .thenReturn(List.of(def));++ StackResource r = provision(null, """+ {"CidrBlock": "10.0.0.0/16"}""");++ assertEquals("vpc-new", r.getPhysicalId());+ assertEquals("vpc-new", r.getAttributes().get("VpcId"));+ assertEquals("10.0.0.0/16", r.getAttributes().get("CidrBlock"));+ assertEquals("sg-default", r.getAttributes().get("DefaultSecurityGroup"));+ }++ @Test+ void anUnchangedVpcIsReusedInsteadOfCreatedAgain() {+ when(ec2.describeVpcs(REGION, List.of("vpc-existing"), Map.of()))+ .thenReturn(List.of(vpc("vpc-existing", "10.0.0.0/16")));++ StackResource r = provision("vpc-existing", """+ {"CidrBlock": "10.0.0.0/16"}""");++ verify(ec2, never()).createVpc(anyString(), anyString(), anyBoolean());+ assertEquals("vpc-existing", r.getPhysicalId(),+ "reusing must keep the id every subnet and route table already references");+ }++ @Test+ void aChangedCidrBlockCreatesAReplacement() {+ when(ec2.describeVpcs(REGION, List.of("vpc-existing"), Map.of()))+ .thenReturn(List.of(vpc("vpc-existing", "10.0.0.0/16")));+ when(ec2.createVpc(anyString(), anyString(), anyBoolean())).thenReturn(vpc("vpc-replaced", "10.1.0.0/16"));++ StackResource r = provision("vpc-existing", """+ {"CidrBlock": "10.1.0.0/16"}""");++ verify(ec2).createVpc(REGION, "10.1.0.0/16", false);+ assertEquals("vpc-replaced", r.getPhysicalId());+ }++ @Test+ void anIdOnTheResourceAloneDoesNotCountAsAnUpdate() {+ when(ec2.createVpc(anyString(), anyString(), anyBoolean())).thenReturn(vpc("vpc-new", "10.0.0.0/16"));++ // A resource carrying a physical id under a create context: what provision() itself+ // produces the moment it assigns the new id. Reading create-vs-update off the resource+ // makes that state indistinguishable from a real update.+ StackResource r = provision(null, "vpc-assigned-mid-method", """+ {"CidrBlock": "10.0.0.0/16"}""");++ verify(ec2, never()).describeVpcs(anyString(), any(), any());+ verify(ec2).createVpc(REGION, "10.0.0.0/16", false);+ assertEquals("vpc-new", r.getPhysicalId());+ }++ @Test+ void aVpcDeletedOutOfBandFallsBackToCreate() {+ when(ec2.describeVpcs(REGION, List.of("vpc-gone"), Map.of()))+ .thenThrow(new AwsException("InvalidVpcID.NotFound", "not found", 400));+ when(ec2.createVpc(anyString(), anyString(), anyBoolean())).thenReturn(vpc("vpc-fresh", "10.0.0.0/16"));++ StackResource r = provision("vpc-gone", """+ {"CidrBlock": "10.0.0.0/16"}""");++ verify(ec2).createVpc(REGION, "10.0.0.0/16", false);+ assertEquals("vpc-fresh", r.getPhysicalId());+ }+}