kumogata-template 0.0.5 → 0.0.6

data/template/output-alb.rb

@@ -0,0 +1,21 @@
+#
+# Output alb
+#
+
+_output "#{args[:name]} load balancer",
+        ref_value: "#{args[:name]} load balancer"
+_output "#{args[:name]} load balancer dns name",
+        ref_value: [ "#{args[:name]} load balancer", "DNSName" ]
+_output "#{args[:name]} load balancer canonical hosted zone id",
+        ref_value: [ "#{args[:name]} load balancer", "CanonicalHostedZoneID" ] if args.key? :route53
+_output "#{args[:name]} load balancer full name",
+        ref_value: [ "#{args[:name]} load balancer", "LoadBalancerFullName" ]
+_output "#{args[:name]} load balancer name",
+        ref_value: [ "#{args[:name]} load balancer", "LoadBalancerName" ]
+
+if args.key? :security_groups
+  args[:security_groups].times do |i|
+    _output "#{args[:name]} load balancer security group #{i}",
+            value: _select(i, _attr_string(args[:name], "SecurityGroups", "load balancer"))
+  end
+end

data/template/output-elb.rb

@@ -4,6 +4,10 @@
 
 _output "#{args[:name]} load balancer",
         ref_value: "#{args[:name]} load balancer"
+_output "#{args[:name]} load balancer canonical hosted zone name",
+        ref_value: [ "#{args[:name]} load balancer", "CanonicalHostedZoneName" ] if args.key? :route53
+_output "#{args[:name]} load balancer canonical hosted zone id",
+        ref_value: [ "#{args[:name]} load balancer", "CanonicalHostedZoneID" ] if args.key? :route53
 _output "#{args[:name]} load balancer dns name",
         ref_value: [ "#{args[:name]} load balancer", "DNSName" ]
 _output "#{args[:name]} load balancer security group name",

data/template/parameter-ec2.rb

@@ -9,14 +9,14 @@ _parameter "#{args[:name]} instance type",
            allowed_values: EC2_INSTANCE_TYPES
 
 _parameter "#{args[:name]} iam instance profile",
-           default: args[:iam_instance] || "",
-           description: "#{args[:name]} iam instance profile"
+           default: args[:iam_instance],
+           description: "#{args[:name]} iam instance profile" if args.key? :iam_instance
 
 _parameter "#{args[:name]} data volume size",
            default: args[:size] || 100,
            description: "#{args[:name]} data volume size"
 
 _parameter "#{args[:name]} key name",
-           default: args[:key],
+           default: args[:key_name],
            description: "#{args[:name]} key name",
-           type: "AWS::EC2::KeyPair::KeyName"
+           type: "AWS::EC2::KeyPair::KeyName" if args.key? :key_name

data/test/alb_test.rb

@@ -0,0 +1,25 @@
+require 'abstract_unit'
+require 'kumogata/template/alb'
+
+class AlbTest < Minitest::Test
+  def test_alb_health_check
+    template = <<-EOS
+Test _alb_health_check({})
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "Test": {
+    "interval": 30,
+    "path": "/",
+    "port": 80,
+    "protocol": "HTTP",
+    "timeout": 5,
+    "healthy": 10,
+    "unhealthly": 2
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/ec2_test.rb

@@ -113,6 +113,26 @@ Test _ec2_tags(name: "test", tags_append: { ref_test: "test" })
   def test_ec2_security_group_egresses
     template = <<-EOS
 args = { egress: [ to: 80, group: "test" ] }
+Test _ec2_security_group_egresses("egress", args)
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "Test": [
+    {
+      "CidrIp": "0.0.0.0/0",
+      "FromPort": "80",
+      "GroupId": "test",
+      "IpProtocol": "tcp",
+      "ToPort": "80"
+    }
+  ]
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+
+    template = <<-EOS
+args = { egress: [ to: 80, group: "test" ] }
 Test _ec2_security_group_egresses("egress", args)
     EOS
     act_template = run_client_as_json(template)
@@ -167,6 +187,31 @@ Test _ec2_security_group_ingresses("ingress", args)
       "ToPort": "80"
     }
   ]
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+
+    template = <<-EOS
+args = { ingress: [ 22, 80 ] }
+Test _ec2_security_group_ingresses("ingress", args)
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "Test": [
+    {
+      "CidrIp": "0.0.0.0/0",
+      "FromPort": "22",
+      "IpProtocol": "tcp",
+      "ToPort": "22"
+    },
+    {
+      "CidrIp": "0.0.0.0/0",
+      "FromPort": "80",
+      "IpProtocol": "tcp",
+      "ToPort": "80"
+    }
+  ]
 }
     EOS
     assert_equal exp_template.chomp, act_template

