Light, fluffy, and always free - The AWS Local Emulator alternative
feat(iot): provision AWS::IoT::Thing, Policy and TopicRule (#3014)
Mario Toffiadec348d38259
diff --git a/docs/services/cloudformation.md b/docs/services/cloudformation.mdindex fd501d4632..75d8894a2c 100644--- a/docs/services/cloudformation.md+++ b/docs/services/cloudformation.md@@ -86,7 +86,7 @@ cross-resource references.| Pipes | `Pipe` || Kinesis | `Stream` || Kinesis Data Firehose | `DeliveryStream` |-| IoT Core | `DomainConfiguration` (`ServerCertificates` resolves to a JSON string) |+| IoT Core | `DomainConfiguration` (`ServerCertificates` resolves to a JSON string), `Policy` (deleted after detaching it from its principals; on AWS the delete fails with `DeleteConflictException` while the policy is attached), `Thing`, `TopicRule` || CloudFront | `Distribution` || CloudWatch | `Alarm` || CloudWatch Logs | `LogGroup` |diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotCfnProvisioner.javanew file mode 100644index 0000000000..b04fdd44e5--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotCfnProvisioner.java@@ -0,0 +1,295 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.JsonNodeFactory;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.iot.IotService;+import io.github.hectorvent.floci.services.iot.model.IotPolicy;+import io.github.hectorvent.floci.services.iot.model.IotTopicRule;+import io.github.hectorvent.floci.services.iot.model.Thing;+import jakarta.enterprise.context.ApplicationScoped;+import org.jboss.logging.Logger;++import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.Set;++/**+ * Provisions the IoT Core registry and rules engine types: {@code AWS::IoT::Thing},+ * {@code AWS::IoT::Policy} and {@code AWS::IoT::TopicRule}. The physical id is the resource name,+ * as it is on AWS, so a rename is a replacement: the new entity is created first and the prior+ * one removed afterwards, since there is no generic replacement flow.+ */+@ApplicationScoped+public class IotCfnProvisioner implements CfnResourceProvisioner {++ private static final Logger LOG = Logger.getLogger(IotCfnProvisioner.class);+ private static final String NOT_FOUND = "ResourceNotFoundException";+ private static final int NAME_MAX_LENGTH = 128;++ private final IotService iotService;++ public IotCfnProvisioner(IotService iotService) {+ this.iotService = iotService;+ }++ @Override+ public Set<String> resourceTypes() {+ return Set.of("AWS::IoT::Thing", "AWS::IoT::Policy", "AWS::IoT::TopicRule");+ }++ @Override+ public void provision(StackResource r, JsonNode props, ProvisionContext ctx) {+ switch (r.getResourceType()) {+ case "AWS::IoT::Thing" -> provisionThing(r, props, ctx);+ case "AWS::IoT::Policy" -> provisionPolicy(r, props, ctx);+ case "AWS::IoT::TopicRule" -> provisionTopicRule(r, props, ctx);+ default -> throw new IllegalStateException("IotCfnProvisioner cannot handle " + r.getResourceType());+ }+ }++ @Override+ public void delete(String resourceType, String physicalId, String region) {+ switch (resourceType) {+ case "AWS::IoT::Thing" -> CfnDeletes.safeDelete("thing", physicalId,+ () -> iotService.deleteThing(physicalId, region), NOT_FOUND);+ case "AWS::IoT::Policy" -> CfnDeletes.safeDelete("policy", physicalId,+ () -> detachAndDeletePolicy(physicalId, region), NOT_FOUND);+ case "AWS::IoT::TopicRule" -> CfnDeletes.safeDelete("topic rule", physicalId,+ () -> iotService.deleteTopicRule(physicalId, region), NOT_FOUND);+ default -> throw new IllegalStateException("IotCfnProvisioner cannot handle " + resourceType);+ }+ }++ /**+ * {@code AttributePayload.Attributes} is the whole desired attribute set: an update replaces the+ * stored attributes rather than merging into them, as the CloudFormation handler does.+ */+ private void provisionThing(StackResource r, JsonNode props, ProvisionContext ctx) {+ String name = ctx.stablePhysicalName(ctx.resolveOptional(props, "ThingName"),+ r.getLogicalId(), NAME_MAX_LENGTH, false);+ Map<String, String> attributes = thingAttributes(props, ctx);+ String region = ctx.region();+ boolean sameThing = ctx.reusesPriorEntity(name);+ Thing thing = sameThing+ ? iotService.updateThing(name, attributes, null, region)+ : iotService.createThing(name, attributes, region);+ r.setPhysicalId(name);+ r.getAttributes().put("Arn", thing.getThingArn());+ r.getAttributes().put("Id", thing.getThingId());+ if (!sameThing) {+ deletePrior(r, ctx);+ }+ }++ /**+ * A changed document becomes a new default version, as the CloudFormation handler does; the+ * document is compared as the string the policy stores, which is what this provisioner wrote+ * on the previous execution. {@code Id} is the policy name, as on AWS.+ */+ private void provisionPolicy(StackResource r, JsonNode props, ProvisionContext ctx) {+ String name = ctx.stablePhysicalName(ctx.resolveOptional(props, "PolicyName"),+ r.getLogicalId(), NAME_MAX_LENGTH, false);+ String document = props == null ? null : ctx.engine().resolveJsonAttribute(props.path("PolicyDocument"));+ if (document == null || document.isBlank()) {+ throw new IllegalArgumentException("AWS::IoT::Policy requires PolicyDocument");+ }+ Map<String, String> tags = ctx.resolveTags(props, "Tags");+ String region = ctx.region();+ if (ctx.reusesPriorEntity(name)) {+ IotPolicy policy = iotService.getPolicy(name, region);+ if (!document.equals(policy.getPolicyDocument())) {+ createDefaultVersion(name, document, region);+ }+ reconcileTags(policy.getPolicyArn(), tags);+ recordPolicy(r, name, policy.getPolicyArn());+ return;+ }+ IotPolicy policy = iotService.createPolicy(name, document, region);+ recordPolicy(r, name, policy.getPolicyArn());+ finishCreate(r, ctx, () -> applyTags(policy.getPolicyArn(), tags));+ deletePrior(r, ctx);+ }++ /**+ * A policy holds at most five versions. When the service refuses a sixth, this does what the+ * AWS handler does: the oldest version goes, in one step on the service's side, and the new one+ * is created again. Unlike that handler it tries more than once, because a version created by+ * another client between the delete and the retry would otherwise fail the stack update; it+ * gives up after as many attempts as a policy has versions.+ */+ private void createDefaultVersion(String name, String document, String region) {+ for (int attempt = 1; ; attempt++) {+ try {+ iotService.createPolicyVersion(name, document, true, region);+ return;+ } catch (AwsException e) {+ if (!"VersionsLimitExceededException".equals(e.getErrorCode())+ || attempt >= IotService.MAX_POLICY_VERSIONS) {+ throw e;+ }+ LOG.debugv("Policy {0} is at its version limit, deleting the oldest version before the new default: {1}",+ name, e.getMessage());+ }+ iotService.makeRoomForPolicyVersion(name, region);+ }+ }++ /**+ * The template payload is handed to the service in the IoT API's own shape: the same members+ * with a lowercase first letter, all the way down into the actions. A generated name keeps only+ * the characters a rule name allows, since AWS rejects the hyphens+ * {@link ProvisionContext#generatePhysicalName} emits.+ */+ private void provisionTopicRule(StackResource r, JsonNode props, ProvisionContext ctx) {+ String name = ctx.resolveOptional(props, "RuleName");+ if (name == null || name.isBlank()) {+ name = ctx.stablePhysicalName(null, r.getLogicalId(), NAME_MAX_LENGTH, false)+ .replaceAll("[^A-Za-z0-9_]", "");+ }+ if (props == null || !props.hasNonNull("TopicRulePayload")) {+ throw new IllegalArgumentException("AWS::IoT::TopicRule requires TopicRulePayload");+ }+ JsonNode payload = toApiShape(ctx.engine().resolveNode(props.get("TopicRulePayload")));+ Map<String, String> tags = ctx.resolveTags(props, "Tags");+ String region = ctx.region();+ if (ctx.reusesPriorEntity(name)) {+ IotTopicRule rule = iotService.replaceTopicRule(name, payload, region);+ reconcileTags(rule.getRuleArn(), tags);+ recordTopicRule(r, name, rule.getRuleArn());+ return;+ }+ IotTopicRule rule = iotService.createTopicRule(name, payload, region);+ recordTopicRule(r, name, rule.getRuleArn());+ finishCreate(r, ctx, () -> applyTags(rule.getRuleArn(), tags));+ deletePrior(r, ctx);+ }++ /**+ * The service refuses to delete a policy that is still attached to a principal, and on AWS the+ * stack would fail with a DeleteConflictException. Here the stack that created the policy also+ * takes its attachments with it, so a local teardown never gets stuck on a device that was+ * connected while the stack existed.+ */+ private void detachAndDeletePolicy(String policyName, String region) {+ for (String target : iotService.listTargetsForPolicy(policyName, region)) {+ iotService.detachPolicy(policyName, target, region);+ }+ iotService.deletePolicy(policyName, region);+ }++ private static void recordPolicy(StackResource r, String name, String arn) {+ r.setPhysicalId(name);+ r.getAttributes().put("Arn", arn);+ r.getAttributes().put("Id", name);+ }++ private static void recordTopicRule(StackResource r, String name, String arn) {+ r.setPhysicalId(name);+ r.getAttributes().put("Arn", arn);+ }++ private static Map<String, String> thingAttributes(JsonNode props, ProvisionContext ctx) {+ Map<String, String> attributes = new LinkedHashMap<>();+ if (props == null || !props.has("AttributePayload")) {+ return attributes;+ }+ JsonNode resolved = ctx.engine().resolveNode(props.get("AttributePayload"));+ JsonNode values = resolved == null ? null : resolved.path("Attributes");+ if (values != null && values.isObject()) {+ values.fields().forEachRemaining(field ->+ attributes.put(field.getKey(), ctx.engine().resolve(field.getValue())));+ }+ return attributes;+ }++ /** Recursively renames the members of a resolved node to the API's camelCase, dropping nulls. */+ private static JsonNode toApiShape(JsonNode node) {+ if (node.isObject()) {+ ObjectNode out = JsonNodeFactory.instance.objectNode();+ node.fields().forEachRemaining(field -> {+ if (!field.getValue().isNull()) {+ out.set(decapitalize(field.getKey()), toApiShape(field.getValue()));+ }+ });+ return out;+ }+ if (node.isArray()) {+ ArrayNode out = JsonNodeFactory.instance.arrayNode();+ node.forEach(item -> out.add(toApiShape(item)));+ return out;+ }+ return node;+ }++ private static String decapitalize(String key) {+ return key.isEmpty() ? key : Character.toLowerCase(key.charAt(0)) + key.substring(1);+ }++ /**+ * Runs the calls that follow a create with the resource marked as owned by this stack, so a+ * failure among them still lets the create rollback delete the entity that now exists. When the+ * create was a replacement, the entity is removed here instead: CloudFormationService restores+ * the prior StackResource and never learns the new name, so nothing else would.+ */+ private void finishCreate(StackResource r, ProvisionContext ctx, Runnable finish) {+ r.getAttributes().put(CfnRollback.ROLLBACK_OWNED_ATTR, "true");+ try {+ finish.run();+ } catch (RuntimeException failure) {+ if (ctx.isUpdate()) {+ unwindReplacement(r, ctx.region(), failure);+ }+ throw failure;+ }+ r.getAttributes().remove(CfnRollback.ROLLBACK_OWNED_ATTR);+ }++ private void unwindReplacement(StackResource r, String region, RuntimeException failure) {+ try {+ delete(r.getResourceType(), r.getPhysicalId(), region);+ r.getAttributes().remove(CfnRollback.ROLLBACK_OWNED_ATTR);+ } catch (RuntimeException cleanupFailure) {+ failure.addSuppressed(cleanupFailure);+ String reason = "Could not remove " + r.getPhysicalId() + ", the replacement created for "+ + r.getLogicalId() + " by a failed update: " + cleanupFailure.getMessage();+ LOG.warn(reason);+ r.getAttributes().put(CfnRollback.UPDATE_ROLLBACK_FAILURE_ATTR, reason);+ }+ }++ /**+ * Removes the entity a replacement supersedes. As in CloudFormation's update cleanup, a failure+ * does not fail the update: the stack already points at the new entity, so the prior one is+ * left behind with a warning in the log.+ */+ private void deletePrior(StackResource r, ProvisionContext ctx) {+ if (!ctx.isUpdate()) {+ return;+ }+ try {+ delete(r.getResourceType(), ctx.priorPhysicalId(), ctx.region());+ } catch (AwsException e) {+ LOG.warnv("Could not delete {0} {1} replaced by {2}: {3}",+ r.getResourceType(), ctx.priorPhysicalId(), r.getPhysicalId(), e.getMessage());+ }+ }++ private void applyTags(String arn, Map<String, String> tags) {+ if (!tags.isEmpty()) {+ iotService.tagResource(arn, tags);+ }+ }++ private void reconcileTags(String arn, Map<String, String> desired) {+ List<String> stale = ProvisionContext.staleTagKeys(iotService.listTagsForResource(arn), desired);+ if (!stale.isEmpty()) {+ iotService.untagResource(arn, stale);+ }+ applyTags(arn, desired);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotService.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotService.javaindex a54b7c92e1..915e39d0be 100644--- a/src/main/java/io/github/hectorvent/floci/services/iot/IotService.java+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotService.java@@ -70,6 +70,10 @@ public class IotService {private static final Pattern THING_NAME_PATTERN = Pattern.compile("[a-zA-Z0-9:_-]{1,128}");/** The {@code FirehoseSeparator} shape of the IoT API model. */private static final Pattern FIREHOSE_SEPARATOR = Pattern.compile("([\\n\\t])|(\\r\\n)|(,)");+ public static final int MAX_POLICY_VERSIONS = 5;++ /** One lock for every policy version write and the policy delete, so a cap check, an append and a delete cannot interleave. */+ private final Object policyWriteLock = new Object();private final StorageBackend<String, Thing> thingStore;private final StorageBackend<String, IotCertificate> certificateStore;@@ -433,34 +437,42 @@ public class IotService {}public void deletePolicy(String policyName, String region) {- getPolicy(policyName, region);- if (!policyAttachmentStore.get(policyAttachmentKey(region, policyName)).orElse(Set.of()).isEmpty()) {- throw new AwsException("InvalidRequestException", "Cannot delete attached policy", 400);+ synchronized (policyWriteLock) {+ getPolicy(policyName, region);+ if (!policyAttachmentStore.get(policyAttachmentKey(region, policyName)).orElse(Set.of()).isEmpty()) {+ throw new AwsException("InvalidRequestException", "Cannot delete attached policy", 400);+ }+ policyStore.delete(policyKey(region, policyName));+ policyAttachmentStore.delete(policyAttachmentKey(region, policyName));}- policyStore.delete(policyKey(region, policyName));- policyAttachmentStore.delete(policyAttachmentKey(region, policyName));}public IotPolicy.PolicyVersion createPolicyVersion(String policyName, String policyDocument, boolean setAsDefault, String region) {- IotPolicy policy = getPolicy(policyName, region);- int next = policy.getVersions().stream()- .map(IotPolicy.PolicyVersion::getVersionId)- .mapToInt(Integer::parseInt)- .max()- .orElse(0) + 1;- IotPolicy.PolicyVersion version = new IotPolicy.PolicyVersion();- version.setVersionId(Integer.toString(next));- version.setDocument(policyDocument);- version.setCreateDate(Instant.now());- List<IotPolicy.PolicyVersion> versions = new java.util.ArrayList<>(policy.getVersions());- versions.add(version);- policy.setVersions(versions);- if (setAsDefault) {- policy.setDefaultVersionId(version.getVersionId());- policy.setPolicyDocument(policyDocument);+ synchronized (policyWriteLock) {+ IotPolicy policy = getPolicy(policyName, region);+ if (policy.getVersions().size() >= MAX_POLICY_VERSIONS) {+ throw new AwsException("VersionsLimitExceededException", "The policy " + policyName+ + " already has the maximum number of versions (" + MAX_POLICY_VERSIONS + ")", 409);+ }+ int next = policy.getVersions().stream()+ .map(IotPolicy.PolicyVersion::getVersionId)+ .mapToInt(Integer::parseInt)+ .max()+ .orElse(0) + 1;+ IotPolicy.PolicyVersion version = new IotPolicy.PolicyVersion();+ version.setVersionId(Integer.toString(next));+ version.setDocument(policyDocument);+ version.setCreateDate(Instant.now());+ List<IotPolicy.PolicyVersion> versions = new ArrayList<>(policy.getVersions());+ versions.add(version);+ policy.setVersions(versions);+ if (setAsDefault) {+ policy.setDefaultVersionId(version.getVersionId());+ policy.setPolicyDocument(policyDocument);+ }+ policyStore.put(policyKey(region, policyName), policy);+ return version;}- policyStore.put(policyKey(region, policyName), policy);- return version;}public IotPolicy.PolicyVersion getPolicyVersion(String policyName, String versionId, String region) {@@ -478,26 +490,55 @@ public class IotService {}public void setDefaultPolicyVersion(String policyName, String versionId, String region) {- IotPolicy policy = getPolicy(policyName, region);- IotPolicy.PolicyVersion version = getPolicyVersion(policyName, versionId, region);- policy.setDefaultVersionId(versionId);- policy.setPolicyDocument(version.getDocument());- policyStore.put(policyKey(region, policyName), policy);+ synchronized (policyWriteLock) {+ IotPolicy policy = getPolicy(policyName, region);+ IotPolicy.PolicyVersion version = getPolicyVersion(policyName, versionId, region);+ policy.setDefaultVersionId(versionId);+ policy.setPolicyDocument(version.getDocument());+ policyStore.put(policyKey(region, policyName), policy);+ }}public void deletePolicyVersion(String policyName, String versionId, String region) {- IotPolicy policy = getPolicy(policyName, region);- if (versionId.equals(policy.getDefaultVersionId())) {- throw new AwsException("InvalidRequestException", "Cannot delete default policy version", 400);+ synchronized (policyWriteLock) {+ IotPolicy policy = getPolicy(policyName, region);+ if (versionId.equals(policy.getDefaultVersionId())) {+ throw new AwsException("InvalidRequestException", "Cannot delete default policy version", 400);+ }+ List<IotPolicy.PolicyVersion> versions = policy.getVersions().stream()+ .filter(version -> !versionId.equals(version.getVersionId()))+ .toList();+ if (versions.size() == policy.getVersions().size()) {+ throw new AwsException("ResourceNotFoundException", "Policy version not found: " + versionId, 404);+ }+ policy.setVersions(versions);+ policyStore.put(policyKey(region, policyName), policy);}- List<IotPolicy.PolicyVersion> versions = policy.getVersions().stream()- .filter(version -> !versionId.equals(version.getVersionId()))- .toList();- if (versions.size() == policy.getVersions().size()) {- throw new AwsException("ResourceNotFoundException", "Policy version not found: " + versionId, 404);+ }++ /**+ * Deletes the oldest versions until one more fits under the cap, which is what the AWS+ * CloudFormation handler means to do once the service refuses a sixth (it sorts version ids as+ * text, so past nine it picks another one). A policy persisted before the cap can hold more+ * than five, so this deletes as many as it takes. A default version cannot be deleted, so when+ * the oldest is the default the newest becomes the default first. One step under the policy+ * write lock, so nothing else can move the selection in between.+ */+ public void makeRoomForPolicyVersion(String policyName, String region) {+ synchronized (policyWriteLock) {+ IotPolicy policy = getPolicy(policyName, region);+ while (policy.getVersions().size() >= MAX_POLICY_VERSIONS) {+ List<IotPolicy.PolicyVersion> versions = policy.getVersions().stream()+ .sorted(Comparator.comparingInt(version -> Integer.parseInt(version.getVersionId())))+ .toList();+ String oldest = versions.get(0).getVersionId();+ if (oldest.equals(policy.getDefaultVersionId())) {+ setDefaultPolicyVersion(policyName, versions.get(versions.size() - 1).getVersionId(), region);+ }+ deletePolicyVersion(policyName, oldest, region);+ policy = getPolicy(policyName, region);+ }}- policy.setVersions(versions);- policyStore.put(policyKey(region, policyName), policy);}public void attachPolicy(String policyName, String target, String region) {diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.javaindex 959cb77fa8..3f0fd369dc 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java@@ -38,6 +38,7 @@ import io.github.hectorvent.floci.services.cloudformation.provisioners.EcrCfnProimport io.github.hectorvent.floci.services.cloudformation.provisioners.EcsCapacityCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.FirehoseCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.IamRoleCfnProvisioner;+import io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.IotDomainConfigurationCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.KinesisCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.KmsCfnProvisioner;@@ -68,6 +69,7 @@ import io.github.hectorvent.floci.services.eventbridge.EventBridgeService;import io.github.hectorvent.floci.services.firehose.FirehoseService;import io.github.hectorvent.floci.services.iam.IamService;import io.github.hectorvent.floci.services.iot.IotDomainConfigurationService;+import io.github.hectorvent.floci.services.iot.IotService;import io.github.hectorvent.floci.services.kinesis.KinesisService;import io.github.hectorvent.floci.services.kms.KmsService;import io.github.hectorvent.floci.services.lambda.LambdaLayerService;@@ -150,6 +152,7 @@ final class CfnProvisionerFixture {// dispatcher. They exist only so inferredProvisioners() can wire their provisioner.private FlowLogService flowLogService;private IotDomainConfigurationService iotDomainConfigurationService;+ private IotService iotService;private LambdaMicrovmsService lambdaMicrovmsService;private AwsConfigService awsConfigService;private OrganizationsService organizationsService;@@ -254,6 +257,9 @@ final class CfnProvisionerFixture {if (iotDomainConfigurationService != null) {discovered.add(new IotDomainConfigurationCfnProvisioner(iotDomainConfigurationService));}+ if (iotService != null) {+ discovered.add(new IotCfnProvisioner(iotService));+ }if (lambdaMicrovmsService != null) {discovered.add(new LambdaMicrovmsCfnProvisioner(lambdaMicrovmsService));}@@ -471,6 +477,11 @@ final class CfnProvisionerFixture {return this;}+ public Builder iot(IotService v) {+ this.iotService = v;+ return this;+ }+public Builder lambdaMicrovms(LambdaMicrovmsService v) {this.lambdaMicrovmsService = v;return this;diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/IotCfnIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/IotCfnIntegrationTest.javanew file mode 100644index 0000000000..169f0ebf42--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/IotCfnIntegrationTest.java@@ -0,0 +1,286 @@+package io.github.hectorvent.floci.services.cloudformation;++import io.github.hectorvent.floci.core.common.XmlParser;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.Test;++import java.util.List;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.contains;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.fail;++/**+ * Provisions an {@code AWS::IoT::Thing}, an {@code AWS::IoT::Policy} and an+ * {@code AWS::IoT::TopicRule} through one CloudFormation stack and asserts that {@code Ref} and every+ * {@code Fn::GetAtt} attribute carry what the IoT API reports, rather than the literal+ * {@code Logical.Attr} the stub arm would leave behind. The rule's action targets a queue from the+ * same template, so a publish through the rule proves the payload reached the service in the API's+ * shape; a second action on a queue that does not exist proves that one failing action neither+ * fails the publish nor the other action, and that the error action receives the failure. Also+ * covers the in-place update of all three and that deleting the stack removes them.+ */+@QuarkusTest+class IotCfnIntegrationTest {++ private static final String CFN_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260903/us-east-1/cloudformation/aws4_request";+ private static final String STACK = "iot-cfn-it";+ private static final String THING = "iot-cfn-it-sensor";+ private static final String POLICY = "iot-cfn-it-policy";+ private static final String RULE = "iotCfnItRule";+ private static final String ROLE_ARN = "arn:aws:iam::000000000000:role/iot-cfn-it";++ private static String template(String serialNumber, String policyAction, String topicFilter, String tagValue) {+ return """+ {+ "Resources": {+ "Queue": {"Type": "AWS::SQS::Queue", "Properties": {"QueueName": "iot-cfn-it-queue"}},+ "ErrorQueue": {"Type": "AWS::SQS::Queue", "Properties": {"QueueName": "iot-cfn-it-error-queue"}},+ "Sensor": {+ "Type": "AWS::IoT::Thing",+ "Properties": {+ "ThingName": "%s",+ "AttributePayload": {"Attributes": {"SerialNumber": "%s"}}+ }+ },+ "Policy": {+ "Type": "AWS::IoT::Policy",+ "Properties": {+ "PolicyName": "%s",+ "PolicyDocument": {+ "Version": "2012-10-17",+ "Statement": [{"Effect": "Allow", "Action": "%s", "Resource": "arn:aws:iot:us-east-1:000000000000:client/${iot:Connection.Thing.ThingName}"}]+ },+ "Tags": [{"Key": "stack", "Value": "%s"}]+ }+ },+ "Rule": {+ "Type": "AWS::IoT::TopicRule",+ "Properties": {+ "RuleName": "%s",+ "TopicRulePayload": {+ "Sql": "SELECT * FROM '%s'",+ "AwsIotSqlVersion": "2016-03-23",+ "RuleDisabled": false,+ "Actions": [+ {"Sqs": {"QueueUrl": {"Ref": "Queue"}, "RoleArn": "%s", "UseBase64": false}},+ {"Sqs": {"QueueUrl": "http://localhost:4566/000000000000/iot-cfn-it-missing-queue", "RoleArn": "%s"}}+ ],+ "ErrorAction": {"Sqs": {"QueueUrl": {"Ref": "ErrorQueue"}, "RoleArn": "%s"}}+ },+ "Tags": [{"Key": "stack", "Value": "%s"}]+ }+ }+ },+ "Outputs": {+ "QueueUrl": {"Value": {"Ref": "Queue"}},+ "ErrorQueueUrl": {"Value": {"Ref": "ErrorQueue"}},+ "SensorRef": {"Value": {"Ref": "Sensor"}},+ "SensorArn": {"Value": {"Fn::GetAtt": ["Sensor", "Arn"]}},+ "SensorId": {"Value": {"Fn::GetAtt": ["Sensor", "Id"]}},+ "PolicyRef": {"Value": {"Ref": "Policy"}},+ "PolicyArn": {"Value": {"Fn::GetAtt": ["Policy", "Arn"]}},+ "PolicyId": {"Value": {"Fn::GetAtt": ["Policy", "Id"]}},+ "RuleRef": {"Value": {"Ref": "Rule"}},+ "RuleArn": {"Value": {"Fn::GetAtt": ["Rule", "Arn"]}}+ }+ }+ """.formatted(THING, serialNumber, POLICY, policyAction, tagValue, RULE, topicFilter,+ ROLE_ARN, ROLE_ARN, ROLE_ARN, tagValue);+ }++ @Test+ void iotStackExposesRealIdentifiersUpdatesInPlaceAndDeletesTheResources() throws Exception {+ cloudFormation("CreateStack", template("SN-1", "iot:Connect", "iot-cfn-it/+/telemetry", "v1"));++ String stacks = describeStacks("CREATE_COMPLETE");+ String queueUrl = outputValue(stacks, "QueueUrl");+ String errorQueueUrl = outputValue(stacks, "ErrorQueueUrl");+ String thingArn = outputValue(stacks, "SensorArn");+ String thingId = outputValue(stacks, "SensorId");+ String policyArn = outputValue(stacks, "PolicyArn");+ String ruleArn = outputValue(stacks, "RuleArn");+ assertEquals(THING, outputValue(stacks, "SensorRef"));+ assertEquals("arn:aws:iot:us-east-1:000000000000:thing/" + THING, thingArn);+ assertEquals(POLICY, outputValue(stacks, "PolicyRef"));+ assertEquals(POLICY, outputValue(stacks, "PolicyId"));+ assertEquals("arn:aws:iot:us-east-1:000000000000:policy/" + POLICY, policyArn);+ assertEquals(RULE, outputValue(stacks, "RuleRef"));+ assertEquals("arn:aws:iot:us-east-1:000000000000:rule/" + RULE, ruleArn);++ given()+ .when()+ .get("/things/" + THING)+ .then()+ .statusCode(200)+ .body("thingArn", equalTo(thingArn))+ .body("thingId", equalTo(thingId))+ .body("attributes.SerialNumber", equalTo("SN-1"));+ given()+ .when()+ .get("/policies/" + POLICY)+ .then()+ .statusCode(200)+ .body("policyArn", equalTo(policyArn))+ .body("defaultVersionId", equalTo("1"))+ .body("policyDocument", containsString("iot:Connect"))+ .body("policyDocument", containsString("${iot:Connection.Thing.ThingName}"));+ assertTagValue(policyArn, "v1");+ given()+ .when()+ .get("/rules/" + RULE)+ .then()+ .statusCode(200)+ .body("ruleArn", equalTo(ruleArn))+ .body("rule.sql", equalTo("SELECT * FROM 'iot-cfn-it/+/telemetry'"))+ .body("rule.awsIotSqlVersion", equalTo("2016-03-23"))+ .body("rule.ruleDisabled", equalTo(false))+ .body("rule.actions[0].sqs.queueUrl", equalTo(queueUrl))+ .body("rule.errorAction.sqs.queueUrl", equalTo(errorQueueUrl));+ assertTagValue(ruleArn, "v1");++ given()+ .contentType("text/plain")+ .body("iot-cfn-it-payload")+ .when()+ .post("/topics/iot-cfn-it/d1/telemetry")+ .then()+ .statusCode(200);+ receiveMessage(queueUrl).body(containsString("iot-cfn-it-payload"));+ receiveMessage(errorQueueUrl)+ .body(containsString(RULE))+ .body(containsString("SqsAction"))+ .body(containsString("iot-cfn-it-missing-queue"));++ cloudFormation("UpdateStack", template("SN-2", "iot:Publish", "iot-cfn-it/+/telemetry/v2", "v2"));++ String updated = describeStacks("UPDATE_COMPLETE");+ assertEquals(thingId, outputValue(updated, "SensorId"));+ given()+ .when()+ .get("/things/" + THING)+ .then()+ .statusCode(200)+ .body("thingId", equalTo(thingId))+ .body("attributes.SerialNumber", equalTo("SN-2"));+ given()+ .when()+ .get("/policies/" + POLICY)+ .then()+ .statusCode(200)+ .body("defaultVersionId", equalTo("2"))+ .body("policyDocument", containsString("iot:Publish"));+ assertTagValue(policyArn, "v2");+ given()+ .when()+ .get("/rules/" + RULE)+ .then()+ .statusCode(200)+ .body("ruleArn", equalTo(ruleArn))+ .body("rule.sql", equalTo("SELECT * FROM 'iot-cfn-it/+/telemetry/v2'"));+ assertTagValue(ruleArn, "v2");++ // Four more document changes. The service refuses a sixth version, so the stack deletes+ // the oldest one first, as the AWS handler does, and the policy keeps five versions.+ for (String action : List.of("iot:Subscribe", "iot:Receive", "iot:GetThingShadow", "iot:UpdateThingShadow")) {+ cloudFormation("UpdateStack", template("SN-2", action, "iot-cfn-it/+/telemetry/v2", "v2"));+ describeStacks("UPDATE_COMPLETE");+ }+ given()+ .when()+ .get("/policies/" + POLICY + "/version")+ .then()+ .statusCode(200)+ .body("policyVersions.versionId", contains("2", "3", "4", "5", "6"))+ .body("policyVersions.find { it.isDefaultVersion }.versionId", equalTo("6"));+ given()+ .when()+ .get("/policies/" + POLICY)+ .then()+ .statusCode(200)+ .body("defaultVersionId", equalTo("6"))+ .body("policyDocument", containsString("iot:UpdateThingShadow"));++ cloudFormation("DeleteStack", null);+ awaitStackDeleted();++ given().when().get("/things/" + THING).then().statusCode(404);+ given().when().get("/policies/" + POLICY).then().statusCode(404);+ given().when().get("/rules/" + RULE).then().statusCode(404);+ }++ private static ValidatableResponse receiveMessage(String queueUrl) {+ return given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "ReceiveMessage")+ .formParam("QueueUrl", queueUrl)+ .formParam("MaxNumberOfMessages", "1")+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ private static void assertTagValue(String arn, String expected) {+ given()+ .queryParam("resourceArn", arn)+ .when()+ .get("/tags")+ .then()+ .statusCode(200)+ .body("tags.find { it.Key == 'stack' }.Value", equalTo(expected));+ }++ private static void cloudFormation(String action, String templateBody) {+ RequestSpecification request = given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", action)+ .formParam("StackName", STACK);+ if (templateBody != null) {+ request.formParam("TemplateBody", templateBody);+ }+ request.when().post("/").then().statusCode(200);+ }++ private static String describeStacks(String expectedStatus) {+ return given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "DescribeStacks")+ .formParam("StackName", STACK)+ .when().post("/").then().statusCode(200)+ .body(containsString("<StackStatus>" + expectedStatus + "</StackStatus>"))+ .extract().asString();+ }++ /** DeleteStack runs asynchronously; a successful delete removes the stack entirely. */+ private static void awaitStackDeleted() throws InterruptedException {+ for (int i = 0; i < 100; i++) {+ String body = given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "DescribeStacks")+ .formParam("StackName", STACK)+ .when().post("/").then().extract().asString();+ if (body.contains("does not exist")) {+ return;+ }+ if (body.contains("<StackStatus>DELETE_FAILED</StackStatus>")) {+ fail("stack delete failed: " + body);+ }+ Thread.sleep(50);+ }+ fail("stack " + STACK + " was not deleted within the timeout");+ }++ private static String outputValue(String xml, String key) {+ return XmlParser.extractPairs(xml, "Outputs", "OutputKey", "OutputValue").get(key);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotCfnProvisionerTestSupport.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotCfnProvisionerTestSupport.javanew file mode 100644index 0000000000..ad7b6284cd--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotCfnProvisionerTestSupport.java@@ -0,0 +1,89 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import com.fasterxml.jackson.databind.node.TextNode;+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 java.util.HashMap;++import static org.mockito.ArgumentMatchers.any;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++/**+ * What the three {@link IotCfnProvisioner} unit tests share: a mocked template engine that behaves+ * like the real one for the shapes these templates use, and the resource and error factories.+ */+final class IotCfnProvisionerTestSupport {++ static final String REGION = "us-east-1";+ static final String ACCOUNT = "000000000000";++ private static final ObjectMapper MAPPER = new ObjectMapper();++ private IotCfnProvisionerTestSupport() {+ }++ static ProvisionContext ctx() {+ return ctx(null);+ }++ /**+ * Scalars resolve to their text, an intrinsic collapses to a {@code resolved:} marker and+ * everything else is walked in place, so a nested payload keeps its shape and scalar types.+ */+ static ProvisionContext ctx(String priorPhysicalId) {+ CloudFormationTemplateEngine engine = mock(CloudFormationTemplateEngine.class);+ when(engine.resolve(any())).thenAnswer(inv -> {+ JsonNode node = inv.getArgument(0);+ return node == null || node.isMissingNode() || node.isNull() ? null : node.asText();+ });+ when(engine.resolveNode(any())).thenAnswer(inv -> resolveIntrinsics(inv.getArgument(0)));+ when(engine.resolveJsonAttribute(any())).thenAnswer(inv -> {+ JsonNode node = inv.getArgument(0);+ if (node == null || node.isMissingNode() || node.isNull()) {+ return null;+ }+ return node.isTextual() ? node.asText() : node.toString();+ });+ return new ProvisionContext(engine, REGION, ACCOUNT, "my-stack", priorPhysicalId);+ }++ static JsonNode resolveIntrinsics(JsonNode node) {+ if (node == null || !node.isContainerNode()) {+ return node;+ }+ if (node.isArray()) {+ ArrayNode out = MAPPER.createArrayNode();+ node.forEach(item -> out.add(resolveIntrinsics(item)));+ return out;+ }+ if (node.has("Fn::GetAtt")) {+ JsonNode target = node.get("Fn::GetAtt");+ return TextNode.valueOf("resolved:" + target.get(0).asText() + "." + target.get(1).asText());+ }+ if (node.has("Ref")) {+ return TextNode.valueOf("resolved:" + node.get("Ref").asText());+ }+ ObjectNode out = MAPPER.createObjectNode();+ node.fields().forEachRemaining(field -> out.set(field.getKey(), resolveIntrinsics(field.getValue())));+ return out;+ }++ static StackResource resource(String type, String logicalId) {+ StackResource r = new StackResource();+ r.setLogicalId(logicalId);+ r.setResourceType(type);+ r.setAttributes(new HashMap<>());+ return r;+ }++ static AwsException notFound(String what) {+ return new AwsException("ResourceNotFoundException", what + " not found", 404);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotPolicyCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotPolicyCfnProvisionerTest.javanew file mode 100644index 0000000000..769842673e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotPolicyCfnProvisionerTest.java@@ -0,0 +1,369 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.iot.IotService;+import io.github.hectorvent.floci.services.iot.model.IotPolicy;+import org.junit.jupiter.api.Test;+import org.mockito.InOrder;++import java.util.List;+import java.util.Map;+import java.util.Set;+import java.util.TreeSet;++import static io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisionerTestSupport.REGION;+import static io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisionerTestSupport.ctx;+import static io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisionerTestSupport.notFound;+import static io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisionerTestSupport.resource;+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyBoolean;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.calls;+import static org.mockito.Mockito.doThrow;+import static org.mockito.Mockito.inOrder;+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.when;++/**+ * {@code AWS::IoT::Policy} through the IoT CFN provisioner in isolation: one mocked service. Every+ * case asserts the exact physical id and the exact {@code Fn::GetAtt} attribute keys, because an+ * unmapped type still reports CREATE_COMPLETE through the dispatcher's stub arm.+ */+class IotPolicyCfnProvisionerTest {++ private static final String TYPE = "AWS::IoT::Policy";+ private static final String ARN = "arn:aws:iot:us-east-1:000000000000:policy/device-policy";+ private static final String RENAMED_ARN = "arn:aws:iot:us-east-1:000000000000:policy/renamed";+ private static final String DOCUMENT =+ "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":\"iot:Connect\",\"Resource\":\"*\"}]}";++ private final IotService iot = mock(IotService.class);+ private final IotCfnProvisioner provisioner = new IotCfnProvisioner(iot);+ private final ObjectMapper mapper = new ObjectMapper();++ private static IotPolicy policy(String name, String document) {+ IotPolicy policy = new IotPolicy();+ policy.setPolicyName(name);+ policy.setPolicyArn("arn:aws:iot:us-east-1:000000000000:policy/" + name);+ policy.setPolicyDocument(document);+ policy.setDefaultVersionId("1");+ return policy;+ }++ private ObjectNode props(String name, JsonNode document, Map<String, String> tags) {+ ObjectNode props = mapper.createObjectNode();+ if (name != null) {+ props.put("PolicyName", name);+ }+ if (document != null) {+ props.set("PolicyDocument", document);+ }+ if (tags != null) {+ tags.forEach((key, value) -> props.withArray("Tags").addObject().put("Key", key).put("Value", value));+ }+ return props;+ }++ private JsonNode document() throws Exception {+ return mapper.readTree(DOCUMENT);+ }++ @Test+ void policyWithAnObjectDocumentSerialisesItAndSetsNameAsPhysicalIdWithArnAndId() throws Exception {+ when(iot.createPolicy("device-policy", DOCUMENT, REGION)).thenReturn(policy("device-policy", DOCUMENT));+ StackResource r = resource(TYPE, "Policy");++ provisioner.provision(r, props("device-policy", document(), null), ctx());++ assertEquals("device-policy", r.getPhysicalId());+ assertEquals(ARN, r.getAttributes().get("Arn"));+ assertEquals("device-policy", r.getAttributes().get("Id"));+ verify(iot, never()).tagResource(anyString(), any());+ }++ @Test+ void policyWithAStringDocumentPassesItThroughUnchanged() {+ String document = "{\"Version\": \"2012-10-17\", \"Statement\": []}";+ when(iot.createPolicy("device-policy", document, REGION)).thenReturn(policy("device-policy", document));+ StackResource r = resource(TYPE, "Policy");++ provisioner.provision(r, props("device-policy", mapper.getNodeFactory().textNode(document), null), ctx());++ verify(iot).createPolicy("device-policy", document, REGION);+ assertEquals(ARN, r.getAttributes().get("Arn"));+ }++ @Test+ void policyRequiresADocument() {+ StackResource r = resource(TYPE, "Policy");+ ObjectNode props = props("device-policy", null, null);++ assertThrows(IllegalArgumentException.class, () -> provisioner.provision(r, props, ctx()));+ verify(iot, never()).createPolicy(anyString(), anyString(), anyString());+ }++ @Test+ void policyWithoutNameGetsAGeneratedName() throws Exception {+ when(iot.createPolicy(anyString(), eq(DOCUMENT), eq(REGION))).thenAnswer(inv -> policy(inv.getArgument(0), DOCUMENT));+ StackResource r = resource(TYPE, "Policy");++ provisioner.provision(r, props(null, document(), null), ctx());++ assertTrue(r.getPhysicalId().matches("my-stack-Policy-[0-9a-f]{12}"), "generated policy name: " + r.getPhysicalId());+ assertEquals(r.getPhysicalId(), r.getAttributes().get("Id"));+ }++ @Test+ void policyCreateAppliesTheTemplateTags() throws Exception {+ when(iot.createPolicy("device-policy", DOCUMENT, REGION)).thenReturn(policy("device-policy", DOCUMENT));+ StackResource r = resource(TYPE, "Policy");++ provisioner.provision(r, props("device-policy", document(), Map.of("env", "test")), ctx());++ verify(iot).tagResource(ARN, Map.of("env", "test"));+ assertFalse(r.getAttributes().containsKey(CfnRollback.ROLLBACK_OWNED_ATTR));+ }++ @Test+ void policyCreateLeavesTheResourceOwnedWhenTaggingFailsSoTheRollbackDeletesIt() throws Exception {+ when(iot.createPolicy("device-policy", DOCUMENT, REGION)).thenReturn(policy("device-policy", DOCUMENT));+ doThrow(new AwsException("InternalFailureException", "tagging failed", 500)).when(iot).tagResource(eq(ARN), any());+ StackResource r = resource(TYPE, "Policy");+ ObjectNode props = props("device-policy", document(), Map.of("env", "test"));++ assertThrows(AwsException.class, () -> provisioner.provision(r, props, ctx()));++ assertEquals("device-policy", r.getPhysicalId());+ assertEquals("true", r.getAttributes().get(CfnRollback.ROLLBACK_OWNED_ATTR));+ verify(iot, never()).deletePolicy(anyString(), anyString());+ }++ @Test+ void policyUpdateWithAChangedDocumentCreatesANewDefaultVersion() throws Exception {+ String changed = "{\"Version\":\"2012-10-17\",\"Statement\":[]}";+ when(iot.getPolicy("device-policy", REGION)).thenReturn(policy("device-policy", DOCUMENT));+ StackResource r = resource(TYPE, "Policy");++ provisioner.provision(r, props("device-policy", mapper.readTree(changed), null), ctx("device-policy"));++ verify(iot).createPolicyVersion("device-policy", changed, true, REGION);+ verify(iot, never()).createPolicy(anyString(), anyString(), anyString());+ verify(iot, never()).deletePolicy(anyString(), anyString());+ assertEquals("device-policy", r.getPhysicalId());+ assertEquals(ARN, r.getAttributes().get("Arn"));+ assertEquals("device-policy", r.getAttributes().get("Id"));+ }++ @Test+ void policyUpdateWithTheSameDocumentDoesNotCreateAVersion() throws Exception {+ when(iot.getPolicy("device-policy", REGION)).thenReturn(policy("device-policy", DOCUMENT));+ StackResource r = resource(TYPE, "Policy");++ provisioner.provision(r, props("device-policy", document(), null), ctx("device-policy"));++ verify(iot, never()).createPolicyVersion(anyString(), anyString(), anyBoolean(), anyString());+ assertEquals(ARN, r.getAttributes().get("Arn"));+ }++ @Test+ void policyUpdateDrivesTheTagsToTheTemplate() throws Exception {+ when(iot.getPolicy("device-policy", REGION)).thenReturn(policy("device-policy", DOCUMENT));+ when(iot.listTagsForResource(ARN)).thenReturn(Map.of("stale", "1", "env", "old"));+ StackResource r = resource(TYPE, "Policy");++ provisioner.provision(r, props("device-policy", document(), Map.of("env", "test")), ctx("device-policy"));++ verify(iot).untagResource(ARN, List.of("stale"));+ verify(iot).tagResource(ARN, Map.of("env", "test"));+ }++ @Test+ void policyUpdateWithoutTagsRemovesEveryStoredTag() throws Exception {+ when(iot.getPolicy("device-policy", REGION)).thenReturn(policy("device-policy", DOCUMENT));+ when(iot.listTagsForResource(ARN)).thenReturn(Map.of("stale", "1"));+ StackResource r = resource(TYPE, "Policy");++ provisioner.provision(r, props("device-policy", document(), null), ctx("device-policy"));++ verify(iot).untagResource(ARN, List.of("stale"));+ verify(iot, never()).tagResource(anyString(), any());+ }++ @Test+ void policyRenameCreatesTheReplacementThenDetachesAndDeletesThePriorPolicy() throws Exception {+ when(iot.createPolicy("renamed", DOCUMENT, REGION)).thenReturn(policy("renamed", DOCUMENT));+ when(iot.listTargetsForPolicy("device-policy", REGION)).thenReturn(Set.of("arn:aws:iot:us-east-1:000000000000:cert/abc"));+ StackResource r = resource(TYPE, "Policy");++ provisioner.provision(r, props("renamed", document(), null), ctx("device-policy"));++ InOrder inOrder = inOrder(iot);+ inOrder.verify(iot).createPolicy("renamed", DOCUMENT, REGION);+ inOrder.verify(iot).detachPolicy("device-policy", "arn:aws:iot:us-east-1:000000000000:cert/abc", REGION);+ inOrder.verify(iot).deletePolicy("device-policy", REGION);+ verify(iot, never()).createPolicyVersion(anyString(), anyString(), anyBoolean(), anyString());+ assertEquals("renamed", r.getPhysicalId());+ assertEquals(RENAMED_ARN, r.getAttributes().get("Arn"));+ assertEquals("renamed", r.getAttributes().get("Id"));+ }++ @Test+ void policyRenameKeepsTheUpdateWhenThePriorPolicyCannotBeDeleted() throws Exception {+ // As in CloudFormation's cleanup phase: the new policy exists and the stack points at it,+ // so a failed removal of the old one is logged and the update completes.+ when(iot.createPolicy("renamed", DOCUMENT, REGION)).thenReturn(policy("renamed", DOCUMENT));+ doThrow(new AwsException("InternalFailureException", "storage", 500)).when(iot).deletePolicy("device-policy", REGION);+ StackResource r = resource(TYPE, "Policy");++ assertDoesNotThrow(() -> provisioner.provision(r, props("renamed", document(), null), ctx("device-policy")));++ assertEquals("renamed", r.getPhysicalId());+ verify(iot, never()).deletePolicy("renamed", REGION);+ }++ @Test+ void policyReplacementRemovesTheNewPolicyWhenTaggingItFails() throws Exception {+ when(iot.createPolicy("renamed", DOCUMENT, REGION)).thenReturn(policy("renamed", DOCUMENT));+ doThrow(new AwsException("InternalFailureException", "tagging failed", 500)).when(iot).tagResource(eq(RENAMED_ARN), any());+ StackResource r = resource(TYPE, "Policy");+ ObjectNode props = props("renamed", document(), Map.of("env", "test"));++ AwsException e = assertThrows(AwsException.class, () -> provisioner.provision(r, props, ctx("device-policy")));++ assertEquals("InternalFailureException", e.getErrorCode());+ verify(iot).deletePolicy("renamed", REGION);+ verify(iot, never()).deletePolicy("device-policy", REGION);+ }++ @Test+ void policyReplacementReportsARollbackFailureWhenTheNewPolicyCannotBeRemoved() throws Exception {+ when(iot.createPolicy("renamed", DOCUMENT, REGION)).thenReturn(policy("renamed", DOCUMENT));+ doThrow(new AwsException("InternalFailureException", "tagging failed", 500)).when(iot).tagResource(eq(RENAMED_ARN), any());+ doThrow(new AwsException("InternalFailureException", "storage", 500)).when(iot).deletePolicy("renamed", REGION);+ StackResource r = resource(TYPE, "Policy");+ ObjectNode props = props("renamed", document(), Map.of("env", "test"));++ AwsException e = assertThrows(AwsException.class, () -> provisioner.provision(r, props, ctx("device-policy")));++ assertEquals("InternalFailureException", e.getErrorCode());+ assertEquals(1, e.getSuppressed().length);+ assertTrue(r.getAttributes().get(CfnRollback.UPDATE_ROLLBACK_FAILURE_ATTR).contains("renamed"));+ }++ @Test+ void deletePolicyDetachesEveryTargetBeforeDeleting() {+ when(iot.listTargetsForPolicy("device-policy", REGION)).thenReturn(new TreeSet<>(List.of(+ "arn:aws:iot:us-east-1:000000000000:cert/abc", "arn:aws:iot:us-east-1:000000000000:cert/def")));++ provisioner.delete(TYPE, "device-policy", REGION);++ InOrder inOrder = inOrder(iot);+ inOrder.verify(iot).detachPolicy("device-policy", "arn:aws:iot:us-east-1:000000000000:cert/abc", REGION);+ inOrder.verify(iot).detachPolicy("device-policy", "arn:aws:iot:us-east-1:000000000000:cert/def", REGION);+ inOrder.verify(iot).deletePolicy("device-policy", REGION);+ }++ @Test+ void deletePolicyToleratesOnlyNotFound() {+ doThrow(notFound("Policy")).when(iot).listTargetsForPolicy("gone", REGION);+ doThrow(new AwsException("InternalFailureException", "storage", 500)).when(iot).deletePolicy("stuck", REGION);++ assertDoesNotThrow(() -> provisioner.delete(TYPE, "gone", REGION));+ verify(iot, never()).deletePolicy("gone", REGION);+ AwsException e = assertThrows(AwsException.class, () -> provisioner.delete(TYPE, "stuck", REGION));+ assertEquals("InternalFailureException", e.getErrorCode());+ }++ private static IotPolicy.PolicyVersion version(String id) {+ IotPolicy.PolicyVersion version = new IotPolicy.PolicyVersion();+ version.setVersionId(id);+ return version;+ }++ private static AwsException versionsLimit() {+ return new AwsException("VersionsLimitExceededException", "The number of policy versions exceeds the limit", 409);+ }++ @Test+ void policyUpdateDeletesTheOldestVersionWhenTheServiceRefusesASixthAndCreatesAgain() throws Exception {+ String changed = "{\"Version\":\"2012-10-17\",\"Statement\":[]}";+ when(iot.getPolicy("device-policy", REGION)).thenReturn(policy("device-policy", DOCUMENT));+ when(iot.createPolicyVersion("device-policy", changed, true, REGION))+ .thenThrow(versionsLimit())+ .thenReturn(version("6"));+ StackResource r = resource(TYPE, "Policy");++ provisioner.provision(r, props("device-policy", mapper.readTree(changed), null), ctx("device-policy"));++ InOrder inOrder = inOrder(iot);+ inOrder.verify(iot, calls(1)).createPolicyVersion("device-policy", changed, true, REGION);+ inOrder.verify(iot).makeRoomForPolicyVersion("device-policy", REGION);+ inOrder.verify(iot, calls(1)).createPolicyVersion("device-policy", changed, true, REGION);+ verify(iot, times(1)).makeRoomForPolicyVersion(anyString(), anyString());+ verify(iot, never()).deletePolicyVersion(anyString(), anyString(), anyString());+ assertEquals(ARN, r.getAttributes().get("Arn"));+ assertEquals("device-policy", r.getAttributes().get("Id"));+ }++ @Test+ void policyUpdatePassesOtherVersionErrorsThroughWithoutPruning() throws Exception {+ String changed = "{\"Version\":\"2012-10-17\",\"Statement\":[]}";+ when(iot.getPolicy("device-policy", REGION)).thenReturn(policy("device-policy", DOCUMENT));+ when(iot.createPolicyVersion("device-policy", changed, true, REGION))+ .thenThrow(new AwsException("InternalFailureException", "storage", 500));+ StackResource r = resource(TYPE, "Policy");+ ObjectNode props = props("device-policy", mapper.readTree(changed), null);++ AwsException e = assertThrows(AwsException.class, () -> provisioner.provision(r, props, ctx("device-policy")));++ assertEquals("InternalFailureException", e.getErrorCode());+ verify(iot, never()).makeRoomForPolicyVersion(anyString(), anyString());+ }++ @Test+ void policyUpdatePrunesAgainWhenAnotherVersionRefilledTheSlotBeforeTheRetry() throws Exception {+ // Another client created a version between the prune and the retry.+ String changed = "{\"Version\":\"2012-10-17\",\"Statement\":[]}";+ when(iot.getPolicy("device-policy", REGION)).thenReturn(policy("device-policy", DOCUMENT));+ when(iot.createPolicyVersion("device-policy", changed, true, REGION))+ .thenThrow(versionsLimit())+ .thenThrow(versionsLimit())+ .thenReturn(version("7"));+ StackResource r = resource(TYPE, "Policy");++ provisioner.provision(r, props("device-policy", mapper.readTree(changed), null), ctx("device-policy"));++ verify(iot, times(2)).makeRoomForPolicyVersion("device-policy", REGION);+ verify(iot, times(3)).createPolicyVersion("device-policy", changed, true, REGION);+ assertEquals(ARN, r.getAttributes().get("Arn"));+ }++ @Test+ void policyUpdateGivesUpAfterAsManyPrunesAsAPolicyHasVersions() throws Exception {+ String changed = "{\"Version\":\"2012-10-17\",\"Statement\":[]}";+ when(iot.getPolicy("device-policy", REGION)).thenReturn(policy("device-policy", DOCUMENT));+ when(iot.createPolicyVersion("device-policy", changed, true, REGION))+ .thenAnswer(inv -> { throw versionsLimit(); });+ StackResource r = resource(TYPE, "Policy");+ ObjectNode props = props("device-policy", mapper.readTree(changed), null);++ AwsException e = assertThrows(AwsException.class, () -> provisioner.provision(r, props, ctx("device-policy")));++ assertEquals("VersionsLimitExceededException", e.getErrorCode());+ verify(iot, times(IotService.MAX_POLICY_VERSIONS - 1)).makeRoomForPolicyVersion("device-policy", REGION);+ verify(iot, times(IotService.MAX_POLICY_VERSIONS)).createPolicyVersion("device-policy", changed, true, REGION);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotThingCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotThingCfnProvisionerTest.javanew file mode 100644index 0000000000..9fe460dc4c--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotThingCfnProvisionerTest.java@@ -0,0 +1,198 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.iot.IotService;+import io.github.hectorvent.floci.services.iot.model.Thing;+import org.junit.jupiter.api.Test;+import org.mockito.ArgumentCaptor;++import java.util.Map;+import java.util.Set;++import static io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisionerTestSupport.REGION;+import static io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisionerTestSupport.ctx;+import static io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisionerTestSupport.notFound;+import static io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisionerTestSupport.resource;+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.ArgumentMatchers.isNull;+import static org.mockito.Mockito.doThrow;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/**+ * {@code AWS::IoT::Thing} through the IoT CFN provisioner in isolation: one mocked service. Every+ * case asserts the exact physical id and the exact {@code Fn::GetAtt} attribute keys, because an+ * unmapped type still reports CREATE_COMPLETE through the dispatcher's stub arm.+ */+class IotThingCfnProvisionerTest {++ private static final String TYPE = "AWS::IoT::Thing";+ private static final String ARN = "arn:aws:iot:us-east-1:000000000000:thing/sensor-1";+ private static final String THING_ID = "11111111-2222-3333-4444-555555555555";++ private final IotService iot = mock(IotService.class);+ private final IotCfnProvisioner provisioner = new IotCfnProvisioner(iot);+ private final ObjectMapper mapper = new ObjectMapper();++ private static Thing thing(String name, Map<String, String> attributes) {+ Thing thing = new Thing();+ thing.setThingName(name);+ thing.setThingArn("arn:aws:iot:us-east-1:000000000000:thing/" + name);+ thing.setThingId(THING_ID);+ thing.setAttributes(attributes);+ return thing;+ }++ private ObjectNode props(String name, Map<String, String> attributes) {+ ObjectNode props = mapper.createObjectNode();+ if (name != null) {+ props.put("ThingName", name);+ }+ if (attributes != null) {+ ObjectNode attrs = props.putObject("AttributePayload").putObject("Attributes");+ attributes.forEach(attrs::put);+ }+ return props;+ }++ private Map<String, String> capturedAttributes(String thingName) {+ @SuppressWarnings("unchecked")+ ArgumentCaptor<Map<String, String>> captor = ArgumentCaptor.forClass(Map.class);+ verify(iot).createThing(eq(thingName), captor.capture(), eq(REGION));+ return captor.getValue();+ }++ @Test+ void resourceTypesCoverThingPolicyAndTopicRule() {+ assertEquals(Set.of(TYPE, "AWS::IoT::Policy", "AWS::IoT::TopicRule"), provisioner.resourceTypes());+ }++ @Test+ void thingSetsNameAsPhysicalIdAndArnAndIdAttributes() {+ Map<String, String> attributes = Map.of("SerialNumber", "SN-1", "Model", "M2");+ when(iot.createThing(eq("sensor-1"), any(), eq(REGION))).thenReturn(thing("sensor-1", attributes));+ StackResource r = resource(TYPE, "Sensor");++ provisioner.provision(r, props("sensor-1", attributes), ctx());++ assertEquals("sensor-1", r.getPhysicalId());+ assertEquals(ARN, r.getAttributes().get("Arn"));+ assertEquals(THING_ID, r.getAttributes().get("Id"));+ assertEquals(attributes, capturedAttributes("sensor-1"));+ }++ @Test+ void thingWithoutAttributePayloadIsCreatedWithNoAttributes() {+ when(iot.createThing(eq("sensor-1"), any(), eq(REGION))).thenReturn(thing("sensor-1", Map.of()));+ StackResource r = resource(TYPE, "Sensor");++ provisioner.provision(r, props("sensor-1", null), ctx());++ assertEquals(Map.of(), capturedAttributes("sensor-1"));+ }++ @Test+ void thingWithoutNameGetsAGeneratedNameWithinTheLimit() {+ when(iot.createThing(anyString(), any(), eq(REGION))).thenAnswer(inv -> thing(inv.getArgument(0), Map.of()));+ StackResource r = resource(TYPE, "Sensor");++ provisioner.provision(r, mapper.createObjectNode(), ctx());++ String name = r.getPhysicalId();+ assertTrue(name.matches("my-stack-Sensor-[0-9a-f]{12}"), "generated thing name: " + name);+ assertTrue(name.length() <= 128);+ assertEquals("arn:aws:iot:us-east-1:000000000000:thing/" + name, r.getAttributes().get("Arn"));+ }++ @Test+ void thingUpdateWithTheSameNameReplacesTheAttributesInPlace() {+ Map<String, String> attributes = Map.of("Model", "M3");+ when(iot.updateThing(eq("sensor-1"), any(), isNull(), eq(REGION))).thenReturn(thing("sensor-1", attributes));+ StackResource r = resource(TYPE, "Sensor");++ provisioner.provision(r, props("sensor-1", attributes), ctx("sensor-1"));++ verify(iot, never()).createThing(anyString(), any(), anyString());+ verify(iot, never()).deleteThing(anyString(), anyString());+ assertEquals("sensor-1", r.getPhysicalId());+ assertEquals(ARN, r.getAttributes().get("Arn"));+ assertEquals(THING_ID, r.getAttributes().get("Id"));+ }++ @Test+ void thingUpdateWithoutAnExplicitNameKeepsThePriorGeneratedName() {+ when(iot.updateThing(eq("my-stack-Sensor-0123456789ab"), any(), isNull(), eq(REGION)))+ .thenReturn(thing("my-stack-Sensor-0123456789ab", Map.of()));+ StackResource r = resource(TYPE, "Sensor");++ provisioner.provision(r, mapper.createObjectNode(), ctx("my-stack-Sensor-0123456789ab"));++ verify(iot, never()).createThing(anyString(), any(), anyString());+ assertEquals("my-stack-Sensor-0123456789ab", r.getPhysicalId());+ }++ @Test+ void thingRenameCreatesTheReplacementThenDeletesThePriorThing() {+ when(iot.createThing(eq("sensor-2"), any(), eq(REGION))).thenReturn(thing("sensor-2", Map.of()));+ StackResource r = resource(TYPE, "Sensor");++ provisioner.provision(r, props("sensor-2", null), ctx("sensor-1"));++ verify(iot).deleteThing("sensor-1", REGION);+ verify(iot, never()).updateThing(anyString(), any(), any(), anyString());+ assertEquals("sensor-2", r.getPhysicalId());+ assertEquals("arn:aws:iot:us-east-1:000000000000:thing/sensor-2", r.getAttributes().get("Arn"));+ }++ @Test+ void thingRenameToleratesAPriorThingThatIsAlreadyGone() {+ when(iot.createThing(eq("sensor-2"), any(), eq(REGION))).thenReturn(thing("sensor-2", Map.of()));+ doThrow(notFound("Thing")).when(iot).deleteThing("sensor-1", REGION);+ StackResource r = resource(TYPE, "Sensor");++ assertDoesNotThrow(() -> provisioner.provision(r, props("sensor-2", null), ctx("sensor-1")));++ assertEquals("sensor-2", r.getPhysicalId());+ }++ @Test+ void thingRenameKeepsTheUpdateWhenThePriorThingCannotBeDeleted() {+ // As in CloudFormation's cleanup phase: the new thing exists and the stack points at it,+ // so a failed removal of the old one is logged and the update completes.+ when(iot.createThing(eq("sensor-2"), any(), eq(REGION))).thenReturn(thing("sensor-2", Map.of()));+ doThrow(new AwsException("InvalidRequestException", "Cannot delete", 400)).when(iot).deleteThing("sensor-1", REGION);+ StackResource r = resource(TYPE, "Sensor");++ assertDoesNotThrow(() -> provisioner.provision(r, props("sensor-2", null), ctx("sensor-1")));++ assertEquals("sensor-2", r.getPhysicalId());+ }++ @Test+ void deleteThingDelegatesToTheService() {+ provisioner.delete(TYPE, "sensor-1", REGION);++ verify(iot).deleteThing("sensor-1", REGION);+ }++ @Test+ void deleteThingToleratesOnlyNotFound() {+ doThrow(notFound("Thing")).when(iot).deleteThing("gone", REGION);+ doThrow(new AwsException("InvalidRequestException", "Cannot delete", 400)).when(iot).deleteThing("held", REGION);++ assertDoesNotThrow(() -> provisioner.delete(TYPE, "gone", REGION));+ AwsException e = assertThrows(AwsException.class, () -> provisioner.delete(TYPE, "held", REGION));+ assertEquals("InvalidRequestException", e.getErrorCode());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotTopicRuleCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotTopicRuleCfnProvisionerTest.javanew file mode 100644index 0000000000..114ff3f9e0--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IotTopicRuleCfnProvisionerTest.java@@ -0,0 +1,248 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.iot.IotService;+import io.github.hectorvent.floci.services.iot.model.IotTopicRule;+import org.junit.jupiter.api.Test;+import org.mockito.ArgumentCaptor;++import java.util.List;+import java.util.Map;++import static io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisionerTestSupport.REGION;+import static io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisionerTestSupport.ctx;+import static io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisionerTestSupport.notFound;+import static io.github.hectorvent.floci.services.cloudformation.provisioners.IotCfnProvisionerTestSupport.resource;+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.doThrow;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/**+ * {@code AWS::IoT::TopicRule} through the IoT CFN provisioner in isolation: one mocked service.+ * Every case asserts the exact physical id and the exact {@code Fn::GetAtt} attribute key, because+ * an unmapped type still reports CREATE_COMPLETE through the dispatcher's stub arm.+ */+class IotTopicRuleCfnProvisionerTest {++ private static final String TYPE = "AWS::IoT::TopicRule";+ private static final String ARN = "arn:aws:iot:us-east-1:000000000000:rule/telemetryRule";+ private static final String RENAMED_ARN = "arn:aws:iot:us-east-1:000000000000:rule/renamedRule";++ private final IotService iot = mock(IotService.class);+ private final IotCfnProvisioner provisioner = new IotCfnProvisioner(iot);+ private final ObjectMapper mapper = new ObjectMapper();++ private static IotTopicRule rule(String name) {+ IotTopicRule rule = new IotTopicRule();+ rule.setRuleName(name);+ rule.setRuleArn("arn:aws:iot:us-east-1:000000000000:rule/" + name);+ return rule;+ }++ /** The payload as CloudFormation spells it, with an intrinsic where CDK puts one. */+ private ObjectNode templatePayload() {+ ObjectNode payload = mapper.createObjectNode()+ .put("Sql", "SELECT * FROM 'devices/+/telemetry'")+ .put("AwsIotSqlVersion", "2016-03-23")+ .put("RuleDisabled", false)+ .put("Description", "telemetry fan-out");+ ObjectNode functionArn = mapper.createObjectNode();+ functionArn.set("Fn::GetAtt", mapper.createArrayNode().add("Handler").add("Arn"));+ payload.withArray("Actions").addObject().putObject("Lambda").set("FunctionArn", functionArn);+ ObjectNode sqs = payload.withArray("Actions").addObject().putObject("Sqs");+ sqs.put("RoleArn", "arn:aws:iam::000000000000:role/rule").put("UseBase64", false);+ sqs.set("QueueUrl", mapper.createObjectNode().put("Ref", "Queue"));+ payload.putObject("ErrorAction").putObject("Sqs")+ .put("QueueUrl", "http://localhost:4566/000000000000/dlq")+ .put("RoleArn", "arn:aws:iam::000000000000:role/rule");+ return payload;+ }++ private ObjectNode props(String name, ObjectNode payload, Map<String, String> tags) {+ ObjectNode props = mapper.createObjectNode();+ if (name != null) {+ props.put("RuleName", name);+ }+ if (payload != null) {+ props.set("TopicRulePayload", payload);+ }+ if (tags != null) {+ tags.forEach((key, value) -> props.withArray("Tags").addObject().put("Key", key).put("Value", value));+ }+ return props;+ }++ private JsonNode capturedPayload(String ruleName) {+ ArgumentCaptor<JsonNode> captor = ArgumentCaptor.forClass(JsonNode.class);+ verify(iot).createTopicRule(eq(ruleName), captor.capture(), eq(REGION));+ return captor.getValue();+ }++ @Test+ void topicRuleHandsTheServiceThePayloadInTheApiShapeAndSetsArn() {+ when(iot.createTopicRule(eq("telemetryRule"), any(), eq(REGION))).thenReturn(rule("telemetryRule"));+ StackResource r = resource(TYPE, "Rule");++ provisioner.provision(r, props("telemetryRule", templatePayload(), null), ctx());++ assertEquals("telemetryRule", r.getPhysicalId());+ assertEquals(ARN, r.getAttributes().get("Arn"));+ JsonNode payload = capturedPayload("telemetryRule");+ assertEquals("SELECT * FROM 'devices/+/telemetry'", payload.get("sql").asText());+ assertEquals("2016-03-23", payload.get("awsIotSqlVersion").asText());+ assertEquals("telemetry fan-out", payload.get("description").asText());+ assertTrue(payload.get("ruleDisabled").isBoolean());+ assertFalse(payload.get("ruleDisabled").asBoolean());+ assertEquals("resolved:Handler.Arn", payload.at("/actions/0/lambda/functionArn").asText());+ assertEquals("resolved:Queue", payload.at("/actions/1/sqs/queueUrl").asText());+ assertTrue(payload.at("/actions/1/sqs/useBase64").isBoolean());+ assertEquals("http://localhost:4566/000000000000/dlq", payload.at("/errorAction/sqs/queueUrl").asText());+ assertFalse(payload.has("Sql") || payload.has("Actions") || payload.has("ErrorAction"),+ "no PascalCase keys may reach the service: " + payload);+ }++ @Test+ void topicRuleDropsNullPayloadMembers() {+ when(iot.createTopicRule(eq("telemetryRule"), any(), eq(REGION))).thenReturn(rule("telemetryRule"));+ ObjectNode payload = mapper.createObjectNode().put("Sql", "SELECT * FROM 'a'");+ payload.putNull("Description");+ payload.withArray("Actions").addObject().putObject("Lambda").put("FunctionArn", "arn:fn");+ StackResource r = resource(TYPE, "Rule");++ provisioner.provision(r, props("telemetryRule", payload, null), ctx());++ assertFalse(capturedPayload("telemetryRule").has("description"));+ }++ @Test+ void topicRuleRequiresAPayload() {+ StackResource r = resource(TYPE, "Rule");+ ObjectNode props = props("telemetryRule", null, null);++ assertThrows(IllegalArgumentException.class, () -> provisioner.provision(r, props, ctx()));+ verify(iot, never()).createTopicRule(anyString(), any(), anyString());+ }++ @Test+ void topicRuleWithoutNameGetsAGeneratedNameWithoutHyphens() {+ when(iot.createTopicRule(anyString(), any(), eq(REGION))).thenAnswer(inv -> rule(inv.getArgument(0)));+ StackResource r = resource(TYPE, "Rule");++ provisioner.provision(r, props(null, templatePayload(), null), ctx());++ assertTrue(r.getPhysicalId().matches("mystackRule[0-9a-f]{12}"), "generated rule name: " + r.getPhysicalId());+ assertEquals("arn:aws:iot:us-east-1:000000000000:rule/" + r.getPhysicalId(), r.getAttributes().get("Arn"));+ }++ @Test+ void topicRuleHandsAnExplicitNameToTheServiceUnchanged() {+ // Only generated names are trimmed to the characters a rule name allows; validating an+ // explicit name is the service's job, so it must not be altered on the way there.+ when(iot.createTopicRule(eq("telemetry-rule"), any(), eq(REGION))).thenReturn(rule("telemetry-rule"));+ StackResource r = resource(TYPE, "Rule");++ provisioner.provision(r, props("telemetry-rule", templatePayload(), null), ctx());++ assertEquals("telemetry-rule", r.getPhysicalId());+ verify(iot).createTopicRule(eq("telemetry-rule"), any(), eq(REGION));+ }++ @Test+ void topicRuleCreateAppliesTheTemplateTags() {+ when(iot.createTopicRule(eq("telemetryRule"), any(), eq(REGION))).thenReturn(rule("telemetryRule"));+ StackResource r = resource(TYPE, "Rule");++ provisioner.provision(r, props("telemetryRule", templatePayload(), Map.of("env", "test")), ctx());++ verify(iot).tagResource(ARN, Map.of("env", "test"));+ assertFalse(r.getAttributes().containsKey(CfnRollback.ROLLBACK_OWNED_ATTR));+ }++ @Test+ void topicRuleUpdateWithTheSameNameReplacesTheRule() {+ when(iot.replaceTopicRule(eq("telemetryRule"), any(), eq(REGION))).thenReturn(rule("telemetryRule"));+ StackResource r = resource(TYPE, "Rule");++ provisioner.provision(r, props("telemetryRule", templatePayload(), null), ctx("telemetryRule"));++ ArgumentCaptor<JsonNode> captor = ArgumentCaptor.forClass(JsonNode.class);+ verify(iot).replaceTopicRule(eq("telemetryRule"), captor.capture(), eq(REGION));+ assertEquals("SELECT * FROM 'devices/+/telemetry'", captor.getValue().get("sql").asText());+ verify(iot, never()).createTopicRule(anyString(), any(), anyString());+ verify(iot, never()).deleteTopicRule(anyString(), anyString());+ assertEquals("telemetryRule", r.getPhysicalId());+ assertEquals(ARN, r.getAttributes().get("Arn"));+ }++ @Test+ void topicRuleUpdateWithoutAnExplicitNameKeepsThePriorGeneratedName() {+ when(iot.replaceTopicRule(eq("mystackRule0123456789ab"), any(), eq(REGION))).thenReturn(rule("mystackRule0123456789ab"));+ StackResource r = resource(TYPE, "Rule");++ provisioner.provision(r, props(null, templatePayload(), null), ctx("mystackRule0123456789ab"));++ verify(iot, never()).createTopicRule(anyString(), any(), anyString());+ assertEquals("mystackRule0123456789ab", r.getPhysicalId());+ }++ @Test+ void topicRuleUpdateDrivesTheTagsToTheTemplate() {+ when(iot.replaceTopicRule(eq("telemetryRule"), any(), eq(REGION))).thenReturn(rule("telemetryRule"));+ when(iot.listTagsForResource(ARN)).thenReturn(Map.of("stale", "1"));+ StackResource r = resource(TYPE, "Rule");++ provisioner.provision(r, props("telemetryRule", templatePayload(), Map.of("env", "test")), ctx("telemetryRule"));++ verify(iot).untagResource(ARN, List.of("stale"));+ verify(iot).tagResource(ARN, Map.of("env", "test"));+ }++ @Test+ void topicRuleRenameCreatesTheReplacementThenDeletesThePriorRule() {+ when(iot.createTopicRule(eq("renamedRule"), any(), eq(REGION))).thenReturn(rule("renamedRule"));+ StackResource r = resource(TYPE, "Rule");++ provisioner.provision(r, props("renamedRule", templatePayload(), null), ctx("telemetryRule"));++ verify(iot).deleteTopicRule("telemetryRule", REGION);+ verify(iot, never()).replaceTopicRule(anyString(), any(), anyString());+ assertEquals("renamedRule", r.getPhysicalId());+ assertEquals(RENAMED_ARN, r.getAttributes().get("Arn"));+ }++ @Test+ void topicRuleReplacementRemovesTheNewRuleWhenTaggingItFails() {+ when(iot.createTopicRule(eq("renamedRule"), any(), eq(REGION))).thenReturn(rule("renamedRule"));+ doThrow(new AwsException("InternalFailureException", "tagging failed", 500)).when(iot).tagResource(eq(RENAMED_ARN), any());+ StackResource r = resource(TYPE, "Rule");+ ObjectNode props = props("renamedRule", templatePayload(), Map.of("env", "test"));++ assertThrows(AwsException.class, () -> provisioner.provision(r, props, ctx("telemetryRule")));++ verify(iot).deleteTopicRule("renamedRule", REGION);+ verify(iot, never()).deleteTopicRule("telemetryRule", REGION);+ }++ @Test+ void deleteTopicRuleToleratesOnlyNotFound() {+ doThrow(notFound("Topic rule")).when(iot).deleteTopicRule("gone", REGION);+ doThrow(new AwsException("InternalFailureException", "storage", 500)).when(iot).deleteTopicRule("stuck", REGION);++ assertDoesNotThrow(() -> provisioner.delete(TYPE, "gone", REGION));+ assertThrows(AwsException.class, () -> provisioner.delete(TYPE, "stuck", REGION));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotIntegrationTest.javaindex 2b8303b333..fb0ab0b467 100644--- a/src/test/java/io/github/hectorvent/floci/services/iot/IotIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotIntegrationTest.java@@ -749,6 +749,52 @@ class IotIntegrationTest {.body("__type", equalTo("ResourceNotFoundException"));}+ @Test+ @Order(20)+ void aSixthPolicyVersionIsRefusedUntilOneIsDeleted() {+ String document = "{\"policyDocument\":\"{\\\"Version\\\":\\\"2012-10-17\\\",\\\"Statement\\\":[]}\"}";+ given()+ .contentType("application/json")+ .body(document)+ .when()+ .post("/policies/five-versions")+ .then()+ .statusCode(200);+ for (int version = 2; version <= 5; version++) {+ given()+ .contentType("application/json")+ .body(document)+ .when()+ .post("/policies/five-versions/version")+ .then()+ .statusCode(200)+ .body("policyVersionId", equalTo(Integer.toString(version)));+ }++ given()+ .contentType("application/json")+ .body(document)+ .when()+ .post("/policies/five-versions/version")+ .then()+ .statusCode(409)+ .body("__type", equalTo("VersionsLimitExceededException"));++ given()+ .when()+ .delete("/policies/five-versions/version/3")+ .then()+ .statusCode(200);+ given()+ .contentType("application/json")+ .body(document)+ .when()+ .post("/policies/five-versions/version")+ .then()+ .statusCode(200)+ .body("policyVersionId", equalTo("6"));+ }+private String createThingAndReturnArn(String thingName) {return given().contentType("application/json")diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotServiceTest.javaindex 5b24f371bd..1b488500da 100644--- a/src/test/java/io/github/hectorvent/floci/services/iot/IotServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotServiceTest.java@@ -11,6 +11,7 @@ import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsServiceimport io.github.hectorvent.floci.services.dynamodb.DynamoDbService;import io.github.hectorvent.floci.services.firehose.FirehoseService;import io.github.hectorvent.floci.services.firehose.model.Record;+import io.github.hectorvent.floci.services.iot.model.IotPolicy;import io.github.hectorvent.floci.services.iot.model.IotTopicRule;import io.github.hectorvent.floci.services.kinesis.KinesisService;import io.github.hectorvent.floci.services.lambda.LambdaService;@@ -23,9 +24,14 @@ import org.junit.jupiter.api.Test;import org.mockito.ArgumentCaptor;import java.nio.charset.StandardCharsets;+import java.util.ArrayList;import java.util.Base64;import java.util.List;import java.util.Map;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.Future;import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;import static org.junit.jupiter.api.Assertions.assertEquals;@@ -47,6 +53,7 @@ import static org.mockito.Mockito.when;* Rules engine behaviour of {@link IotService} with in-memory stores and mocked action targets:* one failing action never fails the publish or the other actions, the error action receives the* failure document, and the {@code firehose} and {@code cloudwatchLogs} actions deliver the payload.+ * Also the five-version cap on a policy, including under racing creates.*/class IotServiceTest {@@ -499,4 +506,161 @@ class IotServiceTest {verify(lambda).invoke(eq(REGION), eq(FUNCTION_ARN), any(), eq(InvocationType.Event));verify(lambda, never()).invoke(eq(REGION), eq(ERROR_FUNCTION_ARN), any(), any());}++ @Test+ void aPolicyHoldsAtMostFiveVersionsUntilOneIsDeleted() {+ service.createPolicy("capped", "{\"v\":1}", REGION);+ for (int v = 2; v <= 5; v++) {+ assertEquals(Integer.toString(v),+ service.createPolicyVersion("capped", "{\"v\":" + v + "}", true, REGION).getVersionId());+ }++ AwsException e = assertThrows(AwsException.class,+ () -> service.createPolicyVersion("capped", "{\"v\":6}", true, REGION));++ assertEquals("VersionsLimitExceededException", e.getErrorCode());+ assertEquals(409, e.getHttpStatus());+ assertEquals(5, service.listPolicyVersions("capped", REGION).size());+ assertEquals("5", service.getPolicy("capped", REGION).getDefaultVersionId());+ service.deletePolicyVersion("capped", "2", REGION);+ assertEquals("6", service.createPolicyVersion("capped", "{\"v\":6}", true, REGION).getVersionId());+ assertEquals("6", service.getPolicy("capped", REGION).getDefaultVersionId());+ }++ @Test+ void racingVersionCreatesNeverPushAPolicyPastFiveVersions() throws Exception {+ service.createPolicy("raced", "{\"v\":1}", REGION);+ int writers = 8;+ CountDownLatch start = new CountDownLatch(1);+ ExecutorService pool = Executors.newFixedThreadPool(writers);+ List<Future<Boolean>> outcomes = new ArrayList<>();+ try {+ for (int i = 0; i < writers; i++) {+ outcomes.add(pool.submit(() -> {+ start.await();+ try {+ service.createPolicyVersion("raced", "{\"v\":true}", false, REGION);+ return true;+ } catch (AwsException e) {+ assertEquals("VersionsLimitExceededException", e.getErrorCode());+ return false;+ }+ }));+ }+ start.countDown();+ int created = 0;+ for (Future<Boolean> outcome : outcomes) {+ if (outcome.get()) {+ created++;+ }+ }+ assertEquals(4, created, "exactly four of eight racing creates fit under the cap");+ } finally {+ pool.shutdownNow();+ }+ assertEquals(5, service.listPolicyVersions("raced", REGION).size());+ }++ @Test+ void deletingTheOldestVersionRemovesTheNumericallySmallestIdAndKeepsTheDefault() {+ service.createPolicy("pruned", "{\"v\":1}", REGION);+ for (int v = 2; v <= 10; v++) {+ if (service.listPolicyVersions("pruned", REGION).size() == IotService.MAX_POLICY_VERSIONS) {+ service.makeRoomForPolicyVersion("pruned", REGION);+ }+ service.createPolicyVersion("pruned", "{\"v\":" + v + "}", true, REGION);+ }+ assertEquals(List.of(6, 7, 8, 9, 10), versionIds("pruned"));++ // Sorted as text, "10" would come before "6"; the oldest version is the numerically smallest id.+ service.makeRoomForPolicyVersion("pruned", REGION);++ assertEquals(List.of(7, 8, 9, 10), versionIds("pruned"));+ assertEquals("10", service.getPolicy("pruned", REGION).getDefaultVersionId());+ }++ @Test+ void deletingTheOldestVersionMovesTheDefaultToTheNewestWhenTheOldestIsTheDefault() {+ service.createPolicy("pinned", "{\"v\":1}", REGION);+ for (int v = 2; v <= 5; v++) {+ service.createPolicyVersion("pinned", "{\"v\":" + v + "}", false, REGION);+ }+ assertEquals("1", service.getPolicy("pinned", REGION).getDefaultVersionId());++ service.makeRoomForPolicyVersion("pinned", REGION);++ assertEquals(List.of(2, 3, 4, 5), versionIds("pinned"));+ assertEquals("5", service.getPolicy("pinned", REGION).getDefaultVersionId());+ assertEquals("{\"v\":5}", service.getPolicy("pinned", REGION).getPolicyDocument());+ }++ @Test+ void makingRoomOnAPolicyStoredWithMoreThanFiveVersionsDeletesDownToFourInOneStep() {+ // A policy persisted before the cap existed can hold more than five versions; the stores+ // hand out the live object, so adding to it is the same as having persisted it that way.+ service.createPolicy("legacy", "{\"v\":1}", REGION);+ for (int v = 2; v <= 5; v++) {+ service.createPolicyVersion("legacy", "{\"v\":" + v + "}", true, REGION);+ }+ IotPolicy stored = service.getPolicy("legacy", REGION);+ List<IotPolicy.PolicyVersion> versions = new ArrayList<>(stored.getVersions());+ for (int v = 6; v <= 8; v++) {+ IotPolicy.PolicyVersion version = new IotPolicy.PolicyVersion();+ version.setVersionId(Integer.toString(v));+ version.setDocument("{\"v\":" + v + "}");+ versions.add(version);+ }+ stored.setVersions(versions);+ assertEquals(List.of(1, 2, 3, 4, 5, 6, 7, 8), versionIds("legacy"));++ service.makeRoomForPolicyVersion("legacy", REGION);++ assertEquals(List.of(5, 6, 7, 8), versionIds("legacy"));+ assertEquals("5", service.getPolicy("legacy", REGION).getDefaultVersionId());+ assertEquals("9", service.createPolicyVersion("legacy", "{\"v\":9}", true, REGION).getVersionId());+ }++ @Test+ void aPolicyDeletedWhileVersionsAreBeingCreatedStaysDeleted() throws Exception {+ for (int round = 0; round < 20; round++) {+ String name = "vanishing-" + round;+ service.createPolicy(name, "{\"v\":1}", REGION);+ CountDownLatch start = new CountDownLatch(1);+ ExecutorService pool = Executors.newFixedThreadPool(4);+ List<Future<?>> outcomes = new ArrayList<>();+ try {+ for (int i = 0; i < 3; i++) {+ outcomes.add(pool.submit(() -> {+ start.await();+ try {+ service.createPolicyVersion(name, "{\"v\":2}", false, REGION);+ } catch (AwsException e) {+ assertEquals("ResourceNotFoundException", e.getErrorCode());+ }+ return null;+ }));+ }+ outcomes.add(pool.submit(() -> {+ start.await();+ service.deletePolicy(name, REGION);+ return null;+ }));+ start.countDown();+ for (Future<?> outcome : outcomes) {+ outcome.get();+ }+ } finally {+ pool.shutdownNow();+ }+ AwsException e = assertThrows(AwsException.class, () -> service.getPolicy(name, REGION));+ assertEquals("ResourceNotFoundException", e.getErrorCode(), "round " + round + " brought the policy back");+ }+ }++ private List<Integer> versionIds(String policyName) {+ return service.listPolicyVersions(policyName, REGION).stream()+ .map(version -> Integer.parseInt(version.getVersionId()))+ .sorted()+ .toList();+ }}diff --git a/src/test/resources/cloudformation/supported-resource-types.tsv b/src/test/resources/cloudformation/supported-resource-types.tsvindex e1e36f0165..1de7988326 100644--- a/src/test/resources/cloudformation/supported-resource-types.tsv+++ b/src/test/resources/cloudformation/supported-resource-types.tsv@@ -75,6 +75,9 @@ AWS::IAM::Policy LEGACY_SWITCHAWS::IAM::Role IamRoleCfnProvisionerAWS::IAM::User LEGACY_SWITCHAWS::IoT::DomainConfiguration IotDomainConfigurationCfnProvisioner+AWS::IoT::Policy IotCfnProvisioner+AWS::IoT::Thing IotCfnProvisioner+AWS::IoT::TopicRule IotCfnProvisionerAWS::KMS::Alias KmsCfnProvisionerAWS::KMS::Key KmsCfnProvisionerAWS::Kinesis::Stream KinesisCfnProvisioner