Light, fluffy, and always free - The AWS Local Emulator alternative
feat(autoscaling): P0 operations and lifecycle-hook delete-by-name (#2673)
Sam Fakhreddinee9a379b37a36
diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandler.javaindex ff8f9eb52c..53c8a44e0b 100644--- a/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandler.java@@ -50,6 +50,8 @@ public class AutoScalingQueryHandler {case "DeleteTags" -> handleDeleteTags(p, region);// Instancescase "DescribeAutoScalingInstances" -> handleDescribeAutoScalingInstances(p, region);+ case "SetInstanceProtection" -> handleSetInstanceProtection(p, region);+ case "SetInstanceHealth" -> handleSetInstanceHealth(p, region);case "AttachInstances" -> handleAttachInstances(p, region);case "DetachInstances" -> handleDetachInstances(p, region);case "TerminateInstanceInAutoScalingGroup" -> handleTerminateInstance(p, region);@@ -472,6 +474,32 @@ public class AutoScalingQueryHandler {return ok(xml.build());}+ private Response handleSetInstanceProtection(MultivaluedMap<String, String> p, String region) {+ String groupName = p.getFirst("AutoScalingGroupName");+ List<String> instanceIds = memberList(p, "InstanceIds");+ boolean protectedFromScaleIn = requiredBoolParam(p, "ProtectedFromScaleIn");+ service.setInstanceProtection(region, groupName, instanceIds, protectedFromScaleIn);+ return ok(new XmlBuilder()+ .start("SetInstanceProtectionResponse", NS)+ .raw(AwsQueryResponse.responseMetadata())+ .end("SetInstanceProtectionResponse")+ .build());+ }++ private Response handleSetInstanceHealth(MultivaluedMap<String, String> p, String region) {+ String instanceId = p.getFirst("InstanceId");+ String healthStatus = p.getFirst("HealthStatus");+ // Defaults to true per the 2011-01-01 model: absent means "respect the grace period".+ boolean shouldRespectGracePeriod = Boolean.parseBoolean(+ Optional.ofNullable(p.getFirst("ShouldRespectGracePeriod")).orElse("true"));+ service.setInstanceHealth(region, instanceId, healthStatus, shouldRespectGracePeriod);+ return ok(new XmlBuilder()+ .start("SetInstanceHealthResponse", NS)+ .raw(AwsQueryResponse.responseMetadata())+ .end("SetInstanceHealthResponse")+ .build());+ }+private static void appendInstanceLaunchTemplateXml(XmlBuilder xml, AsgInstance inst) {if (inst.getLaunchTemplateId() == null && inst.getLaunchTemplateName() == null) {return;@@ -1134,6 +1162,22 @@ public class AutoScalingQueryHandler {return Boolean.parseBoolean(val);}+ /** A required boolean member must be present and exactly "true"/"false" — never silently coerced to false. */+ private boolean requiredBoolParam(MultivaluedMap<String, String> p, String key) {+ String val = p.getFirst(key);+ if (val == null || val.isBlank()) {+ throw new AwsException("ValidationError",+ "1 validation error detected: Value null at '" + key+ + "' failed to satisfy constraint: Member must not be null", 400);+ }+ if (!"true".equalsIgnoreCase(val) && !"false".equalsIgnoreCase(val)) {+ throw new AwsException("ValidationError",+ "1 validation error detected: Value '" + val + "' at '" + key+ + "' failed to satisfy constraint: Member must be a valid boolean", 400);+ }+ return Boolean.parseBoolean(val);+ }+private String intString(Integer value) {return value != null ? String.valueOf(value) : null;}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 aaf0495caf..638a4a8ad2 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@@ -17,6 +17,7 @@ import jakarta.inject.Inject;import java.time.Instant;import java.util.*;import java.util.concurrent.ConcurrentHashMap;+import java.util.regex.Pattern;import java.util.stream.Collectors;@ApplicationScoped@@ -371,6 +372,56 @@ public class AutoScalingService {return all;}+ public void setInstanceProtection(String region, String groupName, List<String> instanceIds,+ boolean protectedFromScaleIn) {+ if (instanceIds == null || instanceIds.isEmpty()) {+ throw new AwsException("ValidationError", "At least one instance ID is required.", 400);+ }+ AutoScalingGroup asg = requireGroup(region, groupName);+ Set<String> requested = new HashSet<>(instanceIds);+ Set<String> found = asg.getInstances().stream()+ .map(AsgInstance::getInstanceId)+ .filter(requested::contains)+ .collect(Collectors.toSet());+ if (!found.containsAll(requested)) {+ String missing = requested.stream()+ .filter(id -> !found.contains(id))+ .collect(Collectors.joining(", "));+ throw new AwsException("ValidationError",+ "Instance(s) '" + missing + "' is/are not part of Auto Scaling group '" + groupName + "'.", 400);+ }+ asg.getInstances().stream()+ .filter(instance -> requested.contains(instance.getInstanceId()))+ .forEach(instance -> instance.setProtectedFromScaleIn(protectedFromScaleIn));+ groups.put(asgKey(region, groupName), asg);+ }++ /**+ * {@code shouldRespectGracePeriod} is parsed and accepted for wire fidelity (2011-01-01 model)+ * but not yet enforced — floci does not currently track instance launch time against+ * {@link AutoScalingGroup#getHealthCheckGracePeriod()}, so the health status change below always+ * applies immediately regardless of the flag.+ */+ public void setInstanceHealth(String region, String instanceId, String healthStatus,+ boolean shouldRespectGracePeriod) {+ if (!"Healthy".equals(healthStatus) && !"Unhealthy".equals(healthStatus)) {+ throw new AwsException("ValidationError",+ "HealthStatus must be Healthy or Unhealthy.", 400);+ }+ AutoScalingGroup asg = groups.values().stream()+ .filter(group -> region.equals(group.getRegion()))+ .filter(group -> group.getInstances().stream()+ .anyMatch(instance -> instanceId != null && instanceId.equals(instance.getInstanceId())))+ .findFirst()+ .orElseThrow(() -> new AwsException("ValidationError",+ "Instance '" + instanceId + "' not found in any Auto Scaling group.", 400));+ asg.getInstances().stream()+ .filter(instance -> instanceId.equals(instance.getInstanceId()))+ .findFirst()+ .ifPresent(instance -> instance.setHealthStatus(healthStatus));+ groups.put(asgKey(region, asg.getAutoScalingGroupName()), asg);+ }+public void attachInstances(String region, String name, List<String> instanceIds) {AutoScalingGroup asg = requireGroup(region, name);for (String id : instanceIds) {@@ -560,6 +611,7 @@ public class AutoScalingService {String roleArn, String notificationMetadata,Integer heartbeatTimeout, String defaultResult) {requireGroup(region, asgName);+ validateLifecycleHookName(hookName);String key = hookKey(region, asgName, hookName);LifecycleHook hook = hooks.computeIfAbsent(key, k -> new LifecycleHook());hook.setLifecycleHookName(hookName);@@ -574,6 +626,7 @@ public class AutoScalingService {}public void deleteLifecycleHook(String region, String asgName, String hookName) {+ validateLifecycleHookName(hookName);hooks.remove(hookKey(region, asgName, hookName));}@@ -586,6 +639,11 @@ public class AutoScalingService {if (hookName == null) {return;}+ // The physical id was only ever assigned from a name that already passed this check+ // (see putLifecycleHook), so this call for parity with deleteLifecycleHook should never+ // reject a hook created through the normal path — it exists to fail loudly, not silently+ // no-op, if a corrupted or hand-authored physical id ever reaches this delete path.+ validateLifecycleHookName(hookName);List<String> keys = new ArrayList<>();for (Map.Entry<String, LifecycleHook> entry : hooks.entrySet()) {LifecycleHook hook = entry.getValue();@@ -616,6 +674,43 @@ public class AutoScalingService {String instanceId, String actionResult, String token) {// Stored-only — Phase 2 reconciler observes this via the instance lifecycle staterequireGroup(region, asgName);+ validateLifecycleHookName(hookName);+ if (token != null) {+ validateLifecycleActionToken(token);+ }+ }++ /** LifecycleHookName pattern/length from the Auto Scaling model (autoscaling/2011-01-01/service-2.json). */+ private static final Pattern LIFECYCLE_HOOK_NAME_PATTERN =+ Pattern.compile("^[A-Za-z0-9\\-_/]+$");++ private static void validateLifecycleHookName(String hookName) {+ if (hookName == null) {+ throw new AwsException("ValidationError",+ "1 validation error detected: Value null at 'lifecycleHookName' failed to satisfy constraint: "+ + "Member must not be null", 400);+ }+ if (hookName.length() > 255) {+ throw new AwsException("ValidationError",+ "1 validation error detected: Value '" + hookName+ + "' at 'lifecycleHookName' failed to satisfy constraint: Member must have length "+ + "less than or equal to 255", 400);+ }+ if (!LIFECYCLE_HOOK_NAME_PATTERN.matcher(hookName).matches()) {+ throw new AwsException("ValidationError",+ "1 validation error detected: Value '" + hookName+ + "' at 'lifecycleHookName' failed to satisfy constraint: Member must satisfy "+ + "regular expression pattern: [A-Za-z0-9\\-_/]+", 400);+ }+ }++ /** LifecycleActionToken is modeled as a fixed 36-character token (autoscaling/2011-01-01/service-2.json). */+ private static void validateLifecycleActionToken(String token) {+ if (token == null || token.length() != 36) {+ throw new AwsException("ValidationError",+ "1 validation error detected: Value at 'lifecycleActionToken' failed to satisfy constraint: "+ + "Member must have length equal to 36", 400);+ }}// ── Scaling policies ───────────────────────────────────────────────────────diff --git a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandlerTest.javaindex ab3347f8e1..f03321ecf6 100644--- a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandlerTest.java@@ -185,6 +185,141 @@ class AutoScalingQueryHandlerTest {assertTrue(xml.contains("<Version>7</Version>"));}+ @Test+ void setInstanceProtectionMutatesInstanceAndReturnsAwsQueryShape() {+ AutoScalingService service = new AutoScalingService();+ service.regionResolver = new RegionResolver(REGION, "000000000000");+ service.createAutoScalingGroup(REGION, "protected-asg", null, "lt", null, "1", null,+ 0, 2, 1, 300, List.of("us-east-1a"), List.of(), List.of(), List.of(),+ "EC2", 0, List.of("Default"), java.util.Map.of(), java.util.Map.of());+ AsgInstance instance = new AsgInstance();+ instance.setInstanceId("i-protected");+ instance.setLifecycleState("InService");+ instance.setHealthStatus("Healthy");+ service.describeAutoScalingGroups(REGION, List.of("protected-asg")).getFirst().getInstances().add(instance);++ AutoScalingQueryHandler handler = new AutoScalingQueryHandler(service);+ MultivaluedHashMap<String, String> params = new MultivaluedHashMap<>();+ params.add("AutoScalingGroupName", "protected-asg");+ params.add("InstanceIds.member.1", "i-protected");+ params.add("ProtectedFromScaleIn", "true");++ Response response = handler.handle("SetInstanceProtection", params, REGION);++ assertEquals(200, response.getStatus());+ assertTrue(((String) response.getEntity()).contains("<SetInstanceProtectionResponse"));+ assertTrue(service.describeAutoScalingInstances(REGION, List.of("i-protected"))+ .getFirst().isProtectedFromScaleIn());+ }++ @Test+ void setInstanceHealthMutatesInstanceAndReturnsAwsQueryShape() {+ AutoScalingService service = new AutoScalingService();+ service.regionResolver = new RegionResolver(REGION, "000000000000");+ service.createAutoScalingGroup(REGION, "health-asg", null, "lt", null, "1", null,+ 0, 2, 1, 300, List.of("us-east-1a"), List.of(), List.of(), List.of(),+ "EC2", 0, List.of("Default"), java.util.Map.of(), java.util.Map.of());+ AsgInstance instance = new AsgInstance();+ instance.setInstanceId("i-unhealthy");+ instance.setLifecycleState("InService");+ instance.setHealthStatus("Healthy");+ service.describeAutoScalingGroups(REGION, List.of("health-asg")).getFirst().getInstances().add(instance);++ AutoScalingQueryHandler handler = new AutoScalingQueryHandler(service);+ MultivaluedHashMap<String, String> params = new MultivaluedHashMap<>();+ params.add("InstanceId", "i-unhealthy");+ params.add("HealthStatus", "Unhealthy");++ Response response = handler.handle("SetInstanceHealth", params, REGION);++ assertEquals(200, response.getStatus());+ assertTrue(((String) response.getEntity()).contains("<SetInstanceHealthResponse"));+ assertEquals("Unhealthy", service.describeAutoScalingInstances(REGION, List.of("i-unhealthy"))+ .getFirst().getHealthStatus());+ }++ @Test+ void setInstanceProtectionRejectsMissingProtectedFromScaleIn() {+ AutoScalingService service = new AutoScalingService();+ service.regionResolver = new RegionResolver(REGION, "000000000000");+ service.createAutoScalingGroup(REGION, "no-protection-flag-asg", null, "lt", null, "1", null,+ 0, 2, 1, 300, List.of("us-east-1a"), List.of(), List.of(), List.of(),+ "EC2", 0, List.of("Default"), java.util.Map.of(), java.util.Map.of());+ AsgInstance instance = new AsgInstance();+ instance.setInstanceId("i-flagless");+ instance.setLifecycleState("InService");+ instance.setHealthStatus("Healthy");+ service.describeAutoScalingGroups(REGION, List.of("no-protection-flag-asg")).getFirst()+ .getInstances().add(instance);++ AutoScalingQueryHandler handler = new AutoScalingQueryHandler(service);+ MultivaluedHashMap<String, String> params = new MultivaluedHashMap<>();+ params.add("AutoScalingGroupName", "no-protection-flag-asg");+ params.add("InstanceIds.member.1", "i-flagless");+ // ProtectedFromScaleIn deliberately omitted — it is a required member.++ Response response = handler.handle("SetInstanceProtection", params, REGION);++ assertEquals(400, response.getStatus());+ assertTrue(((String) response.getEntity()).contains("ValidationError"));+ assertEquals(false, service.describeAutoScalingInstances(REGION, List.of("i-flagless"))+ .getFirst().isProtectedFromScaleIn(),+ "a rejected request must not silently strip/apply protection");+ }++ @Test+ void setInstanceProtectionRejectsMalformedProtectedFromScaleIn() {+ AutoScalingService service = new AutoScalingService();+ service.regionResolver = new RegionResolver(REGION, "000000000000");+ service.createAutoScalingGroup(REGION, "malformed-flag-asg", null, "lt", null, "1", null,+ 0, 2, 1, 300, List.of("us-east-1a"), List.of(), List.of(), List.of(),+ "EC2", 0, List.of("Default"), java.util.Map.of(), java.util.Map.of());+ AsgInstance instance = new AsgInstance();+ instance.setInstanceId("i-malformed");+ instance.setLifecycleState("InService");+ instance.setHealthStatus("Healthy");+ service.describeAutoScalingGroups(REGION, List.of("malformed-flag-asg")).getFirst()+ .getInstances().add(instance);++ AutoScalingQueryHandler handler = new AutoScalingQueryHandler(service);+ MultivaluedHashMap<String, String> params = new MultivaluedHashMap<>();+ params.add("AutoScalingGroupName", "malformed-flag-asg");+ params.add("InstanceIds.member.1", "i-malformed");+ params.add("ProtectedFromScaleIn", "yes");++ Response response = handler.handle("SetInstanceProtection", params, REGION);++ assertEquals(400, response.getStatus());+ assertEquals(false, service.describeAutoScalingInstances(REGION, List.of("i-malformed"))+ .getFirst().isProtectedFromScaleIn(),+ "a malformed boolean must not silently coerce to false and succeed");+ }++ @Test+ void setInstanceHealthParsesShouldRespectGracePeriodWithoutError() {+ AutoScalingService service = new AutoScalingService();+ service.regionResolver = new RegionResolver(REGION, "000000000000");+ service.createAutoScalingGroup(REGION, "grace-asg", null, "lt", null, "1", null,+ 0, 2, 1, 300, List.of("us-east-1a"), List.of(), List.of(), List.of(),+ "EC2", 0, List.of("Default"), java.util.Map.of(), java.util.Map.of());+ AsgInstance instance = new AsgInstance();+ instance.setInstanceId("i-grace");+ instance.setLifecycleState("InService");+ instance.setHealthStatus("Healthy");+ service.describeAutoScalingGroups(REGION, List.of("grace-asg")).getFirst().getInstances().add(instance);++ AutoScalingQueryHandler handler = new AutoScalingQueryHandler(service);+ MultivaluedHashMap<String, String> params = new MultivaluedHashMap<>();+ params.add("InstanceId", "i-grace");+ params.add("HealthStatus", "Unhealthy");+ params.add("ShouldRespectGracePeriod", "true");++ Response response = handler.handle("SetInstanceHealth", params, REGION);++ assertEquals(200, response.getStatus());+ assertTrue(((String) response.getEntity()).contains("<SetInstanceHealthResponse"));+ }+@Testvoid targetTrackingScalingPolicyUsesAwsQueryXmlShape() {AutoScalingService service = new AutoScalingService();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 3cc92f0b21..8648bad6fd 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@@ -636,6 +636,137 @@ class AutoScalingServiceTest {java.util.Map.of(), java.util.Map.of());}+ @Test+ void putLifecycleHookRejectsNameOutsideModeledPattern() {+ AwsException ex = assertThrows(AwsException.class, () -> service.putLifecycleHook(REGION, "test-asg",+ "bad name!", "autoscaling:EC2_INSTANCE_LAUNCHING", null, null, null, null, null));+ assertEquals("ValidationError", ex.getErrorCode());+ }++ @Test+ void deleteLifecycleHookRejectsNameOutsideModeledPattern() {+ assertThrows(AwsException.class,+ () -> service.deleteLifecycleHook(REGION, "test-asg", "bad name!"));+ }++ @Test+ void completeLifecycleActionRejectsNameOutsideModeledPattern() {+ assertThrows(AwsException.class,+ () -> service.completeLifecycleAction(REGION, "test-asg", "bad name!",+ "i-0123456789abcdef0", "CONTINUE", "12345678-1234-1234-1234-123456789012"));+ }++ @Test+ void completeLifecycleActionRejectsTokenOfWrongLength() {+ service.putLifecycleHook(REGION, "test-asg", "hook-1", "autoscaling:EC2_INSTANCE_LAUNCHING",+ null, null, null, null, null);++ AwsException ex = assertThrows(AwsException.class,+ () -> service.completeLifecycleAction(REGION, "test-asg", "hook-1",+ "i-0123456789abcdef0", "CONTINUE", "not-a-uuid"));+ assertEquals("ValidationError", ex.getErrorCode());+ }++ @Test+ void completeLifecycleActionAllowsNullTokenWhenInstanceIdIdentifiesTheAction() {+ service.putLifecycleHook(REGION, "test-asg", "hook-1", "autoscaling:EC2_INSTANCE_LAUNCHING",+ null, null, null, null, null);++ assertDoesNotThrow(() -> service.completeLifecycleAction(REGION, "test-asg", "hook-1",+ "i-0123456789abcdef0", "CONTINUE", null));+ }++ @Test+ void deleteLifecycleHookByNameRejectsNameOutsideModeledPattern() {+ AwsException ex = assertThrows(AwsException.class,+ () -> service.deleteLifecycleHookByName(REGION, "bad name!"));+ assertEquals("ValidationError", ex.getErrorCode());+ }++ @Test+ void deleteLifecycleHookByNameIsIdempotentOnNullPhysicalId() {+ assertDoesNotThrow(() -> service.deleteLifecycleHookByName(REGION, null));+ }++ @Test+ void putLifecycleHookRejectsNullNameWithNotNullMessage() {+ AwsException ex = assertThrows(AwsException.class, () -> service.putLifecycleHook(REGION, "test-asg",+ null, "autoscaling:EC2_INSTANCE_LAUNCHING", null, null, null, null, null));+ assertTrue(ex.getMessage().contains("must not be null"));+ }++ @Test+ void putLifecycleHookRejectsOverlongNameWithLengthMessage() {+ String tooLong = "h".repeat(256);+ AwsException ex = assertThrows(AwsException.class, () -> service.putLifecycleHook(REGION, "test-asg",+ tooLong, "autoscaling:EC2_INSTANCE_LAUNCHING", null, null, null, null, null));+ assertTrue(ex.getMessage().contains("length less than or equal to 255"),+ "expected a length-specific message, got: " + ex.getMessage());+ }++ @Test+ void putLifecycleHookRejectsBadCharsWithPatternMessage() {+ AwsException ex = assertThrows(AwsException.class, () -> service.putLifecycleHook(REGION, "test-asg",+ "bad name!", "autoscaling:EC2_INSTANCE_LAUNCHING", null, null, null, null, null));+ assertTrue(ex.getMessage().contains("regular expression pattern"));+ }++ @Test+ void setInstanceProtectionValidatesEmptyInstanceIdsBeforeGroupLookup() {+ AwsException ex = assertThrows(AwsException.class,+ () -> service.setInstanceProtection(REGION, "no-such-group", List.of(), true));+ assertEquals("ValidationError", ex.getErrorCode());+ assertTrue(ex.getMessage().contains("At least one instance ID is required"),+ "a doubly-bad request (unknown group + empty list) must surface the missing-parameter "+ + "error, not 'Group not found'; got: " + ex.getMessage());+ }++ @Test+ void setInstanceProtectionReportsAllMissingInstanceIds() {+ AsgInstance instance = new AsgInstance();+ instance.setInstanceId("i-real");+ instance.setLifecycleState("InService");+ instance.setHealthStatus("Healthy");+ service.describeAutoScalingGroups(REGION, List.of("test-asg")).getFirst().getInstances().add(instance);++ AwsException ex = assertThrows(AwsException.class,+ () -> service.setInstanceProtection(REGION, "test-asg",+ List.of("i-missing-1", "i-missing-2"), true));+ assertTrue(ex.getMessage().contains("i-missing-1") && ex.getMessage().contains("i-missing-2"),+ "expected both missing IDs in the message, got: " + ex.getMessage());+ }++ @Test+ void setInstanceProtectionUsesSetContainmentAgainstDuplicateStoredInstanceIds() {+ AsgInstance dup1 = new AsgInstance();+ dup1.setInstanceId("i-dup");+ dup1.setLifecycleState("InService");+ dup1.setHealthStatus("Healthy");+ AsgInstance dup2 = new AsgInstance();+ dup2.setInstanceId("i-dup");+ dup2.setLifecycleState("InService");+ dup2.setHealthStatus("Healthy");+ var instances = service.describeAutoScalingGroups(REGION, List.of("test-asg")).getFirst().getInstances();+ instances.add(dup1);+ instances.add(dup2);++ assertDoesNotThrow(() -> service.setInstanceProtection(REGION, "test-asg", List.of("i-dup"), true));+ assertTrue(instances.stream().allMatch(AsgInstance::isProtectedFromScaleIn));+ }++ @Test+ void setInstanceHealthAcceptsShouldRespectGracePeriodFlag() {+ AsgInstance instance = new AsgInstance();+ instance.setInstanceId("i-health");+ instance.setLifecycleState("InService");+ instance.setHealthStatus("Healthy");+ service.describeAutoScalingGroups(REGION, List.of("test-asg")).getFirst().getInstances().add(instance);++ assertDoesNotThrow(() -> service.setInstanceHealth(REGION, "i-health", "Unhealthy", true));+ assertEquals("Unhealthy", service.describeAutoScalingInstances(REGION, List.of("i-health"))+ .getFirst().getHealthStatus());+ }+private static final class AutoScalingGroupFixture {private static void addInstance(AutoScalingService service, String region, String name, String instanceId,String lifecycleState, String launchTemplateId, String launchTemplateVersion) {