Add tests to confirm generated template structure is as expected in preparation for automation.

Author: melvabout

.gitignore

@@ -6,3 +6,7 @@ node_modules
 # CDK asset staging directory
 .cdk.staging
 cdk.out
+
+# unit tests outputs
+test-monitor
+test-activegate

cucumber/features/activegate.feature

@@ -0,0 +1,14 @@
+Feature: AgtiveGate Feature
+
+    Confirm the structure of the AgtiveGate template
+
+    Scenario: AgtiveGate Template
+        Given That synth has run
+        When the file DynatraceActivegateStack.template.json exists
+        Then the AWS::EC2::VPC resource with the CIDR range 10.0.0.0/16 should exist
+        And 2 AWS::EC2::Subnet should exist
+        And 2 AWS::EC2::RouteTable should exist
+        And 2 AWS::EC2::SubnetRouteTableAssociation should exist
+        And 2 AWS::EC2::Route should exist
+        And 1 AWS::EC2::EIP should exist
+        And 1 AWS::EC2::NatGateway should exist

cucumber/features/monitoring.feature

@@ -0,0 +1,10 @@
+Feature: Monitoring Feature
+
+    Confirm the structure of the monitoring template
+
+    Scenario: Monitoring Template
+        Given That synth has run
+        When the file DynatraceMonitoringRoleStack.template.json exists
+        Then the AWS::IAM::Role resource with the RoleName DynatraceMonitoringRole should exist
+        And the AWS::IAM::Policy resource with the PolicyName like roleDefaultPolicy should exist
+        And actions of AWS::IAM::Policy should match actions file

cucumber/files/actions

@@ -0,0 +1 @@
+acm-pca:ListCertificateAuthorities,apigateway:GET,athena:ListWorkGroups,autoscaling:DescribeAutoScalingGroups,cloudfront:ListDistributions,cloudwatch:GetMetricData,cloudwatch:GetMetricStatistics,cloudwatch:ListMetrics,codebuild:ListProjects,dynamodb:ListTables,dynamodb:ListTagsOfResource,ec2:DescribeAvailabilityZones,ec2:DescribeInstances,ec2:DescribeVolumes,ecs:ListClusters,elasticache:DescribeCacheClusters,elasticloadbalancing:DescribeInstanceHealth,elasticloadbalancing:DescribeListeners,elasticloadbalancing:DescribeLoadBalancers,elasticloadbalancing:DescribeRules,elasticloadbalancing:DescribeTags,elasticloadbalancing:DescribeTargetHealth,events:ListEventBuses,glue:GetJobs,lambda:ListFunctions,lambda:ListTags,logs:DescribeLogGroups,rds:DescribeDBInstances,rds:DescribeEvents,rds:ListTagsForResource,route53:ListHostedZones,s3:ListAllMyBuckets,sns:ListTopics,sqs:ListQueues,sts:GetCallerIdentity,tag:GetResources,tag:GetTagKeys

cucumber/step-definitions/activegate.steps.ts

