Light, fluffy, and always free - The AWS Local Emulator alternative
fix(autoscaling): tag member instances with aws:autoscaling:groupName (#6471)
Jackson Pricec517e4eb768a
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AutoScalingMembershipTagTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AutoScalingMembershipTagTest.javanew file mode 100644index 0000000000..a505b16325--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AutoScalingMembershipTagTest.java@@ -0,0 +1,130 @@+package com.floci.test;++import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.autoscaling.AutoScalingClient;+import software.amazon.awssdk.services.autoscaling.model.AutoScalingException;+import software.amazon.awssdk.services.autoscaling.model.Instance;+import software.amazon.awssdk.services.ec2.Ec2Client;+import software.amazon.awssdk.services.ec2.model.InstanceType;+import software.amazon.awssdk.services.ec2.model.ResourceType;++import java.util.HashMap;+import java.util.List;+import java.util.Map;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicReference;+import java.util.stream.Collectors;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++/**+ * The {@code aws:autoscaling:groupName} tag through a member's lifecycle, as the EC2 Auto Scaling+ * user guide's instance tagging lifecycle describes it.+ */+@DisplayName("Auto Scaling membership tag")+class AutoScalingMembershipTagTest {++ private static final String GROUP_NAME_TAG = "aws:autoscaling:groupName";++ @Test+ @DisplayName("aws:autoscaling:groupName is added on launch and attach and removed on detach")+ void groupNameTagFollowsLaunchAttachAndDetach() throws InterruptedException {+ String name = TestFixtures.uniqueName("membership-tag");+ String other = name + "-other";+ String zone = TestFixtures.availabilityZone();+ try (AutoScalingClient autoScaling = TestFixtures.autoScalingClient();+ Ec2Client ec2 = TestFixtures.ec2Client()) {+ ec2.createLaunchTemplate(request -> request.launchTemplateName(name).launchTemplateData(data -> data+ .imageId("ami-amazonlinux2023").instanceType(InstanceType.T3_MICRO)+ .tagSpecifications(spec -> spec.resourceType(ResourceType.INSTANCE).tags(+ tag -> tag.key("Source").value("template"),+ tag -> tag.key("Shared").value("template")))));+ String standalone = ec2.runInstances(request -> request.imageId("ami-amazonlinux2023")+ .instanceType(InstanceType.T3_MICRO).minCount(1).maxCount(1)+ .placement(placement -> placement.availabilityZone(zone))+ .tagSpecifications(spec -> spec.resourceType(ResourceType.INSTANCE).tags(+ tag -> tag.key("Shared").value("mine"), tag -> tag.key("Owner").value("me"))))+ .instances().get(0).instanceId();+ try {+ autoScaling.createAutoScalingGroup(request -> request.autoScalingGroupName(name)+ .launchTemplate(template -> template.launchTemplateName(name).version("1"))+ .minSize(0).maxSize(2).desiredCapacity(1).availabilityZones(zone)+ .tags(tag -> tag.key("Shared").value("group").propagateAtLaunch(true),+ tag -> tag.key("Private").value("group-only").propagateAtLaunch(false)));+ autoScaling.createAutoScalingGroup(request -> request.autoScalingGroupName(other)+ .launchTemplate(template -> template.launchTemplateName(name).version("1"))+ .minSize(0).maxSize(2).desiredCapacity(0).availabilityZones(zone));++ AtomicReference<String> launched = new AtomicReference<>();+ TestFixtures.await(() -> {+ List<Instance> members = autoScaling.describeAutoScalingGroups(request ->+ request.autoScalingGroupNames(name)).autoScalingGroups().get(0).instances();+ members.stream().findFirst().ifPresent(member -> launched.set(member.instanceId()));+ return launched.get() != null;+ }, name, "an instance launched by the group", TimeUnit.SECONDS.toNanos(60), 1000);+ assertThat(userTags(ec2, launched.get())).containsExactlyInAnyOrderEntriesOf(+ Map.of("Source", "template", "Shared", "group"));+ assertThat(tags(ec2, launched.get())).containsEntry(GROUP_NAME_TAG, name);+ assertThat(instancesTaggedWith(ec2, name)).containsExactly(launched.get());++ autoScaling.attachInstances(request -> request.autoScalingGroupName(name).instanceIds(standalone));+ assertThat(userTags(ec2, standalone)).containsExactlyInAnyOrderEntriesOf(+ Map.of("Owner", "me", "Shared", "group"));+ assertThat(tags(ec2, standalone)).containsEntry(GROUP_NAME_TAG, name);++ String alreadyMember = "The Instance: " + standalone + " is already part of AutoScalingGroup:" + name;+ for (String group : List.of(name, other)) {+ assertThatThrownBy(() -> autoScaling.attachInstances(request ->+ request.autoScalingGroupName(group).instanceIds(standalone)))+ .isInstanceOfSatisfying(AutoScalingException.class, error -> {+ assertThat(error.statusCode()).isEqualTo(400);+ assertThat(error.awsErrorDetails().errorCode()).isEqualTo("ValidationError");+ assertThat(error.awsErrorDetails().errorMessage()).contains(alreadyMember);+ });+ }+ assertThat(tags(ec2, standalone)).containsEntry(GROUP_NAME_TAG, name);++ autoScaling.detachInstances(request -> request.autoScalingGroupName(name).instanceIds(standalone)+ .shouldDecrementDesiredCapacity(true));+ assertThat(tags(ec2, standalone)).doesNotContainKey(GROUP_NAME_TAG);+ assertThat(userTags(ec2, standalone)).containsExactlyInAnyOrderEntriesOf(+ Map.of("Owner", "me", "Shared", "group"));+ assertThat(instancesTaggedWith(ec2, name)).containsExactly(launched.get());+ } finally {+ for (String group : List.of(name, other)) {+ try {+ autoScaling.deleteAutoScalingGroup(request -> request.autoScalingGroupName(group)+ .forceDelete(true));+ } catch (AutoScalingException ignored) {+ // A group that was never created has nothing to clean up.+ }+ }+ ec2.terminateInstances(request -> request.instanceIds(standalone));+ ec2.deleteLaunchTemplate(request -> request.launchTemplateName(name));+ }+ }+ }++ private static Map<String, String> tags(Ec2Client ec2, String instanceId) {+ return ec2.describeInstances(request -> request.instanceIds(instanceId)).reservations().get(0)+ .instances().get(0).tags().stream()+ .collect(Collectors.toMap(tag -> tag.key(), tag -> tag.value()));+ }++ /** The instance's tags without the {@code aws:} ones AWS adds on its own, such as launch template ids. */+ private static Map<String, String> userTags(Ec2Client ec2, String instanceId) {+ Map<String, String> tags = new HashMap<>(tags(ec2, instanceId));+ tags.keySet().removeIf(key -> key.startsWith("aws:"));+ return tags;+ }++ private static List<String> instancesTaggedWith(Ec2Client ec2, String group) {+ return ec2.describeInstances(request -> request.filters(filter -> filter.name("tag:" + GROUP_NAME_TAG)+ .values(group))).reservations().stream()+ .flatMap(reservation -> reservation.instances().stream())+ .map(instance -> instance.instanceId())+ .toList();+ }+}diff --git a/docs/services/autoscaling.md b/docs/services/autoscaling.mdindex 0e67a17912..80d9e3b88f 100644--- a/docs/services/autoscaling.md+++ b/docs/services/autoscaling.md@@ -72,12 +72,24 @@ EC2 instance can use a default subnet in a different zone.| `SetInstanceHealth` | Updates an instance's health status immediately; accepts but does not enforce the grace-period flag || `SetInstanceProtection` | Enables or disables scale-in protection for named instances in a group || `SetDesiredCapacity` | Updates desired count; reconciler handles scale-out / scale-in within 10 s |-| `AttachInstances` | Attaches existing EC2 instances to a group; sets lifecycle state to `InService` |+| `AttachInstances` | Attaches existing EC2 instances to a group; sets lifecycle state to `InService`. Refuses the whole batch with `ValidationError` when an instance already belongs to a group || `DetachInstances` | Detaches instances from a group; optionally decrements desired capacity || `TerminateInstanceInAutoScalingGroup` | Terminates a specific instance; optionally decrements desired capacity || `SuspendProcesses` | Records suspended scaling processes (empty list suspends all); reported back by `DescribeAutoScalingGroups` || `ResumeProcesses` | Clears suspended processes (empty list resumes all) |+Member instances carry the tags the+[EC2 instance tagging lifecycle](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-tagging.html#tag-lifecycle)+describes. An instance the group launches gets its launch template's instance tags, then the+group's `PropagateAtLaunch` tags, which win a key both set, then `aws:autoscaling:groupName` with+the group's name. `AttachInstances` adds the same group tags and `aws:autoscaling:groupName`,+overwriting existing tags with the same keys. `DetachInstances` removes only+`aws:autoscaling:groupName`, and only while it names the group being detached from.++`AttachInstances` does not yet refuse what AWS refuses for the instance's state or zone or for+the group's `MaxSize`, and does not grow desired capacity by the number of instances attached.+An ID EC2 has no instance for joins the group without tags.+### Instance Refresh| Operation | Notes |diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconciler.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconciler.javaindex 3cfcfac317..aaabf33ca6 100644--- a/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconciler.java+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconciler.java@@ -596,7 +596,7 @@ public class AutoScalingReconciler {return ec2Service.runInstances(asg.getRegion(), launchSource.imageId(), launchSource.instanceType(), 1, 1,launchSource.keyName(), launchSource.securityGroupIds(), placement.subnetId(), clientToken,- propagatedInstanceTags(asg, launchSource), launchSource.userData(),+ AutoScalingService.propagatedInstanceTags(asg, launchSource.instanceTags()), launchSource.userData(),launchSource.launchConfigurationName() == null ? launchSource.iamInstanceProfile(): asgService.resolveLaunchConfigurationProfile(launchSource.iamInstanceProfile()),launchSource.associatePublicIpAddress(), null, 0, launchZone, launchSource.metadataOptions(), null,@@ -718,23 +718,6 @@ public class AutoScalingReconciler {private record LaunchPlacement(String subnetId, String availabilityZone, int availableIpAddresses,boolean requiresIpv4Address) {}- private static List<io.github.hectorvent.floci.services.ec2.model.Tag> propagatedInstanceTags(- AutoScalingGroup asg,- LaunchSource launchSource) {- Map<String, String> tags = new LinkedHashMap<>();- for (io.github.hectorvent.floci.services.ec2.model.Tag tag : launchSource.instanceTags()) {- tags.put(tag.getKey(), tag.getValue());- }- asg.getTags().forEach((key, value) -> {- if (asg.getTagPropagateAtLaunch().getOrDefault(key, false)) {- tags.put(key, value);- }- });- return tags.entrySet().stream()- .map(entry -> new io.github.hectorvent.floci.services.ec2.model.Tag(entry.getKey(), entry.getValue()))- .toList();- }-private void scaleIn(AutoScalingGroup asg, int count) {List<AsgInstance> candidates = asg.getInstances().stream().filter(i -> "InService".equals(i.getLifecycleState()))diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingService.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingService.javaindex 413d2ffbfd..6003e53566 100644--- a/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingService.java+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingService.java@@ -16,6 +16,7 @@ import io.github.hectorvent.floci.services.ec2.Ec2UserDataDecoder;import io.github.hectorvent.floci.services.ec2.model.Instance;import io.github.hectorvent.floci.services.ec2.model.LaunchTemplate;import io.github.hectorvent.floci.services.ec2.model.LaunchTemplateData;+import io.github.hectorvent.floci.services.ec2.model.Tag;import io.github.hectorvent.floci.services.iam.PassedRoleLookup;import jakarta.annotation.PostConstruct;import jakarta.enterprise.context.ApplicationScoped;@@ -35,6 +36,9 @@ import java.util.stream.Collectors;@ApplicationScopedpublic class AutoScalingService implements PassedRoleLookup {+ /** The tag Auto Scaling puts on every instance it launches or attaches, valued with the group's name. */+ static final String GROUP_NAME_TAG = "aws:autoscaling:groupName";+private static final Logger LOG = Logger.getLogger(AutoScalingService.class);private static final String FULLY_FORMED_LAUNCH_TEMPLATE = "You must use a valid fully-formed launch template. ";static final String MISSING_LAUNCH_TEMPLATE_IMAGE_ID_MESSAGE =@@ -846,25 +850,77 @@ public class AutoScalingService implements PassedRoleLookup {return instanceId != null && asg.getInstances().stream().anyMatch(i -> instanceId.equals(i.getInstanceId()));}+ /**+ * The tags an instance carries as a member of {@code asg}: the launch template's instance tags,+ * then the group's PropagateAtLaunch tags, which win a key both set, then the group-name tag,+ * which names {@code asg} whatever the other two say.+ */+ static List<Tag> propagatedInstanceTags(AutoScalingGroup asg, List<Tag> templateTags) {+ Map<String, String> tags = new LinkedHashMap<>();+ templateTags.forEach(tag -> tags.put(tag.getKey(), tag.getValue()));+ asg.getTags().forEach((key, value) -> {+ if (asg.getTagPropagateAtLaunch().getOrDefault(key, false)) {+ tags.put(key, value);+ }+ });+ tags.put(GROUP_NAME_TAG, asg.getAutoScalingGroupName());+ return tags.entrySet().stream().map(entry -> new Tag(entry.getKey(), entry.getValue())).toList();+ }+public void attachInstances(String region, String name, List<String> instanceIds) {- AutoScalingGroup asg = requireGroup(region, name);- for (String id : instanceIds) {- AsgInstance inst = new AsgInstance();- inst.setInstanceId(id);- inst.setLifecycleState("InService");- inst.setHealthStatus("Healthy");- inst.setAvailabilityZone(- asg.getAvailabilityZones().isEmpty() ? region + "a" : asg.getAvailabilityZones().get(0));- inst.setLaunchConfigurationName(asg.getLaunchConfigurationName());- inst.setLaunchTemplateId(asg.getLaunchTemplateId());- inst.setLaunchTemplateName(asg.getLaunchTemplateName());- inst.setLaunchTemplateVersion(asg.getLaunchTemplateVersion());- asg.getInstances().add(inst);- }- if (asg.getInstances().size() > asg.getDesiredCapacity()) {- asg.setDesiredCapacity(asg.getInstances().size());+ // An instance joins once, however often the request names it.+ List<String> requested = new ArrayList<>(new LinkedHashSet<>(instanceIds));+ // The region lock keeps two groups from each attaching the same instance at once.+ synchronized (lockFor(region)) {+ synchronized (lockFor(asgKey(region, name))) {+ AutoScalingGroup asg = requireGroup(region, name);+ // An instance belongs to one group at a time, so the whole batch fails before any tag changes.+ List<String> conflicts = new ArrayList<>();+ for (AutoScalingGroup group : groups.values()) {+ if (group == null || !region.equals(group.getRegion())) {+ continue;+ }+ // Under the group's own lock, which guards its member list against the reconciler.+ synchronized (lockFor(asgKey(region, group.getAutoScalingGroupName()))) {+ for (AsgInstance member : group.getInstances()) {+ if (requested.contains(member.getInstanceId())) {+ conflicts.add("The Instance: " + member.getInstanceId()+ + " is already part of AutoScalingGroup:" + group.getAutoScalingGroupName());+ }+ }+ }+ }+ if (!conflicts.isEmpty()) {+ throw new AwsException("ValidationError", conflicts.toString(), 400);+ }+ // Attaching does not yet refuse an ID EC2 has no instance for, as AWS does, so such+ // an ID gets no tags: they would outlive it in EC2's DescribeTags.+ List<String> existing = requested.stream()+ .filter(id -> ec2Service.findInstanceForAccount(regionResolver.getAccountId(), region, id)+ .isPresent())+ .toList();+ if (!existing.isEmpty()) {+ ec2Service.createSystemTags(region, existing, propagatedInstanceTags(asg, List.of()));+ }+ for (String id : requested) {+ AsgInstance inst = new AsgInstance();+ inst.setInstanceId(id);+ inst.setLifecycleState("InService");+ inst.setHealthStatus("Healthy");+ inst.setAvailabilityZone(+ asg.getAvailabilityZones().isEmpty() ? region + "a" : asg.getAvailabilityZones().get(0));+ inst.setLaunchConfigurationName(asg.getLaunchConfigurationName());+ inst.setLaunchTemplateId(asg.getLaunchTemplateId());+ inst.setLaunchTemplateName(asg.getLaunchTemplateName());+ inst.setLaunchTemplateVersion(asg.getLaunchTemplateVersion());+ asg.getInstances().add(inst);+ }+ if (asg.getInstances().size() > asg.getDesiredCapacity()) {+ asg.setDesiredCapacity(asg.getInstances().size());+ }+ groups.put(asgKey(region, name), asg);+ }}- groups.put(asgKey(region, name), asg);}public void detachInstances(String region, String name, List<String> instanceIds,@@ -874,6 +930,10 @@ public class AutoScalingService implements PassedRoleLookup {AutoScalingGroup asg = requireGroup(region, name);List<String> detached = asg.getInstances().stream().map(AsgInstance::getInstanceId).filter(instanceIds::contains).toList();+ if (!detached.isEmpty()) {+ // Detaching removes only the group-name tag, and only where it still names this group.+ ec2Service.deleteSystemTag(region, detached, GROUP_NAME_TAG, name);+ }releaseRefreshOwnership(asg, detached);asg.getInstances().removeIf(i -> instanceIds.contains(i.getInstanceId()));if (decrementDesiredCapacity) {diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.javaindex ba19309488..72fcaae145 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java@@ -9984,6 +9984,15 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabpublic void deleteTags(String region, List<String> resourceIds, List<Tag> tagList) {validateTagTargets(region, resourceIds);validateUserTagKeys(tagList);+ deleteResourceTags(region, resourceIds, tagList);+ }++ /** Service-owned tag cleanup, separate from the public EC2 DeleteTags operation. */+ public void deleteSystemTag(String region, List<String> resourceIds, String tagKey, String tagValue) {+ deleteResourceTags(region, resourceIds, List.of(new Tag(tagKey, tagValue)));+ }++ private void deleteResourceTags(String region, List<String> resourceIds, List<Tag> tagList) {ensureDefaultResources(region);for (String resourceId : resourceIds) {withTopologyLockIfNeeded(region, resourceId, () -> {diff --git a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingInstanceMembershipTagIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingInstanceMembershipTagIntegrationTest.javanew file mode 100644index 0000000000..d5b05d87ed--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingInstanceMembershipTagIntegrationTest.java@@ -0,0 +1,158 @@+package io.github.hectorvent.floci.services.autoscaling;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.path.xml.XmlPath;+import io.restassured.response.ValidatableResponse;+import jakarta.inject.Inject;+import org.junit.jupiter.api.Test;++import java.util.HashMap;+import java.util.List;+import java.util.Map;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;+import static org.junit.jupiter.api.Assertions.assertEquals;++/**+ * The {@code aws:autoscaling:groupName} tag over a member's lifecycle, as the EC2 Auto Scaling user+ * guide describes it: the group adds it to the instances it launches and attaches, attaching also+ * applies the group's PropagateAtLaunch tags, and detaching removes only that one tag.+ */+@QuarkusTest+class AutoScalingInstanceMembershipTagIntegrationTest {++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=414141414141/20261022/us-east-1/autoscaling/aws4_request";+ private static final String EC2_AUTH = AUTH.replace("/autoscaling/", "/ec2/");+ private static final String GROUP_NAME_TAG = "aws:autoscaling:groupName";++ @Inject+ AutoScalingReconciler reconciler;++ @Test+ void groupNameTagFollowsLaunchAttachAndDetach() {+ String name = "membership-" + UUID.randomUUID();+ String other = name + "-other";+ given().header("Authorization", EC2_AUTH).formParam("Action", "CreateLaunchTemplate")+ .formParam("LaunchTemplateName", name)+ .formParam("LaunchTemplateData.ImageId", "ami-12345678")+ .formParam("LaunchTemplateData.InstanceType", "t3.micro")+ .formParam("LaunchTemplateData.TagSpecification.1.ResourceType", "instance")+ .formParam("LaunchTemplateData.TagSpecification.1.Tag.1.Key", "Source")+ .formParam("LaunchTemplateData.TagSpecification.1.Tag.1.Value", "template")+ .post("/").then().statusCode(200);+ given().header("Authorization", AUTH).formParam("Action", "CreateAutoScalingGroup")+ .formParam("AutoScalingGroupName", name)+ .formParam("LaunchTemplate.LaunchTemplateName", name).formParam("LaunchTemplate.Version", "1")+ .formParam("MinSize", "0").formParam("MaxSize", "3").formParam("DesiredCapacity", "1")+ .formParam("AvailabilityZones.member.1", "us-east-1a")+ .formParam("Tags.member.1.Key", "Team").formParam("Tags.member.1.Value", "blue")+ .formParam("Tags.member.1.PropagateAtLaunch", "true")+ .formParam("Tags.member.2.Key", "Private").formParam("Tags.member.2.Value", "group-only")+ .formParam("Tags.member.2.PropagateAtLaunch", "false")+ .post("/").then().statusCode(200);+ given().header("Authorization", AUTH).formParam("Action", "CreateAutoScalingGroup")+ .formParam("AutoScalingGroupName", other)+ .formParam("LaunchTemplate.LaunchTemplateName", name).formParam("LaunchTemplate.Version", "1")+ .formParam("MinSize", "0").formParam("MaxSize", "3").formParam("DesiredCapacity", "0")+ .formParam("AvailabilityZones.member.1", "us-east-1a")+ .post("/").then().statusCode(200);+ String standalone = null;+ try {+ reconciler.reconcileAll();+ String launched = given().header("Authorization", AUTH)+ .formParam("Action", "DescribeAutoScalingGroups").formParam("AutoScalingGroupNames.member.1", name)+ .post("/").then().statusCode(200)+ .body("DescribeAutoScalingGroupsResponse.DescribeAutoScalingGroupsResult"+ + ".AutoScalingGroups.member.Instances.member.size()", equalTo(1))+ .extract().path("DescribeAutoScalingGroupsResponse.DescribeAutoScalingGroupsResult"+ + ".AutoScalingGroups.member.Instances.member.InstanceId");+ assertEquals(Map.of("Source", "template", "Team", "blue"), userTags(launched));+ assertEquals(name, instanceTags(launched).get(GROUP_NAME_TAG));+ assertEquals(List.of(launched), instancesTaggedWith(name));++ standalone = given().header("Authorization", EC2_AUTH).formParam("Action", "RunInstances")+ .formParam("ImageId", "ami-12345678").formParam("InstanceType", "t3.micro")+ .formParam("MinCount", "1").formParam("MaxCount", "1")+ .formParam("TagSpecification.1.ResourceType", "instance")+ .formParam("TagSpecification.1.Tag.1.Key", "Team")+ .formParam("TagSpecification.1.Tag.1.Value", "red")+ .formParam("TagSpecification.1.Tag.2.Key", "Owner")+ .formParam("TagSpecification.1.Tag.2.Value", "me")+ .post("/").then().statusCode(200)+ .extract().path("RunInstancesResponse.instancesSet.item.instanceId");+ attach(name, standalone).statusCode(200);+ assertEquals(Map.of("Owner", "me", "Team", "blue"), userTags(standalone));+ assertEquals(name, instanceTags(standalone).get(GROUP_NAME_TAG));++ // An ID EC2 has no instance for gets no tags, which would otherwise outlive it in DescribeTags.+ String unknown = "i-0abcdef1234567890";+ attach(other, unknown);+ given().header("Authorization", EC2_AUTH).formParam("Action", "DescribeTags")+ .formParam("Filter.1.Name", "resource-id").formParam("Filter.1.Value.1", unknown)+ .post("/").then().statusCode(200)+ .body("DescribeTagsResponse.tagSet.item.size()", equalTo(0));++ String alreadyMember = "[The Instance: " + standalone + " is already part of AutoScalingGroup:" + name + "]";+ for (String group : List.of(name, other)) {+ attach(group, standalone).statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"))+ .body("ErrorResponse.Error.Message", equalTo(alreadyMember));+ }+ assertEquals(name, instanceTags(standalone).get(GROUP_NAME_TAG));++ given().header("Authorization", AUTH).formParam("Action", "DetachInstances")+ .formParam("AutoScalingGroupName", name).formParam("InstanceIds.member.1", standalone)+ .formParam("ShouldDecrementDesiredCapacity", "true")+ .post("/").then().statusCode(200);+ assertEquals(Map.of("Owner", "me", "Team", "blue"), instanceTags(standalone));+ assertEquals(List.of(launched), instancesTaggedWith(name));+ } finally {+ for (String group : List.of(name, other)) {+ given().header("Authorization", AUTH).formParam("Action", "DeleteAutoScalingGroup")+ .formParam("AutoScalingGroupName", group).formParam("ForceDelete", "true").post("/");+ }+ if (standalone != null) {+ given().header("Authorization", EC2_AUTH).formParam("Action", "TerminateInstances")+ .formParam("InstanceId.1", standalone).post("/");+ }+ given().header("Authorization", EC2_AUTH).formParam("Action", "DeleteLaunchTemplate")+ .formParam("LaunchTemplateName", name).post("/");+ }+ }++ private static ValidatableResponse attach(String group, String instanceId) {+ return given().header("Authorization", AUTH).formParam("Action", "AttachInstances")+ .formParam("AutoScalingGroupName", group).formParam("InstanceIds.member.1", instanceId)+ .post("/").then();+ }++ private static Map<String, String> instanceTags(String instanceId) {+ XmlPath xml = given().header("Authorization", EC2_AUTH).formParam("Action", "DescribeInstances")+ .formParam("InstanceId.1", instanceId).post("/").then().statusCode(200).extract().xmlPath();+ String item = "DescribeInstancesResponse.reservationSet.item.instancesSet.item.tagSet.item";+ List<String> keys = xml.getList(item + ".key");+ List<String> values = xml.getList(item + ".value");+ Map<String, String> tags = new HashMap<>();+ for (int i = 0; i < keys.size(); i++) {+ tags.put(keys.get(i), values.get(i));+ }+ return tags;+ }++ /** The instance's tags without the {@code aws:} ones AWS adds on its own, such as launch template ids. */+ private static Map<String, String> userTags(String instanceId) {+ Map<String, String> tags = instanceTags(instanceId);+ tags.keySet().removeIf(key -> key.startsWith("aws:"));+ return tags;+ }++ private static List<String> instancesTaggedWith(String group) {+ return given().header("Authorization", EC2_AUTH).formParam("Action", "DescribeInstances")+ .formParam("Filter.1.Name", "tag:" + GROUP_NAME_TAG).formParam("Filter.1.Value.1", group)+ .post("/").then().statusCode(200).extract().xmlPath()+ .getList("DescribeInstancesResponse.reservationSet.item.instancesSet.item.instanceId");+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconcilerTest.java b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconcilerTest.javaindex 15a719cc8f..42aded3cc0 100644--- a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconcilerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconcilerTest.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.autoscaling;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.services.autoscaling.model.AsgInstance;import io.github.hectorvent.floci.services.autoscaling.model.AutoScalingGroup;+import io.github.hectorvent.floci.services.autoscaling.model.CapacityReservationSpecification;import io.github.hectorvent.floci.services.autoscaling.model.LaunchConfiguration;import io.github.hectorvent.floci.services.autoscaling.model.MixedInstancesPolicy;import io.github.hectorvent.floci.services.autoscaling.model.ScalingActivity;@@ -28,6 +29,7 @@ import org.mockito.ArgumentCaptor;import java.util.List;import java.util.Map;import java.util.Set;+import java.util.stream.Collectors;import java.util.stream.Stream;import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;@@ -39,6 +41,7 @@ import static org.mockito.Mockito.any;import static org.mockito.Mockito.anyBoolean;import static org.mockito.Mockito.anyList;import static org.mockito.Mockito.anyString;+import static org.mockito.Mockito.argThat;import static org.mockito.Mockito.doAnswer;import static org.mockito.Mockito.eq;import static org.mockito.Mockito.isNull;@@ -183,7 +186,8 @@ class AutoScalingReconcilerTest {when(ec2Service.iamInstanceProfileArn(version.getData())).thenReturn("arn:aws:iam::000000000000:instance-profile/app-profile");List<Tag> instanceTags = List.of(new Tag("app.ClusterId", "development"));- List<Tag> propagatedTags = List.of(new Tag("app.ClusterId", "development"), new Tag("job-id", "2001"));+ List<Tag> propagatedTags = List.of(new Tag("app.ClusterId", "development"), new Tag("job-id", "2001"),+ new Tag("aws:autoscaling:groupName", "app-asg"));version.getData().setTagSpecifications(List.of(new LaunchTemplateData.TagSpecification("instance", instanceTags)));when(ec2Service.describeLaunchTemplates("us-east-1", List.of("lt-123"), List.of(), Map.of()))@@ -221,6 +225,74 @@ class AutoScalingReconcilerTest {assertEquals("development", tags.getValue().get(0).getValue());assertEquals("job-id", tags.getValue().get(1).getKey());assertEquals("2001", tags.getValue().get(1).getValue());+ assertEquals("aws:autoscaling:groupName", tags.getValue().get(2).getKey());+ assertEquals("app-asg", tags.getValue().get(2).getValue());+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void scaleOutTagsTheActualGroupNameOverConflictingTemplateAndGroupTags(boolean propagateGroupNameTag) {+ AutoScalingService asgService = scalingService();+ Ec2Service ec2Service = mock(Ec2Service.class);+ AutoScalingReconciler reconciler = new AutoScalingReconciler(asgService, ec2Service, mock(ElbV2Service.class));+ AutoScalingGroup asg = launchTemplateAsg();+ asg.getTags().put("aws:autoscaling:groupName", "spoofed-group");+ asg.getTagPropagateAtLaunch().put("aws:autoscaling:groupName", propagateGroupNameTag);+ asg.getTags().put("shared", "group-value");+ asg.getTagPropagateAtLaunch().put("shared", true);+ asg.getTags().put("control-plane-only", "private");+ asg.getTagPropagateAtLaunch().put("control-plane-only", false);+ stubLaunchTemplate(ec2Service, "ami-version-1", "t3.micro");+ LaunchTemplate version = ec2Service.describeLaunchTemplateVersions("us-east-1", "lt-123", null, List.of("1"))+ .getFirst();+ version.getData().setTagSpecifications(List.of(new LaunchTemplateData.TagSpecification("instance", List.of(+ new Tag("aws:autoscaling:groupName", "spoofed-template"), new Tag("shared", "template-value"),+ new Tag("template-only", "kept")))));+ when(asgService.saveAutoScalingGroupIfPresent(asg)).thenReturn(true);+ when(ec2Service.runInstances(any(), any(), any(), any(Integer.class), any(Integer.class), any(),+ any(), any(), any(), any(), any(), any(), any(), any(), any(Integer.class), any(), any(), any(), any(),+ anyBoolean(), any(), any(), any(), eq(false), isNull(), isNull()))+ .thenReturn(reservation(ec2Instance("i-tagged", InstanceState.pending())));++ reconciler.reconcile(asg);++ ArgumentCaptor<List<Tag>> tags = ArgumentCaptor.captor();+ verify(ec2Service).runInstances(any(), any(), any(), any(Integer.class), any(Integer.class), any(),+ any(), any(), any(), tags.capture(), any(), any(), any(), any(), any(Integer.class), any(), any(), any(),+ any(), anyBoolean(), any(), any(), any(), eq(false), isNull(), isNull());+ assertEquals(Map.of("aws:autoscaling:groupName", "app-asg", "shared", "group-value", "template-only", "kept"),+ tags.getValue().stream().collect(Collectors.toMap(Tag::getKey, Tag::getValue)));+ assertEquals("spoofed-group", asg.getTags().get("aws:autoscaling:groupName"));+ }++ @Test+ void capacityFallbackRetryStillTagsTheGroupName() {+ AutoScalingService asgService = scalingService();+ Ec2Service ec2Service = mock(Ec2Service.class);+ AutoScalingReconciler reconciler = new AutoScalingReconciler(asgService, ec2Service, mock(ElbV2Service.class));+ AutoScalingGroup asg = launchTemplateAsg();+ CapacityReservationSpecification capacity = new CapacityReservationSpecification();+ capacity.setCapacityReservationPreference("capacity-reservations-first");+ asg.setCapacityReservationSpecification(capacity);+ stubLaunchTemplate(ec2Service, "ami-version-1", "t3.micro");+ when(asgService.saveAutoScalingGroupIfPresent(asg)).thenReturn(true);+ when(ec2Service.runInstances(any(), any(), any(), any(Integer.class), any(Integer.class), any(),+ any(), any(), any(), any(), any(), any(), any(), any(), any(Integer.class), any(), any(), any(), any(),+ anyBoolean(), any(), any(), any(), eq(false), isNull(), any()))+ .thenThrow(new AwsException("InsufficientInstanceCapacity", "no reserved capacity", 400))+ .thenReturn(reservation(ec2Instance("i-fallback", InstanceState.pending())));++ reconciler.reconcile(asg);++ ArgumentCaptor<List<Tag>> tags = ArgumentCaptor.captor();+ verify(ec2Service, times(2)).runInstances(any(), any(), any(), any(Integer.class), any(Integer.class), any(),+ any(), any(), any(), tags.capture(), any(), any(), any(), any(), any(Integer.class), any(), any(), any(),+ any(), anyBoolean(), any(), any(), any(), eq(false), isNull(), any());+ for (List<Tag> launchTags : tags.getAllValues()) {+ assertEquals(Map.of("aws:autoscaling:groupName", "app-asg"),+ launchTags.stream().collect(Collectors.toMap(Tag::getKey, Tag::getValue)));+ }+ assertEquals("i-fallback", asg.getInstances().getFirst().getInstanceId());}@Test@@ -238,7 +310,7 @@ class AutoScalingReconcilerTest {Reservation reservation = new Reservation();reservation.setInstances(List.of(ec2Instance));when(ec2Service.runInstances(eq("us-east-1"), eq("ami-version-1"), eq("t3.micro"),- eq(1), eq(1), eq(null), eq(List.of()), eq(null), eq(null), eq(List.of()),+ eq(1), eq(1), eq(null), eq(List.of()), eq(null), eq(null), onlyGroupNameTag("app-asg"),eq(null), eq(null), eq(null),isNull(), eq(0), isNull(), isNull(), isNull(), any(),anyBoolean(), isNull(), isNull(), any(), eq(false), isNull(), isNull())).thenReturn(reservation);@@ -333,7 +405,7 @@ class AutoScalingReconcilerTest {Reservation reservation = new Reservation();reservation.setInstances(List.of(ec2Instance));when(ec2Service.runInstances(eq("us-east-1"), eq("ami-version-1"), eq("t3.micro"),- eq(1), eq(1), eq(null), eq(List.of()), eq(null), eq(null), eq(List.of()),+ eq(1), eq(1), eq(null), eq(List.of()), eq(null), eq(null), onlyGroupNameTag("app-asg"),eq(null), eq(null), eq(null),isNull(), eq(0), isNull(), isNull(), isNull(), any(),anyBoolean(), isNull(), isNull(), any(), eq(false), isNull(), isNull())).thenReturn(reservation);@@ -380,7 +452,7 @@ class AutoScalingReconcilerTest {reservation.setInstances(List.of(ec2Instance));when(ec2Service.runInstances(eq("us-east-1"), eq("ami-lc"), eq("t3.micro"),eq(1), eq(1), eq(null), anyList(), eq(null), eq(null),- anyList(), eq(null), eq(null), eq(associatePublicIp),+ onlyGroupNameTag("app-asg"), eq(null), eq(null), eq(associatePublicIp),isNull(), eq(0), isNull(), isNull(), isNull(), any(),anyBoolean(), isNull(), isNull(), any(), eq(false), isNull(), isNull())).thenReturn(reservation);@@ -388,7 +460,7 @@ class AutoScalingReconcilerTest {verify(ec2Service).runInstances(eq("us-east-1"), eq("ami-lc"), eq("t3.micro"),eq(1), eq(1), eq(null), anyList(), eq(null), eq(null),- anyList(), eq(null), eq(null), eq(associatePublicIp),+ onlyGroupNameTag("app-asg"), eq(null), eq(null), eq(associatePublicIp),isNull(), eq(0), isNull(), isNull(), isNull(), any(), anyBoolean(), isNull(), isNull(), any(), eq(false), isNull(), isNull());}@@ -422,7 +494,7 @@ class AutoScalingReconcilerTest {reservation.setInstances(List.of(ec2Instance));when(ec2Service.runInstances(eq("us-east-1"), eq("ami-version-7"), eq("t3.micro"),eq(1), eq(1), eq(null), eq(List.of()), eq(null), eq(null),- eq(List.of()), eq(null), eq(null), eq(null),+ onlyGroupNameTag("app-asg"), eq(null), eq(null), eq(null),isNull(), eq(0), isNull(), isNull(), isNull(), any(),anyBoolean(), isNull(), isNull(), any(), eq(false), isNull(), isNull())).thenReturn(reservation);@@ -480,7 +552,7 @@ class AutoScalingReconcilerTest {reservation.setInstances(List.of(ec2Instance));when(ec2Service.runInstances(eq("us-east-1"), eq("ami-version-3"), eq("t3.small"),eq(1), eq(1), eq(null), eq(List.of()), eq(null), eq(null),- eq(List.of()), eq("#!/bin/bash\necho hi\n"), eq(null), eq(null),+ onlyGroupNameTag("app-asg"), eq("#!/bin/bash\necho hi\n"), eq(null), eq(null),isNull(), eq(0), isNull(), eq(metadata), isNull(), any(),anyBoolean(), isNull(), isNull(), any(), eq(false), isNull(), isNull())).thenReturn(reservation);@@ -493,7 +565,7 @@ class AutoScalingReconcilerTest {assertEquals("t3.small", asg.getInstances().getFirst().getInstanceType());verify(ec2Service).runInstances(eq("us-east-1"), eq("ami-version-3"), eq("t3.small"),eq(1), eq(1), eq(null), eq(List.of()), eq(null), eq(null),- eq(List.of()), eq("#!/bin/bash\necho hi\n"), eq(null), eq(null),+ onlyGroupNameTag("app-asg"), eq("#!/bin/bash\necho hi\n"), eq(null), eq(null),isNull(), eq(0), isNull(), eq(metadata), isNull(), any(), anyBoolean(), isNull(), isNull(), any(), eq(false), isNull(), isNull());assertNull(version.getData().getUserData());}@@ -1100,6 +1172,13 @@ class AutoScalingReconcilerTest {return asg;}+ /** Matches the tags of a launch whose template and group add none of their own. */+ private static List<Tag> onlyGroupNameTag(String groupName) {+ return argThat(tags -> tags != null && tags.size() == 1+ && "aws:autoscaling:groupName".equals(tags.getFirst().getKey())+ && groupName.equals(tags.getFirst().getValue()));+ }+private static void stubLaunchTemplate(Ec2Service ec2Service, String imageId, String instanceType) {LaunchTemplate launchTemplate = new LaunchTemplate();launchTemplate.setLaunchTemplateId("lt-123");diff --git a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingServiceTest.javaindex 8b636eb90a..828c323c80 100644--- a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingServiceTest.java@@ -22,11 +22,13 @@ import io.github.hectorvent.floci.services.ec2.model.Instance;import io.github.hectorvent.floci.services.ec2.model.LaunchTemplate;import io.github.hectorvent.floci.services.ec2.model.LaunchTemplateData;import io.github.hectorvent.floci.services.ec2.model.Reservation;+import io.github.hectorvent.floci.services.ec2.model.Tag;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import org.junit.jupiter.params.ParameterizedTest;import org.junit.jupiter.params.provider.MethodSource;import org.junit.jupiter.params.provider.ValueSource;+import org.mockito.ArgumentCaptor;import java.io.ByteArrayOutputStream;import java.io.IOException;@@ -36,12 +38,19 @@ import java.util.List;import java.util.Map;import java.util.Optional;import java.util.Set;+import java.util.stream.Collectors;import java.util.stream.Stream;import java.util.zip.GZIPOutputStream;import static org.junit.jupiter.api.Assertions.*;+import static org.mockito.Mockito.anyList;+import static org.mockito.Mockito.anyString;+import static org.mockito.Mockito.clearInvocations;import static org.mockito.Mockito.doThrow;+import static org.mockito.Mockito.eq;import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.times;import static org.mockito.Mockito.verify;import static org.mockito.Mockito.verifyNoInteractions;import static org.mockito.Mockito.when;@@ -136,6 +145,110 @@ class AutoScalingServiceTest {assertNull(group.getLaunchConfigurationName());}+ @Test+ void attachedInstancesReceiveThePropagatingTagsAndTheirGroupName() {+ service.ec2Service = mock(Ec2Service.class);+ AutoScalingGroup group = service.describeAutoScalingGroups(REGION, List.of("test-asg")).getFirst();+ group.getTags().put("env", "group");+ group.getTags().put("hidden", "group");+ group.getTags().put("aws:autoscaling:groupName", "spoofed");+ group.getTagPropagateAtLaunch().putAll(Map.of("env", true, "hidden", false,+ "aws:autoscaling:groupName", true));+ ec2HoldsInstances("i-attached");++ service.attachInstances(REGION, "test-asg", List.of("i-attached"));++ ArgumentCaptor<List<Tag>> appliedTags = ArgumentCaptor.captor();+ verify(service.ec2Service).createSystemTags(eq(REGION), eq(List.of("i-attached")), appliedTags.capture());+ assertEquals(Map.of("env", "group", "aws:autoscaling:groupName", "test-asg"),+ appliedTags.getValue().stream().collect(Collectors.toMap(Tag::getKey, Tag::getValue)));+ assertEquals(List.of("i-attached"), group.getInstances().stream().map(AsgInstance::getInstanceId).toList());+ }++ @Test+ void attachTagsOnlyTheInstancesEc2Holds() {+ service.ec2Service = mock(Ec2Service.class);+ ec2HoldsInstances("i-held");++ service.attachInstances(REGION, "test-asg", List.of("i-held", "i-unknown"));++ verify(service.ec2Service).createSystemTags(eq(REGION), eq(List.of("i-held")), anyList());+ verify(service.ec2Service, times(1)).createSystemTags(anyString(), anyList(), anyList());+ }++ @Test+ void attachCountsARepeatedInstanceOnce() {+ service.ec2Service = mock(Ec2Service.class);+ ec2HoldsInstances("i-repeated");++ service.attachInstances(REGION, "test-asg", List.of("i-repeated", "i-repeated"));++ verify(service.ec2Service).createSystemTags(eq(REGION), eq(List.of("i-repeated")), anyList());+ assertEquals(List.of("i-repeated"), service.describeAutoScalingGroups(REGION, List.of("test-asg"))+ .getFirst().getInstances().stream().map(AsgInstance::getInstanceId).toList());+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void attachRejectsAnInstanceThatAlreadyBelongsToAGroupBeforeTaggingAnyOfTheBatch(boolean sameGroup) {+ service.createAutoScalingGroup(REGION, "other-asg", null, "lt-original", null, "1", null,+ 0, 3, 0, 300, List.of(REGION + "a"), List.of(), List.of(), List.of(),+ "EC2", 0, List.of("Default"), Map.of(), Map.of(), AsgOptionalFields.none());+ service.ec2Service = mock(Ec2Service.class);+ service.attachInstances(REGION, "test-asg", List.of("i-owned"));+ clearInvocations(service.ec2Service);+ String target = sameGroup ? "test-asg" : "other-asg";+ AutoScalingGroup group = service.describeAutoScalingGroups(REGION, List.of(target)).getFirst();+ int desired = group.getDesiredCapacity();+ List<String> members = group.getInstances().stream().map(AsgInstance::getInstanceId).toList();++ AwsException failure = assertThrows(AwsException.class,+ () -> service.attachInstances(REGION, target, List.of("i-free", "i-owned")));++ assertEquals("ValidationError", failure.getErrorCode());+ assertEquals(400, failure.getHttpStatus());+ assertEquals("[The Instance: i-owned is already part of AutoScalingGroup:test-asg]", failure.getMessage());+ assertEquals(members, group.getInstances().stream().map(AsgInstance::getInstanceId).toList());+ assertEquals(desired, group.getDesiredCapacity());+ verifyNoInteractions(service.ec2Service);+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void detachRemovesOnlyTheDetachedInstancesGroupNameTag(boolean decrementDesiredCapacity) {+ service.ec2Service = mock(Ec2Service.class);+ service.attachInstances(REGION, "test-asg", List.of("i-detached", "i-retained"));++ service.detachInstances(REGION, "test-asg", List.of("i-detached"), decrementDesiredCapacity);++ verify(service.ec2Service).deleteSystemTag(+ REGION, List.of("i-detached"), "aws:autoscaling:groupName", "test-asg");+ AutoScalingGroup group = service.describeAutoScalingGroups(REGION, List.of("test-asg")).getFirst();+ assertEquals(List.of("i-retained"), group.getInstances().stream().map(AsgInstance::getInstanceId).toList());+ assertEquals(decrementDesiredCapacity ? 1 : 2, group.getDesiredCapacity());+ }++ @Test+ void detachingAnInstanceTheGroupDoesNotHoldChangesNoTags() {+ service.ec2Service = mock(Ec2Service.class);+ service.attachInstances(REGION, "test-asg", List.of("i-member"));+ clearInvocations(service.ec2Service);++ service.detachInstances(REGION, "test-asg", List.of("i-stranger"), false);++ verify(service.ec2Service, never()).deleteSystemTag(anyString(), anyList(), anyString(), anyString());+ assertEquals(List.of("i-member"), service.describeAutoScalingGroups(REGION, List.of("test-asg"))+ .getFirst().getInstances().stream().map(AsgInstance::getInstanceId).toList());+ }++ private void ec2HoldsInstances(String... instanceIds) {+ for (String id : instanceIds) {+ Instance instance = new Instance();+ instance.setInstanceId(id);+ when(service.ec2Service.findInstanceForAccount("000000000000", REGION, id)).thenReturn(Optional.of(instance));+ }+ }+@Testvoid anInstanceRefreshResolvesTheProfileOfTheTemplateItsGroupLaunchesFromOnceItApplies() {Ec2Service ec2Service = mock(Ec2Service.class);@@ -971,6 +1084,7 @@ class AutoScalingServiceTest {StorageBackedMap<AutoScalingGroup> groups = new StorageBackedMap<>(storage);groups.putAll(service.groups);service.groups = groups;+ service.ec2Service = mock(Ec2Service.class);service.attachInstances(REGION, "test-asg", List.of("i-live"));service.createOrUpdateTags(REGION, "test-asg", "auto-scaling-group", Map.of("k", "v"), Map.of());diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.javaindex 95bf1712ea..6d03a8567d 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java@@ -202,6 +202,27 @@ class Ec2ServiceTest {assertEquals(List.of(membership), instance.getTags());}+ @Test+ void deleteSystemTagRemovesTheTagOnlyWhenItsValueMatches() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class), mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class),+ new Ec2InstanceTypeCatalog(), new InMemoryStorageFactory());+ Tag membership = new Tag("aws:autoscaling:groupName", "group-a");+ Tag userTag = new Tag("env", "test");+ List<String> ids = List.of(service.runInstances("us-east-1", "ami-test", "t3.micro",+ 1, 1, null, List.of(), null, null, List.of(membership, userTag), null, null)+ .getInstances().getFirst().getInstanceId());++ service.deleteSystemTag("us-east-1", ids, membership.getKey(), "group-b");+ assertEquals(List.of(membership, userTag), service.describeInstances("us-east-1", ids, Map.of())+ .getFirst().getInstances().getFirst().getTags());++ service.deleteSystemTag("us-east-1", ids, membership.getKey(), "group-a");+ assertEquals(List.of(userTag), service.describeInstances("us-east-1", ids, Map.of())+ .getFirst().getInstances().getFirst().getTags());+ assertEquals(List.of(userTag), service.resourceTags("us-east-1", ids.getFirst()));+ }+@Testvoid subnetAvailableAddressesTrackAllocationsAndRelease() {