github.com/nicgrayson/terraform@v0.4.3-0.20150415203910-c4de50829380/builtin/providers/aws/resource_aws_elb_test.go (about) 1 package aws 2 3 import ( 4 "fmt" 5 "os" 6 "reflect" 7 "sort" 8 "testing" 9 10 "github.com/awslabs/aws-sdk-go/aws" 11 "github.com/awslabs/aws-sdk-go/service/elb" 12 "github.com/hashicorp/terraform/helper/resource" 13 "github.com/hashicorp/terraform/terraform" 14 ) 15 16 func TestAccAWSELB_basic(t *testing.T) { 17 var conf elb.LoadBalancerDescription 18 ssl_certificate_id := os.Getenv("AWS_SSL_CERTIFICATE_ID") 19 20 resource.Test(t, resource.TestCase{ 21 PreCheck: func() { testAccPreCheck(t) }, 22 Providers: testAccProviders, 23 CheckDestroy: testAccCheckAWSELBDestroy, 24 Steps: []resource.TestStep{ 25 resource.TestStep{ 26 Config: testAccAWSELBConfig, 27 Check: resource.ComposeTestCheckFunc( 28 testAccCheckAWSELBExists("aws_elb.bar", &conf), 29 testAccCheckAWSELBAttributes(&conf), 30 resource.TestCheckResourceAttr( 31 "aws_elb.bar", "name", "foobar-terraform-test"), 32 resource.TestCheckResourceAttr( 33 "aws_elb.bar", "availability_zones.2487133097", "us-west-2a"), 34 resource.TestCheckResourceAttr( 35 "aws_elb.bar", "availability_zones.221770259", "us-west-2b"), 36 resource.TestCheckResourceAttr( 37 "aws_elb.bar", "availability_zones.2050015877", "us-west-2c"), 38 resource.TestCheckResourceAttr( 39 "aws_elb.bar", "listener.206423021.instance_port", "8000"), 40 resource.TestCheckResourceAttr( 41 "aws_elb.bar", "listener.206423021.instance_protocol", "http"), 42 resource.TestCheckResourceAttr( 43 "aws_elb.bar", "listener.206423021.ssl_certificate_id", ssl_certificate_id), 44 resource.TestCheckResourceAttr( 45 "aws_elb.bar", "listener.206423021.lb_port", "80"), 46 resource.TestCheckResourceAttr( 47 "aws_elb.bar", "listener.206423021.lb_protocol", "http"), 48 resource.TestCheckResourceAttr( 49 "aws_elb.bar", "cross_zone_load_balancing", "true"), 50 ), 51 }, 52 }, 53 }) 54 } 55 56 func TestAccAWSELB_tags(t *testing.T) { 57 var conf elb.LoadBalancerDescription 58 var td elb.TagDescription 59 60 resource.Test(t, resource.TestCase{ 61 PreCheck: func() { testAccPreCheck(t) }, 62 Providers: testAccProviders, 63 CheckDestroy: testAccCheckAWSELBDestroy, 64 Steps: []resource.TestStep{ 65 resource.TestStep{ 66 Config: testAccAWSELBConfig, 67 Check: resource.ComposeTestCheckFunc( 68 testAccCheckAWSELBExists("aws_elb.bar", &conf), 69 testAccCheckAWSELBAttributes(&conf), 70 resource.TestCheckResourceAttr( 71 "aws_elb.bar", "name", "foobar-terraform-test"), 72 testAccLoadTags(&conf, &td), 73 testAccCheckELBTags(&td.Tags, "bar", "baz"), 74 ), 75 }, 76 77 resource.TestStep{ 78 Config: testAccAWSELBConfig_TagUpdate, 79 Check: resource.ComposeTestCheckFunc( 80 testAccCheckAWSELBExists("aws_elb.bar", &conf), 81 testAccCheckAWSELBAttributes(&conf), 82 resource.TestCheckResourceAttr( 83 "aws_elb.bar", "name", "foobar-terraform-test"), 84 testAccLoadTags(&conf, &td), 85 testAccCheckELBTags(&td.Tags, "foo", "bar"), 86 testAccCheckELBTags(&td.Tags, "new", "type"), 87 ), 88 }, 89 }, 90 }) 91 } 92 93 func testAccLoadTags(conf *elb.LoadBalancerDescription, td *elb.TagDescription) resource.TestCheckFunc { 94 return func(s *terraform.State) error { 95 conn := testAccProvider.Meta().(*AWSClient).elbconn 96 97 describe, err := conn.DescribeTags(&elb.DescribeTagsInput{ 98 LoadBalancerNames: []*string{conf.LoadBalancerName}, 99 }) 100 101 if err != nil { 102 return err 103 } 104 if len(describe.TagDescriptions) > 0 { 105 *td = *describe.TagDescriptions[0] 106 } 107 return nil 108 } 109 } 110 111 func TestAccAWSELB_InstanceAttaching(t *testing.T) { 112 var conf elb.LoadBalancerDescription 113 114 testCheckInstanceAttached := func(count int) resource.TestCheckFunc { 115 return func(*terraform.State) error { 116 if len(conf.Instances) != count { 117 return fmt.Errorf("instance count does not match") 118 } 119 return nil 120 } 121 } 122 123 resource.Test(t, resource.TestCase{ 124 PreCheck: func() { testAccPreCheck(t) }, 125 Providers: testAccProviders, 126 CheckDestroy: testAccCheckAWSELBDestroy, 127 Steps: []resource.TestStep{ 128 resource.TestStep{ 129 Config: testAccAWSELBConfig, 130 Check: resource.ComposeTestCheckFunc( 131 testAccCheckAWSELBExists("aws_elb.bar", &conf), 132 testAccCheckAWSELBAttributes(&conf), 133 ), 134 }, 135 136 resource.TestStep{ 137 Config: testAccAWSELBConfigNewInstance, 138 Check: resource.ComposeTestCheckFunc( 139 testAccCheckAWSELBExists("aws_elb.bar", &conf), 140 testCheckInstanceAttached(1), 141 ), 142 }, 143 }, 144 }) 145 } 146 147 func TestAccAWSELB_HealthCheck(t *testing.T) { 148 var conf elb.LoadBalancerDescription 149 150 resource.Test(t, resource.TestCase{ 151 PreCheck: func() { testAccPreCheck(t) }, 152 Providers: testAccProviders, 153 CheckDestroy: testAccCheckAWSELBDestroy, 154 Steps: []resource.TestStep{ 155 resource.TestStep{ 156 Config: testAccAWSELBConfigHealthCheck, 157 Check: resource.ComposeTestCheckFunc( 158 testAccCheckAWSELBExists("aws_elb.bar", &conf), 159 testAccCheckAWSELBAttributesHealthCheck(&conf), 160 resource.TestCheckResourceAttr( 161 "aws_elb.bar", "health_check.3484319807.healthy_threshold", "5"), 162 resource.TestCheckResourceAttr( 163 "aws_elb.bar", "health_check.3484319807.unhealthy_threshold", "5"), 164 resource.TestCheckResourceAttr( 165 "aws_elb.bar", "health_check.3484319807.target", "HTTP:8000/"), 166 resource.TestCheckResourceAttr( 167 "aws_elb.bar", "health_check.3484319807.timeout", "30"), 168 resource.TestCheckResourceAttr( 169 "aws_elb.bar", "health_check.3484319807.interval", "60"), 170 ), 171 }, 172 }, 173 }) 174 } 175 176 func TestAccAWSELBUpdate_HealthCheck(t *testing.T) { 177 resource.Test(t, resource.TestCase{ 178 PreCheck: func() { testAccPreCheck(t) }, 179 Providers: testAccProviders, 180 CheckDestroy: testAccCheckAWSELBDestroy, 181 Steps: []resource.TestStep{ 182 resource.TestStep{ 183 Config: testAccAWSELBConfigHealthCheck, 184 Check: resource.ComposeTestCheckFunc( 185 resource.TestCheckResourceAttr( 186 "aws_elb.bar", "health_check.3484319807.healthy_threshold", "5"), 187 ), 188 }, 189 resource.TestStep{ 190 Config: testAccAWSELBConfigHealthCheck_update, 191 Check: resource.ComposeTestCheckFunc( 192 resource.TestCheckResourceAttr( 193 "aws_elb.bar", "health_check.2648756019.healthy_threshold", "10"), 194 ), 195 }, 196 }, 197 }) 198 } 199 200 func testAccCheckAWSELBDestroy(s *terraform.State) error { 201 conn := testAccProvider.Meta().(*AWSClient).elbconn 202 203 for _, rs := range s.RootModule().Resources { 204 if rs.Type != "aws_elb" { 205 continue 206 } 207 208 describe, err := conn.DescribeLoadBalancers(&elb.DescribeLoadBalancersInput{ 209 LoadBalancerNames: []*string{aws.String(rs.Primary.ID)}, 210 }) 211 212 if err == nil { 213 if len(describe.LoadBalancerDescriptions) != 0 && 214 *describe.LoadBalancerDescriptions[0].LoadBalancerName == rs.Primary.ID { 215 return fmt.Errorf("ELB still exists") 216 } 217 } 218 219 // Verify the error 220 providerErr, ok := err.(aws.APIError) 221 if !ok { 222 return err 223 } 224 225 if providerErr.Code != "InvalidLoadBalancerName.NotFound" { 226 return fmt.Errorf("Unexpected error: %s", err) 227 } 228 } 229 230 return nil 231 } 232 233 func testAccCheckAWSELBAttributes(conf *elb.LoadBalancerDescription) resource.TestCheckFunc { 234 return func(s *terraform.State) error { 235 zones := []string{"us-west-2a", "us-west-2b", "us-west-2c"} 236 azs := make([]string, 0, len(conf.AvailabilityZones)) 237 for _, x := range conf.AvailabilityZones { 238 azs = append(azs, *x) 239 } 240 sort.StringSlice(azs).Sort() 241 if !reflect.DeepEqual(azs, zones) { 242 return fmt.Errorf("bad availability_zones") 243 } 244 245 if *conf.LoadBalancerName != "foobar-terraform-test" { 246 return fmt.Errorf("bad name") 247 } 248 249 l := elb.Listener{ 250 InstancePort: aws.Long(int64(8000)), 251 InstanceProtocol: aws.String("HTTP"), 252 LoadBalancerPort: aws.Long(int64(80)), 253 Protocol: aws.String("HTTP"), 254 } 255 256 if !reflect.DeepEqual(conf.ListenerDescriptions[0].Listener, &l) { 257 return fmt.Errorf( 258 "Got:\n\n%#v\n\nExpected:\n\n%#v\n", 259 conf.ListenerDescriptions[0].Listener, 260 l) 261 } 262 263 if *conf.DNSName == "" { 264 return fmt.Errorf("empty dns_name") 265 } 266 267 return nil 268 } 269 } 270 271 func testAccCheckAWSELBAttributesHealthCheck(conf *elb.LoadBalancerDescription) resource.TestCheckFunc { 272 return func(s *terraform.State) error { 273 zones := []string{"us-west-2a", "us-west-2b", "us-west-2c"} 274 azs := make([]string, 0, len(conf.AvailabilityZones)) 275 for _, x := range conf.AvailabilityZones { 276 azs = append(azs, *x) 277 } 278 sort.StringSlice(azs).Sort() 279 if !reflect.DeepEqual(azs, zones) { 280 return fmt.Errorf("bad availability_zones") 281 } 282 283 if *conf.LoadBalancerName != "foobar-terraform-test" { 284 return fmt.Errorf("bad name") 285 } 286 287 check := &elb.HealthCheck{ 288 Timeout: aws.Long(int64(30)), 289 UnhealthyThreshold: aws.Long(int64(5)), 290 HealthyThreshold: aws.Long(int64(5)), 291 Interval: aws.Long(int64(60)), 292 Target: aws.String("HTTP:8000/"), 293 } 294 295 if !reflect.DeepEqual(conf.HealthCheck, check) { 296 return fmt.Errorf( 297 "Got:\n\n%#v\n\nExpected:\n\n%#v\n", 298 conf.HealthCheck, 299 check) 300 } 301 302 if *conf.DNSName == "" { 303 return fmt.Errorf("empty dns_name") 304 } 305 306 return nil 307 } 308 } 309 310 func testAccCheckAWSELBExists(n string, res *elb.LoadBalancerDescription) resource.TestCheckFunc { 311 return func(s *terraform.State) error { 312 rs, ok := s.RootModule().Resources[n] 313 if !ok { 314 return fmt.Errorf("Not found: %s", n) 315 } 316 317 if rs.Primary.ID == "" { 318 return fmt.Errorf("No ELB ID is set") 319 } 320 321 conn := testAccProvider.Meta().(*AWSClient).elbconn 322 323 describe, err := conn.DescribeLoadBalancers(&elb.DescribeLoadBalancersInput{ 324 LoadBalancerNames: []*string{aws.String(rs.Primary.ID)}, 325 }) 326 327 if err != nil { 328 return err 329 } 330 331 if len(describe.LoadBalancerDescriptions) != 1 || 332 *describe.LoadBalancerDescriptions[0].LoadBalancerName != rs.Primary.ID { 333 return fmt.Errorf("ELB not found") 334 } 335 336 *res = *describe.LoadBalancerDescriptions[0] 337 338 return nil 339 } 340 } 341 342 const testAccAWSELBConfig = ` 343 resource "aws_elb" "bar" { 344 name = "foobar-terraform-test" 345 availability_zones = ["us-west-2a", "us-west-2b", "us-west-2c"] 346 347 listener { 348 instance_port = 8000 349 instance_protocol = "http" 350 lb_port = 80 351 lb_protocol = "http" 352 } 353 354 tags { 355 bar = "baz" 356 } 357 358 cross_zone_load_balancing = true 359 } 360 ` 361 362 const testAccAWSELBConfig_TagUpdate = ` 363 resource "aws_elb" "bar" { 364 name = "foobar-terraform-test" 365 availability_zones = ["us-west-2a", "us-west-2b", "us-west-2c"] 366 367 listener { 368 instance_port = 8000 369 instance_protocol = "http" 370 lb_port = 80 371 lb_protocol = "http" 372 } 373 374 tags { 375 foo = "bar" 376 new = "type" 377 } 378 379 cross_zone_load_balancing = true 380 } 381 ` 382 383 const testAccAWSELBConfigNewInstance = ` 384 resource "aws_elb" "bar" { 385 name = "foobar-terraform-test" 386 availability_zones = ["us-west-2a", "us-west-2b", "us-west-2c"] 387 388 listener { 389 instance_port = 8000 390 instance_protocol = "http" 391 lb_port = 80 392 lb_protocol = "http" 393 } 394 395 instances = ["${aws_instance.foo.id}"] 396 } 397 398 resource "aws_instance" "foo" { 399 # us-west-2 400 ami = "ami-043a5034" 401 instance_type = "t1.micro" 402 } 403 ` 404 405 const testAccAWSELBConfigListenerSSLCertificateId = ` 406 resource "aws_elb" "bar" { 407 name = "foobar-terraform-test" 408 availability_zones = ["us-west-2a"] 409 410 listener { 411 instance_port = 8000 412 instance_protocol = "http" 413 ssl_certificate_id = "%s" 414 lb_port = 443 415 lb_protocol = "https" 416 } 417 } 418 ` 419 420 const testAccAWSELBConfigHealthCheck = ` 421 resource "aws_elb" "bar" { 422 name = "foobar-terraform-test" 423 availability_zones = ["us-west-2a", "us-west-2b", "us-west-2c"] 424 425 listener { 426 instance_port = 8000 427 instance_protocol = "http" 428 lb_port = 80 429 lb_protocol = "http" 430 } 431 432 health_check { 433 healthy_threshold = 5 434 unhealthy_threshold = 5 435 target = "HTTP:8000/" 436 interval = 60 437 timeout = 30 438 } 439 } 440 ` 441 442 const testAccAWSELBConfigHealthCheck_update = ` 443 resource "aws_elb" "bar" { 444 name = "foobar-terraform-test" 445 availability_zones = ["us-west-2a"] 446 447 listener { 448 instance_port = 8000 449 instance_protocol = "http" 450 lb_port = 80 451 lb_protocol = "http" 452 } 453 454 health_check { 455 healthy_threshold = 10 456 unhealthy_threshold = 5 457 target = "HTTP:8000/" 458 interval = 60 459 timeout = 30 460 } 461 } 462 `