data/test/helper_test.rb

@@ -255,6 +255,27 @@ Test _find_in_map("Test", "test1", "test2")
     assert_equal exp_template.chomp, act_template
   end
 
+  def test_select
+    template = <<-EOS
+Test _select(1, %w( test1 test2 ))
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "Test": {
+    "Fn::Select": [
+      "1",
+      [
+        "test1",
+        "test2"
+      ]
+    ]
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+
   def test_tag
     template = <<-EOS
 Test _tag(key: "test", value: "test")

data/test/template/alb-listener-rule_test.rb

@@ -0,0 +1,40 @@
+require 'abstract_unit'
+
+class AlbListenerRuleTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_alb_listener_rule "test", actions: [ { ref_target: "test" } ], ref_listener: "test", conditions: [ [ "/img/*" ] ]
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestLoadBalancerListenerRule": {
+    "Type": "AWS::ElasticLoadBalancingV2::ListenerRule",
+    "Properties": {
+      "Actions": [
+        {
+          "TargetGroupArn": {
+            "Ref": "TestTargetGroup"
+          },
+          "Type": "forward"
+        }
+      ],
+      "Conditions": [
+        {
+          "Field": "path-pattern",
+          "Values": [
+            "/img/*"
+          ]
+        }
+      ],
+      "ListenerArn": {
+        "Ref": "TestLoadBalancerListener"
+      },
+      "Priority": "1"
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/alb-listener_test.rb

@@ -0,0 +1,33 @@
+require 'abstract_unit'
+
+class AlbListenerTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_alb_listener "test", actions: [ { ref_target: "test" } ], ref_lb: "test"
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestLoadBalancerListener": {
+    "Type": "AWS::ElasticLoadBalancingV2::Listener",
+    "Properties": {
+      "DefaultActions": [
+        {
+          "TargetGroupArn": {
+            "Ref": "TestTargetGroup"
+          },
+          "Type": "forward"
+        }
+      ],
+      "LoadBalancerArn": {
+        "Ref": "TestLoadBalancer"
+      },
+      "Port": "80",
+      "Protocol": "HTTP"
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/alb-load-balancer_test.rb

@@ -0,0 +1,72 @@
+require 'abstract_unit'
+
+class AlbLoadbalancerTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_alb_load_balancer "test", attributes: [ { "test": "test" } ], ref_security_groups: [ "test" ]
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestLoadBalancer": {
+    "Type": "AWS::ElasticLoadBalancingV2::LoadBalancer",
+    "Properties": {
+      "LoadBalancerAttributes": [
+        {
+          "Key": "test",
+          "Value": "test"
+        }
+      ],
+      "Name": {
+        "Fn::Join": [
+          "-",
+          [
+            {
+              "Ref": "Service"
+            },
+            {
+              "Ref": "Name"
+            }
+          ]
+        ]
+      },
+      "SecurityGroups": [
+        {
+          "Ref": "TestSecurityGroup"
+        }
+      ],
+      "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/alb-target-group_test.rb

@@ -0,0 +1,89 @@
+require 'abstract_unit'
+
+class AlbTargetGroupTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_alb_target_group "test", attributes: [ { key: "value" } ], targets: [ { ref_instance: "test" } ], ref_vpc: "test"
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestTargetGroup": {
+    "Type": "AWS::ElasticLoadBalancingV2::TargetGroup",
+    "Properties": {
+      "HealthCheckIntervalSeconds": "30",
+      "HealthCheckPath": "/",
+      "HealthCheckPort": "80",
+      "HealthCheckProtocol": "HTTP",
+      "HealthCheckTimeoutSeconds": "5",
+      "HealthyThresholdCount": "10",
+      "Matcher": {
+        "HttpCode": "200"
+      },
+      "Name": {
+        "Fn::Join": [
+          "-",
+          [
+            {
+              "Ref": "Service"
+            },
+            {
+              "Ref": "Name"
+            }
+          ]
+        ]
+      },
+      "Port": "80",
+      "Protocol": "HTTP",
+      "Tags": [
+        {
+          "Key": "Name",
+          "Value": {
+            "Fn::Join": [
+              "-",
+              [
+                {
+                  "Ref": "Service"
+                },
+                "test"
+              ]
+            ]
+          }
+        },
+        {
+          "Key": "Service",
+          "Value": {
+            "Ref": "Service"
+          }
+        },
+        {
+          "Key": "Version",
+          "Value": {
+            "Ref": "Version"
+          }
+        }
+      ],
+      "TargetGroupAttributes": [
+        {
+          "Key": "key",
+          "Value": "value"
+        }
+      ],
+      "Targets": [
+        {
+          "Id": {
+            "Ref": "TestInstance"
+          }
+        }
+      ],
+      "UnhealthyThresholdCount": "2",
+      "VpcId": {
+        "Ref": "TestVpc"
+      }
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/certificate_test.rb

@@ -0,0 +1,27 @@
+require 'abstract_unit'
+
+class CertificateTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_certificate "test", domain: "test"
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestCertificate": {
+    "Type": "AWS::CertificateManager::Certificate",
+    "Properties": {
+      "DomainName": "test",
+      "DomainValidationOptions": [
+        {
+          "DomainName": "test",
+          "ValidationDomain": "test"
+        }
+      ]
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/ec2-flow-log_test.rb

@@ -0,0 +1,26 @@
+require 'abstract_unit'
+
+class Ec2LowLogTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_ec2_flow_log "test", ref_id: "test"
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestFlowLog": {
+    "Type": "AWS::EC2::FlowLog",
+    "Properties": {
+      "LogGroupName": "test",
+      "ResourceId": {
+        "Ref": "TestVpc"
+      },
+      "ResourceType": "VPC",
+      "TrafficType": "ALL"
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/ec2-host_test.rb

@@ -0,0 +1,23 @@
+require 'abstract_unit'
+
+class Ec2HostTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+_ec2_host "test", auto: "on", az: "test"
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestHost": {
+    "Type": "AWS::EC2::Host",
+    "Properties": {
+      "AutoPlacement": "on",
+      "AvailabilityZone": "test",
+      "InstanceType": "c4.large"
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/ec2-spot-fleet_test.rb

@@ -0,0 +1,173 @@
+require 'abstract_unit'
+
+class Ec2SpotFeetTest < Minitest::Test
+  def test_normal
+    template = <<-EOS
+launches = [
+  { block_devices: [ { ref_size: "test" } ],
+    ref_iam: "test", image_id: "test", ref_key_name: "test", instance_type: "test", network_interfaces: [ { ref_subnet: "test" } ] }
+]
+_ec2_spot_fleet "test", iam: "test", price: 1000, ref_taget: "test", launches: launches, target: 1
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestSpotFleet": {
+    "Type": "AWS::EC2::SpotFleet",
+    "Properties": {
+      "SpotFleetRequestConfigData": {
+        "AllocationStrategy": "lowestPrice",
+        "IamFleetRole": "test",
+        "LaunchSpecifications": [
+          {
+            "BlockDeviceMappings": [
+              {
+                "DeviceName": "/dev/sda1",
+                "Ebs": {
+                  "DeleteOnTermination": "true",
+                  "VolumeSize": {
+                    "Ref": "TestVolumeSize"
+                  },
+                  "VolumeType": "gp2"
+                }
+              }
+            ],
+            "EbsOptimized": "false",
+            "IamInstanceProfile": {
+              "Arn": {
+                "Ref": "TestIamInstanceProfile"
+              }
+            },
+            "ImageId": "test",
+            "InstanceType": "test",
+            "KeyName": {
+              "Ref": "TestKeyName"
+            },
+            "Monitoring": {
+              "Enabled": "false"
+            },
+            "NetworkInterfaces": [
+              {
+                "AssociatePublicIpAddress": "true",
+                "DeleteOnTermination": "true",
+                "DeviceIndex": "0",
+                "SubnetId": {
+                  "Ref": "TestSubnet"
+                }
+              }
+            ]
+          }
+        ],
+        "SpotPrice": "1000",
+        "TargetCapacity": "1",
+        "TerminateInstancesWithExpiration": "false"
+      }
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+
+  def test_aws
+    template = <<-EOS
+launches = [
+  { ebs: false, ref_instance_type: "test", image: "test", ref_subnet: "subnet1", weighted: 8 },
+  { ebs: true, ref_instance_type: "test", image: "test", ref_subnet: "subnet0", weighted: 8, monitoring: true, ref_security_groups: [ "test" ], ref_iam: "root" },
+]
+_ec2_spot_fleet "test", iam: "test", price: 1000, ref_target: "target capacity", launches: launches
+    EOS
+    act_template = run_client_as_json(template)
+    exp_template = <<-EOS
+{
+  "TestSpotFleet": {
+    "Type": "AWS::EC2::SpotFleet",
+    "Properties": {
+      "SpotFleetRequestConfigData": {
+        "AllocationStrategy": "lowestPrice",
+        "IamFleetRole": "test",
+        "LaunchSpecifications": [
+          {
+            "EbsOptimized": "false",
+            "ImageId": {
+              "Fn::FindInMap": [
+                "AWSRegionArch2AMITest",
+                {
+                  "Ref": "AWS::Region"
+                },
+                {
+                  "Fn::FindInMap": [
+                    "AWSInstanceType2Arch",
+                    {
+                      "Ref": "TestInstanceType"
+                    },
+                    "Arch"
+                  ]
+                }
+              ]
+            },
+            "InstanceType": {
+              "Ref": "TestInstanceType"
+            },
+            "Monitoring": {
+              "Enabled": "false"
+            },
+            "SubnetId": {
+              "Ref": "Subnet1Subnet"
+            },
+            "WeightedCapacity": "8"
+          },
+          {
+            "EbsOptimized": "true",
+            "IamInstanceProfile": {
+              "Arn": {
+                "Ref": "RootIamInstanceProfile"
+              }
+            },
+            "ImageId": {
+              "Fn::FindInMap": [
+                "AWSRegionArch2AMITest",
+                {
+                  "Ref": "AWS::Region"
+                },
+                {
+                  "Fn::FindInMap": [
+                    "AWSInstanceType2Arch",
+                    {
+                      "Ref": "TestInstanceType"
+                    },
+                    "Arch"
+                  ]
+                }
+              ]
+            },
+            "InstanceType": {
+              "Ref": "TestInstanceType"
+            },
+            "Monitoring": {
+              "Enabled": "true"
+            },
+            "SecurityGroups": [
+              {
+                "Ref": "TestSecurityGroup"
+              }
+            ],
+            "SubnetId": {
+              "Ref": "Subnet0Subnet"
+            },
+            "WeightedCapacity": "8"
+          }
+        ],
+        "SpotPrice": "1000",
+        "TargetCapacity": {
+          "Ref": "TargetCapacity"
+        },
+        "TerminateInstancesWithExpiration": "false"
+      }
+    }
+  }
+}
+    EOS
+    assert_equal exp_template.chomp, act_template
+  end
+end

data/test/template/{elb-loadbalancer_test.rb → elb-load-balancer_test.rb}

@@ -3,7 +3,7 @@ require 'abstract_unit'
 class ElbLoadbalancerTest < Minitest::Test
   def test_normal
     template = <<-EOS
-_elb_loadbalancer "test", ref_security_groups: [ "test" ], listeners: [ protocol: "http" ]
+_elb_load_balancer "test", ref_security_groups: [ "test" ], listeners: [ protocol: "http" ]
     EOS
     act_template = run_client_as_json(template)
     exp_template = <<-EOS