github.com/tarrant/terraform@v0.3.8-0.20150402012457-f68c9eee638e/builtin/providers/aws/resource_aws_autoscaling_group_test.go (about) 1 package aws 2 3 import ( 4 "fmt" 5 "reflect" 6 "testing" 7 8 "github.com/hashicorp/aws-sdk-go/aws" 9 "github.com/hashicorp/aws-sdk-go/gen/autoscaling" 10 "github.com/hashicorp/terraform/helper/resource" 11 "github.com/hashicorp/terraform/terraform" 12 ) 13 14 func TestAccAWSAutoScalingGroup_basic(t *testing.T) { 15 var group autoscaling.AutoScalingGroup 16 var lc autoscaling.LaunchConfiguration 17 18 resource.Test(t, resource.TestCase{ 19 PreCheck: func() { testAccPreCheck(t) }, 20 Providers: testAccProviders, 21 CheckDestroy: testAccCheckAWSAutoScalingGroupDestroy, 22 Steps: []resource.TestStep{ 23 resource.TestStep{ 24 Config: testAccAWSAutoScalingGroupConfig, 25 Check: resource.ComposeTestCheckFunc( 26 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 27 testAccCheckAWSAutoScalingGroupAttributes(&group), 28 resource.TestCheckResourceAttr( 29 "aws_autoscaling_group.bar", "availability_zones.2487133097", "us-west-2a"), 30 resource.TestCheckResourceAttr( 31 "aws_autoscaling_group.bar", "name", "foobar3-terraform-test"), 32 resource.TestCheckResourceAttr( 33 "aws_autoscaling_group.bar", "max_size", "5"), 34 resource.TestCheckResourceAttr( 35 "aws_autoscaling_group.bar", "min_size", "2"), 36 resource.TestCheckResourceAttr( 37 "aws_autoscaling_group.bar", "health_check_grace_period", "300"), 38 resource.TestCheckResourceAttr( 39 "aws_autoscaling_group.bar", "health_check_type", "ELB"), 40 resource.TestCheckResourceAttr( 41 "aws_autoscaling_group.bar", "desired_capacity", "4"), 42 resource.TestCheckResourceAttr( 43 "aws_autoscaling_group.bar", "force_delete", "true"), 44 resource.TestCheckResourceAttr( 45 "aws_autoscaling_group.bar", "termination_policies.912102603", "OldestInstance"), 46 ), 47 }, 48 49 resource.TestStep{ 50 Config: testAccAWSAutoScalingGroupConfigUpdate, 51 Check: resource.ComposeTestCheckFunc( 52 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 53 testAccCheckAWSLaunchConfigurationExists("aws_launch_configuration.new", &lc), 54 resource.TestCheckResourceAttr( 55 "aws_autoscaling_group.bar", "desired_capacity", "5"), 56 testLaunchConfigurationName("aws_autoscaling_group.bar", &lc), 57 testAccCheckAutoscalingTags(&group.Tags, "Bar", map[string]interface{}{ 58 "value": "bar-foo", 59 "propagate_at_launch": true, 60 }), 61 ), 62 }, 63 }, 64 }) 65 } 66 67 func TestAccAWSAutoScalingGroup_tags(t *testing.T) { 68 var group autoscaling.AutoScalingGroup 69 70 resource.Test(t, resource.TestCase{ 71 PreCheck: func() { testAccPreCheck(t) }, 72 Providers: testAccProviders, 73 CheckDestroy: testAccCheckAWSAutoScalingGroupDestroy, 74 Steps: []resource.TestStep{ 75 resource.TestStep{ 76 Config: testAccAWSAutoScalingGroupConfig, 77 Check: resource.ComposeTestCheckFunc( 78 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 79 testAccCheckAutoscalingTags(&group.Tags, "Foo", map[string]interface{}{ 80 "value": "foo-bar", 81 "propagate_at_launch": true, 82 }), 83 ), 84 }, 85 86 resource.TestStep{ 87 Config: testAccAWSAutoScalingGroupConfigUpdate, 88 Check: resource.ComposeTestCheckFunc( 89 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 90 testAccCheckAutoscalingTagNotExists(&group.Tags, "Foo"), 91 testAccCheckAutoscalingTags(&group.Tags, "Bar", map[string]interface{}{ 92 "value": "bar-foo", 93 "propagate_at_launch": true, 94 }), 95 ), 96 }, 97 }, 98 }) 99 } 100 101 func TestAccAWSAutoScalingGroupWithLoadBalancer(t *testing.T) { 102 var group autoscaling.AutoScalingGroup 103 104 resource.Test(t, resource.TestCase{ 105 PreCheck: func() { testAccPreCheck(t) }, 106 Providers: testAccProviders, 107 CheckDestroy: testAccCheckAWSAutoScalingGroupDestroy, 108 Steps: []resource.TestStep{ 109 resource.TestStep{ 110 Config: testAccAWSAutoScalingGroupConfigWithLoadBalancer, 111 Check: resource.ComposeTestCheckFunc( 112 testAccCheckAWSAutoScalingGroupExists("aws_autoscaling_group.bar", &group), 113 testAccCheckAWSAutoScalingGroupAttributesLoadBalancer(&group), 114 ), 115 }, 116 }, 117 }) 118 } 119 func testAccCheckAWSAutoScalingGroupDestroy(s *terraform.State) error { 120 conn := testAccProvider.Meta().(*AWSClient).autoscalingconn 121 122 for _, rs := range s.RootModule().Resources { 123 if rs.Type != "aws_autoscaling_group" { 124 continue 125 } 126 127 // Try to find the Group 128 describeGroups, err := conn.DescribeAutoScalingGroups( 129 &autoscaling.AutoScalingGroupNamesType{ 130 AutoScalingGroupNames: []string{rs.Primary.ID}, 131 }) 132 133 if err == nil { 134 if len(describeGroups.AutoScalingGroups) != 0 && 135 *describeGroups.AutoScalingGroups[0].AutoScalingGroupName == rs.Primary.ID { 136 return fmt.Errorf("AutoScaling Group still exists") 137 } 138 } 139 140 // Verify the error 141 ec2err, ok := err.(aws.APIError) 142 if !ok { 143 return err 144 } 145 if ec2err.Code != "InvalidGroup.NotFound" { 146 return err 147 } 148 } 149 150 return nil 151 } 152 153 func testAccCheckAWSAutoScalingGroupAttributes(group *autoscaling.AutoScalingGroup) resource.TestCheckFunc { 154 return func(s *terraform.State) error { 155 if group.AvailabilityZones[0] != "us-west-2a" { 156 return fmt.Errorf("Bad availability_zones: %s", group.AvailabilityZones[0]) 157 } 158 159 if *group.AutoScalingGroupName != "foobar3-terraform-test" { 160 return fmt.Errorf("Bad name: %s", *group.AutoScalingGroupName) 161 } 162 163 if *group.MaxSize != 5 { 164 return fmt.Errorf("Bad max_size: %d", *group.MaxSize) 165 } 166 167 if *group.MinSize != 2 { 168 return fmt.Errorf("Bad max_size: %d", *group.MinSize) 169 } 170 171 if *group.HealthCheckType != "ELB" { 172 return fmt.Errorf("Bad health_check_type,\nexpected: %s\ngot: %s", "ELB", *group.HealthCheckType) 173 } 174 175 if *group.HealthCheckGracePeriod != 300 { 176 return fmt.Errorf("Bad health_check_grace_period: %d", *group.HealthCheckGracePeriod) 177 } 178 179 if *group.DesiredCapacity != 4 { 180 return fmt.Errorf("Bad desired_capacity: %d", *group.DesiredCapacity) 181 } 182 183 if *group.LaunchConfigurationName == "" { 184 return fmt.Errorf("Bad launch configuration name: %s", *group.LaunchConfigurationName) 185 } 186 187 t := autoscaling.TagDescription{ 188 Key: aws.String("Foo"), 189 Value: aws.String("foo-bar"), 190 PropagateAtLaunch: aws.Boolean(true), 191 ResourceType: aws.String("auto-scaling-group"), 192 ResourceID: group.AutoScalingGroupName, 193 } 194 195 if !reflect.DeepEqual(group.Tags[0], t) { 196 return fmt.Errorf( 197 "Got:\n\n%#v\n\nExpected:\n\n%#v\n", 198 group.Tags[0], 199 t) 200 } 201 202 return nil 203 } 204 } 205 206 func testAccCheckAWSAutoScalingGroupAttributesLoadBalancer(group *autoscaling.AutoScalingGroup) resource.TestCheckFunc { 207 return func(s *terraform.State) error { 208 if group.LoadBalancerNames[0] != "foobar-terraform-test" { 209 return fmt.Errorf("Bad load_balancers: %s", group.LoadBalancerNames[0]) 210 } 211 212 return nil 213 } 214 } 215 216 func testAccCheckAWSAutoScalingGroupExists(n string, group *autoscaling.AutoScalingGroup) resource.TestCheckFunc { 217 return func(s *terraform.State) error { 218 rs, ok := s.RootModule().Resources[n] 219 if !ok { 220 return fmt.Errorf("Not found: %s", n) 221 } 222 223 if rs.Primary.ID == "" { 224 return fmt.Errorf("No AutoScaling Group ID is set") 225 } 226 227 conn := testAccProvider.Meta().(*AWSClient).autoscalingconn 228 229 describeOpts := autoscaling.AutoScalingGroupNamesType{ 230 AutoScalingGroupNames: []string{rs.Primary.ID}, 231 } 232 describeGroups, err := conn.DescribeAutoScalingGroups(&describeOpts) 233 234 if err != nil { 235 return err 236 } 237 238 if len(describeGroups.AutoScalingGroups) != 1 || 239 *describeGroups.AutoScalingGroups[0].AutoScalingGroupName != rs.Primary.ID { 240 return fmt.Errorf("AutoScaling Group not found") 241 } 242 243 *group = describeGroups.AutoScalingGroups[0] 244 245 return nil 246 } 247 } 248 249 func testLaunchConfigurationName(n string, lc *autoscaling.LaunchConfiguration) resource.TestCheckFunc { 250 return func(s *terraform.State) error { 251 rs, ok := s.RootModule().Resources[n] 252 if !ok { 253 return fmt.Errorf("Not found: %s", n) 254 } 255 256 if *lc.LaunchConfigurationName != rs.Primary.Attributes["launch_configuration"] { 257 return fmt.Errorf("Launch configuration names do not match") 258 } 259 260 return nil 261 } 262 } 263 264 const testAccAWSAutoScalingGroupConfig = ` 265 resource "aws_launch_configuration" "foobar" { 266 name = "foobarautoscaling-terraform-test" 267 image_id = "ami-21f78e11" 268 instance_type = "t1.micro" 269 } 270 271 resource "aws_autoscaling_group" "bar" { 272 availability_zones = ["us-west-2a"] 273 name = "foobar3-terraform-test" 274 max_size = 5 275 min_size = 2 276 health_check_grace_period = 300 277 health_check_type = "ELB" 278 desired_capacity = 4 279 force_delete = true 280 termination_policies = ["OldestInstance"] 281 282 launch_configuration = "${aws_launch_configuration.foobar.name}" 283 284 tag { 285 key = "Foo" 286 value = "foo-bar" 287 propagate_at_launch = true 288 } 289 } 290 ` 291 292 const testAccAWSAutoScalingGroupConfigUpdate = ` 293 resource "aws_launch_configuration" "foobar" { 294 name = "foobarautoscaling-terraform-test" 295 image_id = "ami-21f78e11" 296 instance_type = "t1.micro" 297 } 298 299 resource "aws_launch_configuration" "new" { 300 name = "foobarautoscaling-terraform-test-new" 301 image_id = "ami-21f78e11" 302 instance_type = "t1.micro" 303 } 304 305 resource "aws_autoscaling_group" "bar" { 306 availability_zones = ["us-west-2a"] 307 name = "foobar3-terraform-test" 308 max_size = 5 309 min_size = 2 310 health_check_grace_period = 300 311 health_check_type = "ELB" 312 desired_capacity = 5 313 force_delete = true 314 315 launch_configuration = "${aws_launch_configuration.new.name}" 316 317 tag { 318 key = "Bar" 319 value = "bar-foo" 320 propagate_at_launch = true 321 } 322 } 323 ` 324 325 const testAccAWSAutoScalingGroupConfigWithLoadBalancer = ` 326 resource "aws_elb" "bar" { 327 name = "foobar-terraform-test" 328 availability_zones = ["us-west-2a"] 329 330 listener { 331 instance_port = 8000 332 instance_protocol = "http" 333 lb_port = 80 334 lb_protocol = "http" 335 } 336 } 337 338 resource "aws_launch_configuration" "foobar" { 339 name = "foobarautoscaling-terraform-test" 340 image_id = "ami-21f78e11" 341 instance_type = "t1.micro" 342 } 343 344 resource "aws_autoscaling_group" "bar" { 345 availability_zones = ["us-west-2a"] 346 name = "foobar3-terraform-test" 347 max_size = 5 348 min_size = 2 349 health_check_grace_period = 300 350 health_check_type = "ELB" 351 desired_capacity = 4 352 force_delete = true 353 354 launch_configuration = "${aws_launch_configuration.foobar.name}" 355 load_balancers = ["${aws_elb.bar.name}"] 356 } 357 `