@@ -0,0 +1,68 @@
+import { loadFeature, defineFeature } from "jest-cucumber";
+import { execSync } from "child_process";
+import { existsSync, readFileSync, mkdirSync, rmSync } from "fs";
+import { Template } from '@aws-cdk/assertions';
+
+
+const feature = loadFeature("./cucumber/features/activegate.feature");
+
+defineFeature(feature, (test) => {
+
+    beforeEach(() => {
+        mkdirSync('./test-activegate/');
+    });
+
+    afterEach(() => {
+        rmSync('./test-activegate/', { recursive: true, force: true });
+    });
+
+    test("AgtiveGate Template", ({ given, when, then }) => {
+
+        let template: Template;
+
+        given("That synth has run", () => {
+            execSync("cdk synth --output ./test-activegate/");
+        });
+
+        when(/^the file (.*) exists$/, (fileName: string) => {
+            expect(existsSync(`./test-activegate/${fileName}`)).toBeTruthy();
+            template = Template.fromString(readFileSync(`./test-activegate/${fileName}`, "utf-8"));
+        });
+
+        then(/^the (.*) resource with the CIDR range (.*) should exist$/, (resourceType: string, cidrRange: string) => {
+
+            let props = {
+                Properties: {
+                    CidrBlock: cidrRange
+                }
+            };
+
+            template.hasResource(resourceType, props);
+        });
+
+
+        then(/^(\d+) AWS::EC2::Subnet should exist$/, (resourceCount: number) => {
+            expect(Object.values(template.findResources("AWS::EC2::Subnet")).length).toEqual(+resourceCount)
+        });
+
+        then(/^(\d+) AWS::EC2::RouteTable should exist$/, (resourceCount: number) => {
+            expect(Object.values(template.findResources("AWS::EC2::RouteTable")).length).toEqual(+resourceCount)
+        })
+
+        then(/^(\d+) AWS::EC2::SubnetRouteTableAssociation should exist$/, (resourceCount: number) => {
+            expect(Object.values(template.findResources("AWS::EC2::SubnetRouteTableAssociation")).length).toEqual(+resourceCount)
+        });
+
+        then(/^(\d+) AWS::EC2::Route should exist$/, (resourceCount: number) => {
+            expect(Object.values(template.findResources("AWS::EC2::Route")).length).toEqual(+resourceCount)
+        });
+
+        then(/^(\d+) AWS::EC2::EIP should exist$/, (resourceCount: number) => {
+            expect(Object.values(template.findResources("AWS::EC2::EIP")).length).toEqual(+resourceCount)
+        });
+
+        then(/^(\d+) AWS::EC2::NatGateway should exist$/, (resourceCount: number) => {
+            expect(Object.values(template.findResources("AWS::EC2::NatGateway")).length).toEqual(+resourceCount)
+        });
+    });
+});

cucumber/step-definitions/monitoring.steps.ts

@@ -0,0 +1,57 @@
+import { loadFeature, defineFeature } from "jest-cucumber";
+import { execSync } from "child_process";
+import { existsSync, readFileSync, mkdirSync, rmSync } from "fs";
+import { Template } from '@aws-cdk/assertions';
+
+
+const feature = loadFeature("./cucumber/features/monitoring.feature");
+
+defineFeature(feature, (test) => {
+
+    beforeEach(() => {
+        mkdirSync('./test-monitor/');
+    });
+
+    afterEach(() => {
+        rmSync('./test-monitor/', { recursive: true, force: true });
+    });
+
+    test("Monitoring Template", ({ given, when, then }) => {
+
+        let template: Template;
+
+        given("That synth has run", () => {
+            execSync("cdk synth --output ./test-monitor/");
+        });
+
+        when(/^the file (.*) exists$/, (fileName: string) => {
+            expect(existsSync(`./test-monitor/${fileName}`)).toBeTruthy();
+            template = Template.fromString(readFileSync(`./test-monitor/${fileName}`, "utf-8"));
+        });
+
+        then(/^the (.*) resource with the (.*) (.*) should exist$/, (resourceType: string, resourceNameKey: string, resourceNameValue: string) => {
+
+            let props = {
+                Properties: {
+                    [resourceNameKey]: resourceNameValue
+                }
+            };
+
+            template.hasResource(resourceType, props);
+        });
+
+        then(/^the (.*) resource with the (.*) like (.*) should exist$/, (resourceType: string, resourceNameKey: string, resourceNameValue: string) => {
+            template.hasResource(resourceType , {})
+            let valueKey = Object.values(template.findResources(resourceType))[0]["Properties"][resourceNameKey]
+            expect(valueKey.startsWith(resourceNameValue)).toBeTruthy();
+        });
+
+        then(/^actions of (.*) should match (.*) file$/, (resourceType, actionsFile: string) => {
+            let actionsString = readFileSync(`./cucumber/files/${actionsFile}`, "utf-8")
+            let actionsList = actionsString.split(",")
+            let objectActionsA = Object.values(template.findResources(resourceType))[0]["Properties"]["PolicyDocument"]["Statement"][0]["Action"] as Array<string>
+            expect(actionsList.sort().join(",")).toEqual(objectActionsA.sort().join(","))
+        });
+
+    });
+});

jest.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+  testEnvironment: 'node',
+  roots: ['<rootDir>/cucumber'],
+  testMatch: ['**/*.steps.ts'],
+  transform: {
+    '^.+\\.tsx?$': 'ts-jest'
+  }
+};