Light, fluffy, and always free - The AWS Local Emulator alternative
feat(cloudformation): provision Cloud Map namespaces and services (#4599)
Mario Toffiaa338a430cc4c
diff --git a/compatibility-tests/compat-cdk/lib/floci-stack.js b/compatibility-tests/compat-cdk/lib/floci-stack.jsindex 1e2b356a91..692685e934 100644--- a/compatibility-tests/compat-cdk/lib/floci-stack.js+++ b/compatibility-tests/compat-cdk/lib/floci-stack.js@@ -9,6 +9,7 @@ const secretsmanager = require("aws-cdk-lib/aws-secretsmanager");const lambda = require("aws-cdk-lib/aws-lambda");const ec2 = require("aws-cdk-lib/aws-ec2");const elbv2 = require("aws-cdk-lib/aws-elasticloadbalancingv2");+const servicediscovery = require("aws-cdk-lib/aws-servicediscovery");const path = require("path");class FlociTestStack extends cdk.Stack {constructor(scope, id, props) {@@ -85,6 +86,16 @@ class FlociTestStack extends cdk.Stack {internetFacing: false,vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_ISOLATED },});+ // Cloud Map namespace + service: regression for https://github.com/floci-io/floci/issues/4596.+ const namespace = new servicediscovery.PrivateDnsNamespace(this, 'TestNamespace', {+ name: 'floci-cdk.internal',+ vpc,+ });+ const service = namespace.createService('TestService', {+ name: 'floci-cdk-svc',+ dnsRecordType: servicediscovery.DnsRecordType.A,+ dnsTtl: cdk.Duration.seconds(30),+ });new cdk.CfnOutput(this, 'BucketName', { value: bucket.bucketName });new cdk.CfnOutput(this, 'QueueUrl', { value: queue.queueUrl });new cdk.CfnOutput(this, 'TableName', { value: table.tableName });@@ -92,7 +103,9 @@ class FlociTestStack extends cdk.Stack {new cdk.CfnOutput(this, 'GeneratedSecretName', { value: generatedSecret.name || 'floci-cdk-generated-secret' });new cdk.CfnOutput(this, 'VpcId', { value: vpc.vpcId });new cdk.CfnOutput(this, 'AlbArn', { value: alb.loadBalancerArn });+ new cdk.CfnOutput(this, 'NamespaceId', { value: namespace.namespaceId });+ new cdk.CfnOutput(this, 'ServiceId', { value: service.serviceId });}}exports.FlociTestStack = FlociTestStack;-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"floci-stack.js","sourceRoot":"","sources":["floci-stack.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport * as sqs from 'aws-cdk-lib/aws-sqs';\nimport * as dynamodb from 'aws-cdk-lib/aws-dynamodb';\nimport * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';\nimport * as path from 'path';\nimport { Construct } from 'constructs';\n\nexport class FlociTestStack extends cdk.Stack {\n  constructor(scope: Construct, id: string, props?: cdk.StackProps) {\n    super(scope, id, props);\n\n    const bucket = new s3.Bucket(this, 'TestBucket', {\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n    });\n\n    const queue = new sqs.Queue(this, 'TestQueue', {\n      queueName: 'floci-cdk-test-queue',\n      visibilityTimeout: cdk.Duration.seconds(30),\n    });\n\n    const table = new dynamodb.TableV2(this, 'TestTable', {\n      tableName: 'floci-cdk-test-table',\n      partitionKey: { name: 'pk', type: dynamodb.AttributeType.STRING },\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n    });\n\n    // DynamoDB table with GSI and LSI — validates CloudFormation index provisioning\n    const indexTable = new dynamodb.TableV2(this, 'IndexTestTable', {\n      tableName: 'floci-cdk-index-table',\n      partitionKey: { name: 'pk', type: dynamodb.AttributeType.STRING },\n      sortKey: { name: 'sk', type: dynamodb.AttributeType.STRING },\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n      globalSecondaryIndexes: [\n        {\n          indexName: 'gsi-1',\n          partitionKey: { name: 'gsiPk', type: dynamodb.AttributeType.STRING },\n          sortKey: { name: 'sk', type: dynamodb.AttributeType.STRING },\n          projectionType: dynamodb.ProjectionType.ALL,\n        },\n      ],\n      localSecondaryIndexes: [\n        {\n          indexName: 'lsi-1',\n          sortKey: { name: 'lsiSk', type: dynamodb.AttributeType.STRING },\n          projectionType: dynamodb.ProjectionType.KEYS_ONLY,\n        },\n      ],\n    });\n\n    const generatedSecret = new secretsmanager.CfnSecret(this, 'GeneratedSecret', {\n      name: 'floci-cdk-generated-secret',\n      generateSecretString: {\n        secretStringTemplate: '{\"username\":\"admin\"}',\n        generateStringKey: 'password',\n        passwordLength: 24,\n        excludeCharacters: 'abc',\n      },\n    });\n    generatedSecret.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);\n\n    // Custom Docker image Lambda — exercises ECR emulation end-to-end:\n    // CDK builds the local Dockerfile, cdk-assets pushes it to the bootstrap\n    // ECR repository (via Floci's emulated ECR + registry:2), and Floci's\n    // Lambda runner pulls the image at invoke time.\n    new lambda.DockerImageFunction(this, 'DockerHelloFn', {\n      functionName: 'floci-cdk-docker-hello',\n      code: lambda.DockerImageCode.fromImageAsset(path.join(__dirname, '..', 'docker-fn')),\n      timeout: cdk.Duration.seconds(15),\n      memorySize: 256,\n    });\n\n    // VPC + internal ALB — regression for issue #1297: CloudFormation must create the\n    // EC2 VPC/subnets for real (in EC2), otherwise the ALB that references the\n    // CDK-generated subnets fails with \"The subnet ID '...' does not exist\".\n    const vpc = new ec2.Vpc(this, 'TestVpc', {\n      vpcName: 'floci-cdk-vpc',\n      maxAzs: 2,\n      natGateways: 0,\n      subnetConfiguration: [\n        { name: 'public', subnetType: ec2.SubnetType.PUBLIC, cidrMask: 24 },\n        { name: 'isolated', subnetType: ec2.SubnetType.PRIVATE_ISOLATED, cidrMask: 24 },\n      ],\n    });\n\n    const alb = new elbv2.ApplicationLoadBalancer(this, 'TestAlb', {\n      loadBalancerName: 'floci-cdk-alb',\n      vpc,\n      internetFacing: false,\n      vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_ISOLATED },\n    });\n\n    new cdk.CfnOutput(this, 'BucketName', { value: bucket.bucketName });\n    new cdk.CfnOutput(this, 'QueueUrl', { value: queue.queueUrl });\n    new cdk.CfnOutput(this, 'TableName', { value: table.tableName });\n    new cdk.CfnOutput(this, 'IndexTableName', { value: indexTable.tableName });\n    new cdk.CfnOutput(this, 'GeneratedSecretName', { value: generatedSecret.name || 'floci-cdk-generated-secret' });\n    new cdk.CfnOutput(this, 'VpcId', { value: vpc.vpcId });\n    new cdk.CfnOutput(this, 'AlbArn', { value: alb.loadBalancerArn });\n  }\n}\n"]}\ No newline at end of file+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"floci-stack.js","sourceRoot":"","sources":["floci-stack.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport * as sqs from 'aws-cdk-lib/aws-sqs';\nimport * as dynamodb from 'aws-cdk-lib/aws-dynamodb';\nimport * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';\nimport * as servicediscovery from 'aws-cdk-lib/aws-servicediscovery';\nimport * as path from 'path';\nimport { Construct } from 'constructs';\n\nexport class FlociTestStack extends cdk.Stack {\n  constructor(scope: Construct, id: string, props?: cdk.StackProps) {\n    super(scope, id, props);\n\n    const bucket = new s3.Bucket(this, 'TestBucket', {\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n    });\n\n    const queue = new sqs.Queue(this, 'TestQueue', {\n      queueName: 'floci-cdk-test-queue',\n      visibilityTimeout: cdk.Duration.seconds(30),\n    });\n\n    const table = new dynamodb.TableV2(this, 'TestTable', {\n      tableName: 'floci-cdk-test-table',\n      partitionKey: { name: 'pk', type: dynamodb.AttributeType.STRING },\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n    });\n\n    // DynamoDB table with GSI and LSI — validates CloudFormation index provisioning\n    const indexTable = new dynamodb.TableV2(this, 'IndexTestTable', {\n      tableName: 'floci-cdk-index-table',\n      partitionKey: { name: 'pk', type: dynamodb.AttributeType.STRING },\n      sortKey: { name: 'sk', type: dynamodb.AttributeType.STRING },\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n      globalSecondaryIndexes: [\n        {\n          indexName: 'gsi-1',\n          partitionKey: { name: 'gsiPk', type: dynamodb.AttributeType.STRING },\n          sortKey: { name: 'sk', type: dynamodb.AttributeType.STRING },\n          projectionType: dynamodb.ProjectionType.ALL,\n        },\n      ],\n      localSecondaryIndexes: [\n        {\n          indexName: 'lsi-1',\n          sortKey: { name: 'lsiSk', type: dynamodb.AttributeType.STRING },\n          projectionType: dynamodb.ProjectionType.KEYS_ONLY,\n        },\n      ],\n    });\n\n    const generatedSecret = new secretsmanager.CfnSecret(this, 'GeneratedSecret', {\n      name: 'floci-cdk-generated-secret',\n      generateSecretString: {\n        secretStringTemplate: '{\"username\":\"admin\"}',\n        generateStringKey: 'password',\n        passwordLength: 24,\n        excludeCharacters: 'abc',\n      },\n    });\n    generatedSecret.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);\n\n    // Custom Docker image Lambda — exercises ECR emulation end-to-end:\n    // CDK builds the local Dockerfile, cdk-assets pushes it to the bootstrap\n    // ECR repository (via Floci's emulated ECR + registry:2), and Floci's\n    // Lambda runner pulls the image at invoke time.\n    new lambda.DockerImageFunction(this, 'DockerHelloFn', {\n      functionName: 'floci-cdk-docker-hello',\n      code: lambda.DockerImageCode.fromImageAsset(path.join(__dirname, '..', 'docker-fn')),\n      timeout: cdk.Duration.seconds(15),\n      memorySize: 256,\n    });\n\n    // VPC + internal ALB — regression for issue #1297: CloudFormation must create the\n    // EC2 VPC/subnets for real (in EC2), otherwise the ALB that references the\n    // CDK-generated subnets fails with \"The subnet ID '...' does not exist\".\n    const vpc = new ec2.Vpc(this, 'TestVpc', {\n      vpcName: 'floci-cdk-vpc',\n      maxAzs: 2,\n      natGateways: 0,\n      subnetConfiguration: [\n        { name: 'public', subnetType: ec2.SubnetType.PUBLIC, cidrMask: 24 },\n        { name: 'isolated', subnetType: ec2.SubnetType.PRIVATE_ISOLATED, cidrMask: 24 },\n      ],\n    });\n\n    const alb = new elbv2.ApplicationLoadBalancer(this, 'TestAlb', {\n      loadBalancerName: 'floci-cdk-alb',\n      vpc,\n      internetFacing: false,\n      vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_ISOLATED },\n    });\n\n    // Cloud Map namespace + service: regression for https://github.com/floci-io/floci/issues/4596.\n    const namespace = new servicediscovery.PrivateDnsNamespace(this, 'TestNamespace', {\n      name: 'floci-cdk.internal',\n      vpc,\n    });\n    const service = namespace.createService('TestService', {\n      name: 'floci-cdk-svc',\n      dnsRecordType: servicediscovery.DnsRecordType.A,\n      dnsTtl: cdk.Duration.seconds(30),\n    });\n\n    new cdk.CfnOutput(this, 'BucketName', { value: bucket.bucketName });\n    new cdk.CfnOutput(this, 'QueueUrl', { value: queue.queueUrl });\n    new cdk.CfnOutput(this, 'TableName', { value: table.tableName });\n    new cdk.CfnOutput(this, 'IndexTableName', { value: indexTable.tableName });\n    new cdk.CfnOutput(this, 'GeneratedSecretName', { value: generatedSecret.name || 'floci-cdk-generated-secret' });\n    new cdk.CfnOutput(this, 'VpcId', { value: vpc.vpcId });\n    new cdk.CfnOutput(this, 'AlbArn', { value: alb.loadBalancerArn });\n    new cdk.CfnOutput(this, 'NamespaceId', { value: namespace.namespaceId });\n    new cdk.CfnOutput(this, 'ServiceId', { value: service.serviceId });\n  }\n}\n"]}\ No newline at end of filediff --git a/compatibility-tests/compat-cdk/lib/floci-stack.ts b/compatibility-tests/compat-cdk/lib/floci-stack.tsindex f7ed4d17e6..11806b3704 100644--- a/compatibility-tests/compat-cdk/lib/floci-stack.ts+++ b/compatibility-tests/compat-cdk/lib/floci-stack.ts@@ -6,6 +6,7 @@ import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';import * as lambda from 'aws-cdk-lib/aws-lambda';import * as ec2 from 'aws-cdk-lib/aws-ec2';import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';+import * as servicediscovery from 'aws-cdk-lib/aws-servicediscovery';import * as path from 'path';import { Construct } from 'constructs';@@ -93,6 +94,17 @@ export class FlociTestStack extends cdk.Stack {vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_ISOLATED },});+ // Cloud Map namespace + service: regression for https://github.com/floci-io/floci/issues/4596.+ const namespace = new servicediscovery.PrivateDnsNamespace(this, 'TestNamespace', {+ name: 'floci-cdk.internal',+ vpc,+ });+ const service = namespace.createService('TestService', {+ name: 'floci-cdk-svc',+ dnsRecordType: servicediscovery.DnsRecordType.A,+ dnsTtl: cdk.Duration.seconds(30),+ });+new cdk.CfnOutput(this, 'BucketName', { value: bucket.bucketName });new cdk.CfnOutput(this, 'QueueUrl', { value: queue.queueUrl });new cdk.CfnOutput(this, 'TableName', { value: table.tableName });@@ -100,5 +112,7 @@ export class FlociTestStack extends cdk.Stack {new cdk.CfnOutput(this, 'GeneratedSecretName', { value: generatedSecret.name || 'floci-cdk-generated-secret' });new cdk.CfnOutput(this, 'VpcId', { value: vpc.vpcId });new cdk.CfnOutput(this, 'AlbArn', { value: alb.loadBalancerArn });+ new cdk.CfnOutput(this, 'NamespaceId', { value: namespace.namespaceId });+ new cdk.CfnOutput(this, 'ServiceId', { value: service.serviceId });}}diff --git a/compatibility-tests/compat-cdk/test/cdk.bats b/compatibility-tests/compat-cdk/test/cdk.batsindex 7cfabca3b1..4009e05301 100644--- a/compatibility-tests/compat-cdk/test/cdk.bats+++ b/compatibility-tests/compat-cdk/test/cdk.bats@@ -221,3 +221,22 @@ setup() {count=$(json_get "$output" '.Subnets | length')[ "$count" -eq 2 ]}++# --- Cloud Map namespace + service (regression: issue #4596) ---+#+# CloudFormation must create the CDK-generated AWS::ServiceDiscovery::PrivateDnsNamespace+# and AWS::ServiceDiscovery::Service in Cloud Map instead of stubbing them.+# https://github.com/floci-io/floci/issues/4596++@test "CDK: Cloud Map namespace and service exist" {+ run aws_cmd servicediscovery list-namespaces+ assert_success+ ns_id=$(json_get "$output" '.Namespaces[] | select(.Name == "floci-cdk.internal") | .Id')+ [[ "$ns_id" == ns-* ]]++ run aws_cmd servicediscovery list-services \+ --filters "Name=NAMESPACE_ID,Values=$ns_id,Condition=EQ"+ assert_success+ svc_name=$(json_get "$output" '.Services[] | select(.Name == "floci-cdk-svc") | .Name')+ [ "$svc_name" = "floci-cdk-svc" ]+}diff --git a/docs/services/cloudformation.md b/docs/services/cloudformation.mdindex 5d90d6408e..6f6097b984 100644--- a/docs/services/cloudformation.md+++ b/docs/services/cloudformation.md@@ -143,6 +143,7 @@ cross-resource references.| Elastic Load Balancing v2 | `LoadBalancer`, `TargetGroup`, `Listener`, `ListenerRule` || Auto Scaling | `LaunchConfiguration`, `AutoScalingGroup`, `LifecycleHook`, `ScalingPolicy` || Route 53 | `HostedZone`, `RecordSet` |+| Cloud Map | `HttpNamespace`, `PrivateDnsNamespace`, `PublicDnsNamespace`, `Service` || API Gateway (v1) | `RestApi`, `Resource`, `Authorizer`, `Method`, `Deployment`, `Stage`, `Account`, `DomainName`, `BasePathMapping`, `GatewayResponse`, `ApiKey`, `UsagePlan`, `UsagePlanKey` || API Gateway v2 | `Api`, `Authorizer`, `Route`, `Integration`, `Stage`, `Deployment` || AppSync | `GraphQLApi`, `GraphQLSchema`, `DataSource`, `FunctionConfiguration`, `Resolver`, `ApiKey` |diff --git a/docs/services/cloudmap.md b/docs/services/cloudmap.mdindex a0996b3dbb..26a5c25237 100644--- a/docs/services/cloudmap.md+++ b/docs/services/cloudmap.md@@ -97,6 +97,28 @@ containers, not to processes on the host.and `ALL` health filters, and matches instances whose attributes contain everykey/value pair supplied in `QueryParameters`.+## CloudFormation++Floci provisions these resource types:++- `AWS::ServiceDiscovery::HttpNamespace`+- `AWS::ServiceDiscovery::PrivateDnsNamespace`+- `AWS::ServiceDiscovery::PublicDnsNamespace`+- `AWS::ServiceDiscovery::Service`++`Ref` returns the namespace or service id. `Fn::GetAtt` exposes `Id` and `Arn` on all of them,+`HostedZoneId` on a DNS namespace, and `Name` on a service.++`Description`, `DnsConfig`, `HealthCheckConfig`, and `Tags` update in place and keep the id. Only+the TTLs in `DnsConfig` can change, as on AWS: an update that changes anything else in it, such as+the record types or `RoutingPolicy`, fails with `InvalidInput`. A change to a createOnly property+(`Name`, and `Vpc` on a private DNS namespace; `Name`, `NamespaceId`, `Type`, or+`HealthCheckCustomConfig` on a service) replaces the resource: the new one is created and the old+one is deleted once the stack update completes. As on AWS, a replacement that keeps the same name+fails, since the name is still taken.++`ServiceAttributes` and `Properties.DnsProperties.SOA` are accepted but ignored.+## Configuration| Variable | Default | Description |diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CloudMapCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CloudMapCfnProvisioner.javanew file mode 100644index 0000000000..4704f09bf3--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CloudMapCfnProvisioner.java@@ -0,0 +1,263 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.core.JsonProcessingException;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.MissingNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.cloudmap.CloudMapService;+import io.github.hectorvent.floci.services.cloudmap.model.Namespace;+import io.github.hectorvent.floci.services.cloudmap.model.Operation;+import io.github.hectorvent.floci.services.cloudmap.model.Service;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.math.BigInteger;+import java.util.Arrays;+import java.util.HashMap;+import java.util.Map;+import java.util.Set;+import java.util.UUID;++/**+ * CloudFormation provisioning for the three Cloud Map namespace types+ * ({@code AWS::ServiceDiscovery::PrivateDnsNamespace}, {@code PublicDnsNamespace} and+ * {@code HttpNamespace}) and {@code AWS::ServiceDiscovery::Service}. {@code Ref} returns the id;+ * {@code Fn::GetAtt} exposes {@code Id} and {@code Arn}, plus {@code HostedZoneId} on a DNS+ * namespace and {@code Name} on a service.+ * Description, DnsConfig, HealthCheckConfig and Tags update in place, keeping the prior values to put+ * back when a later resource fails the update; a createOnly change replaces the resource through+ * {@link ReplacementCleanup}. A {@code Ref} to a Number parameter resolves to text, so the numeric+ * DnsConfig and health check fields are coerced back to JSON numbers.+ */+@ApplicationScoped+public class CloudMapCfnProvisioner implements CfnResourceProvisioner {++ private static final String PRIVATE_DNS_NAMESPACE = "AWS::ServiceDiscovery::PrivateDnsNamespace";+ private static final String PUBLIC_DNS_NAMESPACE = "AWS::ServiceDiscovery::PublicDnsNamespace";+ private static final String HTTP_NAMESPACE = "AWS::ServiceDiscovery::HttpNamespace";+ private static final String SERVICE = "AWS::ServiceDiscovery::Service";+ private static final String CREATE_ONLY_ATTR = "__FlociCreateOnly";+ private static final String CREATE_ONLY_PRIOR_ATTR = "__FlociCreateOnlyPrior";+ private static final String SNAPSHOT_ATTR = "__FlociCloudMapUpdateSnapshot";+ private static final ObjectMapper MAPPER = new ObjectMapper();++ private final CloudMapService cloudMapService;++ @Inject+ public CloudMapCfnProvisioner(CloudMapService cloudMapService) {+ this.cloudMapService = cloudMapService;+ }++ @Override+ public Set<String> resourceTypes() {+ return Set.of(PRIVATE_DNS_NAMESPACE, PUBLIC_DNS_NAMESPACE, HTTP_NAMESPACE, SERVICE);+ }++ @Override+ public void provision(StackResource r, JsonNode props, ProvisionContext ctx) {+ Map<String, String> attributesBefore = new HashMap<>(r.getAttributes());+ switch (r.getResourceType()) {+ case PRIVATE_DNS_NAMESPACE, PUBLIC_DNS_NAMESPACE, HTTP_NAMESPACE -> provisionNamespace(r, props, ctx);+ case SERVICE -> provisionService(r, props, ctx);+ }+ ReplacementCleanup.record(r, ctx, attributesBefore);+ if (ctx.isUpdate() && !ctx.priorPhysicalId().equals(r.getPhysicalId())) {+ r.getAttributes().put(CREATE_ONLY_PRIOR_ATTR, attributesBefore.getOrDefault(CREATE_ONLY_ATTR, ""));+ }+ }++ private void provisionNamespace(StackResource r, JsonNode props, ProvisionContext ctx) {+ String name = ctx.resolveOptional(props, "Name");+ String vpc = ctx.resolveOptional(props, "Vpc");+ String description = ctx.resolveOptional(props, "Description");+ Map<String, String> tags = ctx.resolveTags(props, "Tags");+ String createOnly = Arrays.asList(name, vpc).toString();++ if (ctx.isUpdate() && createOnly.equals(r.getAttributes().get(CREATE_ONLY_ATTR))) {+ Namespace current = cloudMapService.getNamespace(ctx.priorPhysicalId());+ snapshot(r, current.getDescription(), null, null, current.getTags());+ cloudMapService.updateNamespace(ctx.priorPhysicalId(), description);+ reconcileTags(r.getAttributes().get("Arn"), tags);+ return;+ }++ Operation op = switch (r.getResourceType()) {+ case HTTP_NAMESPACE -> cloudMapService.createHttpNamespace(name, null, description, tags, ctx.region());+ case PUBLIC_DNS_NAMESPACE ->+ cloudMapService.createPublicDnsNamespace(name, null, description, tags, ctx.region());+ default -> cloudMapService.createPrivateDnsNamespace(name, vpc, null, description, tags, ctx.region());+ };+ Namespace ns = cloudMapService.getNamespace(op.getTargets().get("NAMESPACE"));+ r.setPhysicalId(ns.getId());+ r.getAttributes().put("Id", ns.getId());+ r.getAttributes().put("Arn", ns.getArn());+ if (ns.getHostedZoneId() != null) {+ r.getAttributes().put("HostedZoneId", ns.getHostedZoneId());+ }+ r.getAttributes().put(CREATE_ONLY_ATTR, createOnly);+ }++ private void provisionService(StackResource r, JsonNode props, ProvisionContext ctx) {+ JsonNode dnsConfig = resolveJson(props, "DnsConfig", ctx);+ for (JsonNode record : dnsConfig.path("DnsRecords")) {+ toNumber(record, "TTL");+ }+ JsonNode healthCheckConfig = resolveJson(props, "HealthCheckConfig", ctx);+ toNumber(healthCheckConfig, "FailureThreshold");+ JsonNode customConfig = resolveJson(props, "HealthCheckCustomConfig", ctx);+ toNumber(customConfig, "FailureThreshold");++ String namespaceId = ctx.resolveOptional(props, "NamespaceId");+ if (namespaceId == null) {+ namespaceId = dnsConfig.path("NamespaceId").textValue();+ }+ String name = ctx.resolveOptional(props, "Name");+ String type = ctx.resolveOptional(props, "Type");+ String description = ctx.resolveOptional(props, "Description");+ Map<String, String> tags = ctx.resolveTags(props, "Tags");+ String createOnly = Arrays.asList(name, namespaceId, type, json(customConfig)).toString();++ if (ctx.isUpdate() && createOnly.equals(r.getAttributes().get(CREATE_ONLY_ATTR))) {+ Service current = cloudMapService.getService(ctx.priorPhysicalId());+ snapshot(r, current.getDescription(), current.getDnsConfig(), current.getHealthCheckConfig(),+ current.getTags());+ cloudMapService.updateService(ctx.priorPhysicalId(), description, json(dnsConfig),+ json(healthCheckConfig));+ reconcileTags(r.getAttributes().get("Arn"), tags);+ return;+ }++ String serviceName = name == null || name.isBlank() ? generatedName(r.getLogicalId()) : name;+ Service service = cloudMapService.createService(serviceName, namespaceId, null, description,+ json(dnsConfig), json(healthCheckConfig), json(customConfig), type, tags, ctx.region());+ r.setPhysicalId(service.getId());+ r.getAttributes().put("Id", service.getId());+ r.getAttributes().put("Arn", service.getArn());+ r.getAttributes().put("Name", service.getName());+ r.getAttributes().put(CREATE_ONLY_ATTR, createOnly);+ }++ /** Keeps what an in-place update overwrites, for {@link #rollbackUpdate} to put back. */+ private static void snapshot(StackResource r, String description, String dnsConfig,+ String healthCheckConfig, Map<String, String> tags) {+ ObjectNode snapshot = MAPPER.createObjectNode();+ snapshot.put("Description", description);+ snapshot.put("DnsConfig", dnsConfig);+ snapshot.put("HealthCheckConfig", healthCheckConfig);+ snapshot.set("Tags", MAPPER.valueToTree(tags));+ r.getAttributes().put(SNAPSHOT_ATTR, snapshot.toString());+ }++ /** Resolves an object property to a fresh node, safe to mutate, or a MissingNode when absent. */+ private static JsonNode resolveJson(JsonNode props, String name, ProvisionContext ctx) {+ return props == null ? MissingNode.getInstance() : ctx.engine().resolveNode(props.path(name));+ }++ private static String json(JsonNode node) {+ return node.isObject() ? node.toString() : null;+ }++ private static void toNumber(JsonNode parent, String field) {+ if (parent instanceof ObjectNode object && object.path(field).isTextual()) {+ String text = object.path(field).textValue();+ if (text.matches("\\d+")) {+ object.put(field, new BigInteger(text));+ }+ }+ }++ /** CloudFormation names an unnamed service {@code <LogicalId>-<12 chars>}, with no stack prefix. */+ private static String generatedName(String logicalId) {+ String prefix = logicalId.length() > 50 ? logicalId.substring(0, 50) : logicalId;+ return prefix + "-" + UUID.randomUUID().toString().replace("-", "").substring(0, 12);+ }++ private void reconcileTags(String arn, Map<String, String> desired) {+ cloudMapService.untagResource(arn,+ ProvisionContext.staleTagKeys(cloudMapService.listTagsForResource(arn), desired));+ cloudMapService.tagResource(arn, desired);+ }++ @Override+ public void delete(String resourceType, String physicalId, String region) {+ if (SERVICE.equals(resourceType)) {+ CfnDeletes.safeDelete("Cloud Map service", physicalId,+ () -> cloudMapService.deleteService(physicalId), "ServiceNotFound");+ return;+ }+ CfnDeletes.safeDelete("Cloud Map namespace", physicalId,+ () -> cloudMapService.deleteNamespace(physicalId, region), "NamespaceNotFound");+ }++ @Override+ public boolean hasReplacementUpdate(StackResource resource) {+ return ReplacementCleanup.hasReplacement(resource);+ }++ @Override+ public String updateCleanupPhysicalId(StackResource resource) {+ return ReplacementCleanup.cleanupPhysicalId(resource);+ }++ @Override+ public UpdateCleanupResult completeUpdate(StackResource resource) {+ resource.getAttributes().remove(CREATE_ONLY_PRIOR_ATTR);+ resource.getAttributes().remove(SNAPSHOT_ATTR);+ return ReplacementCleanup.complete(resource, this::delete);+ }++ @Override+ public void clearUpdate(StackResource resource) {+ resource.getAttributes().remove(CREATE_ONLY_PRIOR_ATTR);+ ReplacementCleanup.clear(resource);+ }++ /**+ * A replacement is undone through the cleanup record, an in-place update from the snapshot taken+ * before it. With neither, the provision failed before changing anything (every in-place+ * mutation is preceded by the snapshot, every replacement followed by the record), so there is+ * nothing to undo. {@link ReplacementCleanup} leaves {@code __Floci} attributes alone, so the+ * createOnly record of the prior entity is put back here. A restore that throws leaves the+ * snapshot for the next attempt.+ */+ @Override+ public boolean rollbackUpdate(StackResource resource) {+ boolean replaced = ReplacementCleanup.rollback(resource, this::delete);+ String prior = resource.getAttributes().remove(CREATE_ONLY_PRIOR_ATTR);+ if (prior != null) {+ if (prior.isEmpty()) {+ resource.getAttributes().remove(CREATE_ONLY_ATTR);+ } else {+ resource.getAttributes().put(CREATE_ONLY_ATTR, prior);+ }+ }+ String snapshot = resource.getAttributes().get(SNAPSHOT_ATTR);+ if (!replaced && snapshot != null) {+ restore(resource, snapshot);+ }+ resource.getAttributes().remove(SNAPSHOT_ATTR);+ return true;+ }++ private void restore(StackResource resource, String raw) {+ JsonNode snapshot;+ try {+ snapshot = MAPPER.readTree(raw);+ } catch (JsonProcessingException e) {+ throw new IllegalStateException("Could not read the Cloud Map update snapshot for "+ + resource.getLogicalId(), e);+ }+ String description = snapshot.path("Description").textValue();+ if (SERVICE.equals(resource.getResourceType())) {+ cloudMapService.updateService(resource.getPhysicalId(), description,+ snapshot.path("DnsConfig").textValue(), snapshot.path("HealthCheckConfig").textValue());+ } else {+ cloudMapService.updateNamespace(resource.getPhysicalId(), description);+ }+ Map<String, String> tags = new HashMap<>();+ snapshot.path("Tags").fields().forEachRemaining(tag -> tags.put(tag.getKey(), tag.getValue().asText()));+ reconcileTags(resource.getAttributes().get("Arn"), tags);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudmap/CloudMapService.java b/src/main/java/io/github/hectorvent/floci/services/cloudmap/CloudMapService.javaindex 5335b9b9a5..bed7eaa3b8 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudmap/CloudMapService.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudmap/CloudMapService.java@@ -4,7 +4,9 @@ import com.fasterxml.jackson.core.JacksonException;import com.fasterxml.jackson.core.type.TypeReference;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.MissingNode;+import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RegionResolver;@@ -164,6 +166,12 @@ public class CloudMapService {return result;}+ public void updateNamespace(String id, String description) {+ Namespace ns = requireNamespace(id);+ ns.setDescription(description);+ namespaceStore.put(id, ns);+ }+public Operation deleteNamespace(String id, String region) {Namespace ns = requireNamespace(id);boolean hasServices = scan(serviceStore).stream()@@ -248,6 +256,26 @@ public class CloudMapService {return result;}+ /**+ * Only the TTLs of the existing DNS records can change, as on AWS: any other DnsConfig change+ * (record types or count, RoutingPolicy), or a DnsConfig for a service without one, is rejected.+ * A null {@code dnsConfig} keeps the stored one, since AWS cannot remove it; a null description+ * or health check config clears it, as AWS UpdateService does.+ */+ public void updateService(String id, String description, String dnsConfig, String healthCheckConfig) {+ Service service = requireService(id);+ if (dnsConfig != null) {+ if (!withoutTtls(parseDnsConfig(dnsConfig)).equals(withoutTtls(dnsConfigNode(service)))) {+ throw new AwsException("InvalidInput",+ "Only the TTLs of a service's DNS records can be updated.", 400);+ }+ service.setDnsConfig(dnsConfig);+ }+ service.setDescription(description);+ service.setHealthCheckConfig(healthCheckConfig);+ serviceStore.put(id, service);+ }+public void deleteService(String id) {Service service = requireService(id);boolean hasInstances = !scanInstances(service.getId()).isEmpty();@@ -577,6 +605,21 @@ public class CloudMapService {return config;}+ /** The DnsConfig as an update must keep it: record types in any order, TTLs free to change. */+ private static JsonNode withoutTtls(JsonNode dnsConfig) {+ JsonNode copy = dnsConfig.deepCopy();+ if (copy instanceof ObjectNode object) {+ List<String> types = new ArrayList<>();+ for (JsonNode record : object.path("DnsRecords")) {+ types.add(record.path("Type").asText());+ }+ types.sort(Comparator.naturalOrder());+ ArrayNode records = object.putArray("DnsRecords");+ types.forEach(records::add);+ }+ return copy;+ }+/** Returns -1 when the service has no record of the requested type. */private int dnsRecordTtl(Service service, String type) {JsonNode records = dnsConfigNode(service).path("DnsRecords");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 c20f2461e0..2b85ac196b 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@@ -14,6 +14,7 @@ import io.github.hectorvent.floci.services.batch.BatchService;import io.github.hectorvent.floci.services.cloudformation.provisioners.CfnDynamicReferences;import io.github.hectorvent.floci.services.cloudformation.provisioners.CfnResourceDispatcher;import io.github.hectorvent.floci.services.cloudformation.provisioners.CloudFrontCfnProvisioner;+import io.github.hectorvent.floci.services.cloudformation.provisioners.CloudMapCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.ConfigCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.DynamoDbCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2FlowLogCfnProvisioner;@@ -96,6 +97,7 @@ import io.github.hectorvent.floci.services.cloudformation.provisioners.SsmCfnProimport io.github.hectorvent.floci.services.cloudformation.provisioners.CfnResourceProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.CloudFormationResourceRegistry;import io.github.hectorvent.floci.services.cloudfront.CloudFrontService;+import io.github.hectorvent.floci.services.cloudmap.CloudMapService;import io.github.hectorvent.floci.services.cloudtrail.CloudTrailService;import io.github.hectorvent.floci.services.cloudwatch.dashboards.CloudWatchDashboardsService;import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsMetricFilterService;@@ -211,6 +213,7 @@ final class CfnProvisionerFixture {private WafV2Service wafV2Service;private BackupService backupService;private RedshiftService redshiftService;+ private CloudMapService cloudMapService;private CloudFormationResourceRegistry resourceRegistry;private boolean registryChosenByTest;private CfnDynamicReferences dynamicReferences;@@ -420,6 +423,9 @@ final class CfnProvisionerFixture {if (redshiftService != null) {discovered.add(new RedshiftClusterCfnProvisioner(redshiftService));}+ if (cloudMapService != null) {+ discovered.add(new CloudMapCfnProvisioner(cloudMapService));+ }return discovered;}@@ -672,6 +678,11 @@ final class CfnProvisionerFixture {return redshiftService(s);}+ public Builder cloudMap(CloudMapService v) {+ this.cloudMapService = v;+ return this;+ }+public Builder registry(CloudFormationResourceRegistry v) {this.resourceRegistry = v;this.registryChosenByTest = true;diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudMapCfnIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudMapCfnIntegrationTest.javanew file mode 100644index 0000000000..f5058910ca--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudMapCfnIntegrationTest.java@@ -0,0 +1,270 @@+package io.github.hectorvent.floci.services.cloudformation;++import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.XmlParser;+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.Response;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import java.util.List;+import java.util.Map;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.hamcrest.MatcherAssert.assertThat;+import static org.hamcrest.Matchers.containsInAnyOrder;+import static org.hamcrest.Matchers.endsWith;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.matchesPattern;+import static org.hamcrest.Matchers.startsWith;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotEquals;++/**+ * Provisions an {@code AWS::ServiceDiscovery::PrivateDnsNamespace} with a named and an unnamed+ * {@code AWS::ServiceDiscovery::Service} through a stack, checks Ref and Fn::GetAtt against Cloud+ * Map, that a Number parameter TTL is stored as a number, that Description and TTL update in place,+ * that a later resource failing the update puts those in-place changes back, that renaming the+ * service replaces it, and that deleting the stack removes everything.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class CloudMapCfnIntegrationTest {++ private static final String CFN_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260905/us-east-1/cloudformation/aws4_request";+ private static final String CLOUD_MAP_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260905/us-east-1/servicediscovery/aws4_request";+ private static final String CLOUD_MAP_TARGET = "Route53AutoNaming_v20170314.";+ private static final ObjectMapper MAPPER = new ObjectMapper();+ private static final String STACK = "cloudmap-cfn-it";+ private static final String NAMESPACE_NAME =+ "cfn-" + UUID.randomUUID().toString().replace("-", "").substring(0, 8) + ".internal";++ private static final String TEMPLATE = """+ {+ "Parameters": {+ "NsDescription": {"Type": "String", "Default": "d1"},+ "Ttl": {"Type": "Number", "Default": 60},+ "Fail": {"Type": "String", "Default": "false"}+ },+ "Conditions": {+ "Failing": {"Fn::Equals": [{"Ref": "Fail"}, "true"]}+ },+ "Resources": {+ "Ns": {+ "Type": "AWS::ServiceDiscovery::PrivateDnsNamespace",+ "Properties": {+ "Name": "%s",+ "Vpc": "vpc-0123456789abcdef0",+ "Description": {"Ref": "NsDescription"},+ "Tags": [{"Key": "k1", "Value": "v1"}]+ }+ },+ "Svc": {+ "Type": "AWS::ServiceDiscovery::Service",+ "Properties": {+ "Name": "%s",+ "NamespaceId": {"Fn::GetAtt": ["Ns", "Id"]},+ "Description": "main service",+ "DnsConfig": {+ "NamespaceId": {"Fn::GetAtt": ["Ns", "Id"]},+ "RoutingPolicy": "MULTIVALUE",+ "DnsRecords": [{"Type": "A", "TTL": {"Ref": "Ttl"}}]+ },+ "HealthCheckCustomConfig": {"FailureThreshold": 1}+ }+ },+ "SvcNoName": {+ "Type": "AWS::ServiceDiscovery::Service",+ "Properties": {+ "DnsConfig": {+ "NamespaceId": {"Fn::GetAtt": ["Ns", "Id"]},+ "DnsRecords": [{"Type": "A", "TTL": 30}]+ }+ }+ },+ "BadSecret": {+ "Type": "AWS::SecretsManager::Secret",+ "Condition": "Failing",+ "DependsOn": "Svc",+ "Properties": {"SecretString": "explicit", "GenerateSecretString": {"PasswordLength": 32}}+ }+ },+ "Outputs": {+ "NsRef": {"Value": {"Ref": "Ns"}},+ "NsId": {"Value": {"Fn::GetAtt": ["Ns", "Id"]}},+ "NsArn": {"Value": {"Fn::GetAtt": ["Ns", "Arn"]}},+ "NsHz": {"Value": {"Fn::GetAtt": ["Ns", "HostedZoneId"]}},+ "SvcRef": {"Value": {"Ref": "Svc"}},+ "SvcId": {"Value": {"Fn::GetAtt": ["Svc", "Id"]}},+ "SvcArn": {"Value": {"Fn::GetAtt": ["Svc", "Arn"]}},+ "SvcName": {"Value": {"Fn::GetAtt": ["Svc", "Name"]}},+ "NoNameRef": {"Value": {"Ref": "SvcNoName"}},+ "NoNameName": {"Value": {"Fn::GetAtt": ["SvcNoName", "Name"]}}+ }+ }+ """;++ private static String namespaceId;+ private static String serviceId;+ private static String replacedServiceId;+ private static String noNameServiceId;++ @BeforeAll+ static void configure() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ @Order(1)+ void createPublishesIdsAndStoresTheTtlAsANumber() throws Exception {+ cloudFormation("CreateStack", "main", Map.of());+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(STACK).status());+ String outputs = describeStacks();++ namespaceId = outputValue(outputs, "NsRef");+ serviceId = outputValue(outputs, "SvcRef");+ noNameServiceId = outputValue(outputs, "NoNameRef");+ assertThat(namespaceId, startsWith("ns-"));+ assertThat(serviceId, startsWith("srv-"));+ assertEquals(namespaceId, outputValue(outputs, "NsId"));+ assertEquals(serviceId, outputValue(outputs, "SvcId"));+ assertThat(outputValue(outputs, "NsArn"), endsWith(":namespace/" + namespaceId));+ assertThat(outputValue(outputs, "SvcArn"), endsWith(":service/" + serviceId));+ String hostedZoneId = MAPPER.readTree(cloudMap("GetNamespace", "{\"Id\":\"" + namespaceId + "\"}")+ .then().statusCode(200)+ .extract().asString())+ .path("Namespace").path("Properties").path("DnsProperties").path("HostedZoneId").asText(null);+ assertThat(hostedZoneId, matchesPattern("Z[A-Z0-9]{13}"));+ assertEquals(hostedZoneId, outputValue(outputs, "NsHz"));+ assertEquals("main", outputValue(outputs, "SvcName"));+ assertThat(outputValue(outputs, "NoNameName"), matchesPattern("SvcNoName-[0-9a-f]{12}"));++ List<String> names = listServices(namespaceId).jsonPath().getList("Services.Name");+ assertThat(names, containsInAnyOrder("main", outputValue(outputs, "NoNameName")));+ cloudMap("GetService", "{\"Id\":\"" + serviceId + "\"}")+ .then().statusCode(200)+ .body("Service.DnsConfig.DnsRecords[0].TTL", equalTo(60))+ .body("Service.HealthCheckCustomConfig.FailureThreshold", equalTo(1));+ }++ @Test+ @Order(2)+ void updatingDescriptionAndTtlKeepsTheIds() {+ cloudFormation("UpdateStack", "main", Map.of("NsDescription", "d2", "Ttl", "120"));+ assertEquals("UPDATE_COMPLETE", CfnStackWaits.awaitTerminal(STACK).status());+ String outputs = describeStacks();++ assertEquals(namespaceId, outputValue(outputs, "NsId"));+ assertEquals(serviceId, outputValue(outputs, "SvcId"));+ cloudMap("GetNamespace", "{\"Id\":\"" + namespaceId + "\"}")+ .then().statusCode(200)+ .body("Namespace.Description", equalTo("d2"));+ cloudMap("GetService", "{\"Id\":\"" + serviceId + "\"}")+ .then().statusCode(200)+ .body("Service.DnsConfig.DnsRecords[0].TTL", equalTo(120));+ }++ @Test+ @Order(3)+ void aFailedUpdateRestoresTheInPlaceChanges() {+ cloudFormation("UpdateStack", "main", Map.of("NsDescription", "d3", "Ttl", "90", "Fail", "true"));+ assertEquals("UPDATE_ROLLBACK_COMPLETE", CfnStackWaits.awaitTerminal(STACK).status());+ String outputs = describeStacks();++ assertEquals(namespaceId, outputValue(outputs, "NsId"));+ assertEquals(serviceId, outputValue(outputs, "SvcId"));+ cloudMap("GetNamespace", "{\"Id\":\"" + namespaceId + "\"}")+ .then().statusCode(200)+ .body("Namespace.Description", equalTo("d2"));+ cloudMap("GetService", "{\"Id\":\"" + serviceId + "\"}")+ .then().statusCode(200)+ .body("Service.DnsConfig.DnsRecords[0].TTL", equalTo(120));+ }++ @Test+ @Order(4)+ void renamingTheServiceReplacesIt() {+ cloudFormation("UpdateStack", "main2", Map.of("NsDescription", "d2", "Ttl", "120"));+ assertEquals("UPDATE_COMPLETE", CfnStackWaits.awaitTerminal(STACK).status());+ String outputs = describeStacks();++ replacedServiceId = outputValue(outputs, "SvcId");+ assertNotEquals(serviceId, replacedServiceId);+ assertEquals("main2", outputValue(outputs, "SvcName"));+ cloudMap("GetService", "{\"Id\":\"" + serviceId + "\"}")+ .then().statusCode(404)+ .body("__type", equalTo("ServiceNotFound"));+ List<String> names = listServices(namespaceId).jsonPath().getList("Services.Name");+ assertThat(names, containsInAnyOrder("main2", outputValue(outputs, "NoNameName")));+ }++ @Test+ @Order(5)+ void deletingTheStackRemovesTheNamespaceAndServices() {+ cloudFormation("DeleteStack", "main2", Map.of());+ CfnStackWaits.awaitStackDeleted(STACK);++ cloudMap("GetNamespace", "{\"Id\":\"" + namespaceId + "\"}")+ .then().statusCode(404)+ .body("__type", equalTo("NamespaceNotFound"));+ for (String id : List.of(serviceId, replacedServiceId, noNameServiceId)) {+ cloudMap("GetService", "{\"Id\":\"" + id + "\"}")+ .then().statusCode(404)+ .body("__type", equalTo("ServiceNotFound"));+ }+ }++ private static void cloudFormation(String action, String serviceName, Map<String, String> parameters) {+ RequestSpecification request = given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", action)+ .formParam("StackName", STACK);+ if (!"DeleteStack".equals(action)) {+ request.formParam("TemplateBody", TEMPLATE.formatted(NAMESPACE_NAME, serviceName));+ }+ int index = 1;+ for (Map.Entry<String, String> parameter : parameters.entrySet()) {+ request.formParam("Parameters.member." + index + ".ParameterKey", parameter.getKey());+ request.formParam("Parameters.member." + index + ".ParameterValue", parameter.getValue());+ index++;+ }+ request.when().post("/").then().statusCode(200);+ }++ private static String describeStacks() {+ return given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "DescribeStacks")+ .formParam("StackName", STACK)+ .when().post("/").then().statusCode(200)+ .extract().asString();+ }++ private static String outputValue(String xml, String key) {+ return XmlParser.extractPairs(xml, "Outputs", "OutputKey", "OutputValue").get(key);+ }++ private static Response listServices(String nsId) {+ return cloudMap("ListServices", "{\"Filters\":[{\"Name\":\"NAMESPACE_ID\",\"Values\":[\""+ + nsId + "\"],\"Condition\":\"EQ\"}]}");+ }++ private static Response cloudMap(String action, String body) {+ return given()+ .contentType("application/x-amz-json-1.1")+ .header("Authorization", CLOUD_MAP_AUTH)+ .header("X-Amz-Target", CLOUD_MAP_TARGET + action)+ .body(body)+ .when().post("/");+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CloudMapCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CloudMapCfnProvisionerTest.javanew file mode 100644index 0000000000..d294df2ce7--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CloudMapCfnProvisionerTest.java@@ -0,0 +1,397 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudformation.CloudFormationTemplateEngine;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.cloudmap.CloudMapService;+import io.github.hectorvent.floci.services.cloudmap.model.Namespace;+import io.github.hectorvent.floci.services.cloudmap.model.Operation;+import io.github.hectorvent.floci.services.cloudmap.model.Service;+import org.junit.jupiter.api.Test;+import org.mockito.ArgumentCaptor;++import java.util.HashMap;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++import static org.hamcrest.MatcherAssert.assertThat;+import static org.hamcrest.Matchers.matchesPattern;+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.times;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/**+ * The Cloud Map namespace types and {@code AWS::ServiceDiscovery::Service} in isolation: the ids+ * back Ref and Fn::GetAtt, a textual TTL reaches the service as a number, an unchanged createOnly+ * set updates in place, a changed one replaces, a rolled back replacement puts the createOnly record+ * back, a rolled back in-place update puts the prior description, DnsConfig, health check and tags+ * back from its snapshot, a committed update drops that snapshot, and delete tolerates only the+ * not-found codes.+ */+class CloudMapCfnProvisionerTest {++ private static final String PRIVATE_DNS_NAMESPACE = "AWS::ServiceDiscovery::PrivateDnsNamespace";+ private static final String PUBLIC_DNS_NAMESPACE = "AWS::ServiceDiscovery::PublicDnsNamespace";+ private static final String HTTP_NAMESPACE = "AWS::ServiceDiscovery::HttpNamespace";+ private static final String SERVICE = "AWS::ServiceDiscovery::Service";+ private static final String SNAPSHOT_ATTR = "__FlociCloudMapUpdateSnapshot";+ private static final String NS_ARN = "arn:aws:servicediscovery:us-east-1:000000000000:namespace/ns-1";+ private static final String SRV_ARN = "arn:aws:servicediscovery:us-east-1:000000000000:service/srv-1";+ private static final String SRV2_ARN = "arn:aws:servicediscovery:us-east-1:000000000000:service/srv-2";++ private final CloudMapService cloudMap = mock(CloudMapService.class);+ private final CloudMapCfnProvisioner provisioner = new CloudMapCfnProvisioner(cloudMap);+ private final ObjectMapper mapper = new ObjectMapper();++ @Test+ void namespaceCreatePublishesIdArnAndHostedZoneId() throws Exception {+ stubNamespaceCreate();+ StackResource r = resource(PRIVATE_DNS_NAMESPACE, "Ns");++ provisioner.provision(r, props("""+ {"Name": "svc.internal", "Vpc": "vpc-1", "Description": "d1",+ "Tags": [{"Key": "k1", "Value": "v1"}]}"""), ctx(null));++ verify(cloudMap).createPrivateDnsNamespace("svc.internal", "vpc-1", null, "d1",+ Map.of("k1", "v1"), "us-east-1");+ assertEquals("ns-1", r.getPhysicalId());+ assertEquals("ns-1", r.getAttributes().get("Id"));+ assertEquals(NS_ARN, r.getAttributes().get("Arn"));+ assertEquals("Z0123456789ABC", r.getAttributes().get("HostedZoneId"));+ }++ @Test+ void httpNamespaceCreatePublishesIdAndArn() throws Exception {+ Operation op = stubNamespace(null);+ when(cloudMap.createHttpNamespace(any(), any(), any(), any(), any())).thenReturn(op);+ StackResource r = resource(HTTP_NAMESPACE, "Http");++ provisioner.provision(r, props("""+ {"Name": "svc-http", "Description": "d1"}"""), ctx(null));++ verify(cloudMap).createHttpNamespace("svc-http", null, "d1", Map.of(), "us-east-1");+ assertEquals("ns-1", r.getPhysicalId());+ assertEquals("ns-1", r.getAttributes().get("Id"));+ assertEquals(NS_ARN, r.getAttributes().get("Arn"));+ assertFalse(r.getAttributes().containsKey("HostedZoneId"));+ }++ @Test+ void publicDnsNamespaceCreatePublishesIdArnAndHostedZoneId() throws Exception {+ Operation op = stubNamespace("Z0123456789ABC");+ when(cloudMap.createPublicDnsNamespace(any(), any(), any(), any(), any())).thenReturn(op);+ StackResource r = resource(PUBLIC_DNS_NAMESPACE, "Pub");++ provisioner.provision(r, props("""+ {"Name": "example.com"}"""), ctx(null));++ verify(cloudMap).createPublicDnsNamespace("example.com", null, null, Map.of(), "us-east-1");+ assertEquals("ns-1", r.getPhysicalId());+ assertEquals("ns-1", r.getAttributes().get("Id"));+ assertEquals(NS_ARN, r.getAttributes().get("Arn"));+ assertEquals("Z0123456789ABC", r.getAttributes().get("HostedZoneId"));+ }++ @Test+ void serviceCreatePassesATextualTtlAsANumber() throws Exception {+ stubServiceCreate("srv-1", SRV_ARN);+ StackResource r = resource(SERVICE, "Svc");++ provisioner.provision(r, props("""+ {"Name": "main", "NamespaceId": "ns-1", "Description": "svc",+ "DnsConfig": {"NamespaceId": "ns-1", "RoutingPolicy": "MULTIVALUE",+ "DnsRecords": [{"Type": "A", "TTL": "60"}]},+ "HealthCheckCustomConfig": {"FailureThreshold": "1"}}"""), ctx(null));++ ArgumentCaptor<String> dnsConfig = ArgumentCaptor.forClass(String.class);+ ArgumentCaptor<String> customConfig = ArgumentCaptor.forClass(String.class);+ verify(cloudMap).createService(any(), any(), any(), any(), dnsConfig.capture(), any(),+ customConfig.capture(), any(), any(), any());+ assertEquals("{\"NamespaceId\":\"ns-1\",\"RoutingPolicy\":\"MULTIVALUE\","+ + "\"DnsRecords\":[{\"Type\":\"A\",\"TTL\":60}]}", dnsConfig.getValue());+ assertEquals("{\"FailureThreshold\":1}", customConfig.getValue());+ assertEquals("srv-1", r.getPhysicalId());+ assertEquals("srv-1", r.getAttributes().get("Id"));+ assertEquals(SRV_ARN, r.getAttributes().get("Arn"));+ assertEquals("main", r.getAttributes().get("Name"));+ }++ @Test+ void serviceWithoutNameGetsALogicalIdBasedName() throws Exception {+ stubServiceCreate("srv-1", SRV_ARN);+ StackResource r = resource(SERVICE, "SvcNoName");++ provisioner.provision(r, props("""+ {"DnsConfig": {"NamespaceId": "ns-1", "DnsRecords": [{"Type": "A", "TTL": 30}]}}"""), ctx(null));++ ArgumentCaptor<String> name = ArgumentCaptor.forClass(String.class);+ ArgumentCaptor<String> namespaceId = ArgumentCaptor.forClass(String.class);+ verify(cloudMap).createService(name.capture(), namespaceId.capture(), any(), any(), any(), any(),+ any(), any(), any(), any());+ assertThat(name.getValue(), matchesPattern("SvcNoName-[0-9a-f]{12}"));+ assertEquals("ns-1", namespaceId.getValue());+ assertEquals(name.getValue(), r.getAttributes().get("Name"));+ }++ @Test+ void namespaceUpdateWithUnchangedNameAndVpcUpdatesInPlace() throws Exception {+ stubNamespaceCreate();+ StackResource r = resource(PRIVATE_DNS_NAMESPACE, "Ns");+ provisioner.provision(r, props("""+ {"Name": "svc.internal", "Vpc": "vpc-1", "Description": "d1",+ "Tags": [{"Key": "k1", "Value": "v1"}]}"""), ctx(null));+ Map<String, String> stored = new LinkedHashMap<>();+ stored.put("k1", "v1");+ stored.put("stale", "x");+ when(cloudMap.listTagsForResource(NS_ARN)).thenReturn(stored);++ provisioner.provision(r, props("""+ {"Name": "svc.internal", "Vpc": "vpc-1", "Description": "d2",+ "Tags": [{"Key": "k1", "Value": "v2"}]}"""), ctx("ns-1"));++ verify(cloudMap, times(1)).createPrivateDnsNamespace(any(), any(), any(), any(), any(), any());+ verify(cloudMap).updateNamespace("ns-1", "d2");+ verify(cloudMap).untagResource(NS_ARN, List.of("stale"));+ verify(cloudMap).tagResource(NS_ARN, Map.of("k1", "v2"));+ assertEquals("ns-1", r.getPhysicalId());+ assertEquals("ns-1", r.getAttributes().get("Id"));+ assertFalse(provisioner.hasReplacementUpdate(r));+ }++ @Test+ void serviceUpdateWithUnchangedCreateOnlyPropertiesUpdatesInPlace() throws Exception {+ stubServiceCreate("srv-1", SRV_ARN);+ StackResource r = resource(SERVICE, "Svc");+ provisioner.provision(r, props("""+ {"Name": "main", "NamespaceId": "ns-1", "Description": "d1",+ "DnsConfig": {"DnsRecords": [{"Type": "A", "TTL": 60}]}}"""), ctx(null));++ provisioner.provision(r, props("""+ {"Name": "main", "NamespaceId": "ns-1", "Description": "d2",+ "DnsConfig": {"DnsRecords": [{"Type": "A", "TTL": "120"}]},+ "HealthCheckConfig": {"Type": "HTTP", "FailureThreshold": "1"}}"""),+ ctx("srv-1"));++ verify(cloudMap, times(1)).createService(any(), any(), any(), any(), any(), any(), any(), any(),+ any(), any());+ verify(cloudMap).updateService("srv-1", "d2", "{\"DnsRecords\":[{\"Type\":\"A\",\"TTL\":120}]}",+ "{\"Type\":\"HTTP\",\"FailureThreshold\":1}");+ verify(cloudMap).tagResource(SRV_ARN, Map.of());+ assertEquals("srv-1", r.getPhysicalId());+ assertFalse(provisioner.hasReplacementUpdate(r));+ }++ @Test+ void serviceUpdateWithAChangedNameReplacesTheService() throws Exception {+ stubServiceCreate("srv-1", SRV_ARN);+ StackResource r = resource(SERVICE, "Svc");+ provisioner.provision(r, props("""+ {"Name": "main", "NamespaceId": "ns-1"}"""), ctx(null));+ stubServiceCreate("srv-2", SRV2_ARN);++ provisioner.provision(r, props("""+ {"Name": "main2", "NamespaceId": "ns-1"}"""), ctx("srv-1"));++ verify(cloudMap, times(2)).createService(any(), any(), any(), any(), any(), any(), any(), any(),+ any(), any());+ verify(cloudMap, never()).updateService(anyString(), any(), any(), any());+ assertEquals("srv-2", r.getPhysicalId());+ assertEquals("main2", r.getAttributes().get("Name"));+ assertTrue(provisioner.hasReplacementUpdate(r));+ assertEquals("srv-1", provisioner.updateCleanupPhysicalId(r));+ }++ @Test+ void rolledBackReplacementRestoresTheCreateOnlyRecordSoARetryReplacesAgain() throws Exception {+ stubServiceCreate("srv-1", SRV_ARN);+ StackResource r = resource(SERVICE, "Svc");+ provisioner.provision(r, props("""+ {"Name": "main", "NamespaceId": "ns-1"}"""), ctx(null));+ String createdRecord = r.getAttributes().get("__FlociCreateOnly");+ stubServiceCreate("srv-2", SRV2_ARN);+ provisioner.provision(r, props("""+ {"Name": "main2", "NamespaceId": "ns-1"}"""), ctx("srv-1"));++ assertTrue(provisioner.rollbackUpdate(r));++ verify(cloudMap).deleteService("srv-2");+ assertEquals("srv-1", r.getPhysicalId());+ assertEquals(createdRecord, r.getAttributes().get("__FlociCreateOnly"));+ assertFalse(r.getAttributes().containsKey("__FlociCreateOnlyPrior"));++ provisioner.provision(r, props("""+ {"Name": "main2", "NamespaceId": "ns-1"}"""), ctx("srv-1"));++ verify(cloudMap, times(2)).createService(eq("main2"), any(), any(), any(), any(), any(), any(), any(),+ any(), any());+ verify(cloudMap, never()).updateService(anyString(), any(), any(), any());+ assertEquals("srv-2", r.getPhysicalId());+ }++ @Test+ void serviceInPlaceUpdateRollsBackToTheSnapshot() throws Exception {+ Service stored = stubServiceCreate("srv-1", SRV_ARN);+ StackResource r = resource(SERVICE, "Svc");+ provisioner.provision(r, props("""+ {"Name": "main", "NamespaceId": "ns-1"}"""), ctx(null));+ stored.setDescription("d1");+ stored.setDnsConfig("{\"DnsRecords\":[{\"Type\":\"A\",\"TTL\":60}]}");+ stored.setHealthCheckConfig("{\"Type\":\"HTTP\",\"ResourcePath\":\"/\",\"FailureThreshold\":1}");+ stored.setTags(new HashMap<>(Map.of("k1", "v1")));+ when(cloudMap.listTagsForResource(SRV_ARN)).thenReturn(Map.of("k1", "v2"));++ provisioner.provision(r, props("""+ {"Name": "main", "NamespaceId": "ns-1", "Description": "d2",+ "DnsConfig": {"DnsRecords": [{"Type": "A", "TTL": "120"}]},+ "HealthCheckConfig": {"Type": "HTTP", "ResourcePath": "/health", "FailureThreshold": 2},+ "Tags": [{"Key": "k1", "Value": "v2"}]}"""), ctx("srv-1"));++ assertTrue(provisioner.rollbackUpdate(r));++ verify(cloudMap).updateService("srv-1", "d1", "{\"DnsRecords\":[{\"Type\":\"A\",\"TTL\":60}]}",+ "{\"Type\":\"HTTP\",\"ResourcePath\":\"/\",\"FailureThreshold\":1}");+ verify(cloudMap).tagResource(SRV_ARN, Map.of("k1", "v1"));+ assertFalse(r.getAttributes().containsKey(SNAPSHOT_ATTR));+ assertEquals("srv-1", r.getPhysicalId());+ }++ @Test+ void namespaceInPlaceUpdateRollsBackToTheSnapshot() throws Exception {+ stubNamespaceCreate();+ Namespace stored = new Namespace();+ stored.setId("ns-1");+ stored.setArn(NS_ARN);+ stored.setDescription("d1");+ stored.setTags(new HashMap<>(Map.of("k1", "v1")));+ when(cloudMap.getNamespace("ns-1")).thenReturn(stored);+ StackResource r = resource(PRIVATE_DNS_NAMESPACE, "Ns");+ provisioner.provision(r, props("""+ {"Name": "svc.internal", "Vpc": "vpc-1", "Description": "d1",+ "Tags": [{"Key": "k1", "Value": "v1"}]}"""), ctx(null));++ provisioner.provision(r, props("""+ {"Name": "svc.internal", "Vpc": "vpc-1", "Description": "d2",+ "Tags": [{"Key": "k1", "Value": "v2"}]}"""), ctx("ns-1"));++ assertTrue(provisioner.rollbackUpdate(r));++ verify(cloudMap).updateNamespace("ns-1", "d2");+ verify(cloudMap).updateNamespace("ns-1", "d1");+ verify(cloudMap).tagResource(NS_ARN, Map.of("k1", "v1"));+ assertFalse(r.getAttributes().containsKey(SNAPSHOT_ATTR));+ assertEquals("ns-1", r.getPhysicalId());+ }++ @Test+ void committedUpdateDropsTheSnapshot() throws Exception {+ stubServiceCreate("srv-1", SRV_ARN);+ StackResource r = resource(SERVICE, "Svc");+ provisioner.provision(r, props("""+ {"Name": "main", "NamespaceId": "ns-1"}"""), ctx(null));+ provisioner.provision(r, props("""+ {"Name": "main", "NamespaceId": "ns-1", "Description": "d2"}"""), ctx("srv-1"));+ assertTrue(r.getAttributes().containsKey(SNAPSHOT_ATTR));++ provisioner.completeUpdate(r);++ assertFalse(r.getAttributes().containsKey(SNAPSHOT_ATTR));+ }++ @Test+ void deleteNamespaceToleratesNamespaceNotFound() {+ doThrow(new AwsException("NamespaceNotFound", "gone", 404))+ .when(cloudMap).deleteNamespace("ns-1", "us-east-1");++ assertDoesNotThrow(() -> provisioner.delete(PRIVATE_DNS_NAMESPACE, "ns-1", "us-east-1"));+ verify(cloudMap).deleteNamespace("ns-1", "us-east-1");+ }++ @Test+ void deleteServiceToleratesServiceNotFound() {+ doThrow(new AwsException("ServiceNotFound", "gone", 404)).when(cloudMap).deleteService("srv-1");++ assertDoesNotThrow(() -> provisioner.delete(SERVICE, "srv-1", "us-east-1"));+ verify(cloudMap).deleteService("srv-1");+ }++ @Test+ void deleteServiceWithInstancesPropagatesResourceInUse() {+ doThrow(new AwsException("ResourceInUse", "has instances", 400)).when(cloudMap).deleteService("srv-1");++ AwsException failure = assertThrows(AwsException.class,+ () -> provisioner.delete(SERVICE, "srv-1", "us-east-1"));+ assertEquals("ResourceInUse", failure.getErrorCode());+ }++ private void stubNamespaceCreate() {+ Operation op = stubNamespace("Z0123456789ABC");+ when(cloudMap.createPrivateDnsNamespace(any(), any(), any(), any(), any(), any())).thenReturn(op);+ }++ /** Stubs the lookup of namespace ns-1 and returns the create operation that targets it. */+ private Operation stubNamespace(String hostedZoneId) {+ Operation op = new Operation();+ op.getTargets().put("NAMESPACE", "ns-1");+ Namespace ns = new Namespace();+ ns.setId("ns-1");+ ns.setArn(NS_ARN);+ ns.setHostedZoneId(hostedZoneId);+ when(cloudMap.getNamespace("ns-1")).thenReturn(ns);+ return op;+ }++ /** Stubs the create and the lookup of one service, returning the instance both hand out. */+ private Service stubServiceCreate(String id, String arn) {+ Service service = new Service();+ service.setId(id);+ service.setArn(arn);+ when(cloudMap.createService(any(), any(), any(), any(), any(), any(), any(), any(), any(), any()))+ .thenAnswer(inv -> {+ service.setName(inv.getArgument(0));+ return service;+ });+ when(cloudMap.getService(id)).thenReturn(service);+ return service;+ }++ private ProvisionContext ctx(String priorPhysicalId) {+ CloudFormationTemplateEngine engine = mock(CloudFormationTemplateEngine.class);+ when(engine.resolve(any())).thenAnswer(inv -> {+ JsonNode node = inv.getArgument(0);+ return node == null ? null : node.asText();+ });+ // The engine rebuilds plain objects, and a Ref to a Number parameter resolves to text such as+ // "60", which the templates above write literally.+ when(engine.resolveNode(any())).thenAnswer(inv -> {+ JsonNode node = inv.getArgument(0);+ return node == null ? null : node.deepCopy();+ });+ return new ProvisionContext(engine, "us-east-1", "000000000000", "my-stack", priorPhysicalId);+ }++ private JsonNode props(String json) throws Exception {+ return mapper.readTree(json);+ }++ private static StackResource resource(String type, String logicalId) {+ StackResource r = new StackResource();+ r.setLogicalId(logicalId);+ r.setResourceType(type);+ r.setAttributes(new HashMap<>());+ return r;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudmap/CloudMapServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudmap/CloudMapServiceTest.javanew file mode 100644index 0000000000..1870f0e7af--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudmap/CloudMapServiceTest.java@@ -0,0 +1,113 @@+package io.github.hectorvent.floci.services.cloudmap;++import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudmap.model.Service;+import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.junit.jupiter.api.Test;++import java.util.Map;+import java.util.UUID;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++@QuarkusTest+class CloudMapServiceTest {++ private static final String REGION = "us-east-1";+ private static final String A_RECORD_DNS_CONFIG =+ "{\"RoutingPolicy\":\"MULTIVALUE\",\"DnsRecords\":[{\"Type\":\"A\",\"TTL\":60}]}";++ @Inject+ CloudMapService cloudMapService;++ @Test+ void updateServiceChangesTheTtlOfTheExistingRecords() {+ Service service = createService(privateDnsNamespace(), "ttl", "original", A_RECORD_DNS_CONFIG);++ cloudMapService.updateService(service.getId(), "original",+ "{\"RoutingPolicy\":\"MULTIVALUE\",\"DnsRecords\":[{\"Type\":\"A\",\"TTL\":30}]}", null);++ assertTrue(cloudMapService.getService(service.getId()).getDnsConfig().contains("\"TTL\":30"));+ }++ @Test+ void updateServiceAcceptsTheSameRecordsInAnotherOrder() {+ Service service = createService(privateDnsNamespace(), "order", "original",+ "{\"RoutingPolicy\":\"MULTIVALUE\",\"DnsRecords\":[{\"Type\":\"A\",\"TTL\":60},"+ + "{\"Type\":\"AAAA\",\"TTL\":60}]}");++ cloudMapService.updateService(service.getId(), "original",+ "{\"RoutingPolicy\":\"MULTIVALUE\",\"DnsRecords\":[{\"Type\":\"AAAA\",\"TTL\":30},"+ + "{\"Type\":\"A\",\"TTL\":30}]}", null);++ String stored = cloudMapService.getService(service.getId()).getDnsConfig();+ assertTrue(stored.contains("\"TTL\":30"));+ assertFalse(stored.contains("\"TTL\":60"));+ }++ @Test+ void updateServiceRejectsAChangedRecordType() {+ Service service = createService(privateDnsNamespace(), "type", "original", A_RECORD_DNS_CONFIG);++ AwsException error = assertThrows(AwsException.class, () -> cloudMapService.updateService(+ service.getId(), "changed",+ "{\"RoutingPolicy\":\"MULTIVALUE\",\"DnsRecords\":[{\"Type\":\"AAAA\",\"TTL\":60}]}", null));++ assertEquals("InvalidInput", error.getErrorCode());+ Service stored = cloudMapService.getService(service.getId());+ assertEquals(A_RECORD_DNS_CONFIG, stored.getDnsConfig());+ assertEquals("original", stored.getDescription());+ }++ @Test+ void updateServiceRejectsAChangedRoutingPolicy() {+ Service service = createService(privateDnsNamespace(), "routing", "original", A_RECORD_DNS_CONFIG);++ AwsException error = assertThrows(AwsException.class, () -> cloudMapService.updateService(+ service.getId(), "original",+ "{\"RoutingPolicy\":\"WEIGHTED\",\"DnsRecords\":[{\"Type\":\"A\",\"TTL\":60}]}", null));++ assertEquals("InvalidInput", error.getErrorCode());+ assertEquals(A_RECORD_DNS_CONFIG, cloudMapService.getService(service.getId()).getDnsConfig());+ }++ @Test+ void updateServiceRejectsAnAddedRecord() {+ Service service = createService(privateDnsNamespace(), "added", "original", A_RECORD_DNS_CONFIG);++ AwsException error = assertThrows(AwsException.class, () -> cloudMapService.updateService(+ service.getId(), "original",+ "{\"RoutingPolicy\":\"MULTIVALUE\",\"DnsRecords\":[{\"Type\":\"A\",\"TTL\":60},"+ + "{\"Type\":\"A\",\"TTL\":60}]}", null));++ assertEquals("InvalidInput", error.getErrorCode());+ assertEquals(A_RECORD_DNS_CONFIG, cloudMapService.getService(service.getId()).getDnsConfig());+ }++ @Test+ void updateServiceRejectsADnsConfigForAServiceWithoutOne() {+ Service service = createService(privateDnsNamespace(), "nodns", null, null);++ AwsException error = assertThrows(AwsException.class, () -> cloudMapService.updateService(+ service.getId(), null, "{\"DnsRecords\":[{\"Type\":\"A\",\"TTL\":60}]}", null));++ assertEquals("InvalidInput", error.getErrorCode());+ assertNull(cloudMapService.getService(service.getId()).getDnsConfig());+ }++ private String privateDnsNamespace() {+ String name = "svctest" + UUID.randomUUID().toString().substring(0, 8) + ".internal";+ return cloudMapService.createPrivateDnsNamespace(name, "vpc-dns", null, null, Map.of(), REGION)+ .getTargets().get("NAMESPACE");+ }++ private Service createService(String namespaceId, String name, String description, String dnsConfig) {+ return cloudMapService.createService(name, namespaceId, null, description,+ dnsConfig, null, null, null, Map.of(), REGION);+ }+}diff --git a/src/test/resources/cloudformation/supported-resource-types.tsv b/src/test/resources/cloudformation/supported-resource-types.tsvindex 48280ea81d..6a433973f3 100644--- a/src/test/resources/cloudformation/supported-resource-types.tsv+++ b/src/test/resources/cloudformation/supported-resource-types.tsv@@ -144,6 +144,10 @@ AWS::SSM::Parameter SsmCfnProvisionerAWS::Scheduler::ScheduleGroup SchedulerScheduleGroupCfnProvisionerAWS::SecretsManager::Secret SecretsManagerCfnProvisionerAWS::SecretsManager::SecretTargetAttachment SecretTargetAttachmentCfnProvisioner+AWS::ServiceDiscovery::HttpNamespace CloudMapCfnProvisioner+AWS::ServiceDiscovery::PrivateDnsNamespace CloudMapCfnProvisioner+AWS::ServiceDiscovery::PublicDnsNamespace CloudMapCfnProvisioner+AWS::ServiceDiscovery::Service CloudMapCfnProvisionerAWS::StepFunctions::StateMachine StepFunctionsCfnProvisionerAWS::WAFv2::WebACL WafV2CfnProvisionerCustom::DynamoDBReplica DynamoDbCfnProvisionerdiff --git a/tools/docs/cfn_resource_types.yaml b/tools/docs/cfn_resource_types.yamlindex 03335416de..361ac3bb6e 100644--- a/tools/docs/cfn_resource_types.yaml+++ b/tools/docs/cfn_resource_types.yaml@@ -29,6 +29,7 @@ order:- AWS::ElasticLoadBalancingV2- AWS::AutoScaling- AWS::Route53+ - AWS::ServiceDiscovery- AWS::ApiGateway- AWS::ApiGatewayV2- AWS::AppSync@@ -143,6 +144,7 @@ service_labels:AWS::SSM: SSMAWS::Scheduler: EventBridge SchedulerAWS::SecretsManager: Secrets Manager+ AWS::ServiceDiscovery: Cloud MapAWS::StepFunctions: Step FunctionsAWS::WAFv2: WAFv2Custom: CloudFormation