diff --git a/CHANGELOG.md b/CHANGELOG.md index 77867355f3560..408ea09b12e14 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,13 @@ All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines. +## [1.64.1](https://github.com/aws/aws-cdk/compare/v1.64.0...v1.64.1) (2020-09-25) + + +### Bug Fixes + +* **eks:** `KubernetesPatch` and `FargateCluster` creates a circular dependency and breaks deployment ([#10536](https://github.com/aws/aws-cdk/issues/10536)) ([f0f8a63](https://github.com/aws/aws-cdk/commit/f0f8a63c98e8a7ff5bedcf271a78fcb417988378)), closes [#10528](https://github.com/aws/aws-cdk/issues/10528) + ## [1.64.0](https://github.com/aws/aws-cdk/compare/v1.63.0...v1.64.0) (2020-09-22) diff --git a/lerna.json b/lerna.json index 7b4680783877f..dab86c14f2229 100644 --- a/lerna.json +++ b/lerna.json @@ -10,5 +10,5 @@ "tools/*" ], "rejectCycles": "true", - "version": "1.64.0" + "version": "1.64.1" } diff --git a/packages/@aws-cdk/aws-codebuild/lib/project.ts b/packages/@aws-cdk/aws-codebuild/lib/project.ts index 4c1ec9ca6b752..abf61ea06be86 100644 --- a/packages/@aws-cdk/aws-codebuild/lib/project.ts +++ b/packages/@aws-cdk/aws-codebuild/lib/project.ts @@ -753,7 +753,9 @@ export class Project extends ProjectBase { environment: this.renderEnvironment(props.environment, environmentVariables), fileSystemLocations: Lazy.anyValue({ produce: () => this.renderFileSystemLocations() }), // lazy, because we have a setter for it in setEncryptionKey - encryptionKey: Lazy.stringValue({ produce: () => this._encryptionKey && this._encryptionKey.keyArn }), + // The 'alias/aws/s3' default is necessary because leaving the `encryptionKey` field + // empty will not remove existing encryptionKeys during an update (ref. t/D17810523) + encryptionKey: Lazy.stringValue({ produce: () => this._encryptionKey ? this._encryptionKey.keyArn : 'alias/aws/s3' }), badgeEnabled: props.badge, cache: cache._toCloudFormation(), name: this.physicalName, diff --git a/packages/@aws-cdk/aws-codebuild/test/integ.aws-deep-learning-container-build-image.expected.json b/packages/@aws-cdk/aws-codebuild/test/integ.aws-deep-learning-container-build-image.expected.json index 2c91da398b0a7..6eb429e6cb569 100644 --- a/packages/@aws-cdk/aws-codebuild/test/integ.aws-deep-learning-container-build-image.expected.json +++ b/packages/@aws-cdk/aws-codebuild/test/integ.aws-deep-learning-container-build-image.expected.json @@ -208,7 +208,8 @@ "Source": { "BuildSpec": "{\n \"version\": \"0.2\",\n \"phases\": {\n \"build\": {\n \"commands\": [\n \"ls\"\n ]\n }\n }\n}", "Type": "NO_SOURCE" - } + }, + "EncryptionKey": "alias/aws/s3" } } }, diff --git a/packages/@aws-cdk/aws-codebuild/test/integ.caching.expected.json b/packages/@aws-cdk/aws-codebuild/test/integ.caching.expected.json index 738924ce04b93..79f9c50c2e5a7 100644 --- a/packages/@aws-cdk/aws-codebuild/test/integ.caching.expected.json +++ b/packages/@aws-cdk/aws-codebuild/test/integ.caching.expected.json @@ -165,7 +165,8 @@ ] }, "Type": "S3" - } + }, + "EncryptionKey": "alias/aws/s3" } } } diff --git a/packages/@aws-cdk/aws-codebuild/test/integ.defaults.lit.expected.json b/packages/@aws-cdk/aws-codebuild/test/integ.defaults.lit.expected.json index aae808b132920..c7162f3219c85 100644 --- a/packages/@aws-cdk/aws-codebuild/test/integ.defaults.lit.expected.json +++ b/packages/@aws-cdk/aws-codebuild/test/integ.defaults.lit.expected.json @@ -144,8 +144,9 @@ "Source": { "BuildSpec": "{\n \"version\": \"0.2\",\n \"phases\": {\n \"build\": {\n \"commands\": [\n \"echo \\\"Hello, CodeBuild!\\\"\"\n ]\n }\n }\n}", "Type": "NO_SOURCE" - } + }, + "EncryptionKey": "alias/aws/s3" } } } -} +} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-codebuild/test/integ.docker-asset.lit.expected.json b/packages/@aws-cdk/aws-codebuild/test/integ.docker-asset.lit.expected.json index 561aeb8f22f9a..64ff7f68d7f8c 100644 --- a/packages/@aws-cdk/aws-codebuild/test/integ.docker-asset.lit.expected.json +++ b/packages/@aws-cdk/aws-codebuild/test/integ.docker-asset.lit.expected.json @@ -163,7 +163,8 @@ "Source": { "BuildSpec": "{\n \"version\": \"0.2\",\n \"phases\": {\n \"build\": {\n \"commands\": [\n \"ls\"\n ]\n }\n }\n}", "Type": "NO_SOURCE" - } + }, + "EncryptionKey": "alias/aws/s3" } } } diff --git a/packages/@aws-cdk/aws-codebuild/test/integ.docker-registry.lit.expected.json b/packages/@aws-cdk/aws-codebuild/test/integ.docker-registry.lit.expected.json index efaee26898636..ca3d5bfef0619 100644 --- a/packages/@aws-cdk/aws-codebuild/test/integ.docker-registry.lit.expected.json +++ b/packages/@aws-cdk/aws-codebuild/test/integ.docker-registry.lit.expected.json @@ -154,8 +154,9 @@ "Source": { "BuildSpec": "{\n \"version\": \"0.2\",\n \"phases\": {\n \"build\": {\n \"commands\": [\n \"ls\"\n ]\n }\n }\n}", "Type": "NO_SOURCE" - } + }, + "EncryptionKey": "alias/aws/s3" } } } -} +} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-codebuild/test/integ.ecr.lit.expected.json b/packages/@aws-cdk/aws-codebuild/test/integ.ecr.lit.expected.json index c92a8b6c2deba..12ca8fff1853b 100644 --- a/packages/@aws-cdk/aws-codebuild/test/integ.ecr.lit.expected.json +++ b/packages/@aws-cdk/aws-codebuild/test/integ.ecr.lit.expected.json @@ -184,7 +184,8 @@ "Source": { "BuildSpec": "{\n \"version\": \"0.2\",\n \"phases\": {\n \"build\": {\n \"commands\": [\n \"ls\"\n ]\n }\n }\n}", "Type": "NO_SOURCE" - } + }, + "EncryptionKey": "alias/aws/s3" } } } diff --git a/packages/@aws-cdk/aws-codebuild/test/integ.github.expected.json b/packages/@aws-cdk/aws-codebuild/test/integ.github.expected.json index 017456796ac69..222a29feeeb8a 100644 --- a/packages/@aws-cdk/aws-codebuild/test/integ.github.expected.json +++ b/packages/@aws-cdk/aws-codebuild/test/integ.github.expected.json @@ -112,7 +112,8 @@ "Location": "https://github.com/aws/aws-cdk.git", "ReportBuildStatus": false, "Type": "GITHUB" - } + }, + "EncryptionKey": "alias/aws/s3" } } } diff --git a/packages/@aws-cdk/aws-codebuild/test/integ.project-bucket.expected.json b/packages/@aws-cdk/aws-codebuild/test/integ.project-bucket.expected.json index 3c3262ad23747..0ba33dae84b91 100644 --- a/packages/@aws-cdk/aws-codebuild/test/integ.project-bucket.expected.json +++ b/packages/@aws-cdk/aws-codebuild/test/integ.project-bucket.expected.json @@ -156,7 +156,8 @@ ] }, "Type": "S3" - } + }, + "EncryptionKey": "alias/aws/s3" } } } diff --git a/packages/@aws-cdk/aws-codebuild/test/integ.project-buildspec-artifacts.expected.json b/packages/@aws-cdk/aws-codebuild/test/integ.project-buildspec-artifacts.expected.json index fff6b92d11f44..13ff8f1e054c0 100644 --- a/packages/@aws-cdk/aws-codebuild/test/integ.project-buildspec-artifacts.expected.json +++ b/packages/@aws-cdk/aws-codebuild/test/integ.project-buildspec-artifacts.expected.json @@ -1,9 +1,9 @@ { "Resources": { "MyBucketF68F3FF0": { - "DeletionPolicy": "Delete", + "Type": "AWS::S3::Bucket", "UpdateReplacePolicy": "Delete", - "Type": "AWS::S3::Bucket" + "DeletionPolicy": "Delete" }, "MyProjectRole9BBE5233": { "Type": "AWS::IAM::Role", @@ -133,7 +133,9 @@ "Properties": { "Artifacts": { "ArtifactIdentifier": "AddArtifact1", - "Location": { "Ref": "MyBucketF68F3FF0" }, + "Location": { + "Ref": "MyBucketF68F3FF0" + }, "NamespaceType": "NONE", "OverrideArtifactName": true, "Packaging": "ZIP", @@ -155,9 +157,9 @@ "Source": { "BuildSpec": "{\n \"version\": \"0.2\"\n}", "Type": "NO_SOURCE" - } + }, + "EncryptionKey": "alias/aws/s3" } } } -} - +} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-codebuild/test/integ.project-file-system-location.expected.json b/packages/@aws-cdk/aws-codebuild/test/integ.project-file-system-location.expected.json index c23bcab0e013a..ef679f0b9fb7a 100644 --- a/packages/@aws-cdk/aws-codebuild/test/integ.project-file-system-location.expected.json +++ b/packages/@aws-cdk/aws-codebuild/test/integ.project-file-system-location.expected.json @@ -371,6 +371,7 @@ "BuildSpec": "{\n \"version\": \"0.2\"\n}", "Type": "NO_SOURCE" }, + "EncryptionKey": "alias/aws/s3", "FileSystemLocations": [ { "Identifier": "myidentifier", diff --git a/packages/@aws-cdk/aws-codebuild/test/integ.project-secondary-sources-artifacts.expected.json b/packages/@aws-cdk/aws-codebuild/test/integ.project-secondary-sources-artifacts.expected.json index 26a3636bfc5b3..f7261ca4b21ae 100644 --- a/packages/@aws-cdk/aws-codebuild/test/integ.project-secondary-sources-artifacts.expected.json +++ b/packages/@aws-cdk/aws-codebuild/test/integ.project-secondary-sources-artifacts.expected.json @@ -180,6 +180,7 @@ "BuildSpec": "{\n \"version\": \"0.2\"\n}", "Type": "NO_SOURCE" }, + "EncryptionKey": "alias/aws/s3", "SecondaryArtifacts": [ { "ArtifactIdentifier": "AddArtifact1", diff --git a/packages/@aws-cdk/aws-codebuild/test/integ.project-vpc.expected.json b/packages/@aws-cdk/aws-codebuild/test/integ.project-vpc.expected.json index 2e46025573d0b..6d3eb3091b7ed 100644 --- a/packages/@aws-cdk/aws-codebuild/test/integ.project-vpc.expected.json +++ b/packages/@aws-cdk/aws-codebuild/test/integ.project-vpc.expected.json @@ -371,6 +371,7 @@ "BuildSpec": "{\n \"version\": \"0.2\",\n \"phases\": {\n \"build\": {\n \"commands\": [\n \"echo \\\"Nothing to do!\\\"\"\n ]\n }\n }\n}", "Type": "NO_SOURCE" }, + "EncryptionKey": "alias/aws/s3", "VpcConfig": { "SecurityGroupIds": [ { diff --git a/packages/@aws-cdk/aws-codebuild/test/test.codebuild.ts b/packages/@aws-cdk/aws-codebuild/test/test.codebuild.ts index 8a5a9decfc1e2..558dd072c7f3f 100644 --- a/packages/@aws-cdk/aws-codebuild/test/test.codebuild.ts +++ b/packages/@aws-cdk/aws-codebuild/test/test.codebuild.ts @@ -153,6 +153,7 @@ export = { 'Image': 'aws/codebuild/standard:1.0', 'ComputeType': 'BUILD_GENERAL1_SMALL', }, + 'EncryptionKey': 'alias/aws/s3', }, }, }, @@ -331,6 +332,7 @@ export = { 'GitCloneDepth': 2, 'Type': 'CODECOMMIT', }, + 'EncryptionKey': 'alias/aws/s3', }, }, }, @@ -532,6 +534,7 @@ export = { }, 'Type': 'S3', }, + 'EncryptionKey': 'alias/aws/s3', }, }, }, @@ -800,6 +803,21 @@ export = { test.done(); }, + 'no KMS Key defaults to default S3 managed key'(test: Test) { + // GIVEN + const stack = new cdk.Stack(); + + // WHEN + new codebuild.PipelineProject(stack, 'MyProject'); + + // THEN + expect(stack).to(haveResourceLike('AWS::CodeBuild::Project', { + EncryptionKey: 'alias/aws/s3', + })); + + test.done(); + }, + 'with a KMS Key adds decrypt permissions to the CodeBuild Role'(test: Test) { const stack = new cdk.Stack(); diff --git a/packages/@aws-cdk/aws-codepipeline-actions/test/integ.pipeline-code-build-multiple-inputs-outputs.expected.json b/packages/@aws-cdk/aws-codepipeline-actions/test/integ.pipeline-code-build-multiple-inputs-outputs.expected.json index 0b47b23b12a50..d2d59b1fe8884 100644 --- a/packages/@aws-cdk/aws-codepipeline-actions/test/integ.pipeline-code-build-multiple-inputs-outputs.expected.json +++ b/packages/@aws-cdk/aws-codepipeline-actions/test/integ.pipeline-code-build-multiple-inputs-outputs.expected.json @@ -614,8 +614,9 @@ }, "Source": { "Type": "CODEPIPELINE" - } + }, + "EncryptionKey": "alias/aws/s3" } } } -} \ No newline at end of file +} diff --git a/packages/@aws-cdk/aws-codepipeline-actions/test/integ.pipeline-ecs-deploy.expected.json b/packages/@aws-cdk/aws-codepipeline-actions/test/integ.pipeline-ecs-deploy.expected.json index 34a425b48a1a6..5570acefe6336 100644 --- a/packages/@aws-cdk/aws-codepipeline-actions/test/integ.pipeline-ecs-deploy.expected.json +++ b/packages/@aws-cdk/aws-codepipeline-actions/test/integ.pipeline-ecs-deploy.expected.json @@ -540,7 +540,8 @@ "Source": { "BuildSpec": "{\n \"version\": \"0.2\",\n \"phases\": {\n \"pre_build\": {\n \"commands\": \"$(aws ecr get-login --region $AWS_DEFAULT_REGION --no-include-email)\"\n },\n \"build\": {\n \"commands\": \"docker build -t $REPOSITORY_URI:latest .\"\n },\n \"post_build\": {\n \"commands\": [\n \"docker push $REPOSITORY_URI:latest\",\n \"printf '[{ \\\"name\\\": \\\"Container\\\", \\\"imageUri\\\": \\\"%s\\\" }]' $REPOSITORY_URI:latest > imagedefinitions.json\"\n ]\n }\n },\n \"artifacts\": {\n \"files\": \"imagedefinitions.json\"\n }\n}", "Type": "CODEPIPELINE" - } + }, + "EncryptionKey": "alias/aws/s3" } }, "MyPipelineRoleC0D47CA4": { @@ -1041,4 +1042,4 @@ } } } -} \ No newline at end of file +} diff --git a/packages/@aws-cdk/aws-eks/lib/k8s-patch.ts b/packages/@aws-cdk/aws-eks/lib/k8s-patch.ts index d35de30a18fe5..88db0f4352f11 100644 --- a/packages/@aws-cdk/aws-eks/lib/k8s-patch.ts +++ b/packages/@aws-cdk/aws-eks/lib/k8s-patch.ts @@ -71,7 +71,7 @@ export class KubernetesPatch extends Construct { super(scope, id); const stack = Stack.of(this); - const provider = KubectlProvider.getOrCreate(scope, props.cluster); + const provider = KubectlProvider.getOrCreate(this, props.cluster); new CustomResource(this, 'Resource', { serviceToken: provider.serviceToken, diff --git a/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.expected.json b/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.expected.json new file mode 100644 index 0000000000000..de489ef72836e --- /dev/null +++ b/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.expected.json @@ -0,0 +1,1388 @@ +{ + "Resources": { + "FargateClusterDefaultVpcE69D3A13": { + "Type": "AWS::EC2::VPC", + "Properties": { + "CidrBlock": "10.0.0.0/16", + "EnableDnsHostnames": true, + "EnableDnsSupport": true, + "InstanceTenancy": "default", + "Tags": [ + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.0.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1a", + "MapPublicIpOnLaunch": true, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Public" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Public" + }, + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet1RouteTableAssociation43821F5B": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC" + } + } + }, + "FargateClusterDefaultVpcPublicSubnet1DefaultRouteA0A93C70": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "GatewayId": { + "Ref": "FargateClusterDefaultVpcIGWFD9278DA" + } + }, + "DependsOn": [ + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0": { + "Type": "AWS::EC2::EIP", + "Properties": { + "Domain": "vpc", + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51": { + "Type": "AWS::EC2::NatGateway", + "Properties": { + "AllocationId": { + "Fn::GetAtt": [ + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0", + "AllocationId" + ] + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.32.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1b", + "MapPublicIpOnLaunch": true, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Public" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Public" + }, + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet2RouteTableAssociationCF18C87A": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93" + } + } + }, + "FargateClusterDefaultVpcPublicSubnet2DefaultRouteABE51CF2": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "GatewayId": { + "Ref": "FargateClusterDefaultVpcIGWFD9278DA" + } + }, + "DependsOn": [ + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68": { + "Type": "AWS::EC2::EIP", + "Properties": { + "Domain": "vpc", + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579": { + "Type": "AWS::EC2::NatGateway", + "Properties": { + "AllocationId": { + "Fn::GetAtt": [ + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68", + "AllocationId" + ] + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.64.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1c", + "MapPublicIpOnLaunch": true, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Public" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Public" + }, + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet3RouteTableAssociation93B95514": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9" + } + } + }, + "FargateClusterDefaultVpcPublicSubnet3DefaultRoute8341F833": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "GatewayId": { + "Ref": "FargateClusterDefaultVpcIGWFD9278DA" + } + }, + "DependsOn": [ + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF": { + "Type": "AWS::EC2::EIP", + "Properties": { + "Domain": "vpc", + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F": { + "Type": "AWS::EC2::NatGateway", + "Properties": { + "AllocationId": { + "Fn::GetAtt": [ + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF", + "AllocationId" + ] + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.96.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1a", + "MapPublicIpOnLaunch": false, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Private" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Private" + }, + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet1RouteTableAssociationDC34627F": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet1DefaultRouteE93D7B93": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "NatGatewayId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.128.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1b", + "MapPublicIpOnLaunch": false, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Private" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Private" + }, + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet2RouteTableAssociation6C0234FE": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet2DefaultRouteABCE20FF": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "NatGatewayId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.160.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1c", + "MapPublicIpOnLaunch": false, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Private" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Private" + }, + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet3RouteTableAssociationCC0949D8": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet3DefaultRouteEFE144B5": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "NatGatewayId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F" + } + } + }, + "FargateClusterDefaultVpcIGWFD9278DA": { + "Type": "AWS::EC2::InternetGateway", + "Properties": { + "Tags": [ + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc" + } + ] + } + }, + "FargateClusterDefaultVpcVPCGWA7F012E1": { + "Type": "AWS::EC2::VPCGatewayAttachment", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "InternetGatewayId": { + "Ref": "FargateClusterDefaultVpcIGWFD9278DA" + } + } + }, + "FargateClusterRole8E36B33A": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "eks.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "ManagedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/AmazonEKSClusterPolicy" + ] + ] + } + ] + } + }, + "FargateClusterControlPlaneSecurityGroup1021A150": { + "Type": "AWS::EC2::SecurityGroup", + "Properties": { + "GroupDescription": "EKS Control Plane Security Group", + "SecurityGroupEgress": [ + { + "CidrIp": "0.0.0.0/0", + "Description": "Allow all outbound traffic by default", + "IpProtocol": "-1" + } + ], + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + } + } + }, + "FargateClusterCreationRole8C524AD8": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "AWS": { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::12345678:root" + ] + ] + } + } + } + ], + "Version": "2012-10-17" + } + }, + "DependsOn": [ + "FargateClusterDefaultVpcIGWFD9278DA", + "FargateClusterDefaultVpcPrivateSubnet1DefaultRouteE93D7B93", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableAssociationDC34627F", + "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA", + "FargateClusterDefaultVpcPrivateSubnet2DefaultRouteABCE20FF", + "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C", + "FargateClusterDefaultVpcPrivateSubnet2RouteTableAssociation6C0234FE", + "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154", + "FargateClusterDefaultVpcPrivateSubnet3DefaultRouteEFE144B5", + "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96", + "FargateClusterDefaultVpcPrivateSubnet3RouteTableAssociationCC0949D8", + "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1", + "FargateClusterDefaultVpcPublicSubnet1DefaultRouteA0A93C70", + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0", + "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51", + "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434", + "FargateClusterDefaultVpcPublicSubnet1RouteTableAssociation43821F5B", + "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC", + "FargateClusterDefaultVpcPublicSubnet2DefaultRouteABE51CF2", + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68", + "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579", + "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9", + "FargateClusterDefaultVpcPublicSubnet2RouteTableAssociationCF18C87A", + "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93", + "FargateClusterDefaultVpcPublicSubnet3DefaultRoute8341F833", + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF", + "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F", + "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182", + "FargateClusterDefaultVpcPublicSubnet3RouteTableAssociation93B95514", + "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9", + "FargateClusterDefaultVpcE69D3A13", + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateClusterCreationRoleDefaultPolicy629049D0": { + "Type": "AWS::IAM::Policy", + "Properties": { + "PolicyDocument": { + "Statement": [ + { + "Action": "iam:PassRole", + "Effect": "Allow", + "Resource": { + "Fn::GetAtt": [ + "FargateClusterRole8E36B33A", + "Arn" + ] + } + }, + { + "Action": [ + "ec2:DescribeSubnets", + "ec2:DescribeRouteTables" + ], + "Effect": "Allow", + "Resource": "*" + }, + { + "Action": [ + "eks:CreateCluster", + "eks:DescribeCluster", + "eks:DescribeUpdate", + "eks:DeleteCluster", + "eks:UpdateClusterVersion", + "eks:UpdateClusterConfig", + "eks:CreateFargateProfile", + "eks:TagResource", + "eks:UntagResource" + ], + "Effect": "Allow", + "Resource": [ + "*" + ] + }, + { + "Action": [ + "eks:DescribeFargateProfile", + "eks:DeleteFargateProfile" + ], + "Effect": "Allow", + "Resource": "*" + }, + { + "Action": [ + "iam:GetRole", + "iam:listAttachedRolePolicies" + ], + "Effect": "Allow", + "Resource": "*" + }, + { + "Action": "iam:CreateServiceLinkedRole", + "Effect": "Allow", + "Resource": "*" + }, + { + "Action": "ec2:DescribeVpcs", + "Effect": "Allow", + "Resource": { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":ec2:test-region:12345678:vpc/", + { + "Ref": "FargateClusterDefaultVpcE69D3A13" + } + ] + ] + } + }, + { + "Action": "iam:PassRole", + "Effect": "Allow", + "Resource": { + "Fn::GetAtt": [ + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E", + "Arn" + ] + } + } + ], + "Version": "2012-10-17" + }, + "PolicyName": "FargateClusterCreationRoleDefaultPolicy629049D0", + "Roles": [ + { + "Ref": "FargateClusterCreationRole8C524AD8" + } + ] + }, + "DependsOn": [ + "FargateClusterDefaultVpcIGWFD9278DA", + "FargateClusterDefaultVpcPrivateSubnet1DefaultRouteE93D7B93", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableAssociationDC34627F", + "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA", + "FargateClusterDefaultVpcPrivateSubnet2DefaultRouteABCE20FF", + "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C", + "FargateClusterDefaultVpcPrivateSubnet2RouteTableAssociation6C0234FE", + "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154", + "FargateClusterDefaultVpcPrivateSubnet3DefaultRouteEFE144B5", + "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96", + "FargateClusterDefaultVpcPrivateSubnet3RouteTableAssociationCC0949D8", + "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1", + "FargateClusterDefaultVpcPublicSubnet1DefaultRouteA0A93C70", + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0", + "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51", + "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434", + "FargateClusterDefaultVpcPublicSubnet1RouteTableAssociation43821F5B", + "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC", + "FargateClusterDefaultVpcPublicSubnet2DefaultRouteABE51CF2", + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68", + "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579", + "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9", + "FargateClusterDefaultVpcPublicSubnet2RouteTableAssociationCF18C87A", + "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93", + "FargateClusterDefaultVpcPublicSubnet3DefaultRoute8341F833", + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF", + "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F", + "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182", + "FargateClusterDefaultVpcPublicSubnet3RouteTableAssociation93B95514", + "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9", + "FargateClusterDefaultVpcE69D3A13", + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateCluster019F03E8": { + "Type": "Custom::AWSCDK-EKS-Cluster", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "awscdkawseksClusterResourceProviderNestedStackawscdkawseksClusterResourceProviderNestedStackResource9827C454", + "Outputs.awscdkeksfargateclustertestawscdkawseksClusterResourceProviderframeworkonEventC85EBDF3Arn" + ] + }, + "Config": { + "version": "1.17", + "roleArn": { + "Fn::GetAtt": [ + "FargateClusterRole8E36B33A", + "Arn" + ] + }, + "resourcesVpcConfig": { + "subnetIds": [ + { + "Ref": "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC" + }, + { + "Ref": "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93" + }, + { + "Ref": "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9" + }, + { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA" + }, + { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154" + }, + { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1" + } + ], + "securityGroupIds": [ + { + "Fn::GetAtt": [ + "FargateClusterControlPlaneSecurityGroup1021A150", + "GroupId" + ] + } + ], + "endpointPublicAccess": true, + "endpointPrivateAccess": true + } + }, + "AssumeRoleArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "AttributesRevision": 2 + }, + "DependsOn": [ + "FargateClusterDefaultVpcIGWFD9278DA", + "FargateClusterDefaultVpcPrivateSubnet1DefaultRouteE93D7B93", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableAssociationDC34627F", + "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA", + "FargateClusterDefaultVpcPrivateSubnet2DefaultRouteABCE20FF", + "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C", + "FargateClusterDefaultVpcPrivateSubnet2RouteTableAssociation6C0234FE", + "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154", + "FargateClusterDefaultVpcPrivateSubnet3DefaultRouteEFE144B5", + "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96", + "FargateClusterDefaultVpcPrivateSubnet3RouteTableAssociationCC0949D8", + "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1", + "FargateClusterDefaultVpcPublicSubnet1DefaultRouteA0A93C70", + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0", + "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51", + "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434", + "FargateClusterDefaultVpcPublicSubnet1RouteTableAssociation43821F5B", + "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC", + "FargateClusterDefaultVpcPublicSubnet2DefaultRouteABE51CF2", + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68", + "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579", + "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9", + "FargateClusterDefaultVpcPublicSubnet2RouteTableAssociationCF18C87A", + "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93", + "FargateClusterDefaultVpcPublicSubnet3DefaultRoute8341F833", + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF", + "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F", + "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182", + "FargateClusterDefaultVpcPublicSubnet3RouteTableAssociation93B95514", + "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9", + "FargateClusterDefaultVpcE69D3A13", + "FargateClusterDefaultVpcVPCGWA7F012E1", + "FargateClusterCreationRoleDefaultPolicy629049D0", + "FargateClusterCreationRole8C524AD8" + ], + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "FargateClusterKubectlReadyBarrier93746934": { + "Type": "AWS::SSM::Parameter", + "Properties": { + "Type": "String", + "Value": "aws:cdk:eks:kubectl-ready" + }, + "DependsOn": [ + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E", + "FargateClusterfargateprofiledefault10E54561", + "FargateClusterCreationRoleDefaultPolicy629049D0", + "FargateClusterCreationRole8C524AD8", + "FargateCluster019F03E8" + ] + }, + "FargateClusterMastersRole50BAF9FD": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "AWS": { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::12345678:root" + ] + ] + } + } + } + ], + "Version": "2012-10-17" + } + } + }, + "FargateClusterAwsAuthmanifest1F7A5553": { + "Type": "Custom::AWSCDK-EKS-KubernetesResource", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "awscdkawseksKubectlProviderNestedStackawscdkawseksKubectlProviderNestedStackResourceA7AEBA6B", + "Outputs.awscdkeksfargateclustertestawscdkawseksKubectlProviderframeworkonEvent33B2ACA4Arn" + ] + }, + "Manifest": { + "Fn::Join": [ + "", + [ + "[{\"apiVersion\":\"v1\",\"kind\":\"ConfigMap\",\"metadata\":{\"name\":\"aws-auth\",\"namespace\":\"kube-system\"},\"data\":{\"mapRoles\":\"[{\\\"rolearn\\\":\\\"", + { + "Fn::GetAtt": [ + "FargateClusterMastersRole50BAF9FD", + "Arn" + ] + }, + "\\\",\\\"username\\\":\\\"", + { + "Fn::GetAtt": [ + "FargateClusterMastersRole50BAF9FD", + "Arn" + ] + }, + "\\\",\\\"groups\\\":[\\\"system:masters\\\"]},{\\\"rolearn\\\":\\\"", + { + "Fn::GetAtt": [ + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E", + "Arn" + ] + }, + "\\\",\\\"username\\\":\\\"system:node:{{SessionName}}\\\",\\\"groups\\\":[\\\"system:bootstrappers\\\",\\\"system:nodes\\\",\\\"system:node-proxier\\\"]}]\",\"mapUsers\":\"[]\",\"mapAccounts\":\"[]\"}}]" + ] + ] + }, + "ClusterName": { + "Ref": "FargateCluster019F03E8" + }, + "RoleArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + } + }, + "DependsOn": [ + "FargateClusterKubectlReadyBarrier93746934" + ], + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "FargateClusterCoreDnsComputeTypePatch711BF1B2": { + "Type": "Custom::AWSCDK-EKS-KubernetesPatch", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "awscdkawseksKubectlProviderNestedStackawscdkawseksKubectlProviderNestedStackResourceA7AEBA6B", + "Outputs.awscdkeksfargateclustertestawscdkawseksKubectlProviderframeworkonEvent33B2ACA4Arn" + ] + }, + "ResourceName": "deployment/coredns", + "ResourceNamespace": "kube-system", + "ApplyPatchJson": "{\"spec\":{\"template\":{\"metadata\":{\"annotations\":{\"eks.amazonaws.com/compute-type\":\"fargate\"}}}}}", + "RestorePatchJson": "{\"spec\":{\"template\":{\"metadata\":{\"annotations\":{\"eks.amazonaws.com/compute-type\":\"ec2\"}}}}}", + "ClusterName": { + "Ref": "FargateCluster019F03E8" + }, + "RoleArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "PatchType": "strategic" + }, + "DependsOn": [ + "FargateClusterKubectlReadyBarrier93746934" + ], + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "eks-fargate-pods.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "ManagedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/AmazonEKSFargatePodExecutionRolePolicy" + ] + ] + } + ] + } + }, + "FargateClusterfargateprofiledefault10E54561": { + "Type": "Custom::AWSCDK-EKS-FargateProfile", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "awscdkawseksClusterResourceProviderNestedStackawscdkawseksClusterResourceProviderNestedStackResource9827C454", + "Outputs.awscdkeksfargateclustertestawscdkawseksClusterResourceProviderframeworkonEventC85EBDF3Arn" + ] + }, + "AssumeRoleArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "Config": { + "clusterName": { + "Ref": "FargateCluster019F03E8" + }, + "podExecutionRoleArn": { + "Fn::GetAtt": [ + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E", + "Arn" + ] + }, + "selectors": [ + { + "namespace": "default" + }, + { + "namespace": "kube-system" + } + ] + } + }, + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "awscdkawseksClusterResourceProviderNestedStackawscdkawseksClusterResourceProviderNestedStackResource9827C454": { + "Type": "AWS::CloudFormation::Stack", + "Properties": { + "TemplateURL": { + "Fn::Join": [ + "", + [ + "https://s3.test-region.", + { + "Ref": "AWS::URLSuffix" + }, + "/", + { + "Ref": "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3Bucket60C2BF28" + }, + "/", + { + "Fn::Select": [ + 0, + { + "Fn::Split": [ + "||", + { + "Ref": "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3VersionKey81C20166" + } + ] + } + ] + }, + { + "Fn::Select": [ + 1, + { + "Fn::Split": [ + "||", + { + "Ref": "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3VersionKey81C20166" + } + ] + } + ] + } + ] + ] + }, + "Parameters": { + "referencetoawscdkeksfargateclustertestFargateClusterCreationRoleFB2229CFArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "referencetoawscdkeksfargateclustertestAssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3Bucket122A6EA8Ref": { + "Ref": "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3Bucket14D204F9" + }, + "referencetoawscdkeksfargateclustertestAssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3VersionKey56570425Ref": { + "Ref": "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3VersionKeyDE8A2F1F" + }, + "referencetoawscdkeksfargateclustertestAssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket7ABEDF68Ref": { + "Ref": "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket8132A6E0" + }, + "referencetoawscdkeksfargateclustertestAssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey810DC943Ref": { + "Ref": "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey722E831A" + } + } + } + }, + "awscdkawseksKubectlProviderNestedStackawscdkawseksKubectlProviderNestedStackResourceA7AEBA6B": { + "Type": "AWS::CloudFormation::Stack", + "Properties": { + "TemplateURL": { + "Fn::Join": [ + "", + [ + "https://s3.test-region.", + { + "Ref": "AWS::URLSuffix" + }, + "/", + { + "Ref": "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3Bucket1E579A0A" + }, + "/", + { + "Fn::Select": [ + 0, + { + "Fn::Split": [ + "||", + { + "Ref": "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3VersionKey91701E13" + } + ] + } + ] + }, + { + "Fn::Select": [ + 1, + { + "Fn::Split": [ + "||", + { + "Ref": "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3VersionKey91701E13" + } + ] + } + ] + } + ] + ] + }, + "Parameters": { + "referencetoawscdkeksfargateclustertestFargateCluster8588769EArn": { + "Fn::GetAtt": [ + "FargateCluster019F03E8", + "Arn" + ] + }, + "referencetoawscdkeksfargateclustertestFargateClusterCreationRoleFB2229CFArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "referencetoawscdkeksfargateclustertestAssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3BucketF3D15942Ref": { + "Ref": "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3Bucket9ABBD5A2" + }, + "referencetoawscdkeksfargateclustertestAssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3VersionKey362BF04DRef": { + "Ref": "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3VersionKey40FF2C4A" + }, + "referencetoawscdkeksfargateclustertestFargateClusterDefaultVpcPrivateSubnet1Subnet0278E6BCRef": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA" + }, + "referencetoawscdkeksfargateclustertestFargateClusterDefaultVpcPrivateSubnet2Subnet1F1EC575Ref": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154" + }, + "referencetoawscdkeksfargateclustertestFargateClusterDefaultVpcPrivateSubnet3Subnet3A4CBF94Ref": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1" + }, + "referencetoawscdkeksfargateclustertestFargateCluster8588769EClusterSecurityGroupId": { + "Fn::GetAtt": [ + "FargateCluster019F03E8", + "ClusterSecurityGroupId" + ] + }, + "referencetoawscdkeksfargateclustertestAssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket7ABEDF68Ref": { + "Ref": "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket8132A6E0" + }, + "referencetoawscdkeksfargateclustertestAssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey810DC943Ref": { + "Ref": "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey722E831A" + } + } + } + } + }, + "Outputs": { + "FargateClusterConfigCommand46D4A6C7": { + "Value": { + "Fn::Join": [ + "", + [ + "aws eks update-kubeconfig --name ", + { + "Ref": "FargateCluster019F03E8" + }, + " --region test-region --role-arn ", + { + "Fn::GetAtt": [ + "FargateClusterMastersRole50BAF9FD", + "Arn" + ] + } + ] + ] + } + }, + "FargateClusterGetTokenCommand4ADED7BB": { + "Value": { + "Fn::Join": [ + "", + [ + "aws eks get-token --cluster-name ", + { + "Ref": "FargateCluster019F03E8" + }, + " --region test-region --role-arn ", + { + "Fn::GetAtt": [ + "FargateClusterMastersRole50BAF9FD", + "Arn" + ] + } + ] + ] + } + } + }, + "Parameters": { + "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3Bucket14D204F9": { + "Type": "String", + "Description": "S3 bucket for asset \"87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dba\"" + }, + "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3VersionKeyDE8A2F1F": { + "Type": "String", + "Description": "S3 key for asset version \"87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dba\"" + }, + "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaArtifactHash54822A43": { + "Type": "String", + "Description": "Artifact hash for asset \"87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dba\"" + }, + "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket8132A6E0": { + "Type": "String", + "Description": "S3 bucket for asset \"5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0c\"" + }, + "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey722E831A": { + "Type": "String", + "Description": "S3 key for asset version \"5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0c\"" + }, + "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cArtifactHash67988836": { + "Type": "String", + "Description": "Artifact hash for asset \"5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0c\"" + }, + "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3Bucket9ABBD5A2": { + "Type": "String", + "Description": "S3 bucket for asset \"b7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2\"" + }, + "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3VersionKey40FF2C4A": { + "Type": "String", + "Description": "S3 key for asset version \"b7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2\"" + }, + "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2ArtifactHashE86B38C7": { + "Type": "String", + "Description": "Artifact hash for asset \"b7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2\"" + }, + "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3Bucket60C2BF28": { + "Type": "String", + "Description": "S3 bucket for asset \"bedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89\"" + }, + "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3VersionKey81C20166": { + "Type": "String", + "Description": "S3 key for asset version \"bedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89\"" + }, + "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89ArtifactHashC2E43922": { + "Type": "String", + "Description": "Artifact hash for asset \"bedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89\"" + }, + "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3Bucket1E579A0A": { + "Type": "String", + "Description": "S3 bucket for asset \"c3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7c\"" + }, + "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3VersionKey91701E13": { + "Type": "String", + "Description": "S3 key for asset version \"c3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7c\"" + }, + "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cArtifactHash4D9F989B": { + "Type": "String", + "Description": "Artifact hash for asset \"c3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7c\"" + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.ts b/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.ts new file mode 100644 index 0000000000000..870b3059b1a2b --- /dev/null +++ b/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.ts @@ -0,0 +1,21 @@ +/// !cdk-integ pragma:ignore-assets +import { App } from '@aws-cdk/core'; +import * as eks from '../lib'; +import { TestStack } from './util'; + +class EksFargateClusterStack extends TestStack { + + constructor(scope: App, id: string) { + super(scope, id); + + new eks.FargateCluster(this, 'FargateCluster', { + version: eks.KubernetesVersion.V1_17, + }); + } +} + +const app = new App(); + +new EksFargateClusterStack(app, 'aws-cdk-eks-fargate-cluster-test'); + +app.synth(); \ No newline at end of file diff --git a/packages/@aws-cdk/aws-eks/test/test.k8s-patch.ts b/packages/@aws-cdk/aws-eks/test/test.k8s-patch.ts index e77035688b19e..c4defdf107606 100644 --- a/packages/@aws-cdk/aws-eks/test/test.k8s-patch.ts +++ b/packages/@aws-cdk/aws-eks/test/test.k8s-patch.ts @@ -13,7 +13,7 @@ export = { const cluster = new eks.Cluster(stack, 'MyCluster', { version: CLUSTER_VERSION }); // WHEN - new KubernetesPatch(stack, 'MyPatch', { + const patch = new KubernetesPatch(stack, 'MyPatch', { cluster, applyPatch: { patch: { to: 'apply' } }, restorePatch: { restore: { patch: 123 } }, @@ -42,6 +42,10 @@ export = { ], }, })); + + // also make sure a dependency on the barrier is added to the patch construct. + test.deepEqual(patch.node.dependencies.map(d => d.target.node.uniqueId), ['MyClusterKubectlReadyBarrier7547948A']); + test.done(); }, 'defaults to "strategic" patch type if no patchType is specified'(test: Test) { diff --git a/packages/@aws-cdk/aws-events-targets/test/codebuild/integ.project-events.expected.json b/packages/@aws-cdk/aws-events-targets/test/codebuild/integ.project-events.expected.json index 178bba14bbc1c..ed269b2e7b524 100644 --- a/packages/@aws-cdk/aws-events-targets/test/codebuild/integ.project-events.expected.json +++ b/packages/@aws-cdk/aws-events-targets/test/codebuild/integ.project-events.expected.json @@ -226,7 +226,8 @@ ] }, "Type": "CODECOMMIT" - } + }, + "EncryptionKey": "alias/aws/s3" } }, "MyProjectStateChange2DAB75B7": { diff --git a/packages/@aws-cdk/aws-secretsmanager/lib/secret.ts b/packages/@aws-cdk/aws-secretsmanager/lib/secret.ts index c4539cca154ea..1e6bf8d2441a5 100644 --- a/packages/@aws-cdk/aws-secretsmanager/lib/secret.ts +++ b/packages/@aws-cdk/aws-secretsmanager/lib/secret.ts @@ -1,6 +1,6 @@ import * as iam from '@aws-cdk/aws-iam'; import * as kms from '@aws-cdk/aws-kms'; -import { Construct, IConstruct, IResource, RemovalPolicy, Resource, SecretValue, Stack } from '@aws-cdk/core'; +import { Construct, IConstruct, IResource, RemovalPolicy, Resource, SecretValue, Stack, Token } from '@aws-cdk/core'; import { ResourcePolicy } from './policy'; import { RotationSchedule, RotationScheduleOptions } from './rotation-schedule'; import * as secretsmanager from './secretsmanager.generated'; @@ -596,8 +596,13 @@ export interface SecretStringGenerator { /** Parses the secret name from the ARN. */ function parseSecretName(construct: IConstruct, secretArn: string) { - const resourceName = Stack.of(construct).parseArn(secretArn).resourceName; + const resourceName = Stack.of(construct).parseArn(secretArn, ':').resourceName; if (resourceName) { + // Can't operate on the token to remove the SecretsManager suffix, so just return the full secret name + if (Token.isUnresolved(resourceName)) { + return resourceName; + } + // Secret resource names are in the format `${secretName}-${SecretsManager suffix}` const secretNameFromArn = resourceName.substr(0, resourceName.lastIndexOf('-')); if (secretNameFromArn) { return secretNameFromArn; } diff --git a/packages/@aws-cdk/aws-secretsmanager/test/test.secret.ts b/packages/@aws-cdk/aws-secretsmanager/test/test.secret.ts index 1b7c1e3063ed9..523ce501b9126 100644 --- a/packages/@aws-cdk/aws-secretsmanager/test/test.secret.ts +++ b/packages/@aws-cdk/aws-secretsmanager/test/test.secret.ts @@ -482,6 +482,30 @@ export = { test.done(); }, + 'import by secretArn supports tokens for ARNs'(test: Test) { + // GIVEN + const app = new cdk.App(); + const stackA = new cdk.Stack(app, 'StackA'); + const stackB = new cdk.Stack(app, 'StackB'); + const secretA = new secretsmanager.Secret(stackA, 'SecretA'); + + // WHEN + const secretB = secretsmanager.Secret.fromSecretArn(stackB, 'SecretB', secretA.secretArn); + new cdk.CfnOutput(stackB, 'secretBSecretName', { value: secretB.secretName }); + + // THEN + test.equals(secretB.secretArn, secretA.secretArn); + expect(stackB).toMatch({ + Outputs: { + secretBSecretName: { + Value: { 'Fn::Select': [6, { 'Fn::Split': [':', { 'Fn::ImportValue': 'StackA:ExportsOutputRefSecretA188F281703FC8A52' }] }] }, + }, + }, + }); + + test.done(); + }, + 'import by attributes'(test: Test) { // GIVEN const stack = new cdk.Stack(); diff --git a/packages/@aws-cdk/aws-stepfunctions-tasks/test/codebuild/integ.start-build.expected.json b/packages/@aws-cdk/aws-stepfunctions-tasks/test/codebuild/integ.start-build.expected.json index a3a245b0ddfd8..360eadea837cb 100644 --- a/packages/@aws-cdk/aws-stepfunctions-tasks/test/codebuild/integ.start-build.expected.json +++ b/packages/@aws-cdk/aws-stepfunctions-tasks/test/codebuild/integ.start-build.expected.json @@ -152,7 +152,8 @@ "BuildSpec": "{\n \"version\": \"0.2\",\n \"phases\": {\n \"build\": {\n \"commands\": [\n \"echo \\\"Hello, CodeBuild!\\\"\"\n ]\n }\n }\n}", "Type": "NO_SOURCE" }, - "Name": "MyTestProject" + "Name": "MyTestProject", + "EncryptionKey": "alias/aws/s3" } }, "StateMachineRoleB840431D": { @@ -258,4 +259,4 @@ } } } -} \ No newline at end of file +} diff --git a/packages/@aws-cdk/cloudformation-include/lib/cfn-include.ts b/packages/@aws-cdk/cloudformation-include/lib/cfn-include.ts index aad5c653c3693..becb5666c3653 100644 --- a/packages/@aws-cdk/cloudformation-include/lib/cfn-include.ts +++ b/packages/@aws-cdk/cloudformation-include/lib/cfn-include.ts @@ -589,8 +589,8 @@ export class CfnInclude extends core.CfnElement { // fail early for resource attributes we don't support yet const knownAttributes = [ - 'Type', 'Properties', 'Condition', 'DependsOn', 'Metadata', 'Version', - 'CreationPolicy', 'UpdatePolicy', 'DeletionPolicy', 'UpdateReplacePolicy', + 'Condition', 'DependsOn', 'Description', 'Metadata', 'Properties', 'Type', 'Version', + 'CreationPolicy', 'DeletionPolicy', 'UpdatePolicy', 'UpdateReplacePolicy', ]; for (const attribute of Object.keys(resourceAttributes)) { if (!knownAttributes.includes(attribute)) { diff --git a/packages/@aws-cdk/cloudformation-include/test/test-templates/custom-resource-with-attributes.json b/packages/@aws-cdk/cloudformation-include/test/test-templates/custom-resource-with-attributes.json index c490a16515944..b1dcf4d219bf1 100644 --- a/packages/@aws-cdk/cloudformation-include/test/test-templates/custom-resource-with-attributes.json +++ b/packages/@aws-cdk/cloudformation-include/test/test-templates/custom-resource-with-attributes.json @@ -28,6 +28,7 @@ }, "CustomResource": { "Type": "AWS::CloudFormation::CustomResource", + "Description": "some random custom resource", "Properties": { "ServiceToken": "CustomValue", "CustomFuncProp": { diff --git a/packages/@aws-cdk/cloudformation-include/test/test-templates/get-att-string-form.json b/packages/@aws-cdk/cloudformation-include/test/test-templates/get-att-string-form.json new file mode 100644 index 0000000000000..c76fc888ba6a6 --- /dev/null +++ b/packages/@aws-cdk/cloudformation-include/test/test-templates/get-att-string-form.json @@ -0,0 +1,15 @@ +{ + "Resources": { + "Bucket1": { + "Type": "AWS::S3::Bucket" + }, + "Bucket2": { + "Type": "AWS::S3::Bucket", + "Metadata": { + "Bucket1Arn": { + "Fn::GetAtt": "Bucket1.Arn" + } + } + } + } +} diff --git a/packages/@aws-cdk/cloudformation-include/test/valid-templates.test.ts b/packages/@aws-cdk/cloudformation-include/test/valid-templates.test.ts index 7394ada485266..3072ca6844214 100644 --- a/packages/@aws-cdk/cloudformation-include/test/valid-templates.test.ts +++ b/packages/@aws-cdk/cloudformation-include/test/valid-templates.test.ts @@ -232,6 +232,14 @@ describe('CDK Include', () => { ); }); + test('can ingest a JSON template with string-form Fn::GetAtt, and output it unchanged', () => { + includeTestTemplate(stack, 'get-att-string-form.json'); + + expect(stack).toMatchTemplate( + loadTestFileToJsObject('get-att-string-form.json'), + ); + }); + test('can ingest a template with Fn::Sub in string form with escaped and unescaped references and output it unchanged', () => { includeTestTemplate(stack, 'fn-sub-string.json'); diff --git a/packages/@aws-cdk/cloudformation-include/test/yaml-templates.test.ts b/packages/@aws-cdk/cloudformation-include/test/yaml-templates.test.ts index 84f3fb43ab4bc..664b558841832 100644 --- a/packages/@aws-cdk/cloudformation-include/test/yaml-templates.test.ts +++ b/packages/@aws-cdk/cloudformation-include/test/yaml-templates.test.ts @@ -140,7 +140,7 @@ describe('CDK Include', () => { "Bucket1": { "Type": "AWS::S3::Bucket", "Properties": { - "BucketName": { "Fn::GetAtt": ["Bucket0", "Arn"] }, + "BucketName": { "Fn::GetAtt": "Bucket0.Arn" }, "AccessControl": { "Fn::GetAtt": ["ELB", "SourceSecurityGroup.GroupName"] }, }, }, @@ -148,7 +148,7 @@ describe('CDK Include', () => { "Type": "AWS::S3::Bucket", "Properties": { "BucketName": { "Fn::GetAtt": ["Bucket1", "Arn"] }, - "AccessControl": { "Fn::GetAtt": ["ELB", "SourceSecurityGroup.GroupName"] }, + "AccessControl": { "Fn::GetAtt": "ELB.SourceSecurityGroup.GroupName" }, }, }, }, diff --git a/packages/@aws-cdk/core/lib/cfn-parse.ts b/packages/@aws-cdk/core/lib/cfn-parse.ts index 7a18378556b9d..886a9228b3d0a 100644 --- a/packages/@aws-cdk/core/lib/cfn-parse.ts +++ b/packages/@aws-cdk/core/lib/cfn-parse.ts @@ -10,7 +10,7 @@ import { } from './cfn-resource-policy'; import { CfnTag } from './cfn-tag'; import { Lazy } from './lazy'; -import { CfnReference } from './private/cfn-reference'; +import { CfnReference, ReferenceRendering } from './private/cfn-reference'; import { IResolvable } from './resolvable'; import { Mapper, Validator } from './runtime'; import { isResolvableObject, Token } from './token'; @@ -285,6 +285,7 @@ export class CfnParser { cfnOptions.deletionPolicy = this.parseDeletionPolicy(resourceAttributes.DeletionPolicy); cfnOptions.updateReplacePolicy = this.parseDeletionPolicy(resourceAttributes.UpdateReplacePolicy); cfnOptions.version = this.parseValue(resourceAttributes.Version); + cfnOptions.description = this.parseValue(resourceAttributes.Description); cfnOptions.metadata = this.parseValue(resourceAttributes.Metadata); // handle Condition @@ -457,13 +458,29 @@ export class CfnParser { } } case 'Fn::GetAtt': { - // Fn::GetAtt takes a 2-element list as its argument const value = object[key]; - const target = this.finder.findResource(value[0]); + let logicalId: string, attributeName: string, stringForm: boolean; + // Fn::GetAtt takes as arguments either a string... + if (typeof value === 'string') { + // ...in which case the logical ID and the attribute name are separated with '.' + const dotIndex = value.indexOf('.'); + if (dotIndex === -1) { + throw new Error(`Short-form Fn::GetAtt must contain a '.' in its string argument, got: '${value}'`); + } + logicalId = value.substr(0, dotIndex); + attributeName = value.substr(dotIndex + 1); // the +1 is to skip the actual '.' + stringForm = true; + } else { + // ...or a 2-element list + logicalId = value[0]; + attributeName = value[1]; + stringForm = false; + } + const target = this.finder.findResource(logicalId); if (!target) { - throw new Error(`Resource used in GetAtt expression with logical ID: '${value[0]}' not found`); + throw new Error(`Resource used in GetAtt expression with logical ID: '${logicalId}' not found`); } - return target.getAtt(value[1]); + return CfnReference.for(target, attributeName, stringForm ? ReferenceRendering.GET_ATT_STRING : undefined); } case 'Fn::Join': { // Fn::Join takes a 2-element list as its argument, @@ -618,7 +635,7 @@ export class CfnParser { if (!refElement) { throw new Error(`Element referenced in Fn::Sub expression with logical ID: '${refTarget}' was not found in the template`); } - return leftHalf + CfnReference.for(refElement, 'Ref', true).toString() + this.parseFnSubString(rightHalf, map); + return leftHalf + CfnReference.for(refElement, 'Ref', ReferenceRendering.FN_SUB).toString() + this.parseFnSubString(rightHalf, map); } else { const targetId = refTarget.substring(0, dotIndex); const refResource = this.finder.findResource(targetId); @@ -626,7 +643,7 @@ export class CfnParser { throw new Error(`Resource referenced in Fn::Sub expression with logical ID: '${targetId}' was not found in the template`); } const attribute = refTarget.substring(dotIndex + 1); - return leftHalf + CfnReference.for(refResource, attribute, true).toString() + this.parseFnSubString(rightHalf, map); + return leftHalf + CfnReference.for(refResource, attribute, ReferenceRendering.FN_SUB).toString() + this.parseFnSubString(rightHalf, map); } } diff --git a/packages/@aws-cdk/core/lib/cfn-resource.ts b/packages/@aws-cdk/core/lib/cfn-resource.ts index fcb1c95eaf5bb..f5049bdcd2326 100644 --- a/packages/@aws-cdk/core/lib/cfn-resource.ts +++ b/packages/@aws-cdk/core/lib/cfn-resource.ts @@ -301,6 +301,7 @@ export class CfnResource extends CfnRefElement { UpdateReplacePolicy: capitalizePropertyNames(this, this.cfnOptions.updateReplacePolicy), DeletionPolicy: capitalizePropertyNames(this, this.cfnOptions.deletionPolicy), Version: this.cfnOptions.version, + Description: this.cfnOptions.description, Metadata: ignoreEmpty(this.cfnOptions.metadata), Condition: this.cfnOptions.condition && this.cfnOptions.condition.logicalId, }, props => { @@ -438,6 +439,14 @@ export interface ICfnResourceOptions { */ version?: string; + /** + * The description of this resource. + * Used for informational purposes only, is not processed in any way + * (and stays with the CloudFormation template, is not passed to the underlying resource, + * even if it does have a 'description' property). + */ + description?: string; + /** * Metadata associated with the CloudFormation resource. This is not the same as the construct metadata which can be added * using construct.addMetadata(), but would not appear in the CloudFormation template automatically. diff --git a/packages/@aws-cdk/core/lib/private/cfn-reference.ts b/packages/@aws-cdk/core/lib/private/cfn-reference.ts index 201b5bebfa7d3..b25597602f6b6 100644 --- a/packages/@aws-cdk/core/lib/private/cfn-reference.ts +++ b/packages/@aws-cdk/core/lib/private/cfn-reference.ts @@ -2,6 +2,24 @@ import { Reference } from '../reference'; const CFN_REFERENCE_SYMBOL = Symbol.for('@aws-cdk/core.CfnReference'); +/** + * An enum that allows controlling how will the created reference + * be rendered in the resulting CloudFormation template. + */ +export enum ReferenceRendering { + /** + * Used for rendering a reference inside Fn::Sub expressions, + * which mean these must resolve to "${Sth}" instead of { Ref: "Sth" }. + */ + FN_SUB, + + /** + * Used for rendering Fn::GetAtt with its arguments in string form + * (as opposed to the more common arguments in array form, which we render by default). + */ + GET_ATT_STRING, +} + /** * A Token that represents a CloudFormation reference to another resource * @@ -34,14 +52,19 @@ export class CfnReference extends Reference { * * Lazy.stringValue({ produce: () => new CfnReference(...) }) * - * If fnSub is true, then this reference will resolve as ${logicalID}. - * This allows cloudformation-include to correctly handle Fn::Sub. */ - public static for(target: CfnElement, attribute: string, fnSub: boolean = false) { - return CfnReference.singletonReference(target, attribute, fnSub, () => { - const cfnIntrinsic = fnSub + public static for(target: CfnElement, attribute: string, refRender?: ReferenceRendering) { + return CfnReference.singletonReference(target, attribute, refRender, () => { + const cfnIntrinsic = refRender === ReferenceRendering.FN_SUB ? ('${' + target.logicalId + (attribute === 'Ref' ? '' : `.${attribute}`) + '}') - : (attribute === 'Ref' ? { Ref: target.logicalId } : { 'Fn::GetAtt': [target.logicalId, attribute] }); + : (attribute === 'Ref' + ? { Ref: target.logicalId } + : { + 'Fn::GetAtt': refRender === ReferenceRendering.GET_ATT_STRING + ? `${target.logicalId}.${attribute}` + : [target.logicalId, attribute], + } + ); return new CfnReference(cfnIntrinsic, attribute, target); }); } @@ -50,7 +73,7 @@ export class CfnReference extends Reference { * Return a CfnReference that references a pseudo referencd */ public static forPseudo(pseudoName: string, scope: Construct) { - return CfnReference.singletonReference(scope, `Pseudo:${pseudoName}`, false, () => { + return CfnReference.singletonReference(scope, `Pseudo:${pseudoName}`, undefined, () => { const cfnIntrinsic = { Ref: pseudoName }; return new CfnReference(cfnIntrinsic, pseudoName, scope); }); @@ -65,13 +88,21 @@ export class CfnReference extends Reference { * Get or create the table. * Passing fnSub = true allows cloudformation-include to correctly handle Fn::Sub. */ - private static singletonReference(target: Construct, attribKey: string, fnSub: boolean, fresh: () => CfnReference) { + private static singletonReference(target: Construct, attribKey: string, refRender: ReferenceRendering | undefined, fresh: () => CfnReference) { let attribs = CfnReference.referenceTable.get(target); if (!attribs) { attribs = new Map(); CfnReference.referenceTable.set(target, attribs); } - const cacheKey = attribKey + (fnSub ? 'Fn::Sub' : ''); + let cacheKey = attribKey; + switch (refRender) { + case ReferenceRendering.FN_SUB: + cacheKey += 'Fn::Sub'; + break; + case ReferenceRendering.GET_ATT_STRING: + cacheKey += 'Fn::GetAtt::String'; + break; + } let ref = attribs.get(cacheKey); if (!ref) { ref = fresh(); diff --git a/packages/@aws-cdk/yaml-cfn/lib/yaml.ts b/packages/@aws-cdk/yaml-cfn/lib/yaml.ts index 0a613f5aa7e14..eca37db0ed048 100644 --- a/packages/@aws-cdk/yaml-cfn/lib/yaml.ts +++ b/packages/@aws-cdk/yaml-cfn/lib/yaml.ts @@ -29,54 +29,26 @@ export function deserialize(str: string): any { return parseYamlStrWithCfnTags(str); } -function makeTagForCfnIntrinsic( - intrinsicName: string, addFnPrefix: boolean = true, - resolveFun?: (_doc: yaml.Document, cstNode: yaml_cst.CST.Node) => any): yaml_types.Schema.CustomTag { - +function makeTagForCfnIntrinsic(intrinsicName: string, addFnPrefix: boolean): yaml_types.Schema.CustomTag { return { identify(value: any) { return typeof value === 'string'; }, tag: `!${intrinsicName}`, - resolve: resolveFun || ((_doc: yaml.Document, cstNode: yaml_cst.CST.Node) => { + resolve: (_doc: yaml.Document, cstNode: yaml_cst.CST.Node) => { const ret: any = {}; ret[addFnPrefix ? `Fn::${intrinsicName}` : intrinsicName] = // the +1 is to account for the ! the short form begins with parseYamlStrWithCfnTags(cstNode.toString().substring(intrinsicName.length + 1)); return ret; - }), + }, }; } const shortForms: yaml_types.Schema.CustomTag[] = [ 'Base64', 'Cidr', 'FindInMap', 'GetAZs', 'ImportValue', 'Join', 'Sub', - 'Select', 'Split', 'Transform', 'And', 'Equals', 'If', 'Not', 'Or', -].map(name => makeTagForCfnIntrinsic(name)).concat( + 'Select', 'Split', 'Transform', 'And', 'Equals', 'If', 'Not', 'Or', 'GetAtt', +].map(name => makeTagForCfnIntrinsic(name, true)).concat( makeTagForCfnIntrinsic('Ref', false), makeTagForCfnIntrinsic('Condition', false), - makeTagForCfnIntrinsic('GetAtt', true, (_doc: yaml.Document, cstNode: yaml_cst.CST.Node): any => { - const parsedArguments = parseYamlStrWithCfnTags(cstNode.toString().substring('!GetAtt'.length)); - - let value: any; - if (typeof parsedArguments === 'string') { - // if the arguments to !GetAtt are a string, - // the part before the first '.' is the logical ID, - // and the rest is the attribute name - // (which can contain '.') - const firstDot = parsedArguments.indexOf('.'); - if (firstDot === -1) { - throw new Error(`Short-form Fn::GetAtt must contain a '.' in its string argument, got: '${parsedArguments}'`); - } - value = [ - parsedArguments.substring(0, firstDot), - parsedArguments.substring(firstDot + 1), // the + 1 is to skip the actual '.' - ]; - } else { - // this is the form where the arguments to Fn::GetAtt are already an array - - // in this case, nothing more to do - value = parsedArguments; - } - - return { 'Fn::GetAtt': value }; - }), ); function parseYamlStrWithCfnTags(text: string): any { diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md new file mode 100644 index 0000000000000..1cb31072ab5de --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md @@ -0,0 +1,3 @@ +Added a `-v` switch to the cdk executions that also needs to be +applied to the regression tests so we have a better chance +of catching sporadically failing tests in the act. \ No newline at end of file diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js new file mode 100644 index 0000000000000..da45aebb27469 --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js @@ -0,0 +1,325 @@ +"use strict"; +var _a, _b; +Object.defineProperty(exports, "__esModule", { value: true }); +const child_process = require("child_process"); +const fs = require("fs"); +const os = require("os"); +const path = require("path"); +const aws_helpers_1 = require("./aws-helpers"); +const resource_pool_1 = require("./resource-pool"); +const REGIONS = process.env.AWS_REGIONS +? process.env.AWS_REGIONS.split(',') +: [(_b = (_a = process.env.AWS_REGION) !== null && _a !== void 0 ? _a : process.env.AWS_DEFAULT_REGION) !== null && _b !== void 0 ? _b : 'us-east-1']; +process.stdout.write(`Using regions: ${REGIONS}\n`); +const REGION_POOL = new resource_pool_1.ResourcePool(REGIONS); +/** + * Higher order function to execute a block with an AWS client setup + * + * Allocate the next region from the REGION pool and dispose it afterwards. + */ +function withAws(block) { +return (context) => REGION_POOL.using(async (region) => { + const aws = await aws_helpers_1.AwsClients.forRegion(region, context.output); + await sanityCheck(aws); + return block({ ...context, aws }); +}); +} +exports.withAws = withAws; +/** + * Higher order function to execute a block with a CDK app fixture + * + * Requires an AWS client to be passed in. + * + * For backwards compatibility with existing tests (so we don't have to change + * too much) the inner block is expected to take a `TestFixture` object. + */ +function withCdkApp(block) { +return async (context) => { + const randy = randomString(); + const stackNamePrefix = `cdktest-${randy}`; + const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`); + context.output.write(` Stack prefix: ${stackNamePrefix}\n`); + context.output.write(` Test directory: ${integTestDir}\n`); + context.output.write(` Region: ${context.aws.region}\n`); + await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output); + const fixture = new TestFixture(integTestDir, stackNamePrefix, context.output, context.aws); + let success = true; + try { + await fixture.shell(['npm', 'install', + '@aws-cdk/core', + '@aws-cdk/aws-sns', + '@aws-cdk/aws-iam', + '@aws-cdk/aws-lambda', + '@aws-cdk/aws-ssm', + '@aws-cdk/aws-ecr-assets', + '@aws-cdk/aws-cloudformation', + '@aws-cdk/aws-ec2']); + await ensureBootstrapped(fixture); + await block(fixture); + } + catch (e) { + success = false; + throw e; + } + finally { + await fixture.dispose(success); + } +}; +} +exports.withCdkApp = withCdkApp; +/** + * Default test fixture for most (all?) integ tests + * + * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture` + * object. + * + * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every + * test declaration but centralizing it is going to make it convenient to modify in the future. + */ +function withDefaultFixture(block) { +return withAws(withCdkApp(block)); +// ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this. +} +exports.withDefaultFixture = withDefaultFixture; +/** + * Prepare a target dir byreplicating a source directory + */ +async function cloneDirectory(source, target, output) { +await shell(['rm', '-rf', target], { output }); +await shell(['mkdir', '-p', target], { output }); +await shell(['cp', '-R', source + '/*', target], { output }); +} +exports.cloneDirectory = cloneDirectory; +class TestFixture { +constructor(integTestDir, stackNamePrefix, output, aws) { + this.integTestDir = integTestDir; + this.stackNamePrefix = stackNamePrefix; + this.output = output; + this.aws = aws; + this.qualifier = randomString().substr(0, 10); + this.bucketsToDelete = new Array(); +} +log(s) { + this.output.write(`${s}\n`); +} +async shell(command, options = {}) { + return shell(command, { + output: this.output, + cwd: this.integTestDir, + ...options, + }); +} +async cdkDeploy(stackNames, options = {}) { + var _a, _b; + stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames; + const neverRequireApproval = (_a = options.neverRequireApproval) !== null && _a !== void 0 ? _a : true; + return this.cdk(['deploy', + ...(neverRequireApproval ? ['--require-approval=never'] : []), + ...((_b = options.options) !== null && _b !== void 0 ? _b : []), + ...this.fullStackName(stackNames)], options); +} +async cdkDestroy(stackNames, options = {}) { + var _a; + stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames; + return this.cdk(['destroy', + '-f', + ...((_a = options.options) !== null && _a !== void 0 ? _a : []), + ...this.fullStackName(stackNames)], options); +} +async cdk(args, options = {}) { + var _a; + const verbose = (_a = options.verbose) !== null && _a !== void 0 ? _a : true; + return this.shell(['cdk', ...(verbose ? ['-v'] : []), ...args], { + ...options, + modEnv: { + AWS_REGION: this.aws.region, + AWS_DEFAULT_REGION: this.aws.region, + STACK_NAME_PREFIX: this.stackNamePrefix, + ...options.modEnv, + }, + }); +} +fullStackName(stackNames) { + if (typeof stackNames === 'string') { + return `${this.stackNamePrefix}-${stackNames}`; + } + else { + return stackNames.map(s => `${this.stackNamePrefix}-${s}`); + } +} +/** + * Append this to the list of buckets to potentially delete + * + * At the end of a test, we clean up buckets that may not have gotten destroyed + * (for whatever reason). + */ +rememberToDeleteBucket(bucketName) { + this.bucketsToDelete.push(bucketName); +} +/** + * Cleanup leftover stacks and buckets + */ +async dispose(success) { + const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix); + // Bootstrap stacks have buckets that need to be cleaned + const bucketNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('BucketName', stack)).filter(defined); + await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b))); + // Bootstrap stacks have ECR repositories with images which should be deleted + const imageRepositoryNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('ImageRepositoryName', stack)).filter(defined); + await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r))); + await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName)); + // We might have leaked some buckets by upgrading the bootstrap stack. Be + // sure to clean everything. + for (const bucket of this.bucketsToDelete) { + await this.aws.deleteBucket(bucket); + } + // If the tests completed successfully, happily delete the fixture + // (otherwise leave it for humans to inspect) + if (success) { + rimraf(this.integTestDir); + } +} +/** + * Return the stacks starting with our testing prefix that should be deleted + */ +async deleteableStacks(prefix) { + var _a; + const statusFilter = [ + 'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE', + 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE', + 'DELETE_FAILED', + 'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS', + 'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS', + 'UPDATE_ROLLBACK_FAILED', + 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS', + 'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS', + 'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE', + 'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED', + 'IMPORT_ROLLBACK_COMPLETE', + ]; + const response = await this.aws.cloudFormation('describeStacks', {}); + return ((_a = response.Stacks) !== null && _a !== void 0 ? _a : []) + .filter(s => s.StackName.startsWith(prefix)) + .filter(s => statusFilter.includes(s.StackStatus)) + .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process +} +} +exports.TestFixture = TestFixture; +/** + * Perform a one-time quick sanity check that the AWS clients has properly configured credentials + * + * If we don't do this, calls are going to fail and they'll be retried and everything will take + * forever before the user notices a simple misconfiguration. + * + * We can't check for the presence of environment variables since credentials could come from + * anywhere, so do simple account retrieval. + * + * Only do it once per process. + */ +async function sanityCheck(aws) { +if (sanityChecked === undefined) { + try { + await aws.account(); + sanityChecked = true; + } + catch (e) { + sanityChecked = false; + throw new Error(`AWS credentials probably not configured, got error: ${e.message}`); + } +} +if (!sanityChecked) { + throw new Error('AWS credentials probably not configured, see previous error'); +} +} +let sanityChecked; +/** + * Make sure that the given environment is bootstrapped + * + * Since we go striping across regions, it's going to suck doing this + * by hand so let's just mass-automate it. + */ +async function ensureBootstrapped(fixture) { +// Old-style bootstrap stack with default name +if (await fixture.aws.stackStatus('CDKToolkit') === undefined) { + await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]); +} +} +/** + * A shell command that does what you want + * + * Is platform-aware, handles errors nicely. + */ +async function shell(command, options = {}) { +var _a, _b; +if (options.modEnv && options.env) { + throw new Error('Use either env or modEnv but not both'); +} +(_a = options.output) === null || _a === void 0 ? void 0 : _a.write(`💻 ${command.join(' ')}\n`); +const env = (_b = options.env) !== null && _b !== void 0 ? _b : (options.modEnv ? { ...process.env, ...options.modEnv } : undefined); +const child = child_process.spawn(command[0], command.slice(1), { + ...options, + env, + // Need this for Windows where we want .cmd and .bat to be found as well. + shell: true, + stdio: ['ignore', 'pipe', 'pipe'], +}); +return new Promise((resolve, reject) => { + const stdout = new Array(); + const stderr = new Array(); + child.stdout.on('data', chunk => { + var _a; + (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk); + stdout.push(chunk); + }); + child.stderr.on('data', chunk => { + var _a, _b; + (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk); + if ((_b = options.captureStderr) !== null && _b !== void 0 ? _b : true) { + stderr.push(chunk); + } + }); + child.once('error', reject); + child.once('close', code => { + if (code === 0 || options.allowErrExit) { + resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim()); + } + else { + reject(new Error(`'${command.join(' ')}' exited with error code ${code}`)); + } + }); +}); +} +exports.shell = shell; +function defined(x) { +return x !== undefined; +} +/** + * rm -rf reimplementation, don't want to depend on an NPM package for this + */ +function rimraf(fsPath) { +try { + const isDir = fs.lstatSync(fsPath).isDirectory(); + if (isDir) { + for (const file of fs.readdirSync(fsPath)) { + rimraf(path.join(fsPath, file)); + } + fs.rmdirSync(fsPath); + } + else { + fs.unlinkSync(fsPath); + } +} +catch (e) { + // We will survive ENOENT + if (e.code !== 'ENOENT') { + throw e; + } +} +} +exports.rimraf = rimraf; +function randomString() { +// Crazy +return Math.random().toString(36).replace(/[^a-z0-9]+/g, ''); +} +exports.randomString = randomString; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-helpers.js","sourceRoot":"","sources":["cdk-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from 'child_process';\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { outputFromStack, AwsClients } from './aws-helpers';\nimport { ResourcePool } from './resource-pool';\nimport { TestContext } from './test-helpers';\n\nconst REGIONS = process.env.AWS_REGIONS\n  ? process.env.AWS_REGIONS.split(',')\n  : [process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1'];\n\nprocess.stdout.write(`Using regions: ${REGIONS}\\n`);\n\nconst REGION_POOL = new ResourcePool(REGIONS);\n\n\nexport type AwsContext = { readonly aws: AwsClients };\n\n/**\n * Higher order function to execute a block with an AWS client setup\n *\n * Allocate the next region from the REGION pool and dispose it afterwards.\n */\nexport function withAws<A extends TestContext>(block: (context: A & AwsContext) => Promise<void>) {\n  return (context: A) => REGION_POOL.using(async (region) => {\n    const aws = await AwsClients.forRegion(region, context.output);\n    await sanityCheck(aws);\n\n    return block({ ...context, aws });\n  });\n}\n\n/**\n * Higher order function to execute a block with a CDK app fixture\n *\n * Requires an AWS client to be passed in.\n *\n * For backwards compatibility with existing tests (so we don't have to change\n * too much) the inner block is expected to take a `TestFixture` object.\n */\nexport function withCdkApp<A extends TestContext & AwsContext>(block: (context: TestFixture) => Promise<void>) {\n  return async (context: A) => {\n    const randy = randomString();\n    const stackNamePrefix = `cdktest-${randy}`;\n    const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`);\n\n    context.output.write(` Stack prefix:   ${stackNamePrefix}\\n`);\n    context.output.write(` Test directory: ${integTestDir}\\n`);\n    context.output.write(` Region:         ${context.aws.region}\\n`);\n\n    await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output);\n    const fixture = new TestFixture(\n      integTestDir,\n      stackNamePrefix,\n      context.output,\n      context.aws);\n\n    let success = true;\n    try {\n      await fixture.shell(['npm', 'install',\n        '@aws-cdk/core',\n        '@aws-cdk/aws-sns',\n        '@aws-cdk/aws-iam',\n        '@aws-cdk/aws-lambda',\n        '@aws-cdk/aws-ssm',\n        '@aws-cdk/aws-ecr-assets',\n        '@aws-cdk/aws-cloudformation',\n        '@aws-cdk/aws-ec2']);\n\n      await ensureBootstrapped(fixture);\n\n      await block(fixture);\n    } catch (e) {\n      success = false;\n      throw e;\n    } finally {\n      await fixture.dispose(success);\n    }\n  };\n}\n\n/**\n * Default test fixture for most (all?) integ tests\n *\n * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture`\n * object.\n *\n * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every\n * test declaration but centralizing it is going to make it convenient to modify in the future.\n */\nexport function withDefaultFixture(block: (context: TestFixture) => Promise<void>) {\n  return withAws<TestContext>(withCdkApp(block));\n  //              ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this.\n}\n\nexport interface ShellOptions extends child_process.SpawnOptions {\n  /**\n   * Properties to add to 'env'\n   */\n  modEnv?: Record<string, string>;\n\n  /**\n   * Don't fail when exiting with an error\n   *\n   * @default false\n   */\n  allowErrExit?: boolean;\n\n  /**\n   * Whether to capture stderr\n   *\n   * @default true\n   */\n  captureStderr?: boolean;\n\n  /**\n   * Pass output here\n   */\n  output?: NodeJS.WritableStream;\n}\n\nexport interface CdkCliOptions extends ShellOptions {\n  options?: string[];\n  neverRequireApproval?: boolean;\n  verbose?: boolean;\n}\n\n/**\n * Prepare a target dir byreplicating a source directory\n */\nexport async function cloneDirectory(source: string, target: string, output?: NodeJS.WritableStream) {\n  await shell(['rm', '-rf', target], { output });\n  await shell(['mkdir', '-p', target], { output });\n  await shell(['cp', '-R', source + '/*', target], { output });\n}\n\nexport class TestFixture {\n  public readonly qualifier = randomString().substr(0, 10);\n  private readonly bucketsToDelete = new Array<string>();\n\n  constructor(\n    public readonly integTestDir: string,\n    public readonly stackNamePrefix: string,\n    public readonly output: NodeJS.WritableStream,\n    public readonly aws: AwsClients) {\n  }\n\n  public log(s: string) {\n    this.output.write(`${s}\\n`);\n  }\n\n  public async shell(command: string[], options: Omit<ShellOptions, 'cwd'|'output'> = {}): Promise<string> {\n    return shell(command, {\n      output: this.output,\n      cwd: this.integTestDir,\n      ...options,\n    });\n  }\n\n  public async cdkDeploy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    const neverRequireApproval = options.neverRequireApproval ?? true;\n\n    return this.cdk(['deploy',\n      ...(neverRequireApproval ? ['--require-approval=never'] : []), // Default to no approval in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdkDestroy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    return this.cdk(['destroy',\n      '-f', // We never want a prompt in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdk(args: string[], options: CdkCliOptions = {}) {\n    const verbose = options.verbose ?? true;\n\n    return this.shell(['cdk', ...(verbose ? ['-v'] : []), ...args], {\n      ...options,\n      modEnv: {\n        AWS_REGION: this.aws.region,\n        AWS_DEFAULT_REGION: this.aws.region,\n        STACK_NAME_PREFIX: this.stackNamePrefix,\n        ...options.modEnv,\n      },\n    });\n  }\n\n  public fullStackName(stackName: string): string;\n  public fullStackName(stackNames: string[]): string[];\n  public fullStackName(stackNames: string | string[]): string | string[] {\n    if (typeof stackNames === 'string') {\n      return `${this.stackNamePrefix}-${stackNames}`;\n    } else {\n      return stackNames.map(s => `${this.stackNamePrefix}-${s}`);\n    }\n  }\n\n  /**\n   * Append this to the list of buckets to potentially delete\n   *\n   * At the end of a test, we clean up buckets that may not have gotten destroyed\n   * (for whatever reason).\n   */\n  public rememberToDeleteBucket(bucketName: string) {\n    this.bucketsToDelete.push(bucketName);\n  }\n\n  /**\n   * Cleanup leftover stacks and buckets\n   */\n  public async dispose(success: boolean) {\n    const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix);\n\n    // Bootstrap stacks have buckets that need to be cleaned\n    const bucketNames = stacksToDelete.map(stack => outputFromStack('BucketName', stack)).filter(defined);\n    await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b)));\n\n    // Bootstrap stacks have ECR repositories with images which should be deleted\n    const imageRepositoryNames = stacksToDelete.map(stack => outputFromStack('ImageRepositoryName', stack)).filter(defined);\n    await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r)));\n\n    await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName));\n\n    // We might have leaked some buckets by upgrading the bootstrap stack. Be\n    // sure to clean everything.\n    for (const bucket of this.bucketsToDelete) {\n      await this.aws.deleteBucket(bucket);\n    }\n\n    // If the tests completed successfully, happily delete the fixture\n    // (otherwise leave it for humans to inspect)\n    if (success) {\n      rimraf(this.integTestDir);\n    }\n  }\n\n  /**\n   * Return the stacks starting with our testing prefix that should be deleted\n   */\n  private async deleteableStacks(prefix: string): Promise<AWS.CloudFormation.Stack[]> {\n    const statusFilter = [\n      'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE',\n      'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE',\n      'DELETE_FAILED',\n      'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS',\n      'UPDATE_ROLLBACK_FAILED',\n      'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS',\n      'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE',\n      'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED',\n      'IMPORT_ROLLBACK_COMPLETE',\n    ];\n\n    const response = await this.aws.cloudFormation('describeStacks', {});\n\n    return (response.Stacks ?? [])\n      .filter(s => s.StackName.startsWith(prefix))\n      .filter(s => statusFilter.includes(s.StackStatus))\n      .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process\n  }\n}\n\n/**\n * Perform a one-time quick sanity check that the AWS clients has properly configured credentials\n *\n * If we don't do this, calls are going to fail and they'll be retried and everything will take\n * forever before the user notices a simple misconfiguration.\n *\n * We can't check for the presence of environment variables since credentials could come from\n * anywhere, so do simple account retrieval.\n *\n * Only do it once per process.\n */\nasync function sanityCheck(aws: AwsClients) {\n  if (sanityChecked === undefined) {\n    try {\n      await aws.account();\n      sanityChecked = true;\n    } catch (e) {\n      sanityChecked = false;\n      throw new Error(`AWS credentials probably not configured, got error: ${e.message}`);\n    }\n  }\n  if (!sanityChecked) {\n    throw new Error('AWS credentials probably not configured, see previous error');\n  }\n}\nlet sanityChecked: boolean | undefined;\n\n/**\n * Make sure that the given environment is bootstrapped\n *\n * Since we go striping across regions, it's going to suck doing this\n * by hand so let's just mass-automate it.\n */\nasync function ensureBootstrapped(fixture: TestFixture) {\n  // Old-style bootstrap stack with default name\n  if (await fixture.aws.stackStatus('CDKToolkit') === undefined) {\n    await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]);\n  }\n}\n\n/**\n * A shell command that does what you want\n *\n * Is platform-aware, handles errors nicely.\n */\nexport async function shell(command: string[], options: ShellOptions = {}): Promise<string> {\n  if (options.modEnv && options.env) {\n    throw new Error('Use either env or modEnv but not both');\n  }\n\n  options.output?.write(`💻 ${command.join(' ')}\\n`);\n\n  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : undefined);\n\n  const child = child_process.spawn(command[0], command.slice(1), {\n    ...options,\n    env,\n    // Need this for Windows where we want .cmd and .bat to be found as well.\n    shell: true,\n    stdio: ['ignore', 'pipe', 'pipe'],\n  });\n\n  return new Promise<string>((resolve, reject) => {\n    const stdout = new Array<Buffer>();\n    const stderr = new Array<Buffer>();\n\n    child.stdout!.on('data', chunk => {\n      options.output?.write(chunk);\n      stdout.push(chunk);\n    });\n\n    child.stderr!.on('data', chunk => {\n      options.output?.write(chunk);\n      if (options.captureStderr ?? true) {\n        stderr.push(chunk);\n      }\n    });\n\n    child.once('error', reject);\n\n    child.once('close', code => {\n      if (code === 0 || options.allowErrExit) {\n        resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim());\n      } else {\n        reject(new Error(`'${command.join(' ')}' exited with error code ${code}`));\n      }\n    });\n  });\n}\n\nfunction defined<A>(x: A): x is NonNullable<A> {\n  return x !== undefined;\n}\n\n/**\n * rm -rf reimplementation, don't want to depend on an NPM package for this\n */\nexport function rimraf(fsPath: string) {\n  try {\n    const isDir = fs.lstatSync(fsPath).isDirectory();\n\n    if (isDir) {\n      for (const file of fs.readdirSync(fsPath)) {\n        rimraf(path.join(fsPath, file));\n      }\n      fs.rmdirSync(fsPath);\n    } else {\n      fs.unlinkSync(fsPath);\n    }\n  } catch (e) {\n    // We will survive ENOENT\n    if (e.code !== 'ENOENT') { throw e; }\n  }\n}\n\nexport function randomString() {\n  // Crazy\n  return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');\n}"]} \ No newline at end of file diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cli.integtest.js b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cli.integtest.js new file mode 100644 index 0000000000000..a63578ecfaee1 --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cli.integtest.js @@ -0,0 +1,599 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const fs_1 = require("fs"); +const os = require("os"); +const path = require("path"); +const aws_helpers_1 = require("./aws-helpers"); +const cdk_helpers_1 = require("./cdk-helpers"); +const test_helpers_1 = require("./test-helpers"); +jest.setTimeout(600 * 1000); +test_helpers_1.integTest('VPC Lookup', cdk_helpers_1.withDefaultFixture(async (fixture) => { + fixture.log('Making sure we are clean before starting.'); + await fixture.cdkDestroy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } }); + fixture.log('Setting up: creating a VPC with known tags'); + await fixture.cdkDeploy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } }); + fixture.log('Setup complete!'); + fixture.log('Verifying we can now import that VPC'); + await fixture.cdkDeploy('import-vpc', { modEnv: { ENABLE_VPC_TESTING: 'IMPORT' } }); +})); +test_helpers_1.integTest('Two ways of shoing the version', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const version1 = await fixture.cdk(['version'], { verbose: false }); + const version2 = await fixture.cdk(['--version'], { verbose: false }); + expect(version1).toEqual(version2); +})); +test_helpers_1.integTest('Termination protection', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const stackName = 'termination-protection'; + await fixture.cdkDeploy(stackName); + // Try a destroy that should fail + await expect(fixture.cdkDestroy(stackName)).rejects.toThrow('exited with error'); + // Can update termination protection even though the change set doesn't contain changes + await fixture.cdkDeploy(stackName, { modEnv: { TERMINATION_PROTECTION: 'FALSE' } }); + await fixture.cdkDestroy(stackName); +})); +test_helpers_1.integTest('cdk synth', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await expect(fixture.cdk(['synth', fixture.fullStackName('test-1')], { verbose: false })).resolves.toEqual(`Resources: + topic69831491: + Type: AWS::SNS::Topic + Metadata: + aws:cdk:path: ${fixture.stackNamePrefix}-test-1/topic/Resource`); + await expect(fixture.cdk(['synth', fixture.fullStackName('test-2')], { verbose: false })).resolves.toEqual(`Resources: + topic152D84A37: + Type: AWS::SNS::Topic + Metadata: + aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic1/Resource + topic2A4FB547F: + Type: AWS::SNS::Topic + Metadata: + aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic2/Resource`); +})); +test_helpers_1.integTest('ssm parameter provider error', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await expect(fixture.cdk(['synth', + fixture.fullStackName('missing-ssm-parameter'), + '-c', 'test:ssm-parameter-name=/does/not/exist'], { + allowErrExit: true, + })).resolves.toContain('SSM parameter not available in account'); +})); +test_helpers_1.integTest('automatic ordering', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // Deploy the consuming stack which will include the producing stack + await fixture.cdkDeploy('order-consuming'); + // Destroy the providing stack which will include the consuming stack + await fixture.cdkDestroy('order-providing'); +})); +test_helpers_1.integTest('context setting', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await fs_1.promises.writeFile(path.join(fixture.integTestDir, 'cdk.context.json'), JSON.stringify({ + contextkey: 'this is the context value', + })); + try { + await expect(fixture.cdk(['context'])).resolves.toContain('this is the context value'); + // Test that deleting the contextkey works + await fixture.cdk(['context', '--reset', 'contextkey']); + await expect(fixture.cdk(['context'])).resolves.not.toContain('this is the context value'); + // Test that forced delete of the context key does not throw + await fixture.cdk(['context', '-f', '--reset', 'contextkey']); + } + finally { + await fs_1.promises.unlink(path.join(fixture.integTestDir, 'cdk.context.json')); + } +})); +test_helpers_1.integTest('deploy', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const stackArn = await fixture.cdkDeploy('test-2', { captureStderr: false }); + // verify the number of resources in the stack + const response = await fixture.aws.cloudFormation('describeStackResources', { + StackName: stackArn, + }); + expect((_a = response.StackResources) === null || _a === void 0 ? void 0 : _a.length).toEqual(2); +})); +test_helpers_1.integTest('deploy all', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const arns = await fixture.cdkDeploy('test-*', { captureStderr: false }); + // verify that we only deployed a single stack (there's a single ARN in the output) + expect(arns.split('\n').length).toEqual(2); +})); +test_helpers_1.integTest('nested stack with parameters', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + // STACK_NAME_PREFIX is used in MyTopicParam to allow multiple instances + // of this test to run in parallel, othewise they will attempt to create the same SNS topic. + const stackArn = await fixture.cdkDeploy('with-nested-stack-using-parameters', { + options: ['--parameters', `MyTopicParam=${fixture.stackNamePrefix}ThereIsNoSpoon`], + captureStderr: false, + }); + // verify that we only deployed a single stack (there's a single ARN in the output) + expect(stackArn.split('\n').length).toEqual(1); + // verify the number of resources in the stack + const response = await fixture.aws.cloudFormation('describeStackResources', { + StackName: stackArn, + }); + expect((_a = response.StackResources) === null || _a === void 0 ? void 0 : _a.length).toEqual(1); +})); +test_helpers_1.integTest('deploy without execute', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const stackArn = await fixture.cdkDeploy('test-2', { + options: ['--no-execute'], + captureStderr: false, + }); + // verify that we only deployed a single stack (there's a single ARN in the output) + expect(stackArn.split('\n').length).toEqual(1); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].StackStatus).toEqual('REVIEW_IN_PROGRESS'); +})); +test_helpers_1.integTest('security related changes without a CLI are expected to fail', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // redirect /dev/null to stdin, which means there will not be tty attached + // since this stack includes security-related changes, the deployment should + // immediately fail because we can't confirm the changes + const stackName = 'iam-test'; + await expect(fixture.cdkDeploy(stackName, { + options: ['<', '/dev/null'], + neverRequireApproval: false, + })).rejects.toThrow('exited with error'); + // Ensure stack was not deployed + await expect(fixture.aws.cloudFormation('describeStacks', { + StackName: fixture.fullStackName(stackName), + })).rejects.toThrow('does not exist'); +})); +test_helpers_1.integTest('deploy wildcard with outputs', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const outputsFile = path.join(fixture.integTestDir, 'outputs', 'outputs.json'); + await fs_1.promises.mkdir(path.dirname(outputsFile), { recursive: true }); + await fixture.cdkDeploy(['outputs-test-*'], { + options: ['--outputs-file', outputsFile], + }); + const outputs = JSON.parse((await fs_1.promises.readFile(outputsFile, { encoding: 'utf-8' })).toString()); + expect(outputs).toEqual({ + [`${fixture.stackNamePrefix}-outputs-test-1`]: { + TopicName: `${fixture.stackNamePrefix}-outputs-test-1MyTopic`, + }, + [`${fixture.stackNamePrefix}-outputs-test-2`]: { + TopicName: `${fixture.stackNamePrefix}-outputs-test-2MyOtherTopic`, + }, + }); +})); +test_helpers_1.integTest('deploy with parameters', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const stackArn = await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}bazinga`, + ], + captureStderr: false, + }); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].Parameters).toEqual([ + { + ParameterKey: 'TopicNameParam', + ParameterValue: `${fixture.stackNamePrefix}bazinga`, + }, + ]); +})); +test_helpers_1.integTest('update to stack in ROLLBACK_COMPLETE state will delete stack and create a new one', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a, _b, _c, _d; + // GIVEN + await expect(fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`, + ], + captureStderr: false, + })).rejects.toThrow('exited with error'); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: fixture.fullStackName('param-test-1'), + }); + const stackArn = (_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].StackId; + expect((_b = response.Stacks) === null || _b === void 0 ? void 0 : _b[0].StackStatus).toEqual('ROLLBACK_COMPLETE'); + // WHEN + const newStackArn = await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`, + ], + captureStderr: false, + }); + const newStackResponse = await fixture.aws.cloudFormation('describeStacks', { + StackName: newStackArn, + }); + // THEN + expect(stackArn).not.toEqual(newStackArn); // new stack was created + expect((_c = newStackResponse.Stacks) === null || _c === void 0 ? void 0 : _c[0].StackStatus).toEqual('CREATE_COMPLETE'); + expect((_d = newStackResponse.Stacks) === null || _d === void 0 ? void 0 : _d[0].Parameters).toEqual([ + { + ParameterKey: 'TopicNameParam', + ParameterValue: `${fixture.stackNamePrefix}allgood`, + }, + ]); +})); +test_helpers_1.integTest('stack in UPDATE_ROLLBACK_COMPLETE state can be updated', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a, _b, _c, _d; + // GIVEN + const stackArn = await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}nice`, + ], + captureStderr: false, + }); + let response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].StackStatus).toEqual('CREATE_COMPLETE'); + // bad parameter name with @ will put stack into UPDATE_ROLLBACK_COMPLETE + await expect(fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`, + ], + captureStderr: false, + })).rejects.toThrow('exited with error'); + ; + response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_b = response.Stacks) === null || _b === void 0 ? void 0 : _b[0].StackStatus).toEqual('UPDATE_ROLLBACK_COMPLETE'); + // WHEN + await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`, + ], + captureStderr: false, + }); + response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + // THEN + expect((_c = response.Stacks) === null || _c === void 0 ? void 0 : _c[0].StackStatus).toEqual('UPDATE_COMPLETE'); + expect((_d = response.Stacks) === null || _d === void 0 ? void 0 : _d[0].Parameters).toEqual([ + { + ParameterKey: 'TopicNameParam', + ParameterValue: `${fixture.stackNamePrefix}allgood`, + }, + ]); +})); +test_helpers_1.integTest('deploy with wildcard and parameters', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await fixture.cdkDeploy('param-test-*', { + options: [ + '--parameters', `${fixture.stackNamePrefix}-param-test-1:TopicNameParam=${fixture.stackNamePrefix}bazinga`, + '--parameters', `${fixture.stackNamePrefix}-param-test-2:OtherTopicNameParam=${fixture.stackNamePrefix}ThatsMySpot`, + '--parameters', `${fixture.stackNamePrefix}-param-test-3:DisplayNameParam=${fixture.stackNamePrefix}HeyThere`, + '--parameters', `${fixture.stackNamePrefix}-param-test-3:OtherDisplayNameParam=${fixture.stackNamePrefix}AnotherOne`, + ], + }); +})); +test_helpers_1.integTest('deploy with parameters multi', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const paramVal1 = `${fixture.stackNamePrefix}bazinga`; + const paramVal2 = `${fixture.stackNamePrefix}=jagshemash`; + const stackArn = await fixture.cdkDeploy('param-test-3', { + options: [ + '--parameters', `DisplayNameParam=${paramVal1}`, + '--parameters', `OtherDisplayNameParam=${paramVal2}`, + ], + captureStderr: false, + }); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].Parameters).toEqual([ + { + ParameterKey: 'DisplayNameParam', + ParameterValue: paramVal1, + }, + { + ParameterKey: 'OtherDisplayNameParam', + ParameterValue: paramVal2, + }, + ]); +})); +test_helpers_1.integTest('deploy with notification ARN', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const topicName = `${fixture.stackNamePrefix}-test-topic`; + const response = await fixture.aws.sns('createTopic', { Name: topicName }); + const topicArn = response.TopicArn; + try { + await fixture.cdkDeploy('test-2', { + options: ['--notification-arns', topicArn], + }); + // verify that the stack we deployed has our notification ARN + const describeResponse = await fixture.aws.cloudFormation('describeStacks', { + StackName: fixture.fullStackName('test-2'), + }); + expect((_a = describeResponse.Stacks) === null || _a === void 0 ? void 0 : _a[0].NotificationARNs).toEqual([topicArn]); + } + finally { + await fixture.aws.sns('deleteTopic', { + TopicArn: topicArn, + }); + } +})); +test_helpers_1.integTest('deploy with role', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const roleName = `${fixture.stackNamePrefix}-test-role`; + await deleteRole(); + const createResponse = await fixture.aws.iam('createRole', { + RoleName: roleName, + AssumeRolePolicyDocument: JSON.stringify({ + Version: '2012-10-17', + Statement: [{ + Action: 'sts:AssumeRole', + Principal: { Service: 'cloudformation.amazonaws.com' }, + Effect: 'Allow', + }, { + Action: 'sts:AssumeRole', + Principal: { AWS: (await fixture.aws.sts('getCallerIdentity', {})).Arn }, + Effect: 'Allow', + }], + }), + }); + const roleArn = createResponse.Role.Arn; + try { + await fixture.aws.iam('putRolePolicy', { + RoleName: roleName, + PolicyName: 'DefaultPolicy', + PolicyDocument: JSON.stringify({ + Version: '2012-10-17', + Statement: [{ + Action: '*', + Resource: '*', + Effect: 'Allow', + }], + }), + }); + await aws_helpers_1.retry(fixture.output, 'Trying to assume fresh role', aws_helpers_1.retry.forSeconds(300), async () => { + await fixture.aws.sts('assumeRole', { + RoleArn: roleArn, + RoleSessionName: 'testing', + }); + }); + // In principle, the role has replicated from 'us-east-1' to wherever we're testing. + // Give it a little more sleep to make sure CloudFormation is not hitting a box + // that doesn't have it yet. + await aws_helpers_1.sleep(5000); + await fixture.cdkDeploy('test-2', { + options: ['--role-arn', roleArn], + }); + // Immediately delete the stack again before we delete the role. + // + // Since roles are sticky, if we delete the role before the stack, subsequent DeleteStack + // operations will fail when CloudFormation tries to assume the role that's already gone. + await fixture.cdkDestroy('test-2'); + } + finally { + await deleteRole(); + } + async function deleteRole() { + try { + for (const policyName of (await fixture.aws.iam('listRolePolicies', { RoleName: roleName })).PolicyNames) { + await fixture.aws.iam('deleteRolePolicy', { + RoleName: roleName, + PolicyName: policyName, + }); + } + await fixture.aws.iam('deleteRole', { RoleName: roleName }); + } + catch (e) { + if (e.message.indexOf('cannot be found') > -1) { + return; + } + throw e; + } + } +})); +test_helpers_1.integTest('cdk diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]); + expect(diff1).toContain('AWS::SNS::Topic'); + const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]); + expect(diff2).toContain('AWS::SNS::Topic'); + // We can make it fail by passing --fail + await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1')])) + .rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('cdk diff --fail on multiple stacks exits with error if any of the stacks contains a diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // GIVEN + const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]); + expect(diff1).toContain('AWS::SNS::Topic'); + await fixture.cdkDeploy('test-2'); + const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]); + expect(diff2).toContain('There were no differences'); + // WHEN / THEN + await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('cdk diff --fail with multiple stack exits with if any of the stacks contains a diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // GIVEN + await fixture.cdkDeploy('test-1'); + const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]); + expect(diff1).toContain('There were no differences'); + const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]); + expect(diff2).toContain('AWS::SNS::Topic'); + // WHEN / THEN + await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('deploy stack with docker asset', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await fixture.cdkDeploy('docker'); +})); +test_helpers_1.integTest('deploy and test stack with lambda asset', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a, _b; + const stackArn = await fixture.cdkDeploy('lambda', { captureStderr: false }); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + const lambdaArn = (_b = (_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].Outputs) === null || _b === void 0 ? void 0 : _b[0].OutputValue; + if (lambdaArn === undefined) { + throw new Error('Stack did not have expected Lambda ARN output'); + } + const output = await fixture.aws.lambda('invoke', { + FunctionName: lambdaArn, + }); + expect(JSON.stringify(output.Payload)).toContain('dear asset'); +})); +test_helpers_1.integTest('cdk ls', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const listing = await fixture.cdk(['ls'], { captureStderr: false }); + const expectedStacks = [ + 'conditional-resource', + 'docker', + 'docker-with-custom-file', + 'failed', + 'iam-test', + 'lambda', + 'missing-ssm-parameter', + 'order-providing', + 'outputs-test-1', + 'outputs-test-2', + 'param-test-1', + 'param-test-2', + 'param-test-3', + 'termination-protection', + 'test-1', + 'test-2', + 'with-nested-stack', + 'with-nested-stack-using-parameters', + 'order-consuming', + ]; + for (const stack of expectedStacks) { + expect(listing).toContain(fixture.fullStackName(stack)); + } +})); +test_helpers_1.integTest('deploy stack without resource', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // Deploy the stack without resources + await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } }); + // This should have succeeded but not deployed the stack. + await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') })) + .rejects.toThrow('conditional-resource does not exist'); + // Deploy the stack with resources + await fixture.cdkDeploy('conditional-resource'); + // Then again WITHOUT resources (this should destroy the stack) + await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } }); + await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') })) + .rejects.toThrow('conditional-resource does not exist'); +})); +test_helpers_1.integTest('IAM diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const output = await fixture.cdk(['diff', fixture.fullStackName('iam-test')]); + // Roughly check for a table like this: + // + // ┌───┬─────────────────┬────────┬────────────────┬────────────────────────────-──┬───────────┐ + // │ │ Resource │ Effect │ Action │ Principal │ Condition │ + // ├───┼─────────────────┼────────┼────────────────┼───────────────────────────────┼───────────┤ + // │ + │ ${SomeRole.Arn} │ Allow │ sts:AssumeRole │ Service:ec2.amazonaws.com │ │ + // └───┴─────────────────┴────────┴────────────────┴───────────────────────────────┴───────────┘ + expect(output).toContain('${SomeRole.Arn}'); + expect(output).toContain('sts:AssumeRole'); + expect(output).toContain('ec2.amazonaws.com'); +})); +test_helpers_1.integTest('fast deploy', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // we are using a stack with a nested stack because CFN will always attempt to + // update a nested stack, which will allow us to verify that updates are actually + // skipped unless --force is specified. + const stackArn = await fixture.cdkDeploy('with-nested-stack', { captureStderr: false }); + const changeSet1 = await getLatestChangeSet(); + // Deploy the same stack again, there should be no new change set created + await fixture.cdkDeploy('with-nested-stack'); + const changeSet2 = await getLatestChangeSet(); + expect(changeSet2.ChangeSetId).toEqual(changeSet1.ChangeSetId); + // Deploy the stack again with --force, now we should create a changeset + await fixture.cdkDeploy('with-nested-stack', { options: ['--force'] }); + const changeSet3 = await getLatestChangeSet(); + expect(changeSet3.ChangeSetId).not.toEqual(changeSet2.ChangeSetId); + // Deploy the stack again with tags, expected to create a new changeset + // even though the resources didn't change. + await fixture.cdkDeploy('with-nested-stack', { options: ['--tags', 'key=value'] }); + const changeSet4 = await getLatestChangeSet(); + expect(changeSet4.ChangeSetId).not.toEqual(changeSet3.ChangeSetId); + async function getLatestChangeSet() { + var _a, _b, _c; + const response = await fixture.aws.cloudFormation('describeStacks', { StackName: stackArn }); + if (!((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0])) { + throw new Error('Did not get a ChangeSet at all'); + } + fixture.log(`Found Change Set ${(_b = response.Stacks) === null || _b === void 0 ? void 0 : _b[0].ChangeSetId}`); + return (_c = response.Stacks) === null || _c === void 0 ? void 0 : _c[0]; + } +})); +test_helpers_1.integTest('failed deploy does not hang', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // this will hang if we introduce https://github.com/aws/aws-cdk/issues/6403 again. + await expect(fixture.cdkDeploy('failed')).rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('can still load old assemblies', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const cxAsmDir = path.join(os.tmpdir(), 'cdk-integ-cx'); + const testAssembliesDirectory = path.join(__dirname, 'cloud-assemblies'); + for (const asmdir of await listChildDirs(testAssembliesDirectory)) { + fixture.log(`ASSEMBLY ${asmdir}`); + await cdk_helpers_1.cloneDirectory(asmdir, cxAsmDir); + // Some files in the asm directory that have a .js extension are + // actually treated as templates. Evaluate them using NodeJS. + const templates = await listChildren(cxAsmDir, fullPath => Promise.resolve(fullPath.endsWith('.js'))); + for (const template of templates) { + const targetName = template.replace(/.js$/, ''); + await cdk_helpers_1.shell([process.execPath, template, '>', targetName], { + cwd: cxAsmDir, + output: fixture.output, + modEnv: { + TEST_ACCOUNT: await fixture.aws.account(), + TEST_REGION: fixture.aws.region, + }, + }); + } + // Use this directory as a Cloud Assembly + const output = await fixture.cdk([ + '--app', cxAsmDir, + '-v', + 'synth', + ]); + // Assert that there was no providerError in CDK's stderr + // Because we rely on the app/framework to actually error in case the + // provider fails, we inspect the logs here. + expect(output).not.toContain('$providerError'); + } +})); +test_helpers_1.integTest('generating and loading assembly', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const asmOutputDir = `${fixture.integTestDir}-cdk-integ-asm`; + await fixture.shell(['rm', '-rf', asmOutputDir]); + // Synthesize a Cloud Assembly tothe default directory (cdk.out) and a specific directory. + await fixture.cdk(['synth']); + await fixture.cdk(['synth', '--output', asmOutputDir]); + // cdk.out in the current directory and the indicated --output should be the same + await fixture.shell(['diff', 'cdk.out', asmOutputDir]); + // Check that we can 'ls' the synthesized asm. + // Change to some random directory to make sure we're not accidentally loading cdk.json + const list = await fixture.cdk(['--app', asmOutputDir, 'ls'], { cwd: os.tmpdir() }); + // Same stacks we know are in the app + expect(list).toContain(`${fixture.stackNamePrefix}-lambda`); + expect(list).toContain(`${fixture.stackNamePrefix}-test-1`); + expect(list).toContain(`${fixture.stackNamePrefix}-test-2`); + // Check that we can use '.' and just synth ,the generated asm + const stackTemplate = await fixture.cdk(['--app', '.', 'synth', fixture.fullStackName('test-2')], { + cwd: asmOutputDir, + }); + expect(stackTemplate).toContain('topic152D84A37'); + // Deploy a Lambda from the copied asm + await fixture.cdkDeploy('lambda', { options: ['-a', '.'], cwd: asmOutputDir }); + // Remove (rename) the original custom docker file that was used during synth. + // this verifies that the assemly has a copy of it and that the manifest uses + // relative paths to reference to it. + const customDockerFile = path.join(fixture.integTestDir, 'docker', 'Dockerfile.Custom'); + await fs_1.promises.rename(customDockerFile, `${customDockerFile}~`); + try { + // deploy a docker image with custom file without synth (uses assets) + await fixture.cdkDeploy('docker-with-custom-file', { options: ['-a', '.'], cwd: asmOutputDir }); + } + finally { + // Rename back to restore fixture to original state + await fs_1.promises.rename(`${customDockerFile}~`, customDockerFile); + } +})); +test_helpers_1.integTest('templates on disk contain metadata resource, also in nested assemblies', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // Synth first, and switch on version reporting because cdk.json is disabling it + await fixture.cdk(['synth', '--version-reporting=true']); + // Load template from disk from root assembly + const templateContents = await fixture.shell(['cat', 'cdk.out/*-lambda.template.json']); + expect(JSON.parse(templateContents).Resources.CDKMetadata).toBeTruthy(); + // Load template from nested assembly + const nestedTemplateContents = await fixture.shell(['cat', 'cdk.out/assembly-*-stage/*-stage-StackInStage.template.json']); + expect(JSON.parse(nestedTemplateContents).Resources.CDKMetadata).toBeTruthy(); +})); +async function listChildren(parent, pred) { + const ret = new Array(); + for (const child of await fs_1.promises.readdir(parent, { encoding: 'utf-8' })) { + const fullPath = path.join(parent, child.toString()); + if (await pred(fullPath)) { + ret.push(fullPath); + } + } + return ret; +} +async function listChildDirs(parent) { + return listChildren(parent, async (fullPath) => (await fs_1.promises.stat(fullPath)).isDirectory()); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.integtest.js","sourceRoot":"","sources":["cli.integtest.ts"],"names":[],"mappings":"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","sourcesContent":["import { promises as fs } from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { retry, sleep } from './aws-helpers';\nimport { cloneDirectory, shell, withDefaultFixture } from './cdk-helpers';\nimport { integTest } from './test-helpers';\n\njest.setTimeout(600 * 1000);\n\nintegTest('VPC Lookup', withDefaultFixture(async (fixture) => {\n  fixture.log('Making sure we are clean before starting.');\n  await fixture.cdkDestroy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } });\n\n  fixture.log('Setting up: creating a VPC with known tags');\n  await fixture.cdkDeploy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } });\n  fixture.log('Setup complete!');\n\n  fixture.log('Verifying we can now import that VPC');\n  await fixture.cdkDeploy('import-vpc', { modEnv: { ENABLE_VPC_TESTING: 'IMPORT' } });\n}));\n\nintegTest('Two ways of shoing the version', withDefaultFixture(async (fixture) => {\n  const version1 = await fixture.cdk(['version'], { verbose: false });\n  const version2 = await fixture.cdk(['--version'], { verbose: false });\n\n  expect(version1).toEqual(version2);\n}));\n\nintegTest('Termination protection', withDefaultFixture(async (fixture) => {\n  const stackName = 'termination-protection';\n  await fixture.cdkDeploy(stackName);\n\n  // Try a destroy that should fail\n  await expect(fixture.cdkDestroy(stackName)).rejects.toThrow('exited with error');\n\n  // Can update termination protection even though the change set doesn't contain changes\n  await fixture.cdkDeploy(stackName, { modEnv: { TERMINATION_PROTECTION: 'FALSE' } });\n  await fixture.cdkDestroy(stackName);\n}));\n\nintegTest('cdk synth', withDefaultFixture(async (fixture) => {\n  await expect(fixture.cdk(['synth', fixture.fullStackName('test-1')], { verbose: false })).resolves.toEqual(\n    `Resources:\n  topic69831491:\n    Type: AWS::SNS::Topic\n    Metadata:\n      aws:cdk:path: ${fixture.stackNamePrefix}-test-1/topic/Resource`);\n\n  await expect(fixture.cdk(['synth', fixture.fullStackName('test-2')], { verbose: false })).resolves.toEqual(\n    `Resources:\n  topic152D84A37:\n    Type: AWS::SNS::Topic\n    Metadata:\n      aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic1/Resource\n  topic2A4FB547F:\n    Type: AWS::SNS::Topic\n    Metadata:\n      aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic2/Resource`);\n}));\n\nintegTest('ssm parameter provider error', withDefaultFixture(async (fixture) => {\n  await expect(fixture.cdk(['synth',\n    fixture.fullStackName('missing-ssm-parameter'),\n    '-c', 'test:ssm-parameter-name=/does/not/exist'], {\n    allowErrExit: true,\n  })).resolves.toContain('SSM parameter not available in account');\n}));\n\nintegTest('automatic ordering', withDefaultFixture(async (fixture) => {\n  // Deploy the consuming stack which will include the producing stack\n  await fixture.cdkDeploy('order-consuming');\n\n  // Destroy the providing stack which will include the consuming stack\n  await fixture.cdkDestroy('order-providing');\n}));\n\nintegTest('context setting', withDefaultFixture(async (fixture) => {\n  await fs.writeFile(path.join(fixture.integTestDir, 'cdk.context.json'), JSON.stringify({\n    contextkey: 'this is the context value',\n  }));\n  try {\n    await expect(fixture.cdk(['context'])).resolves.toContain('this is the context value');\n\n    // Test that deleting the contextkey works\n    await fixture.cdk(['context', '--reset', 'contextkey']);\n    await expect(fixture.cdk(['context'])).resolves.not.toContain('this is the context value');\n\n    // Test that forced delete of the context key does not throw\n    await fixture.cdk(['context', '-f', '--reset', 'contextkey']);\n\n  } finally {\n    await fs.unlink(path.join(fixture.integTestDir, 'cdk.context.json'));\n  }\n}));\n\nintegTest('deploy', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('test-2', { captureStderr: false });\n\n  // verify the number of resources in the stack\n  const response = await fixture.aws.cloudFormation('describeStackResources', {\n    StackName: stackArn,\n  });\n  expect(response.StackResources?.length).toEqual(2);\n}));\n\nintegTest('deploy all', withDefaultFixture(async (fixture) => {\n  const arns = await fixture.cdkDeploy('test-*', { captureStderr: false });\n\n  // verify that we only deployed a single stack (there's a single ARN in the output)\n  expect(arns.split('\\n').length).toEqual(2);\n}));\n\nintegTest('nested stack with parameters', withDefaultFixture(async (fixture) => {\n  // STACK_NAME_PREFIX is used in MyTopicParam to allow multiple instances\n  // of this test to run in parallel, othewise they will attempt to create the same SNS topic.\n  const stackArn = await fixture.cdkDeploy('with-nested-stack-using-parameters', {\n    options: ['--parameters', `MyTopicParam=${fixture.stackNamePrefix}ThereIsNoSpoon`],\n    captureStderr: false,\n  });\n\n  // verify that we only deployed a single stack (there's a single ARN in the output)\n  expect(stackArn.split('\\n').length).toEqual(1);\n\n  // verify the number of resources in the stack\n  const response = await fixture.aws.cloudFormation('describeStackResources', {\n    StackName: stackArn,\n  });\n  expect(response.StackResources?.length).toEqual(1);\n}));\n\nintegTest('deploy without execute', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('test-2', {\n    options: ['--no-execute'],\n    captureStderr: false,\n  });\n  // verify that we only deployed a single stack (there's a single ARN in the output)\n  expect(stackArn.split('\\n').length).toEqual(1);\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].StackStatus).toEqual('REVIEW_IN_PROGRESS');\n}));\n\nintegTest('security related changes without a CLI are expected to fail', withDefaultFixture(async (fixture) => {\n  // redirect /dev/null to stdin, which means there will not be tty attached\n  // since this stack includes security-related changes, the deployment should\n  // immediately fail because we can't confirm the changes\n  const stackName = 'iam-test';\n  await expect(fixture.cdkDeploy(stackName, {\n    options: ['<', '/dev/null'], // H4x, this only works because I happen to know we pass shell: true.\n    neverRequireApproval: false,\n  })).rejects.toThrow('exited with error');\n\n  // Ensure stack was not deployed\n  await expect(fixture.aws.cloudFormation('describeStacks', {\n    StackName: fixture.fullStackName(stackName),\n  })).rejects.toThrow('does not exist');\n}));\n\nintegTest('deploy wildcard with outputs', withDefaultFixture(async (fixture) => {\n  const outputsFile = path.join(fixture.integTestDir, 'outputs', 'outputs.json');\n  await fs.mkdir(path.dirname(outputsFile), { recursive: true });\n\n  await fixture.cdkDeploy(['outputs-test-*'], {\n    options: ['--outputs-file', outputsFile],\n  });\n\n  const outputs = JSON.parse((await fs.readFile(outputsFile, { encoding: 'utf-8' })).toString());\n  expect(outputs).toEqual({\n    [`${fixture.stackNamePrefix}-outputs-test-1`]: {\n      TopicName: `${fixture.stackNamePrefix}-outputs-test-1MyTopic`,\n    },\n    [`${fixture.stackNamePrefix}-outputs-test-2`]: {\n      TopicName: `${fixture.stackNamePrefix}-outputs-test-2MyOtherTopic`,\n    },\n  });\n}));\n\nintegTest('deploy with parameters', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}bazinga`,\n    ],\n    captureStderr: false,\n  });\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'TopicNameParam',\n      ParameterValue: `${fixture.stackNamePrefix}bazinga`,\n    },\n  ]);\n}));\n\nintegTest('update to stack in ROLLBACK_COMPLETE state will delete stack and create a new one', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  await expect(fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`,\n    ],\n    captureStderr: false,\n  })).rejects.toThrow('exited with error');\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: fixture.fullStackName('param-test-1'),\n  });\n\n  const stackArn = response.Stacks?.[0].StackId;\n  expect(response.Stacks?.[0].StackStatus).toEqual('ROLLBACK_COMPLETE');\n\n  // WHEN\n  const newStackArn = await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`,\n    ],\n    captureStderr: false,\n  });\n\n  const newStackResponse = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: newStackArn,\n  });\n\n  // THEN\n  expect (stackArn).not.toEqual(newStackArn); // new stack was created\n  expect(newStackResponse.Stacks?.[0].StackStatus).toEqual('CREATE_COMPLETE');\n  expect(newStackResponse.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'TopicNameParam',\n      ParameterValue: `${fixture.stackNamePrefix}allgood`,\n    },\n  ]);\n}));\n\nintegTest('stack in UPDATE_ROLLBACK_COMPLETE state can be updated', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  const stackArn = await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}nice`,\n    ],\n    captureStderr: false,\n  });\n\n  let response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].StackStatus).toEqual('CREATE_COMPLETE');\n\n  // bad parameter name with @ will put stack into UPDATE_ROLLBACK_COMPLETE\n  await expect(fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`,\n    ],\n    captureStderr: false,\n  })).rejects.toThrow('exited with error');;\n\n  response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].StackStatus).toEqual('UPDATE_ROLLBACK_COMPLETE');\n\n  // WHEN\n  await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`,\n    ],\n    captureStderr: false,\n  });\n\n  response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  // THEN\n  expect(response.Stacks?.[0].StackStatus).toEqual('UPDATE_COMPLETE');\n  expect(response.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'TopicNameParam',\n      ParameterValue: `${fixture.stackNamePrefix}allgood`,\n    },\n  ]);\n}));\n\nintegTest('deploy with wildcard and parameters', withDefaultFixture(async (fixture) => {\n  await fixture.cdkDeploy('param-test-*', {\n    options: [\n      '--parameters', `${fixture.stackNamePrefix}-param-test-1:TopicNameParam=${fixture.stackNamePrefix}bazinga`,\n      '--parameters', `${fixture.stackNamePrefix}-param-test-2:OtherTopicNameParam=${fixture.stackNamePrefix}ThatsMySpot`,\n      '--parameters', `${fixture.stackNamePrefix}-param-test-3:DisplayNameParam=${fixture.stackNamePrefix}HeyThere`,\n      '--parameters', `${fixture.stackNamePrefix}-param-test-3:OtherDisplayNameParam=${fixture.stackNamePrefix}AnotherOne`,\n    ],\n  });\n}));\n\nintegTest('deploy with parameters multi', withDefaultFixture(async (fixture) => {\n  const paramVal1 = `${fixture.stackNamePrefix}bazinga`;\n  const paramVal2 = `${fixture.stackNamePrefix}=jagshemash`;\n\n  const stackArn = await fixture.cdkDeploy('param-test-3', {\n    options: [\n      '--parameters', `DisplayNameParam=${paramVal1}`,\n      '--parameters', `OtherDisplayNameParam=${paramVal2}`,\n    ],\n    captureStderr: false,\n  });\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'DisplayNameParam',\n      ParameterValue: paramVal1,\n    },\n    {\n      ParameterKey: 'OtherDisplayNameParam',\n      ParameterValue: paramVal2,\n    },\n  ]);\n}));\n\nintegTest('deploy with notification ARN', withDefaultFixture(async (fixture) => {\n  const topicName = `${fixture.stackNamePrefix}-test-topic`;\n\n  const response = await fixture.aws.sns('createTopic', { Name: topicName });\n  const topicArn = response.TopicArn!;\n  try {\n    await fixture.cdkDeploy('test-2', {\n      options: ['--notification-arns', topicArn],\n    });\n\n    // verify that the stack we deployed has our notification ARN\n    const describeResponse = await fixture.aws.cloudFormation('describeStacks', {\n      StackName: fixture.fullStackName('test-2'),\n    });\n    expect(describeResponse.Stacks?.[0].NotificationARNs).toEqual([topicArn]);\n  } finally {\n    await fixture.aws.sns('deleteTopic', {\n      TopicArn: topicArn,\n    });\n  }\n}));\n\nintegTest('deploy with role', withDefaultFixture(async (fixture) => {\n  const roleName = `${fixture.stackNamePrefix}-test-role`;\n\n  await deleteRole();\n\n  const createResponse = await fixture.aws.iam('createRole', {\n    RoleName: roleName,\n    AssumeRolePolicyDocument: JSON.stringify({\n      Version: '2012-10-17',\n      Statement: [{\n        Action: 'sts:AssumeRole',\n        Principal: { Service: 'cloudformation.amazonaws.com' },\n        Effect: 'Allow',\n      }, {\n        Action: 'sts:AssumeRole',\n        Principal: { AWS: (await fixture.aws.sts('getCallerIdentity', {})).Arn },\n        Effect: 'Allow',\n      }],\n    }),\n  });\n  const roleArn = createResponse.Role.Arn;\n  try {\n    await fixture.aws.iam('putRolePolicy', {\n      RoleName: roleName,\n      PolicyName: 'DefaultPolicy',\n      PolicyDocument: JSON.stringify({\n        Version: '2012-10-17',\n        Statement: [{\n          Action: '*',\n          Resource: '*',\n          Effect: 'Allow',\n        }],\n      }),\n    });\n\n    await retry(fixture.output, 'Trying to assume fresh role', retry.forSeconds(300), async () => {\n      await fixture.aws.sts('assumeRole', {\n        RoleArn: roleArn,\n        RoleSessionName: 'testing',\n      });\n    });\n\n    // In principle, the role has replicated from 'us-east-1' to wherever we're testing.\n    // Give it a little more sleep to make sure CloudFormation is not hitting a box\n    // that doesn't have it yet.\n    await sleep(5000);\n\n    await fixture.cdkDeploy('test-2', {\n      options: ['--role-arn', roleArn],\n    });\n\n    // Immediately delete the stack again before we delete the role.\n    //\n    // Since roles are sticky, if we delete the role before the stack, subsequent DeleteStack\n    // operations will fail when CloudFormation tries to assume the role that's already gone.\n    await fixture.cdkDestroy('test-2');\n\n  } finally {\n    await deleteRole();\n  }\n\n  async function deleteRole() {\n    try {\n      for (const policyName of (await fixture.aws.iam('listRolePolicies', { RoleName: roleName })).PolicyNames) {\n        await fixture.aws.iam('deleteRolePolicy', {\n          RoleName: roleName,\n          PolicyName: policyName,\n        });\n      }\n      await fixture.aws.iam('deleteRole', { RoleName: roleName });\n    } catch (e) {\n      if (e.message.indexOf('cannot be found') > -1) { return; }\n      throw e;\n    }\n  }\n}));\n\nintegTest('cdk diff', withDefaultFixture(async (fixture) => {\n  const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);\n  expect(diff1).toContain('AWS::SNS::Topic');\n\n  const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);\n  expect(diff2).toContain('AWS::SNS::Topic');\n\n  // We can make it fail by passing --fail\n  await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1')]))\n    .rejects.toThrow('exited with error');\n}));\n\nintegTest('cdk diff --fail on multiple stacks exits with error if any of the stacks contains a diff', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);\n  expect(diff1).toContain('AWS::SNS::Topic');\n\n  await fixture.cdkDeploy('test-2');\n  const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);\n  expect(diff2).toContain('There were no differences');\n\n  // WHEN / THEN\n  await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error');\n}));\n\nintegTest('cdk diff --fail with multiple stack exits with if any of the stacks contains a diff', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  await fixture.cdkDeploy('test-1');\n  const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);\n  expect(diff1).toContain('There were no differences');\n\n  const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);\n  expect(diff2).toContain('AWS::SNS::Topic');\n\n  // WHEN / THEN\n  await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error');\n}));\n\nintegTest('deploy stack with docker asset', withDefaultFixture(async (fixture) => {\n  await fixture.cdkDeploy('docker');\n}));\n\nintegTest('deploy and test stack with lambda asset', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('lambda', { captureStderr: false });\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n  const lambdaArn = response.Stacks?.[0].Outputs?.[0].OutputValue;\n  if (lambdaArn === undefined) {\n    throw new Error('Stack did not have expected Lambda ARN output');\n  }\n\n  const output = await fixture.aws.lambda('invoke', {\n    FunctionName: lambdaArn,\n  });\n\n  expect(JSON.stringify(output.Payload)).toContain('dear asset');\n}));\n\nintegTest('cdk ls', withDefaultFixture(async (fixture) => {\n  const listing = await fixture.cdk(['ls'], { captureStderr: false });\n\n  const expectedStacks = [\n    'conditional-resource',\n    'docker',\n    'docker-with-custom-file',\n    'failed',\n    'iam-test',\n    'lambda',\n    'missing-ssm-parameter',\n    'order-providing',\n    'outputs-test-1',\n    'outputs-test-2',\n    'param-test-1',\n    'param-test-2',\n    'param-test-3',\n    'termination-protection',\n    'test-1',\n    'test-2',\n    'with-nested-stack',\n    'with-nested-stack-using-parameters',\n    'order-consuming',\n  ];\n\n  for (const stack of expectedStacks) {\n    expect(listing).toContain(fixture.fullStackName(stack));\n  }\n}));\n\nintegTest('deploy stack without resource', withDefaultFixture(async (fixture) => {\n  // Deploy the stack without resources\n  await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } });\n\n  // This should have succeeded but not deployed the stack.\n  await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') }))\n    .rejects.toThrow('conditional-resource does not exist');\n\n  // Deploy the stack with resources\n  await fixture.cdkDeploy('conditional-resource');\n\n  // Then again WITHOUT resources (this should destroy the stack)\n  await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } });\n\n  await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') }))\n    .rejects.toThrow('conditional-resource does not exist');\n}));\n\nintegTest('IAM diff', withDefaultFixture(async (fixture) => {\n  const output = await fixture.cdk(['diff', fixture.fullStackName('iam-test')]);\n\n  // Roughly check for a table like this:\n  //\n  // ┌───┬─────────────────┬────────┬────────────────┬────────────────────────────-──┬───────────┐\n  // │   │ Resource        │ Effect │ Action         │ Principal                     │ Condition │\n  // ├───┼─────────────────┼────────┼────────────────┼───────────────────────────────┼───────────┤\n  // │ + │ ${SomeRole.Arn} │ Allow  │ sts:AssumeRole │ Service:ec2.amazonaws.com     │           │\n  // └───┴─────────────────┴────────┴────────────────┴───────────────────────────────┴───────────┘\n\n  expect(output).toContain('${SomeRole.Arn}');\n  expect(output).toContain('sts:AssumeRole');\n  expect(output).toContain('ec2.amazonaws.com');\n}));\n\nintegTest('fast deploy', withDefaultFixture(async (fixture) => {\n  // we are using a stack with a nested stack because CFN will always attempt to\n  // update a nested stack, which will allow us to verify that updates are actually\n  // skipped unless --force is specified.\n  const stackArn = await fixture.cdkDeploy('with-nested-stack', { captureStderr: false });\n  const changeSet1 = await getLatestChangeSet();\n\n  // Deploy the same stack again, there should be no new change set created\n  await fixture.cdkDeploy('with-nested-stack');\n  const changeSet2 = await getLatestChangeSet();\n  expect(changeSet2.ChangeSetId).toEqual(changeSet1.ChangeSetId);\n\n  // Deploy the stack again with --force, now we should create a changeset\n  await fixture.cdkDeploy('with-nested-stack', { options: ['--force'] });\n  const changeSet3 = await getLatestChangeSet();\n  expect(changeSet3.ChangeSetId).not.toEqual(changeSet2.ChangeSetId);\n\n  // Deploy the stack again with tags, expected to create a new changeset\n  // even though the resources didn't change.\n  await fixture.cdkDeploy('with-nested-stack', { options: ['--tags', 'key=value'] });\n  const changeSet4 = await getLatestChangeSet();\n  expect(changeSet4.ChangeSetId).not.toEqual(changeSet3.ChangeSetId);\n\n  async function getLatestChangeSet() {\n    const response = await fixture.aws.cloudFormation('describeStacks', { StackName: stackArn });\n    if (!response.Stacks?.[0]) { throw new Error('Did not get a ChangeSet at all'); }\n    fixture.log(`Found Change Set ${response.Stacks?.[0].ChangeSetId}`);\n    return response.Stacks?.[0];\n  }\n}));\n\nintegTest('failed deploy does not hang', withDefaultFixture(async (fixture) => {\n  // this will hang if we introduce https://github.com/aws/aws-cdk/issues/6403 again.\n  await expect(fixture.cdkDeploy('failed')).rejects.toThrow('exited with error');\n}));\n\nintegTest('can still load old assemblies', withDefaultFixture(async (fixture) => {\n  const cxAsmDir = path.join(os.tmpdir(), 'cdk-integ-cx');\n\n  const testAssembliesDirectory = path.join(__dirname, 'cloud-assemblies');\n  for (const asmdir of await listChildDirs(testAssembliesDirectory)) {\n    fixture.log(`ASSEMBLY ${asmdir}`);\n    await cloneDirectory(asmdir, cxAsmDir);\n\n    // Some files in the asm directory that have a .js extension are\n    // actually treated as templates. Evaluate them using NodeJS.\n    const templates = await listChildren(cxAsmDir, fullPath => Promise.resolve(fullPath.endsWith('.js')));\n    for (const template of templates) {\n      const targetName = template.replace(/.js$/, '');\n      await shell([process.execPath, template, '>', targetName], {\n        cwd: cxAsmDir,\n        output: fixture.output,\n        modEnv: {\n          TEST_ACCOUNT: await fixture.aws.account(),\n          TEST_REGION: fixture.aws.region,\n        },\n      });\n    }\n\n    // Use this directory as a Cloud Assembly\n    const output = await fixture.cdk([\n      '--app', cxAsmDir,\n      '-v',\n      'synth',\n    ]);\n\n    // Assert that there was no providerError in CDK's stderr\n    // Because we rely on the app/framework to actually error in case the\n    // provider fails, we inspect the logs here.\n    expect(output).not.toContain('$providerError');\n  }\n}));\n\nintegTest('generating and loading assembly', withDefaultFixture(async (fixture) => {\n  const asmOutputDir = `${fixture.integTestDir}-cdk-integ-asm`;\n  await fixture.shell(['rm', '-rf', asmOutputDir]);\n\n  // Synthesize a Cloud Assembly tothe default directory (cdk.out) and a specific directory.\n  await fixture.cdk(['synth']);\n  await fixture.cdk(['synth', '--output', asmOutputDir]);\n\n  // cdk.out in the current directory and the indicated --output should be the same\n  await fixture.shell(['diff', 'cdk.out', asmOutputDir]);\n\n  // Check that we can 'ls' the synthesized asm.\n  // Change to some random directory to make sure we're not accidentally loading cdk.json\n  const list = await fixture.cdk(['--app', asmOutputDir, 'ls'], { cwd: os.tmpdir() });\n  // Same stacks we know are in the app\n  expect(list).toContain(`${fixture.stackNamePrefix}-lambda`);\n  expect(list).toContain(`${fixture.stackNamePrefix}-test-1`);\n  expect(list).toContain(`${fixture.stackNamePrefix}-test-2`);\n\n  // Check that we can use '.' and just synth ,the generated asm\n  const stackTemplate = await fixture.cdk(['--app', '.', 'synth', fixture.fullStackName('test-2')], {\n    cwd: asmOutputDir,\n  });\n  expect(stackTemplate).toContain('topic152D84A37');\n\n  // Deploy a Lambda from the copied asm\n  await fixture.cdkDeploy('lambda', { options: ['-a', '.'], cwd: asmOutputDir });\n\n  // Remove (rename) the original custom docker file that was used during synth.\n  // this verifies that the assemly has a copy of it and that the manifest uses\n  // relative paths to reference to it.\n  const customDockerFile = path.join(fixture.integTestDir, 'docker', 'Dockerfile.Custom');\n  await fs.rename(customDockerFile, `${customDockerFile}~`);\n  try {\n\n    // deploy a docker image with custom file without synth (uses assets)\n    await fixture.cdkDeploy('docker-with-custom-file', { options: ['-a', '.'], cwd: asmOutputDir });\n\n  } finally {\n    // Rename back to restore fixture to original state\n    await fs.rename(`${customDockerFile}~`, customDockerFile);\n  }\n}));\n\nintegTest('templates on disk contain metadata resource, also in nested assemblies', withDefaultFixture(async (fixture) => {\n  // Synth first, and switch on version reporting because cdk.json is disabling it\n  await fixture.cdk(['synth', '--version-reporting=true']);\n\n  // Load template from disk from root assembly\n  const templateContents = await fixture.shell(['cat', 'cdk.out/*-lambda.template.json']);\n\n  expect(JSON.parse(templateContents).Resources.CDKMetadata).toBeTruthy();\n\n  // Load template from nested assembly\n  const nestedTemplateContents = await fixture.shell(['cat', 'cdk.out/assembly-*-stage/*-stage-StackInStage.template.json']);\n\n  expect(JSON.parse(nestedTemplateContents).Resources.CDKMetadata).toBeTruthy();\n}));\n\nasync function listChildren(parent: string, pred: (x: string) => Promise<boolean>) {\n  const ret = new Array<string>();\n  for (const child of await fs.readdir(parent, { encoding: 'utf-8' })) {\n    const fullPath = path.join(parent, child.toString());\n    if (await pred(fullPath)) {\n      ret.push(fullPath);\n    }\n  }\n  return ret;\n}\n\nasync function listChildDirs(parent: string) {\n  return listChildren(parent, async (fullPath: string) => (await fs.stat(fullPath)).isDirectory());\n}\n"]} \ No newline at end of file diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/NOTES.md b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/NOTES.md new file mode 100644 index 0000000000000..1cb31072ab5de --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/NOTES.md @@ -0,0 +1,3 @@ +Added a `-v` switch to the cdk executions that also needs to be +applied to the regression tests so we have a better chance +of catching sporadically failing tests in the act. \ No newline at end of file diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cdk-helpers.js b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cdk-helpers.js new file mode 100644 index 0000000000000..ef82e3d3edace --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cdk-helpers.js @@ -0,0 +1,324 @@ +"use strict"; +var _a, _b; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.randomString = exports.rimraf = exports.shell = exports.TestFixture = exports.cloneDirectory = exports.withDefaultFixture = exports.withCdkApp = exports.withAws = void 0; +const child_process = require("child_process"); +const fs = require("fs"); +const os = require("os"); +const path = require("path"); +const aws_helpers_1 = require("./aws-helpers"); +const resource_pool_1 = require("./resource-pool"); +const REGIONS = process.env.AWS_REGIONS + ? process.env.AWS_REGIONS.split(',') + : [(_b = (_a = process.env.AWS_REGION) !== null && _a !== void 0 ? _a : process.env.AWS_DEFAULT_REGION) !== null && _b !== void 0 ? _b : 'us-east-1']; +process.stdout.write(`Using regions: ${REGIONS}\n`); +const REGION_POOL = new resource_pool_1.ResourcePool(REGIONS); +/** + * Higher order function to execute a block with an AWS client setup + * + * Allocate the next region from the REGION pool and dispose it afterwards. + */ +function withAws(block) { + return (context) => REGION_POOL.using(async (region) => { + const aws = await aws_helpers_1.AwsClients.forRegion(region, context.output); + await sanityCheck(aws); + return block({ ...context, aws }); + }); +} +exports.withAws = withAws; +/** + * Higher order function to execute a block with a CDK app fixture + * + * Requires an AWS client to be passed in. + * + * For backwards compatibility with existing tests (so we don't have to change + * too much) the inner block is expected to take a `TestFixture` object. + */ +function withCdkApp(block) { + return async (context) => { + const randy = randomString(); + const stackNamePrefix = `cdktest-${randy}`; + const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`); + context.output.write(` Stack prefix: ${stackNamePrefix}\n`); + context.output.write(` Test directory: ${integTestDir}\n`); + context.output.write(` Region: ${context.aws.region}\n`); + await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output); + const fixture = new TestFixture(integTestDir, stackNamePrefix, context.output, context.aws); + let success = true; + try { + await fixture.shell(['npm', 'install', + '@aws-cdk/core', + '@aws-cdk/aws-sns', + '@aws-cdk/aws-iam', + '@aws-cdk/aws-lambda', + '@aws-cdk/aws-ssm', + '@aws-cdk/aws-ecr-assets', + '@aws-cdk/aws-cloudformation', + '@aws-cdk/aws-ec2']); + await ensureBootstrapped(fixture); + await block(fixture); + } + catch (e) { + success = false; + throw e; + } + finally { + await fixture.dispose(success); + } + }; +} +exports.withCdkApp = withCdkApp; +/** + * Default test fixture for most (all?) integ tests + * + * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture` + * object. + * + * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every + * test declaration but centralizing it is going to make it convenient to modify in the future. + */ +function withDefaultFixture(block) { + return withAws(withCdkApp(block)); + // ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this. +} +exports.withDefaultFixture = withDefaultFixture; +/** + * Prepare a target dir byreplicating a source directory + */ +async function cloneDirectory(source, target, output) { + await shell(['rm', '-rf', target], { output }); + await shell(['mkdir', '-p', target], { output }); + await shell(['cp', '-R', source + '/*', target], { output }); +} +exports.cloneDirectory = cloneDirectory; +class TestFixture { + constructor(integTestDir, stackNamePrefix, output, aws) { + this.integTestDir = integTestDir; + this.stackNamePrefix = stackNamePrefix; + this.output = output; + this.aws = aws; + this.qualifier = randomString().substr(0, 10); + this.bucketsToDelete = new Array(); + } + log(s) { + this.output.write(`${s}\n`); + } + async shell(command, options = {}) { + return shell(command, { + output: this.output, + cwd: this.integTestDir, + ...options, + }); + } + async cdkDeploy(stackNames, options = {}) { + var _a, _b; + stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames; + const neverRequireApproval = (_a = options.neverRequireApproval) !== null && _a !== void 0 ? _a : true; + return this.cdk(['deploy', + ...(neverRequireApproval ? ['--require-approval=never'] : []), // Default to no approval in an unattended test + ...((_b = options.options) !== null && _b !== void 0 ? _b : []), ...this.fullStackName(stackNames)], options); + } + async cdkDestroy(stackNames, options = {}) { + var _a; + stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames; + return this.cdk(['destroy', + '-f', // We never want a prompt in an unattended test + ...((_a = options.options) !== null && _a !== void 0 ? _a : []), ...this.fullStackName(stackNames)], options); + } + async cdk(args, options = {}) { + var _a; + const verbose = (_a = options.verbose) !== null && _a !== void 0 ? _a : true; + return this.shell(['cdk', ...(verbose ? ['-v'] : []), ...args], { + ...options, + modEnv: { + AWS_REGION: this.aws.region, + AWS_DEFAULT_REGION: this.aws.region, + STACK_NAME_PREFIX: this.stackNamePrefix, + ...options.modEnv, + }, + }); + } + fullStackName(stackNames) { + if (typeof stackNames === 'string') { + return `${this.stackNamePrefix}-${stackNames}`; + } + else { + return stackNames.map(s => `${this.stackNamePrefix}-${s}`); + } + } + /** + * Append this to the list of buckets to potentially delete + * + * At the end of a test, we clean up buckets that may not have gotten destroyed + * (for whatever reason). + */ + rememberToDeleteBucket(bucketName) { + this.bucketsToDelete.push(bucketName); + } + /** + * Cleanup leftover stacks and buckets + */ + async dispose(success) { + const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix); + // Bootstrap stacks have buckets that need to be cleaned + const bucketNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('BucketName', stack)).filter(defined); + await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b))); + // Bootstrap stacks have ECR repositories with images which should be deleted + const imageRepositoryNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('ImageRepositoryName', stack)).filter(defined); + await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r))); + await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName)); + // We might have leaked some buckets by upgrading the bootstrap stack. Be + // sure to clean everything. + for (const bucket of this.bucketsToDelete) { + await this.aws.deleteBucket(bucket); + } + // If the tests completed successfully, happily delete the fixture + // (otherwise leave it for humans to inspect) + if (success) { + rimraf(this.integTestDir); + } + } + /** + * Return the stacks starting with our testing prefix that should be deleted + */ + async deleteableStacks(prefix) { + var _a; + const statusFilter = [ + 'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE', + 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE', + 'DELETE_FAILED', + 'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS', + 'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS', + 'UPDATE_ROLLBACK_FAILED', + 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS', + 'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS', + 'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE', + 'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED', + 'IMPORT_ROLLBACK_COMPLETE', + ]; + const response = await this.aws.cloudFormation('describeStacks', {}); + return ((_a = response.Stacks) !== null && _a !== void 0 ? _a : []) + .filter(s => s.StackName.startsWith(prefix)) + .filter(s => statusFilter.includes(s.StackStatus)) + .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process + } +} +exports.TestFixture = TestFixture; +/** + * Perform a one-time quick sanity check that the AWS clients has properly configured credentials + * + * If we don't do this, calls are going to fail and they'll be retried and everything will take + * forever before the user notices a simple misconfiguration. + * + * We can't check for the presence of environment variables since credentials could come from + * anywhere, so do simple account retrieval. + * + * Only do it once per process. + */ +async function sanityCheck(aws) { + if (sanityChecked === undefined) { + try { + await aws.account(); + sanityChecked = true; + } + catch (e) { + sanityChecked = false; + throw new Error(`AWS credentials probably not configured, got error: ${e.message}`); + } + } + if (!sanityChecked) { + throw new Error('AWS credentials probably not configured, see previous error'); + } +} +let sanityChecked; +/** + * Make sure that the given environment is bootstrapped + * + * Since we go striping across regions, it's going to suck doing this + * by hand so let's just mass-automate it. + */ +async function ensureBootstrapped(fixture) { + // Old-style bootstrap stack with default name + if (await fixture.aws.stackStatus('CDKToolkit') === undefined) { + await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]); + } +} +/** + * A shell command that does what you want + * + * Is platform-aware, handles errors nicely. + */ +async function shell(command, options = {}) { + var _a, _b; + if (options.modEnv && options.env) { + throw new Error('Use either env or modEnv but not both'); + } + (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(`💻 ${command.join(' ')}\n`); + const env = (_b = options.env) !== null && _b !== void 0 ? _b : (options.modEnv ? { ...process.env, ...options.modEnv } : undefined); + const child = child_process.spawn(command[0], command.slice(1), { + ...options, + env, + // Need this for Windows where we want .cmd and .bat to be found as well. + shell: true, + stdio: ['ignore', 'pipe', 'pipe'], + }); + return new Promise((resolve, reject) => { + const stdout = new Array(); + const stderr = new Array(); + child.stdout.on('data', chunk => { + var _a; + (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk); + stdout.push(chunk); + }); + child.stderr.on('data', chunk => { + var _a, _b; + (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk); + if ((_b = options.captureStderr) !== null && _b !== void 0 ? _b : true) { + stderr.push(chunk); + } + }); + child.once('error', reject); + child.once('close', code => { + if (code === 0 || options.allowErrExit) { + resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim()); + } + else { + reject(new Error(`'${command.join(' ')}' exited with error code ${code}`)); + } + }); + }); +} +exports.shell = shell; +function defined(x) { + return x !== undefined; +} +/** + * rm -rf reimplementation, don't want to depend on an NPM package for this + */ +function rimraf(fsPath) { + try { + const isDir = fs.lstatSync(fsPath).isDirectory(); + if (isDir) { + for (const file of fs.readdirSync(fsPath)) { + rimraf(path.join(fsPath, file)); + } + fs.rmdirSync(fsPath); + } + else { + fs.unlinkSync(fsPath); + } + } + catch (e) { + // We will survive ENOENT + if (e.code !== 'ENOENT') { + throw e; + } + } +} +exports.rimraf = rimraf; +function randomString() { + // Crazy + return Math.random().toString(36).replace(/[^a-z0-9]+/g, ''); +} +exports.randomString = randomString; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-helpers.js","sourceRoot":"","sources":["cdk-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from 'child_process';\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { outputFromStack, AwsClients } from './aws-helpers';\nimport { ResourcePool } from './resource-pool';\nimport { TestContext } from './test-helpers';\n\nconst REGIONS = process.env.AWS_REGIONS\n  ? process.env.AWS_REGIONS.split(',')\n  : [process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1'];\n\nprocess.stdout.write(`Using regions: ${REGIONS}\\n`);\n\nconst REGION_POOL = new ResourcePool(REGIONS);\n\n\nexport type AwsContext = { readonly aws: AwsClients };\n\n/**\n * Higher order function to execute a block with an AWS client setup\n *\n * Allocate the next region from the REGION pool and dispose it afterwards.\n */\nexport function withAws<A extends TestContext>(block: (context: A & AwsContext) => Promise<void>) {\n  return (context: A) => REGION_POOL.using(async (region) => {\n    const aws = await AwsClients.forRegion(region, context.output);\n    await sanityCheck(aws);\n\n    return block({ ...context, aws });\n  });\n}\n\n/**\n * Higher order function to execute a block with a CDK app fixture\n *\n * Requires an AWS client to be passed in.\n *\n * For backwards compatibility with existing tests (so we don't have to change\n * too much) the inner block is expected to take a `TestFixture` object.\n */\nexport function withCdkApp<A extends TestContext & AwsContext>(block: (context: TestFixture) => Promise<void>) {\n  return async (context: A) => {\n    const randy = randomString();\n    const stackNamePrefix = `cdktest-${randy}`;\n    const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`);\n\n    context.output.write(` Stack prefix:   ${stackNamePrefix}\\n`);\n    context.output.write(` Test directory: ${integTestDir}\\n`);\n    context.output.write(` Region:         ${context.aws.region}\\n`);\n\n    await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output);\n    const fixture = new TestFixture(\n      integTestDir,\n      stackNamePrefix,\n      context.output,\n      context.aws);\n\n    let success = true;\n    try {\n      await fixture.shell(['npm', 'install',\n        '@aws-cdk/core',\n        '@aws-cdk/aws-sns',\n        '@aws-cdk/aws-iam',\n        '@aws-cdk/aws-lambda',\n        '@aws-cdk/aws-ssm',\n        '@aws-cdk/aws-ecr-assets',\n        '@aws-cdk/aws-cloudformation',\n        '@aws-cdk/aws-ec2']);\n\n      await ensureBootstrapped(fixture);\n\n      await block(fixture);\n    } catch (e) {\n      success = false;\n      throw e;\n    } finally {\n      await fixture.dispose(success);\n    }\n  };\n}\n\n/**\n * Default test fixture for most (all?) integ tests\n *\n * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture`\n * object.\n *\n * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every\n * test declaration but centralizing it is going to make it convenient to modify in the future.\n */\nexport function withDefaultFixture(block: (context: TestFixture) => Promise<void>) {\n  return withAws<TestContext>(withCdkApp(block));\n  //              ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this.\n}\n\nexport interface ShellOptions extends child_process.SpawnOptions {\n  /**\n   * Properties to add to 'env'\n   */\n  modEnv?: Record<string, string>;\n\n  /**\n   * Don't fail when exiting with an error\n   *\n   * @default false\n   */\n  allowErrExit?: boolean;\n\n  /**\n   * Whether to capture stderr\n   *\n   * @default true\n   */\n  captureStderr?: boolean;\n\n  /**\n   * Pass output here\n   */\n  output?: NodeJS.WritableStream;\n}\n\nexport interface CdkCliOptions extends ShellOptions {\n  options?: string[];\n  neverRequireApproval?: boolean;\n  verbose?: boolean;\n}\n\n/**\n * Prepare a target dir byreplicating a source directory\n */\nexport async function cloneDirectory(source: string, target: string, output?: NodeJS.WritableStream) {\n  await shell(['rm', '-rf', target], { output });\n  await shell(['mkdir', '-p', target], { output });\n  await shell(['cp', '-R', source + '/*', target], { output });\n}\n\nexport class TestFixture {\n  public readonly qualifier = randomString().substr(0, 10);\n  private readonly bucketsToDelete = new Array<string>();\n\n  constructor(\n    public readonly integTestDir: string,\n    public readonly stackNamePrefix: string,\n    public readonly output: NodeJS.WritableStream,\n    public readonly aws: AwsClients) {\n  }\n\n  public log(s: string) {\n    this.output.write(`${s}\\n`);\n  }\n\n  public async shell(command: string[], options: Omit<ShellOptions, 'cwd'|'output'> = {}): Promise<string> {\n    return shell(command, {\n      output: this.output,\n      cwd: this.integTestDir,\n      ...options,\n    });\n  }\n\n  public async cdkDeploy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    const neverRequireApproval = options.neverRequireApproval ?? true;\n\n    return this.cdk(['deploy',\n      ...(neverRequireApproval ? ['--require-approval=never'] : []), // Default to no approval in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdkDestroy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    return this.cdk(['destroy',\n      '-f', // We never want a prompt in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdk(args: string[], options: CdkCliOptions = {}) {\n    const verbose = options.verbose ?? true;\n\n    return this.shell(['cdk', ...(verbose ? ['-v'] : []), ...args], {\n      ...options,\n      modEnv: {\n        AWS_REGION: this.aws.region,\n        AWS_DEFAULT_REGION: this.aws.region,\n        STACK_NAME_PREFIX: this.stackNamePrefix,\n        ...options.modEnv,\n      },\n    });\n  }\n\n  public fullStackName(stackName: string): string;\n  public fullStackName(stackNames: string[]): string[];\n  public fullStackName(stackNames: string | string[]): string | string[] {\n    if (typeof stackNames === 'string') {\n      return `${this.stackNamePrefix}-${stackNames}`;\n    } else {\n      return stackNames.map(s => `${this.stackNamePrefix}-${s}`);\n    }\n  }\n\n  /**\n   * Append this to the list of buckets to potentially delete\n   *\n   * At the end of a test, we clean up buckets that may not have gotten destroyed\n   * (for whatever reason).\n   */\n  public rememberToDeleteBucket(bucketName: string) {\n    this.bucketsToDelete.push(bucketName);\n  }\n\n  /**\n   * Cleanup leftover stacks and buckets\n   */\n  public async dispose(success: boolean) {\n    const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix);\n\n    // Bootstrap stacks have buckets that need to be cleaned\n    const bucketNames = stacksToDelete.map(stack => outputFromStack('BucketName', stack)).filter(defined);\n    await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b)));\n\n    // Bootstrap stacks have ECR repositories with images which should be deleted\n    const imageRepositoryNames = stacksToDelete.map(stack => outputFromStack('ImageRepositoryName', stack)).filter(defined);\n    await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r)));\n\n    await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName));\n\n    // We might have leaked some buckets by upgrading the bootstrap stack. Be\n    // sure to clean everything.\n    for (const bucket of this.bucketsToDelete) {\n      await this.aws.deleteBucket(bucket);\n    }\n\n    // If the tests completed successfully, happily delete the fixture\n    // (otherwise leave it for humans to inspect)\n    if (success) {\n      rimraf(this.integTestDir);\n    }\n  }\n\n  /**\n   * Return the stacks starting with our testing prefix that should be deleted\n   */\n  private async deleteableStacks(prefix: string): Promise<AWS.CloudFormation.Stack[]> {\n    const statusFilter = [\n      'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE',\n      'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE',\n      'DELETE_FAILED',\n      'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS',\n      'UPDATE_ROLLBACK_FAILED',\n      'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS',\n      'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE',\n      'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED',\n      'IMPORT_ROLLBACK_COMPLETE',\n    ];\n\n    const response = await this.aws.cloudFormation('describeStacks', {});\n\n    return (response.Stacks ?? [])\n      .filter(s => s.StackName.startsWith(prefix))\n      .filter(s => statusFilter.includes(s.StackStatus))\n      .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process\n  }\n}\n\n/**\n * Perform a one-time quick sanity check that the AWS clients has properly configured credentials\n *\n * If we don't do this, calls are going to fail and they'll be retried and everything will take\n * forever before the user notices a simple misconfiguration.\n *\n * We can't check for the presence of environment variables since credentials could come from\n * anywhere, so do simple account retrieval.\n *\n * Only do it once per process.\n */\nasync function sanityCheck(aws: AwsClients) {\n  if (sanityChecked === undefined) {\n    try {\n      await aws.account();\n      sanityChecked = true;\n    } catch (e) {\n      sanityChecked = false;\n      throw new Error(`AWS credentials probably not configured, got error: ${e.message}`);\n    }\n  }\n  if (!sanityChecked) {\n    throw new Error('AWS credentials probably not configured, see previous error');\n  }\n}\nlet sanityChecked: boolean | undefined;\n\n/**\n * Make sure that the given environment is bootstrapped\n *\n * Since we go striping across regions, it's going to suck doing this\n * by hand so let's just mass-automate it.\n */\nasync function ensureBootstrapped(fixture: TestFixture) {\n  // Old-style bootstrap stack with default name\n  if (await fixture.aws.stackStatus('CDKToolkit') === undefined) {\n    await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]);\n  }\n}\n\n/**\n * A shell command that does what you want\n *\n * Is platform-aware, handles errors nicely.\n */\nexport async function shell(command: string[], options: ShellOptions = {}): Promise<string> {\n  if (options.modEnv && options.env) {\n    throw new Error('Use either env or modEnv but not both');\n  }\n\n  options.output?.write(`💻 ${command.join(' ')}\\n`);\n\n  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : undefined);\n\n  const child = child_process.spawn(command[0], command.slice(1), {\n    ...options,\n    env,\n    // Need this for Windows where we want .cmd and .bat to be found as well.\n    shell: true,\n    stdio: ['ignore', 'pipe', 'pipe'],\n  });\n\n  return new Promise<string>((resolve, reject) => {\n    const stdout = new Array<Buffer>();\n    const stderr = new Array<Buffer>();\n\n    child.stdout!.on('data', chunk => {\n      options.output?.write(chunk);\n      stdout.push(chunk);\n    });\n\n    child.stderr!.on('data', chunk => {\n      options.output?.write(chunk);\n      if (options.captureStderr ?? true) {\n        stderr.push(chunk);\n      }\n    });\n\n    child.once('error', reject);\n\n    child.once('close', code => {\n      if (code === 0 || options.allowErrExit) {\n        resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim());\n      } else {\n        reject(new Error(`'${command.join(' ')}' exited with error code ${code}`));\n      }\n    });\n  });\n}\n\nfunction defined<A>(x: A): x is NonNullable<A> {\n  return x !== undefined;\n}\n\n/**\n * rm -rf reimplementation, don't want to depend on an NPM package for this\n */\nexport function rimraf(fsPath: string) {\n  try {\n    const isDir = fs.lstatSync(fsPath).isDirectory();\n\n    if (isDir) {\n      for (const file of fs.readdirSync(fsPath)) {\n        rimraf(path.join(fsPath, file));\n      }\n      fs.rmdirSync(fsPath);\n    } else {\n      fs.unlinkSync(fsPath);\n    }\n  } catch (e) {\n    // We will survive ENOENT\n    if (e.code !== 'ENOENT') { throw e; }\n  }\n}\n\nexport function randomString() {\n  // Crazy\n  return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');\n}"]} \ No newline at end of file diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cli.integtest.js b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cli.integtest.js new file mode 100644 index 0000000000000..a63578ecfaee1 --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cli.integtest.js @@ -0,0 +1,599 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const fs_1 = require("fs"); +const os = require("os"); +const path = require("path"); +const aws_helpers_1 = require("./aws-helpers"); +const cdk_helpers_1 = require("./cdk-helpers"); +const test_helpers_1 = require("./test-helpers"); +jest.setTimeout(600 * 1000); +test_helpers_1.integTest('VPC Lookup', cdk_helpers_1.withDefaultFixture(async (fixture) => { + fixture.log('Making sure we are clean before starting.'); + await fixture.cdkDestroy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } }); + fixture.log('Setting up: creating a VPC with known tags'); + await fixture.cdkDeploy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } }); + fixture.log('Setup complete!'); + fixture.log('Verifying we can now import that VPC'); + await fixture.cdkDeploy('import-vpc', { modEnv: { ENABLE_VPC_TESTING: 'IMPORT' } }); +})); +test_helpers_1.integTest('Two ways of shoing the version', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const version1 = await fixture.cdk(['version'], { verbose: false }); + const version2 = await fixture.cdk(['--version'], { verbose: false }); + expect(version1).toEqual(version2); +})); +test_helpers_1.integTest('Termination protection', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const stackName = 'termination-protection'; + await fixture.cdkDeploy(stackName); + // Try a destroy that should fail + await expect(fixture.cdkDestroy(stackName)).rejects.toThrow('exited with error'); + // Can update termination protection even though the change set doesn't contain changes + await fixture.cdkDeploy(stackName, { modEnv: { TERMINATION_PROTECTION: 'FALSE' } }); + await fixture.cdkDestroy(stackName); +})); +test_helpers_1.integTest('cdk synth', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await expect(fixture.cdk(['synth', fixture.fullStackName('test-1')], { verbose: false })).resolves.toEqual(`Resources: + topic69831491: + Type: AWS::SNS::Topic + Metadata: + aws:cdk:path: ${fixture.stackNamePrefix}-test-1/topic/Resource`); + await expect(fixture.cdk(['synth', fixture.fullStackName('test-2')], { verbose: false })).resolves.toEqual(`Resources: + topic152D84A37: + Type: AWS::SNS::Topic + Metadata: + aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic1/Resource + topic2A4FB547F: + Type: AWS::SNS::Topic + Metadata: + aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic2/Resource`); +})); +test_helpers_1.integTest('ssm parameter provider error', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await expect(fixture.cdk(['synth', + fixture.fullStackName('missing-ssm-parameter'), + '-c', 'test:ssm-parameter-name=/does/not/exist'], { + allowErrExit: true, + })).resolves.toContain('SSM parameter not available in account'); +})); +test_helpers_1.integTest('automatic ordering', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // Deploy the consuming stack which will include the producing stack + await fixture.cdkDeploy('order-consuming'); + // Destroy the providing stack which will include the consuming stack + await fixture.cdkDestroy('order-providing'); +})); +test_helpers_1.integTest('context setting', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await fs_1.promises.writeFile(path.join(fixture.integTestDir, 'cdk.context.json'), JSON.stringify({ + contextkey: 'this is the context value', + })); + try { + await expect(fixture.cdk(['context'])).resolves.toContain('this is the context value'); + // Test that deleting the contextkey works + await fixture.cdk(['context', '--reset', 'contextkey']); + await expect(fixture.cdk(['context'])).resolves.not.toContain('this is the context value'); + // Test that forced delete of the context key does not throw + await fixture.cdk(['context', '-f', '--reset', 'contextkey']); + } + finally { + await fs_1.promises.unlink(path.join(fixture.integTestDir, 'cdk.context.json')); + } +})); +test_helpers_1.integTest('deploy', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const stackArn = await fixture.cdkDeploy('test-2', { captureStderr: false }); + // verify the number of resources in the stack + const response = await fixture.aws.cloudFormation('describeStackResources', { + StackName: stackArn, + }); + expect((_a = response.StackResources) === null || _a === void 0 ? void 0 : _a.length).toEqual(2); +})); +test_helpers_1.integTest('deploy all', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const arns = await fixture.cdkDeploy('test-*', { captureStderr: false }); + // verify that we only deployed a single stack (there's a single ARN in the output) + expect(arns.split('\n').length).toEqual(2); +})); +test_helpers_1.integTest('nested stack with parameters', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + // STACK_NAME_PREFIX is used in MyTopicParam to allow multiple instances + // of this test to run in parallel, othewise they will attempt to create the same SNS topic. + const stackArn = await fixture.cdkDeploy('with-nested-stack-using-parameters', { + options: ['--parameters', `MyTopicParam=${fixture.stackNamePrefix}ThereIsNoSpoon`], + captureStderr: false, + }); + // verify that we only deployed a single stack (there's a single ARN in the output) + expect(stackArn.split('\n').length).toEqual(1); + // verify the number of resources in the stack + const response = await fixture.aws.cloudFormation('describeStackResources', { + StackName: stackArn, + }); + expect((_a = response.StackResources) === null || _a === void 0 ? void 0 : _a.length).toEqual(1); +})); +test_helpers_1.integTest('deploy without execute', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const stackArn = await fixture.cdkDeploy('test-2', { + options: ['--no-execute'], + captureStderr: false, + }); + // verify that we only deployed a single stack (there's a single ARN in the output) + expect(stackArn.split('\n').length).toEqual(1); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].StackStatus).toEqual('REVIEW_IN_PROGRESS'); +})); +test_helpers_1.integTest('security related changes without a CLI are expected to fail', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // redirect /dev/null to stdin, which means there will not be tty attached + // since this stack includes security-related changes, the deployment should + // immediately fail because we can't confirm the changes + const stackName = 'iam-test'; + await expect(fixture.cdkDeploy(stackName, { + options: ['<', '/dev/null'], + neverRequireApproval: false, + })).rejects.toThrow('exited with error'); + // Ensure stack was not deployed + await expect(fixture.aws.cloudFormation('describeStacks', { + StackName: fixture.fullStackName(stackName), + })).rejects.toThrow('does not exist'); +})); +test_helpers_1.integTest('deploy wildcard with outputs', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const outputsFile = path.join(fixture.integTestDir, 'outputs', 'outputs.json'); + await fs_1.promises.mkdir(path.dirname(outputsFile), { recursive: true }); + await fixture.cdkDeploy(['outputs-test-*'], { + options: ['--outputs-file', outputsFile], + }); + const outputs = JSON.parse((await fs_1.promises.readFile(outputsFile, { encoding: 'utf-8' })).toString()); + expect(outputs).toEqual({ + [`${fixture.stackNamePrefix}-outputs-test-1`]: { + TopicName: `${fixture.stackNamePrefix}-outputs-test-1MyTopic`, + }, + [`${fixture.stackNamePrefix}-outputs-test-2`]: { + TopicName: `${fixture.stackNamePrefix}-outputs-test-2MyOtherTopic`, + }, + }); +})); +test_helpers_1.integTest('deploy with parameters', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const stackArn = await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}bazinga`, + ], + captureStderr: false, + }); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].Parameters).toEqual([ + { + ParameterKey: 'TopicNameParam', + ParameterValue: `${fixture.stackNamePrefix}bazinga`, + }, + ]); +})); +test_helpers_1.integTest('update to stack in ROLLBACK_COMPLETE state will delete stack and create a new one', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a, _b, _c, _d; + // GIVEN + await expect(fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`, + ], + captureStderr: false, + })).rejects.toThrow('exited with error'); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: fixture.fullStackName('param-test-1'), + }); + const stackArn = (_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].StackId; + expect((_b = response.Stacks) === null || _b === void 0 ? void 0 : _b[0].StackStatus).toEqual('ROLLBACK_COMPLETE'); + // WHEN + const newStackArn = await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`, + ], + captureStderr: false, + }); + const newStackResponse = await fixture.aws.cloudFormation('describeStacks', { + StackName: newStackArn, + }); + // THEN + expect(stackArn).not.toEqual(newStackArn); // new stack was created + expect((_c = newStackResponse.Stacks) === null || _c === void 0 ? void 0 : _c[0].StackStatus).toEqual('CREATE_COMPLETE'); + expect((_d = newStackResponse.Stacks) === null || _d === void 0 ? void 0 : _d[0].Parameters).toEqual([ + { + ParameterKey: 'TopicNameParam', + ParameterValue: `${fixture.stackNamePrefix}allgood`, + }, + ]); +})); +test_helpers_1.integTest('stack in UPDATE_ROLLBACK_COMPLETE state can be updated', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a, _b, _c, _d; + // GIVEN + const stackArn = await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}nice`, + ], + captureStderr: false, + }); + let response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].StackStatus).toEqual('CREATE_COMPLETE'); + // bad parameter name with @ will put stack into UPDATE_ROLLBACK_COMPLETE + await expect(fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`, + ], + captureStderr: false, + })).rejects.toThrow('exited with error'); + ; + response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_b = response.Stacks) === null || _b === void 0 ? void 0 : _b[0].StackStatus).toEqual('UPDATE_ROLLBACK_COMPLETE'); + // WHEN + await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`, + ], + captureStderr: false, + }); + response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + // THEN + expect((_c = response.Stacks) === null || _c === void 0 ? void 0 : _c[0].StackStatus).toEqual('UPDATE_COMPLETE'); + expect((_d = response.Stacks) === null || _d === void 0 ? void 0 : _d[0].Parameters).toEqual([ + { + ParameterKey: 'TopicNameParam', + ParameterValue: `${fixture.stackNamePrefix}allgood`, + }, + ]); +})); +test_helpers_1.integTest('deploy with wildcard and parameters', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await fixture.cdkDeploy('param-test-*', { + options: [ + '--parameters', `${fixture.stackNamePrefix}-param-test-1:TopicNameParam=${fixture.stackNamePrefix}bazinga`, + '--parameters', `${fixture.stackNamePrefix}-param-test-2:OtherTopicNameParam=${fixture.stackNamePrefix}ThatsMySpot`, + '--parameters', `${fixture.stackNamePrefix}-param-test-3:DisplayNameParam=${fixture.stackNamePrefix}HeyThere`, + '--parameters', `${fixture.stackNamePrefix}-param-test-3:OtherDisplayNameParam=${fixture.stackNamePrefix}AnotherOne`, + ], + }); +})); +test_helpers_1.integTest('deploy with parameters multi', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const paramVal1 = `${fixture.stackNamePrefix}bazinga`; + const paramVal2 = `${fixture.stackNamePrefix}=jagshemash`; + const stackArn = await fixture.cdkDeploy('param-test-3', { + options: [ + '--parameters', `DisplayNameParam=${paramVal1}`, + '--parameters', `OtherDisplayNameParam=${paramVal2}`, + ], + captureStderr: false, + }); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].Parameters).toEqual([ + { + ParameterKey: 'DisplayNameParam', + ParameterValue: paramVal1, + }, + { + ParameterKey: 'OtherDisplayNameParam', + ParameterValue: paramVal2, + }, + ]); +})); +test_helpers_1.integTest('deploy with notification ARN', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const topicName = `${fixture.stackNamePrefix}-test-topic`; + const response = await fixture.aws.sns('createTopic', { Name: topicName }); + const topicArn = response.TopicArn; + try { + await fixture.cdkDeploy('test-2', { + options: ['--notification-arns', topicArn], + }); + // verify that the stack we deployed has our notification ARN + const describeResponse = await fixture.aws.cloudFormation('describeStacks', { + StackName: fixture.fullStackName('test-2'), + }); + expect((_a = describeResponse.Stacks) === null || _a === void 0 ? void 0 : _a[0].NotificationARNs).toEqual([topicArn]); + } + finally { + await fixture.aws.sns('deleteTopic', { + TopicArn: topicArn, + }); + } +})); +test_helpers_1.integTest('deploy with role', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const roleName = `${fixture.stackNamePrefix}-test-role`; + await deleteRole(); + const createResponse = await fixture.aws.iam('createRole', { + RoleName: roleName, + AssumeRolePolicyDocument: JSON.stringify({ + Version: '2012-10-17', + Statement: [{ + Action: 'sts:AssumeRole', + Principal: { Service: 'cloudformation.amazonaws.com' }, + Effect: 'Allow', + }, { + Action: 'sts:AssumeRole', + Principal: { AWS: (await fixture.aws.sts('getCallerIdentity', {})).Arn }, + Effect: 'Allow', + }], + }), + }); + const roleArn = createResponse.Role.Arn; + try { + await fixture.aws.iam('putRolePolicy', { + RoleName: roleName, + PolicyName: 'DefaultPolicy', + PolicyDocument: JSON.stringify({ + Version: '2012-10-17', + Statement: [{ + Action: '*', + Resource: '*', + Effect: 'Allow', + }], + }), + }); + await aws_helpers_1.retry(fixture.output, 'Trying to assume fresh role', aws_helpers_1.retry.forSeconds(300), async () => { + await fixture.aws.sts('assumeRole', { + RoleArn: roleArn, + RoleSessionName: 'testing', + }); + }); + // In principle, the role has replicated from 'us-east-1' to wherever we're testing. + // Give it a little more sleep to make sure CloudFormation is not hitting a box + // that doesn't have it yet. + await aws_helpers_1.sleep(5000); + await fixture.cdkDeploy('test-2', { + options: ['--role-arn', roleArn], + }); + // Immediately delete the stack again before we delete the role. + // + // Since roles are sticky, if we delete the role before the stack, subsequent DeleteStack + // operations will fail when CloudFormation tries to assume the role that's already gone. + await fixture.cdkDestroy('test-2'); + } + finally { + await deleteRole(); + } + async function deleteRole() { + try { + for (const policyName of (await fixture.aws.iam('listRolePolicies', { RoleName: roleName })).PolicyNames) { + await fixture.aws.iam('deleteRolePolicy', { + RoleName: roleName, + PolicyName: policyName, + }); + } + await fixture.aws.iam('deleteRole', { RoleName: roleName }); + } + catch (e) { + if (e.message.indexOf('cannot be found') > -1) { + return; + } + throw e; + } + } +})); +test_helpers_1.integTest('cdk diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]); + expect(diff1).toContain('AWS::SNS::Topic'); + const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]); + expect(diff2).toContain('AWS::SNS::Topic'); + // We can make it fail by passing --fail + await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1')])) + .rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('cdk diff --fail on multiple stacks exits with error if any of the stacks contains a diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // GIVEN + const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]); + expect(diff1).toContain('AWS::SNS::Topic'); + await fixture.cdkDeploy('test-2'); + const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]); + expect(diff2).toContain('There were no differences'); + // WHEN / THEN + await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('cdk diff --fail with multiple stack exits with if any of the stacks contains a diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // GIVEN + await fixture.cdkDeploy('test-1'); + const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]); + expect(diff1).toContain('There were no differences'); + const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]); + expect(diff2).toContain('AWS::SNS::Topic'); + // WHEN / THEN + await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('deploy stack with docker asset', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await fixture.cdkDeploy('docker'); +})); +test_helpers_1.integTest('deploy and test stack with lambda asset', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a, _b; + const stackArn = await fixture.cdkDeploy('lambda', { captureStderr: false }); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + const lambdaArn = (_b = (_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].Outputs) === null || _b === void 0 ? void 0 : _b[0].OutputValue; + if (lambdaArn === undefined) { + throw new Error('Stack did not have expected Lambda ARN output'); + } + const output = await fixture.aws.lambda('invoke', { + FunctionName: lambdaArn, + }); + expect(JSON.stringify(output.Payload)).toContain('dear asset'); +})); +test_helpers_1.integTest('cdk ls', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const listing = await fixture.cdk(['ls'], { captureStderr: false }); + const expectedStacks = [ + 'conditional-resource', + 'docker', + 'docker-with-custom-file', + 'failed', + 'iam-test', + 'lambda', + 'missing-ssm-parameter', + 'order-providing', + 'outputs-test-1', + 'outputs-test-2', + 'param-test-1', + 'param-test-2', + 'param-test-3', + 'termination-protection', + 'test-1', + 'test-2', + 'with-nested-stack', + 'with-nested-stack-using-parameters', + 'order-consuming', + ]; + for (const stack of expectedStacks) { + expect(listing).toContain(fixture.fullStackName(stack)); + } +})); +test_helpers_1.integTest('deploy stack without resource', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // Deploy the stack without resources + await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } }); + // This should have succeeded but not deployed the stack. + await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') })) + .rejects.toThrow('conditional-resource does not exist'); + // Deploy the stack with resources + await fixture.cdkDeploy('conditional-resource'); + // Then again WITHOUT resources (this should destroy the stack) + await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } }); + await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') })) + .rejects.toThrow('conditional-resource does not exist'); +})); +test_helpers_1.integTest('IAM diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const output = await fixture.cdk(['diff', fixture.fullStackName('iam-test')]); + // Roughly check for a table like this: + // + // ┌───┬─────────────────┬────────┬────────────────┬────────────────────────────-──┬───────────┐ + // │ │ Resource │ Effect │ Action │ Principal │ Condition │ + // ├───┼─────────────────┼────────┼────────────────┼───────────────────────────────┼───────────┤ + // │ + │ ${SomeRole.Arn} │ Allow │ sts:AssumeRole │ Service:ec2.amazonaws.com │ │ + // └───┴─────────────────┴────────┴────────────────┴───────────────────────────────┴───────────┘ + expect(output).toContain('${SomeRole.Arn}'); + expect(output).toContain('sts:AssumeRole'); + expect(output).toContain('ec2.amazonaws.com'); +})); +test_helpers_1.integTest('fast deploy', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // we are using a stack with a nested stack because CFN will always attempt to + // update a nested stack, which will allow us to verify that updates are actually + // skipped unless --force is specified. + const stackArn = await fixture.cdkDeploy('with-nested-stack', { captureStderr: false }); + const changeSet1 = await getLatestChangeSet(); + // Deploy the same stack again, there should be no new change set created + await fixture.cdkDeploy('with-nested-stack'); + const changeSet2 = await getLatestChangeSet(); + expect(changeSet2.ChangeSetId).toEqual(changeSet1.ChangeSetId); + // Deploy the stack again with --force, now we should create a changeset + await fixture.cdkDeploy('with-nested-stack', { options: ['--force'] }); + const changeSet3 = await getLatestChangeSet(); + expect(changeSet3.ChangeSetId).not.toEqual(changeSet2.ChangeSetId); + // Deploy the stack again with tags, expected to create a new changeset + // even though the resources didn't change. + await fixture.cdkDeploy('with-nested-stack', { options: ['--tags', 'key=value'] }); + const changeSet4 = await getLatestChangeSet(); + expect(changeSet4.ChangeSetId).not.toEqual(changeSet3.ChangeSetId); + async function getLatestChangeSet() { + var _a, _b, _c; + const response = await fixture.aws.cloudFormation('describeStacks', { StackName: stackArn }); + if (!((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0])) { + throw new Error('Did not get a ChangeSet at all'); + } + fixture.log(`Found Change Set ${(_b = response.Stacks) === null || _b === void 0 ? void 0 : _b[0].ChangeSetId}`); + return (_c = response.Stacks) === null || _c === void 0 ? void 0 : _c[0]; + } +})); +test_helpers_1.integTest('failed deploy does not hang', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // this will hang if we introduce https://github.com/aws/aws-cdk/issues/6403 again. + await expect(fixture.cdkDeploy('failed')).rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('can still load old assemblies', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const cxAsmDir = path.join(os.tmpdir(), 'cdk-integ-cx'); + const testAssembliesDirectory = path.join(__dirname, 'cloud-assemblies'); + for (const asmdir of await listChildDirs(testAssembliesDirectory)) { + fixture.log(`ASSEMBLY ${asmdir}`); + await cdk_helpers_1.cloneDirectory(asmdir, cxAsmDir); + // Some files in the asm directory that have a .js extension are + // actually treated as templates. Evaluate them using NodeJS. + const templates = await listChildren(cxAsmDir, fullPath => Promise.resolve(fullPath.endsWith('.js'))); + for (const template of templates) { + const targetName = template.replace(/.js$/, ''); + await cdk_helpers_1.shell([process.execPath, template, '>', targetName], { + cwd: cxAsmDir, + output: fixture.output, + modEnv: { + TEST_ACCOUNT: await fixture.aws.account(), + TEST_REGION: fixture.aws.region, + }, + }); + } + // Use this directory as a Cloud Assembly + const output = await fixture.cdk([ + '--app', cxAsmDir, + '-v', + 'synth', + ]); + // Assert that there was no providerError in CDK's stderr + // Because we rely on the app/framework to actually error in case the + // provider fails, we inspect the logs here. + expect(output).not.toContain('$providerError'); + } +})); +test_helpers_1.integTest('generating and loading assembly', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const asmOutputDir = `${fixture.integTestDir}-cdk-integ-asm`; + await fixture.shell(['rm', '-rf', asmOutputDir]); + // Synthesize a Cloud Assembly tothe default directory (cdk.out) and a specific directory. + await fixture.cdk(['synth']); + await fixture.cdk(['synth', '--output', asmOutputDir]); + // cdk.out in the current directory and the indicated --output should be the same + await fixture.shell(['diff', 'cdk.out', asmOutputDir]); + // Check that we can 'ls' the synthesized asm. + // Change to some random directory to make sure we're not accidentally loading cdk.json + const list = await fixture.cdk(['--app', asmOutputDir, 'ls'], { cwd: os.tmpdir() }); + // Same stacks we know are in the app + expect(list).toContain(`${fixture.stackNamePrefix}-lambda`); + expect(list).toContain(`${fixture.stackNamePrefix}-test-1`); + expect(list).toContain(`${fixture.stackNamePrefix}-test-2`); + // Check that we can use '.' and just synth ,the generated asm + const stackTemplate = await fixture.cdk(['--app', '.', 'synth', fixture.fullStackName('test-2')], { + cwd: asmOutputDir, + }); + expect(stackTemplate).toContain('topic152D84A37'); + // Deploy a Lambda from the copied asm + await fixture.cdkDeploy('lambda', { options: ['-a', '.'], cwd: asmOutputDir }); + // Remove (rename) the original custom docker file that was used during synth. + // this verifies that the assemly has a copy of it and that the manifest uses + // relative paths to reference to it. + const customDockerFile = path.join(fixture.integTestDir, 'docker', 'Dockerfile.Custom'); + await fs_1.promises.rename(customDockerFile, `${customDockerFile}~`); + try { + // deploy a docker image with custom file without synth (uses assets) + await fixture.cdkDeploy('docker-with-custom-file', { options: ['-a', '.'], cwd: asmOutputDir }); + } + finally { + // Rename back to restore fixture to original state + await fs_1.promises.rename(`${customDockerFile}~`, customDockerFile); + } +})); +test_helpers_1.integTest('templates on disk contain metadata resource, also in nested assemblies', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // Synth first, and switch on version reporting because cdk.json is disabling it + await fixture.cdk(['synth', '--version-reporting=true']); + // Load template from disk from root assembly + const templateContents = await fixture.shell(['cat', 'cdk.out/*-lambda.template.json']); + expect(JSON.parse(templateContents).Resources.CDKMetadata).toBeTruthy(); + // Load template from nested assembly + const nestedTemplateContents = await fixture.shell(['cat', 'cdk.out/assembly-*-stage/*-stage-StackInStage.template.json']); + expect(JSON.parse(nestedTemplateContents).Resources.CDKMetadata).toBeTruthy(); +})); +async function listChildren(parent, pred) { + const ret = new Array(); + for (const child of await fs_1.promises.readdir(parent, { encoding: 'utf-8' })) { + const fullPath = path.join(parent, child.toString()); + if (await pred(fullPath)) { + ret.push(fullPath); + } + } + return ret; +} +async function listChildDirs(parent) { + return listChildren(parent, async (fullPath) => (await fs_1.promises.stat(fullPath)).isDirectory()); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.integtest.js","sourceRoot":"","sources":["cli.integtest.ts"],"names":[],"mappings":"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","sourcesContent":["import { promises as fs } from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { retry, sleep } from './aws-helpers';\nimport { cloneDirectory, shell, withDefaultFixture } from './cdk-helpers';\nimport { integTest } from './test-helpers';\n\njest.setTimeout(600 * 1000);\n\nintegTest('VPC Lookup', withDefaultFixture(async (fixture) => {\n  fixture.log('Making sure we are clean before starting.');\n  await fixture.cdkDestroy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } });\n\n  fixture.log('Setting up: creating a VPC with known tags');\n  await fixture.cdkDeploy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } });\n  fixture.log('Setup complete!');\n\n  fixture.log('Verifying we can now import that VPC');\n  await fixture.cdkDeploy('import-vpc', { modEnv: { ENABLE_VPC_TESTING: 'IMPORT' } });\n}));\n\nintegTest('Two ways of shoing the version', withDefaultFixture(async (fixture) => {\n  const version1 = await fixture.cdk(['version'], { verbose: false });\n  const version2 = await fixture.cdk(['--version'], { verbose: false });\n\n  expect(version1).toEqual(version2);\n}));\n\nintegTest('Termination protection', withDefaultFixture(async (fixture) => {\n  const stackName = 'termination-protection';\n  await fixture.cdkDeploy(stackName);\n\n  // Try a destroy that should fail\n  await expect(fixture.cdkDestroy(stackName)).rejects.toThrow('exited with error');\n\n  // Can update termination protection even though the change set doesn't contain changes\n  await fixture.cdkDeploy(stackName, { modEnv: { TERMINATION_PROTECTION: 'FALSE' } });\n  await fixture.cdkDestroy(stackName);\n}));\n\nintegTest('cdk synth', withDefaultFixture(async (fixture) => {\n  await expect(fixture.cdk(['synth', fixture.fullStackName('test-1')], { verbose: false })).resolves.toEqual(\n    `Resources:\n  topic69831491:\n    Type: AWS::SNS::Topic\n    Metadata:\n      aws:cdk:path: ${fixture.stackNamePrefix}-test-1/topic/Resource`);\n\n  await expect(fixture.cdk(['synth', fixture.fullStackName('test-2')], { verbose: false })).resolves.toEqual(\n    `Resources:\n  topic152D84A37:\n    Type: AWS::SNS::Topic\n    Metadata:\n      aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic1/Resource\n  topic2A4FB547F:\n    Type: AWS::SNS::Topic\n    Metadata:\n      aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic2/Resource`);\n}));\n\nintegTest('ssm parameter provider error', withDefaultFixture(async (fixture) => {\n  await expect(fixture.cdk(['synth',\n    fixture.fullStackName('missing-ssm-parameter'),\n    '-c', 'test:ssm-parameter-name=/does/not/exist'], {\n    allowErrExit: true,\n  })).resolves.toContain('SSM parameter not available in account');\n}));\n\nintegTest('automatic ordering', withDefaultFixture(async (fixture) => {\n  // Deploy the consuming stack which will include the producing stack\n  await fixture.cdkDeploy('order-consuming');\n\n  // Destroy the providing stack which will include the consuming stack\n  await fixture.cdkDestroy('order-providing');\n}));\n\nintegTest('context setting', withDefaultFixture(async (fixture) => {\n  await fs.writeFile(path.join(fixture.integTestDir, 'cdk.context.json'), JSON.stringify({\n    contextkey: 'this is the context value',\n  }));\n  try {\n    await expect(fixture.cdk(['context'])).resolves.toContain('this is the context value');\n\n    // Test that deleting the contextkey works\n    await fixture.cdk(['context', '--reset', 'contextkey']);\n    await expect(fixture.cdk(['context'])).resolves.not.toContain('this is the context value');\n\n    // Test that forced delete of the context key does not throw\n    await fixture.cdk(['context', '-f', '--reset', 'contextkey']);\n\n  } finally {\n    await fs.unlink(path.join(fixture.integTestDir, 'cdk.context.json'));\n  }\n}));\n\nintegTest('deploy', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('test-2', { captureStderr: false });\n\n  // verify the number of resources in the stack\n  const response = await fixture.aws.cloudFormation('describeStackResources', {\n    StackName: stackArn,\n  });\n  expect(response.StackResources?.length).toEqual(2);\n}));\n\nintegTest('deploy all', withDefaultFixture(async (fixture) => {\n  const arns = await fixture.cdkDeploy('test-*', { captureStderr: false });\n\n  // verify that we only deployed a single stack (there's a single ARN in the output)\n  expect(arns.split('\\n').length).toEqual(2);\n}));\n\nintegTest('nested stack with parameters', withDefaultFixture(async (fixture) => {\n  // STACK_NAME_PREFIX is used in MyTopicParam to allow multiple instances\n  // of this test to run in parallel, othewise they will attempt to create the same SNS topic.\n  const stackArn = await fixture.cdkDeploy('with-nested-stack-using-parameters', {\n    options: ['--parameters', `MyTopicParam=${fixture.stackNamePrefix}ThereIsNoSpoon`],\n    captureStderr: false,\n  });\n\n  // verify that we only deployed a single stack (there's a single ARN in the output)\n  expect(stackArn.split('\\n').length).toEqual(1);\n\n  // verify the number of resources in the stack\n  const response = await fixture.aws.cloudFormation('describeStackResources', {\n    StackName: stackArn,\n  });\n  expect(response.StackResources?.length).toEqual(1);\n}));\n\nintegTest('deploy without execute', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('test-2', {\n    options: ['--no-execute'],\n    captureStderr: false,\n  });\n  // verify that we only deployed a single stack (there's a single ARN in the output)\n  expect(stackArn.split('\\n').length).toEqual(1);\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].StackStatus).toEqual('REVIEW_IN_PROGRESS');\n}));\n\nintegTest('security related changes without a CLI are expected to fail', withDefaultFixture(async (fixture) => {\n  // redirect /dev/null to stdin, which means there will not be tty attached\n  // since this stack includes security-related changes, the deployment should\n  // immediately fail because we can't confirm the changes\n  const stackName = 'iam-test';\n  await expect(fixture.cdkDeploy(stackName, {\n    options: ['<', '/dev/null'], // H4x, this only works because I happen to know we pass shell: true.\n    neverRequireApproval: false,\n  })).rejects.toThrow('exited with error');\n\n  // Ensure stack was not deployed\n  await expect(fixture.aws.cloudFormation('describeStacks', {\n    StackName: fixture.fullStackName(stackName),\n  })).rejects.toThrow('does not exist');\n}));\n\nintegTest('deploy wildcard with outputs', withDefaultFixture(async (fixture) => {\n  const outputsFile = path.join(fixture.integTestDir, 'outputs', 'outputs.json');\n  await fs.mkdir(path.dirname(outputsFile), { recursive: true });\n\n  await fixture.cdkDeploy(['outputs-test-*'], {\n    options: ['--outputs-file', outputsFile],\n  });\n\n  const outputs = JSON.parse((await fs.readFile(outputsFile, { encoding: 'utf-8' })).toString());\n  expect(outputs).toEqual({\n    [`${fixture.stackNamePrefix}-outputs-test-1`]: {\n      TopicName: `${fixture.stackNamePrefix}-outputs-test-1MyTopic`,\n    },\n    [`${fixture.stackNamePrefix}-outputs-test-2`]: {\n      TopicName: `${fixture.stackNamePrefix}-outputs-test-2MyOtherTopic`,\n    },\n  });\n}));\n\nintegTest('deploy with parameters', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}bazinga`,\n    ],\n    captureStderr: false,\n  });\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'TopicNameParam',\n      ParameterValue: `${fixture.stackNamePrefix}bazinga`,\n    },\n  ]);\n}));\n\nintegTest('update to stack in ROLLBACK_COMPLETE state will delete stack and create a new one', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  await expect(fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`,\n    ],\n    captureStderr: false,\n  })).rejects.toThrow('exited with error');\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: fixture.fullStackName('param-test-1'),\n  });\n\n  const stackArn = response.Stacks?.[0].StackId;\n  expect(response.Stacks?.[0].StackStatus).toEqual('ROLLBACK_COMPLETE');\n\n  // WHEN\n  const newStackArn = await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`,\n    ],\n    captureStderr: false,\n  });\n\n  const newStackResponse = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: newStackArn,\n  });\n\n  // THEN\n  expect (stackArn).not.toEqual(newStackArn); // new stack was created\n  expect(newStackResponse.Stacks?.[0].StackStatus).toEqual('CREATE_COMPLETE');\n  expect(newStackResponse.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'TopicNameParam',\n      ParameterValue: `${fixture.stackNamePrefix}allgood`,\n    },\n  ]);\n}));\n\nintegTest('stack in UPDATE_ROLLBACK_COMPLETE state can be updated', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  const stackArn = await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}nice`,\n    ],\n    captureStderr: false,\n  });\n\n  let response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].StackStatus).toEqual('CREATE_COMPLETE');\n\n  // bad parameter name with @ will put stack into UPDATE_ROLLBACK_COMPLETE\n  await expect(fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`,\n    ],\n    captureStderr: false,\n  })).rejects.toThrow('exited with error');;\n\n  response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].StackStatus).toEqual('UPDATE_ROLLBACK_COMPLETE');\n\n  // WHEN\n  await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`,\n    ],\n    captureStderr: false,\n  });\n\n  response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  // THEN\n  expect(response.Stacks?.[0].StackStatus).toEqual('UPDATE_COMPLETE');\n  expect(response.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'TopicNameParam',\n      ParameterValue: `${fixture.stackNamePrefix}allgood`,\n    },\n  ]);\n}));\n\nintegTest('deploy with wildcard and parameters', withDefaultFixture(async (fixture) => {\n  await fixture.cdkDeploy('param-test-*', {\n    options: [\n      '--parameters', `${fixture.stackNamePrefix}-param-test-1:TopicNameParam=${fixture.stackNamePrefix}bazinga`,\n      '--parameters', `${fixture.stackNamePrefix}-param-test-2:OtherTopicNameParam=${fixture.stackNamePrefix}ThatsMySpot`,\n      '--parameters', `${fixture.stackNamePrefix}-param-test-3:DisplayNameParam=${fixture.stackNamePrefix}HeyThere`,\n      '--parameters', `${fixture.stackNamePrefix}-param-test-3:OtherDisplayNameParam=${fixture.stackNamePrefix}AnotherOne`,\n    ],\n  });\n}));\n\nintegTest('deploy with parameters multi', withDefaultFixture(async (fixture) => {\n  const paramVal1 = `${fixture.stackNamePrefix}bazinga`;\n  const paramVal2 = `${fixture.stackNamePrefix}=jagshemash`;\n\n  const stackArn = await fixture.cdkDeploy('param-test-3', {\n    options: [\n      '--parameters', `DisplayNameParam=${paramVal1}`,\n      '--parameters', `OtherDisplayNameParam=${paramVal2}`,\n    ],\n    captureStderr: false,\n  });\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'DisplayNameParam',\n      ParameterValue: paramVal1,\n    },\n    {\n      ParameterKey: 'OtherDisplayNameParam',\n      ParameterValue: paramVal2,\n    },\n  ]);\n}));\n\nintegTest('deploy with notification ARN', withDefaultFixture(async (fixture) => {\n  const topicName = `${fixture.stackNamePrefix}-test-topic`;\n\n  const response = await fixture.aws.sns('createTopic', { Name: topicName });\n  const topicArn = response.TopicArn!;\n  try {\n    await fixture.cdkDeploy('test-2', {\n      options: ['--notification-arns', topicArn],\n    });\n\n    // verify that the stack we deployed has our notification ARN\n    const describeResponse = await fixture.aws.cloudFormation('describeStacks', {\n      StackName: fixture.fullStackName('test-2'),\n    });\n    expect(describeResponse.Stacks?.[0].NotificationARNs).toEqual([topicArn]);\n  } finally {\n    await fixture.aws.sns('deleteTopic', {\n      TopicArn: topicArn,\n    });\n  }\n}));\n\nintegTest('deploy with role', withDefaultFixture(async (fixture) => {\n  const roleName = `${fixture.stackNamePrefix}-test-role`;\n\n  await deleteRole();\n\n  const createResponse = await fixture.aws.iam('createRole', {\n    RoleName: roleName,\n    AssumeRolePolicyDocument: JSON.stringify({\n      Version: '2012-10-17',\n      Statement: [{\n        Action: 'sts:AssumeRole',\n        Principal: { Service: 'cloudformation.amazonaws.com' },\n        Effect: 'Allow',\n      }, {\n        Action: 'sts:AssumeRole',\n        Principal: { AWS: (await fixture.aws.sts('getCallerIdentity', {})).Arn },\n        Effect: 'Allow',\n      }],\n    }),\n  });\n  const roleArn = createResponse.Role.Arn;\n  try {\n    await fixture.aws.iam('putRolePolicy', {\n      RoleName: roleName,\n      PolicyName: 'DefaultPolicy',\n      PolicyDocument: JSON.stringify({\n        Version: '2012-10-17',\n        Statement: [{\n          Action: '*',\n          Resource: '*',\n          Effect: 'Allow',\n        }],\n      }),\n    });\n\n    await retry(fixture.output, 'Trying to assume fresh role', retry.forSeconds(300), async () => {\n      await fixture.aws.sts('assumeRole', {\n        RoleArn: roleArn,\n        RoleSessionName: 'testing',\n      });\n    });\n\n    // In principle, the role has replicated from 'us-east-1' to wherever we're testing.\n    // Give it a little more sleep to make sure CloudFormation is not hitting a box\n    // that doesn't have it yet.\n    await sleep(5000);\n\n    await fixture.cdkDeploy('test-2', {\n      options: ['--role-arn', roleArn],\n    });\n\n    // Immediately delete the stack again before we delete the role.\n    //\n    // Since roles are sticky, if we delete the role before the stack, subsequent DeleteStack\n    // operations will fail when CloudFormation tries to assume the role that's already gone.\n    await fixture.cdkDestroy('test-2');\n\n  } finally {\n    await deleteRole();\n  }\n\n  async function deleteRole() {\n    try {\n      for (const policyName of (await fixture.aws.iam('listRolePolicies', { RoleName: roleName })).PolicyNames) {\n        await fixture.aws.iam('deleteRolePolicy', {\n          RoleName: roleName,\n          PolicyName: policyName,\n        });\n      }\n      await fixture.aws.iam('deleteRole', { RoleName: roleName });\n    } catch (e) {\n      if (e.message.indexOf('cannot be found') > -1) { return; }\n      throw e;\n    }\n  }\n}));\n\nintegTest('cdk diff', withDefaultFixture(async (fixture) => {\n  const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);\n  expect(diff1).toContain('AWS::SNS::Topic');\n\n  const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);\n  expect(diff2).toContain('AWS::SNS::Topic');\n\n  // We can make it fail by passing --fail\n  await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1')]))\n    .rejects.toThrow('exited with error');\n}));\n\nintegTest('cdk diff --fail on multiple stacks exits with error if any of the stacks contains a diff', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);\n  expect(diff1).toContain('AWS::SNS::Topic');\n\n  await fixture.cdkDeploy('test-2');\n  const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);\n  expect(diff2).toContain('There were no differences');\n\n  // WHEN / THEN\n  await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error');\n}));\n\nintegTest('cdk diff --fail with multiple stack exits with if any of the stacks contains a diff', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  await fixture.cdkDeploy('test-1');\n  const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);\n  expect(diff1).toContain('There were no differences');\n\n  const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);\n  expect(diff2).toContain('AWS::SNS::Topic');\n\n  // WHEN / THEN\n  await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error');\n}));\n\nintegTest('deploy stack with docker asset', withDefaultFixture(async (fixture) => {\n  await fixture.cdkDeploy('docker');\n}));\n\nintegTest('deploy and test stack with lambda asset', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('lambda', { captureStderr: false });\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n  const lambdaArn = response.Stacks?.[0].Outputs?.[0].OutputValue;\n  if (lambdaArn === undefined) {\n    throw new Error('Stack did not have expected Lambda ARN output');\n  }\n\n  const output = await fixture.aws.lambda('invoke', {\n    FunctionName: lambdaArn,\n  });\n\n  expect(JSON.stringify(output.Payload)).toContain('dear asset');\n}));\n\nintegTest('cdk ls', withDefaultFixture(async (fixture) => {\n  const listing = await fixture.cdk(['ls'], { captureStderr: false });\n\n  const expectedStacks = [\n    'conditional-resource',\n    'docker',\n    'docker-with-custom-file',\n    'failed',\n    'iam-test',\n    'lambda',\n    'missing-ssm-parameter',\n    'order-providing',\n    'outputs-test-1',\n    'outputs-test-2',\n    'param-test-1',\n    'param-test-2',\n    'param-test-3',\n    'termination-protection',\n    'test-1',\n    'test-2',\n    'with-nested-stack',\n    'with-nested-stack-using-parameters',\n    'order-consuming',\n  ];\n\n  for (const stack of expectedStacks) {\n    expect(listing).toContain(fixture.fullStackName(stack));\n  }\n}));\n\nintegTest('deploy stack without resource', withDefaultFixture(async (fixture) => {\n  // Deploy the stack without resources\n  await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } });\n\n  // This should have succeeded but not deployed the stack.\n  await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') }))\n    .rejects.toThrow('conditional-resource does not exist');\n\n  // Deploy the stack with resources\n  await fixture.cdkDeploy('conditional-resource');\n\n  // Then again WITHOUT resources (this should destroy the stack)\n  await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } });\n\n  await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') }))\n    .rejects.toThrow('conditional-resource does not exist');\n}));\n\nintegTest('IAM diff', withDefaultFixture(async (fixture) => {\n  const output = await fixture.cdk(['diff', fixture.fullStackName('iam-test')]);\n\n  // Roughly check for a table like this:\n  //\n  // ┌───┬─────────────────┬────────┬────────────────┬────────────────────────────-──┬───────────┐\n  // │   │ Resource        │ Effect │ Action         │ Principal                     │ Condition │\n  // ├───┼─────────────────┼────────┼────────────────┼───────────────────────────────┼───────────┤\n  // │ + │ ${SomeRole.Arn} │ Allow  │ sts:AssumeRole │ Service:ec2.amazonaws.com     │           │\n  // └───┴─────────────────┴────────┴────────────────┴───────────────────────────────┴───────────┘\n\n  expect(output).toContain('${SomeRole.Arn}');\n  expect(output).toContain('sts:AssumeRole');\n  expect(output).toContain('ec2.amazonaws.com');\n}));\n\nintegTest('fast deploy', withDefaultFixture(async (fixture) => {\n  // we are using a stack with a nested stack because CFN will always attempt to\n  // update a nested stack, which will allow us to verify that updates are actually\n  // skipped unless --force is specified.\n  const stackArn = await fixture.cdkDeploy('with-nested-stack', { captureStderr: false });\n  const changeSet1 = await getLatestChangeSet();\n\n  // Deploy the same stack again, there should be no new change set created\n  await fixture.cdkDeploy('with-nested-stack');\n  const changeSet2 = await getLatestChangeSet();\n  expect(changeSet2.ChangeSetId).toEqual(changeSet1.ChangeSetId);\n\n  // Deploy the stack again with --force, now we should create a changeset\n  await fixture.cdkDeploy('with-nested-stack', { options: ['--force'] });\n  const changeSet3 = await getLatestChangeSet();\n  expect(changeSet3.ChangeSetId).not.toEqual(changeSet2.ChangeSetId);\n\n  // Deploy the stack again with tags, expected to create a new changeset\n  // even though the resources didn't change.\n  await fixture.cdkDeploy('with-nested-stack', { options: ['--tags', 'key=value'] });\n  const changeSet4 = await getLatestChangeSet();\n  expect(changeSet4.ChangeSetId).not.toEqual(changeSet3.ChangeSetId);\n\n  async function getLatestChangeSet() {\n    const response = await fixture.aws.cloudFormation('describeStacks', { StackName: stackArn });\n    if (!response.Stacks?.[0]) { throw new Error('Did not get a ChangeSet at all'); }\n    fixture.log(`Found Change Set ${response.Stacks?.[0].ChangeSetId}`);\n    return response.Stacks?.[0];\n  }\n}));\n\nintegTest('failed deploy does not hang', withDefaultFixture(async (fixture) => {\n  // this will hang if we introduce https://github.com/aws/aws-cdk/issues/6403 again.\n  await expect(fixture.cdkDeploy('failed')).rejects.toThrow('exited with error');\n}));\n\nintegTest('can still load old assemblies', withDefaultFixture(async (fixture) => {\n  const cxAsmDir = path.join(os.tmpdir(), 'cdk-integ-cx');\n\n  const testAssembliesDirectory = path.join(__dirname, 'cloud-assemblies');\n  for (const asmdir of await listChildDirs(testAssembliesDirectory)) {\n    fixture.log(`ASSEMBLY ${asmdir}`);\n    await cloneDirectory(asmdir, cxAsmDir);\n\n    // Some files in the asm directory that have a .js extension are\n    // actually treated as templates. Evaluate them using NodeJS.\n    const templates = await listChildren(cxAsmDir, fullPath => Promise.resolve(fullPath.endsWith('.js')));\n    for (const template of templates) {\n      const targetName = template.replace(/.js$/, '');\n      await shell([process.execPath, template, '>', targetName], {\n        cwd: cxAsmDir,\n        output: fixture.output,\n        modEnv: {\n          TEST_ACCOUNT: await fixture.aws.account(),\n          TEST_REGION: fixture.aws.region,\n        },\n      });\n    }\n\n    // Use this directory as a Cloud Assembly\n    const output = await fixture.cdk([\n      '--app', cxAsmDir,\n      '-v',\n      'synth',\n    ]);\n\n    // Assert that there was no providerError in CDK's stderr\n    // Because we rely on the app/framework to actually error in case the\n    // provider fails, we inspect the logs here.\n    expect(output).not.toContain('$providerError');\n  }\n}));\n\nintegTest('generating and loading assembly', withDefaultFixture(async (fixture) => {\n  const asmOutputDir = `${fixture.integTestDir}-cdk-integ-asm`;\n  await fixture.shell(['rm', '-rf', asmOutputDir]);\n\n  // Synthesize a Cloud Assembly tothe default directory (cdk.out) and a specific directory.\n  await fixture.cdk(['synth']);\n  await fixture.cdk(['synth', '--output', asmOutputDir]);\n\n  // cdk.out in the current directory and the indicated --output should be the same\n  await fixture.shell(['diff', 'cdk.out', asmOutputDir]);\n\n  // Check that we can 'ls' the synthesized asm.\n  // Change to some random directory to make sure we're not accidentally loading cdk.json\n  const list = await fixture.cdk(['--app', asmOutputDir, 'ls'], { cwd: os.tmpdir() });\n  // Same stacks we know are in the app\n  expect(list).toContain(`${fixture.stackNamePrefix}-lambda`);\n  expect(list).toContain(`${fixture.stackNamePrefix}-test-1`);\n  expect(list).toContain(`${fixture.stackNamePrefix}-test-2`);\n\n  // Check that we can use '.' and just synth ,the generated asm\n  const stackTemplate = await fixture.cdk(['--app', '.', 'synth', fixture.fullStackName('test-2')], {\n    cwd: asmOutputDir,\n  });\n  expect(stackTemplate).toContain('topic152D84A37');\n\n  // Deploy a Lambda from the copied asm\n  await fixture.cdkDeploy('lambda', { options: ['-a', '.'], cwd: asmOutputDir });\n\n  // Remove (rename) the original custom docker file that was used during synth.\n  // this verifies that the assemly has a copy of it and that the manifest uses\n  // relative paths to reference to it.\n  const customDockerFile = path.join(fixture.integTestDir, 'docker', 'Dockerfile.Custom');\n  await fs.rename(customDockerFile, `${customDockerFile}~`);\n  try {\n\n    // deploy a docker image with custom file without synth (uses assets)\n    await fixture.cdkDeploy('docker-with-custom-file', { options: ['-a', '.'], cwd: asmOutputDir });\n\n  } finally {\n    // Rename back to restore fixture to original state\n    await fs.rename(`${customDockerFile}~`, customDockerFile);\n  }\n}));\n\nintegTest('templates on disk contain metadata resource, also in nested assemblies', withDefaultFixture(async (fixture) => {\n  // Synth first, and switch on version reporting because cdk.json is disabling it\n  await fixture.cdk(['synth', '--version-reporting=true']);\n\n  // Load template from disk from root assembly\n  const templateContents = await fixture.shell(['cat', 'cdk.out/*-lambda.template.json']);\n\n  expect(JSON.parse(templateContents).Resources.CDKMetadata).toBeTruthy();\n\n  // Load template from nested assembly\n  const nestedTemplateContents = await fixture.shell(['cat', 'cdk.out/assembly-*-stage/*-stage-StackInStage.template.json']);\n\n  expect(JSON.parse(nestedTemplateContents).Resources.CDKMetadata).toBeTruthy();\n}));\n\nasync function listChildren(parent: string, pred: (x: string) => Promise<boolean>) {\n  const ret = new Array<string>();\n  for (const child of await fs.readdir(parent, { encoding: 'utf-8' })) {\n    const fullPath = path.join(parent, child.toString());\n    if (await pred(fullPath)) {\n      ret.push(fullPath);\n    }\n  }\n  return ret;\n}\n\nasync function listChildDirs(parent: string) {\n  return listChildren(parent, async (fullPath: string) => (await fs.stat(fullPath)).isDirectory());\n}\n"]} \ No newline at end of file diff --git a/packages/aws-cdk/test/integ/cli/cdk-helpers.ts b/packages/aws-cdk/test/integ/cli/cdk-helpers.ts index 66c6799164fd8..01829ebff413f 100644 --- a/packages/aws-cdk/test/integ/cli/cdk-helpers.ts +++ b/packages/aws-cdk/test/integ/cli/cdk-helpers.ts @@ -37,7 +37,7 @@ export function withAws(block: (context: A & AwsContext) * Requires an AWS client to be passed in. * * For backwards compatibility with existing tests (so we don't have to change - * too much) the inner block is expecte to take a `TestFixture` object. + * too much) the inner block is expected to take a `TestFixture` object. */ export function withCdkApp(block: (context: TestFixture) => Promise) { return async (context: A) => { @@ -123,6 +123,7 @@ export interface ShellOptions extends child_process.SpawnOptions { export interface CdkCliOptions extends ShellOptions { options?: string[]; neverRequireApproval?: boolean; + verbose?: boolean; } /** @@ -178,7 +179,9 @@ export class TestFixture { } public async cdk(args: string[], options: CdkCliOptions = {}) { - return this.shell(['cdk', ...args], { + const verbose = options.verbose ?? true; + + return this.shell(['cdk', ...(verbose ? ['-v'] : []), ...args], { ...options, modEnv: { AWS_REGION: this.aws.region, diff --git a/packages/aws-cdk/test/integ/cli/cli.integtest.ts b/packages/aws-cdk/test/integ/cli/cli.integtest.ts index d203c0f66e605..079a560175a8d 100644 --- a/packages/aws-cdk/test/integ/cli/cli.integtest.ts +++ b/packages/aws-cdk/test/integ/cli/cli.integtest.ts @@ -20,8 +20,8 @@ integTest('VPC Lookup', withDefaultFixture(async (fixture) => { })); integTest('Two ways of shoing the version', withDefaultFixture(async (fixture) => { - const version1 = await fixture.cdk(['version']); - const version2 = await fixture.cdk(['--version']); + const version1 = await fixture.cdk(['version'], { verbose: false }); + const version2 = await fixture.cdk(['--version'], { verbose: false }); expect(version1).toEqual(version2); })); @@ -39,14 +39,14 @@ integTest('Termination protection', withDefaultFixture(async (fixture) => { })); integTest('cdk synth', withDefaultFixture(async (fixture) => { - await expect(fixture.cdk(['synth', fixture.fullStackName('test-1')])).resolves.toEqual( + await expect(fixture.cdk(['synth', fixture.fullStackName('test-1')], { verbose: false })).resolves.toEqual( `Resources: topic69831491: Type: AWS::SNS::Topic Metadata: aws:cdk:path: ${fixture.stackNamePrefix}-test-1/topic/Resource`); - await expect(fixture.cdk(['synth', fixture.fullStackName('test-2')])).resolves.toEqual( + await expect(fixture.cdk(['synth', fixture.fullStackName('test-2')], { verbose: false })).resolves.toEqual( `Resources: topic152D84A37: Type: AWS::SNS::Topic