kumogata-template 0.0.1

data/test/template/autoscaling-launch-configuration_test.rb

@@ -0,0 +1,117 @@
+require 'abstract_unit'
+
+class AutoscalingLaunchConfigurationTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_autoscaling_launch_configuration "test", image: "test", ref_instance_type: "test", key_name: "test", instance_monitoring: false
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestAutoscalingLaunchConfiguration": {
+    "Type": "AWS::AutoScaling::LaunchConfiguration",
+    "Properties": {
+      "AssociatePublicIpAddress": "false",
+      "ImageId": {
+        "Fn::FindInMap": [
+          "AWSRegionArch2AMITest",
+          {
+            "Ref": "AWS::Region"
+          },
+          {
+            "Fn::FindInMap": [
+              "AWSInstanceType2Arch",
+              {
+                "Ref": "TestInstanceType"
+              },
+              "Arch"
+            ]
+          }
+        ]
+      },
+      "InstanceMonitoring": "false",
+      "InstanceType": {
+        "Ref": "TestInstanceType"
+      },
+      "KeyName": "test",
+      "UserData": {
+        "Fn::Base64": "#!/bin/bash\\n\\n"
+      }
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+
+  def test_aws
+    template = <<-EOS
+_autoscaling_launch_configuration "test", ref_key_name: "test", ref_security_groups: %w( test ), ref_instance_type: "test", block_device: [ { device: "/dev/sda1", size: 50, type: "io1", iops: 200 }, { device: "/dev/sdm", size: 100, delete: true } ], ref_user_data: "web server port"
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestAutoscalingLaunchConfiguration": {
+    "Type": "AWS::AutoScaling::LaunchConfiguration",
+    "Properties": {
+      "AssociatePublicIpAddress": "false",
+      "BlockDeviceMappings": [
+        {
+          "DeviceName": "/dev/sda1",
+          "Ebs": {
+            "DeleteOnTermination": "true",
+            "Iops": "200",
+            "VolumeSize": "50",
+            "VolumeType": "io1"
+          }
+        },
+        {
+          "DeviceName": "/dev/sdm",
+          "Ebs": {
+            "DeleteOnTermination": "true",
+            "VolumeSize": "100",
+            "VolumeType": "gp2"
+          }
+        }
+      ],
+      "ImageId": {
+        "Fn::FindInMap": [
+          "AWSRegionArch2AMIAmazonLinuxOfficial",
+          {
+            "Ref": "AWS::Region"
+          },
+          {
+            "Fn::FindInMap": [
+              "AWSInstanceType2Arch",
+              {
+                "Ref": "TestInstanceType"
+              },
+              "Arch"
+            ]
+          }
+        ]
+      },
+      "InstanceMonitoring": "true",
+      "InstanceType": {
+        "Ref": "TestInstanceType"
+      },
+      "KeyName": {
+        "Ref": "TestKeyName"
+      },
+      "SecurityGroups": [
+        {
+          "Ref": "TestSecurityGroup"
+        }
+      ],
+      "UserData": {
+        "Fn::Base64": {
+          "Ref": "WebServerPortUserData"
+        }
+      }
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/autoscaling-lifecycle-hook_test.rb

@@ -0,0 +1,33 @@
+require 'abstract_unit'
+
+class AutoscalingLifecycleHookTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_autoscaling_lifecycle_hook "test", ref_autoscaling: "test", ref_topic: "test", ref_role: "test"
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestAutoscalingLifecycleHook": {
+    "Type": "AWS::AutoScaling::LifecycleHook",
+    "Properties": {
+      "AutoScalingGroupName": {
+        "Ref": "TestAutoscalingGroup"
+      },
+      "LifecycleTransition": "autoscaling::EC2_INSTANCE_TERMINATING",
+      "NotificationTargetARN": {
+        "Ref": "TestTopic"
+      },
+      "RoleARN": {
+        "Fn::GetAtt": [
+          "TestRole",
+          "Arn"
+        ]
+      }
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/autoscaling-scaling-policy_test.rb

@@ -0,0 +1,26 @@
+require 'abstract_unit'
+
+class AutoscalingScalingPolicyTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_autoscaling_scaling_policy "test", ref_autoscaling: "test"
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestAutoscalingScalingPolicy": {
+    "Type": "AWS::AutoScaling::ScalingPolicy",
+    "Properties": {
+      "AdjustmentType": "ChangeInCapacity",
+      "AutoScalingGroupName": {
+        "Ref": "TestAutoscalingGroup"
+      },
+      "PolicyType": "SimpleScaling",
+      "ScalingAdjustment": "1"
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/autoscaling-scheduled-action_test.rb

@@ -0,0 +1,26 @@
+require 'abstract_unit'
+
+class AutoscalingScheduledActionTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_autoscaling_scheduled_action "test", ref_autoscaling: "test", max: "1", min: "1", recurrence: "0 19 * * *"
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestAutoscalingScheduledAction": {
+    "Type": "AWS::AutoScaling::ScheduledAction",
+    "Properties": {
+      "AutoScalingGroupName": {
+        "Ref": "TestAutoscalingGroup"
+      },
+      "MaxSize": "1",
+      "MinSize": "1",
+      "Recurrence": "0 19 * * *"
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/cloudtrail_test.rb

@@ -0,0 +1,55 @@
+require 'abstract_unit'
+
+class CloudtrailTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_cloudtrail "test", depends: %w( test ), s3_bucket: "test"
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestTrail": {
+    "DependsOn": [
+      "test"
+    ],
+    "Type": "AWS::CloudTrail::Trail",
+    "Properties": {
+      "EnableLogFileValidation": "false",
+      "IncludeGlobalServiceEvents": "false",
+      "IsLogging": "true",
+      "S3BucketName": "test",
+      "Tags": [
+        {
+          "Key": "Name",
+          "Value": {
+            "Fn::Join": [
+              "-",
+              [
+                {
+                  "Ref": "Service"
+                },
+                "test"
+              ]
+            ]
+          }
+        },
+        {
+          "Key": "Service",
+          "Value": {
+            "Ref": "Service"
+          }
+        },
+        {
+          "Key": "Version",
+          "Value": {
+            "Ref": "Version"
+          }
+        }
+      ]
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/cloudwatch-alarm_test.rb

@@ -0,0 +1,38 @@
+require 'abstract_unit'
+
+class CloudWatchAlarmTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_cloudwatch_alarm "test", actions: "test", alarm_name: "test", namespace: "test", operator: "<", metric: "test", dimensions: [ { name: "test", value: "test" } ]
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestAlarm": {
+    "Type": "AWS::CloudWatch::Alarm",
+    "Properties": {
+      "ActionsEnabled": "true",
+      "AlarmActions": [
+        "test"
+      ],
+      "AlarmName": "test",
+      "ComparisonOperator": "LessThanOrEqualToThreshold",
+      "Dimensions": [
+        {
+          "Name": "test",
+          "Value": "test"
+        }
+      ],
+      "EvaluationPeriods": "3",
+      "MetricName": "test",
+      "Namespace": "test",
+      "Period": "60",
+      "Statistic": "Average",
+      "Threshold": "60"
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/codedeploy-application_test.rb

@@ -0,0 +1,21 @@
+require 'abstract_unit'
+
+class CodedeploApplicationTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_codedeploy_application "test", application: "test"
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestCodedeployApplication": {
+    "Type": "AWS::CodeDeploy::Application",
+    "Properties": {
+      "ApplicationName": "test"
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/codedeploy-deployment-config_test.rb

@@ -0,0 +1,26 @@
+require 'abstract_unit'
+
+class CodedeployDeploymentConfigTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_codedeploy_deployment_config "test", deployment: "test",
+                                      minimum: { type: "fleet_percent", value: "75" }
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestDeploymentConfig": {
+    "Type": "AWS::CodeDeploy::DeploymentConfig",
+    "Properties": {
+      "DeploymentConfigName": "test",
+      "MinimumHealthyHosts": {
+        "Type": "FLEET_PERCENT",
+        "Value": "75"
+      }
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/codedeploy-deployment-group_test.rb

@@ -0,0 +1,48 @@
+require 'abstract_unit'
+
+class CodedeployDeploymentGroupTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+deployment = { description: "test", revision: { s3: { bucket: "test", key: "test", version: "test" } } }
+_codedeploy_deployment_group "test", ref_application: "test",
+                                     ref_autoscalings: %w( test ),
+                                     deployment: deployment,
+                                     ref_service: "test"
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestDeploymentGroup": {
+    "Type": "AWS::CodeDeploy::DeploymentGroup",
+    "Properties": {
+      "ApplicationName": {
+        "Ref": "TestCodedeployApplication"
+      },
+      "AutoScalingGroups": [
+        {
+          "Ref": "TestAutoscalingGroup"
+        }
+      ],
+      "Deployment": {
+        "Description": "test",
+        "IgnoreApplicationStopFailures": "true",
+        "Revision": {
+          "RevisionType": "S3",
+          "S3Location": {
+            "Bucket": "test",
+            "Key": "test",
+            "BundleType": "Zip",
+            "Version": "test"
+          }
+        }
+      },
+      "ServiceRoleArn": {
+        "Ref": "TestServiceRole"
+      }
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/datapipeline-pipeline_test.rb

@@ -0,0 +1,358 @@
+require 'abstract_unit'
+
+class DatapipelinePipelineTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+parameter_objects = [ { test: { attributes: { test: "test" } } } ]
+parameter_values = { test: "test" }
+fields = { test: { ref: "test", string: "test" } }
+pipeline_objects = [ test: { name: "test", fields: fields } ]
+pipeline_tags = { test: "test" }
+_datapipeline_pipeline "test", parameter_objects: parameter_objects, parameter_values: parameter_values,
+                               objects: pipeline_objects, tags: pipeline_tags
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestPipeline": {
+    "Type": "AWS::DataPipeline::Pipeline",
+    "Properties": {
+      "Activate": "true",
+      "Name": {
+        "Fn::Join": [
+          "-",
+          [
+            {
+              "Ref": "Service"
+            },
+            {
+              "Ref": "Name"
+            }
+          ]
+        ]
+      },
+      "ParameterObjects": [
+        {
+          "Attributes": [
+            {
+              "Key": "test",
+              "StringValue": "test"
+            }
+          ],
+          "Id": "test"
+        }
+      ],
+      "ParameterValues": [
+        {
+          "Id": "test",
+          "StringValue": "test"
+        }
+      ],
+      "PipelineObjects": [
+        {
+          "Fields": [
+            {
+              "Key": "test",
+              "RefValue": "test",
+              "StringValue": "test"
+            }
+          ],
+          "Id": "test",
+          "Name": "test"
+        }
+      ],
+      "PipelineTags": [
+        {
+          "Key": "test",
+          "Value": "test"
+        }
+      ]
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+
+  def test_aws
+    template = <<-'EOS'
+description = "Pipeline to backup DynamoDB data to S3"
+parameter_objects = [
+  { "myDDBReadThroughputRatio": { attributes: { description: "DynamoDB read throughput ratio",
+                                                type: "Double",
+                                                default: 0.2 } } },
+  { "myOutputS3Loc": { attributes: { description: "S3 output bucket",
+                                     type: "AWS::S3::ObjectKey",
+                                     default: _{ Fn__Join [ "", [ "s3://", _{ Ref "S3OutputLoc" } ] ] } } } },
+  { "myDDBTableName": { attributes: { description: "DynamoDB Table Name",
+                                      type: "String" } } },
+]
+parameter_values = {
+  myDDBTableName: _{ Ref "TableName" }
+}
+fields1 = { type: { string: "S3DataNode" }, dataFormat: { ref: "DDBExportFormat"}, directoryPath: { string: '#{myOutputS3Loc}/#{format(@scheduledStartTime, \'YYYY-MM-dd-HH-mm-ss\')}' } }
+fields2 = { type: { string: "DynamoDBDataNode" } , tableName: { string: '#{myDDBTableName}' }, dataFormat: { ref: "DDBExportFormat" }, readThroughputPercent: { string: '#{myDDBReadThroughputRatio}' } }
+fields3 = { type: { string: "DynamoDBExportDataFormat" } }
+fields4 = { type: { string: "HiveCopyActivity" }, resizeClusterBeforeRunning: { string: true }, input: { ref: "DDBSourceTable" }, runsOn: { ref: "EmrClusterForBackup" }, output: { ref: "S3BackupLocation" } }
+fields5 = { type: { string: "Schedule" }, occurrences: { string: 1 }, startAt: { string: "FIRST_ACTIVATION_DATE_TIME" }, period: { string: "1 Day" } }
+fields6 = { type: { string: "Default" }, scheduleType: { string: "cron" }, failureAndRerunMode: { string: "CASCADE" }, role: { string: "DataPipelineDefaultRole" }, resourceRole: { string: "DataPipelineDefaultResourceRole" }, schedule: { ref: "DefaultSchedule" } }
+fields7 = { type: { string: "EmrCluster" }, terminateAfter: { string: "2 Hours" }, amiVersion: { string: "3.3.2" }, masterInstanceType: { string: "m1.medium" }, coreInstanceType: { string: "m1.medium" }, coreInstanceCount: { string: 1 } }
+objects = [
+  { S3BackupLocation: { name: "Copy data to this S3 location", fields: fields1 } },
+  { DDBSourceTable: { name: "DDBSourceTable", fields: fields2 } },
+  { DDBExportFormat: { name: "DDBExportFormat", fields: fields3 } },
+  { TableBackupActivity: { name: "TableBackupActivity", fields: fields4 } },
+  { DefaultSchedule: { name: "RunOnce", fields: fields5 } },
+  { Default: { name: "Default", fields: fields6 } },
+  { EmrClusterForBackup: { name: "EmrClusterForBackup" ,fields: fields7 } },
+]
+tags = []
+_datapipeline_pipeline "dynamo d b input s3 output hive",
+                       { pl_name: "DynamoDBInputS3OutputHive",
+                         description: description,
+                         parameter_objects: parameter_objects, parameter_values: parameter_values,
+                         objects: objects, tags: tags }
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-'EOS'
+{
+  "DynamoDBInputS3OutputHivePipeline": {
+    "Type": "AWS::DataPipeline::Pipeline",
+    "Properties": {
+      "Activate": "true",
+      "Description": "Pipeline to backup DynamoDB data to S3",
+      "Name": "DynamoDBInputS3OutputHive",
+      "ParameterObjects": [
+        {
+          "Attributes": [
+            {
+              "Key": "description",
+              "StringValue": "DynamoDB read throughput ratio"
+            },
+            {
+              "Key": "type",
+              "StringValue": "Double"
+            },
+            {
+              "Key": "default",
+              "StringValue": "0.2"
+            }
+          ],
+          "Id": "myDDBReadThroughputRatio"
+        },
+        {
+          "Attributes": [
+            {
+              "Key": "description",
+              "StringValue": "S3 output bucket"
+            },
+            {
+              "Key": "type",
+              "StringValue": "AWS::S3::ObjectKey"
+            },
+            {
+              "Key": "default",
+              "StringValue": {
+                "Fn::Join": [
+                  "",
+                  [
+                    "s3://",
+                    {
+                      "Ref": "S3OutputLoc"
+                    }
+                  ]
+                ]
+              }
+            }
+          ],
+          "Id": "myOutputS3Loc"
+        },
+        {
+          "Attributes": [
+            {
+              "Key": "description",
+              "StringValue": "DynamoDB Table Name"
+            },
+            {
+              "Key": "type",
+              "StringValue": "String"
+            }
+          ],
+          "Id": "myDDBTableName"
+        }
+      ],
+      "ParameterValues": [
+        {
+          "Id": "myDDBTableName",
+          "StringValue": {
+            "Ref": "TableName"
+          }
+        }
+      ],
+      "PipelineObjects": [
+        {
+          "Fields": [
+            {
+              "Key": "type",
+              "StringValue": "S3DataNode"
+            },
+            {
+              "Key": "dataFormat",
+              "RefValue": "DDBExportFormat"
+            },
+            {
+              "Key": "directoryPath",
+              "StringValue": "#{myOutputS3Loc}/#{format(@scheduledStartTime, 'YYYY-MM-dd-HH-mm-ss')}"
+            }
+          ],
+          "Id": "S3BackupLocation",
+          "Name": "Copy data to this S3 location"
+        },
+        {
+          "Fields": [
+            {
+              "Key": "type",
+              "StringValue": "DynamoDBDataNode"
+            },
+            {
+              "Key": "tableName",
+              "StringValue": "#{myDDBTableName}"
+            },
+            {
+              "Key": "dataFormat",
+              "RefValue": "DDBExportFormat"
+            },
+            {
+              "Key": "readThroughputPercent",
+              "StringValue": "#{myDDBReadThroughputRatio}"
+            }
+          ],
+          "Id": "DDBSourceTable",
+          "Name": "DDBSourceTable"
+        },
+        {
+          "Fields": [
+            {
+              "Key": "type",
+              "StringValue": "DynamoDBExportDataFormat"
+            }
+          ],
+          "Id": "DDBExportFormat",
+          "Name": "DDBExportFormat"
+        },
+        {
+          "Fields": [
+            {
+              "Key": "type",
+              "StringValue": "HiveCopyActivity"
+            },
+            {
+              "Key": "resizeClusterBeforeRunning",
+              "StringValue": "true"
+            },
+            {
+              "Key": "input",
+              "RefValue": "DDBSourceTable"
+            },
+            {
+              "Key": "runsOn",
+              "RefValue": "EmrClusterForBackup"
+            },
+            {
+              "Key": "output",
+              "RefValue": "S3BackupLocation"
+            }
+          ],
+          "Id": "TableBackupActivity",
+          "Name": "TableBackupActivity"
+        },
+        {
+          "Fields": [
+            {
+              "Key": "type",
+              "StringValue": "Schedule"
+            },
+            {
+              "Key": "occurrences",
+              "StringValue": "1"
+            },
+            {
+              "Key": "startAt",
+              "StringValue": "FIRST_ACTIVATION_DATE_TIME"
+            },
+            {
+              "Key": "period",
+              "StringValue": "1 Day"
+            }
+          ],
+          "Id": "DefaultSchedule",
+          "Name": "RunOnce"
+        },
+        {
+          "Fields": [
+            {
+              "Key": "type",
+              "StringValue": "Default"
+            },
+            {
+              "Key": "scheduleType",
+              "StringValue": "cron"
+            },
+            {
+              "Key": "failureAndRerunMode",
+              "StringValue": "CASCADE"
+            },
+            {
+              "Key": "role",
+              "StringValue": "DataPipelineDefaultRole"
+            },
+            {
+              "Key": "resourceRole",
+              "StringValue": "DataPipelineDefaultResourceRole"
+            },
+            {
+              "Key": "schedule",
+              "RefValue": "DefaultSchedule"
+            }
+          ],
+          "Id": "Default",
+          "Name": "Default"
+        },
+        {
+          "Fields": [
+            {
+              "Key": "type",
+              "StringValue": "EmrCluster"
+            },
+            {
+              "Key": "terminateAfter",
+              "StringValue": "2 Hours"
+            },
+            {
+              "Key": "amiVersion",
+              "StringValue": "3.3.2"
+            },
+            {
+              "Key": "masterInstanceType",
+              "StringValue": "m1.medium"
+            },
+            {
+              "Key": "coreInstanceType",
+              "StringValue": "m1.medium"
+            },
+            {
+              "Key": "coreInstanceCount",
+              "StringValue": "1"
+            }
+          ],
+          "Id": "EmrClusterForBackup",
+          "Name": "EmrClusterForBackup"
+        }
+      ]
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end