github.com/inge4pres/terraform@v0.7.5-0.20160930053151-bd083f84f376/builtin/providers/aws/resource_aws_alb_test.go (about) 1 package aws 2 3 import ( 4 "errors" 5 "fmt" 6 "regexp" 7 "testing" 8 9 "github.com/aws/aws-sdk-go/aws" 10 "github.com/aws/aws-sdk-go/service/elbv2" 11 "github.com/hashicorp/errwrap" 12 "github.com/hashicorp/terraform/helper/acctest" 13 "github.com/hashicorp/terraform/helper/resource" 14 "github.com/hashicorp/terraform/terraform" 15 ) 16 17 func TestALBCloudwatchSuffixFromARN(t *testing.T) { 18 cases := []struct { 19 name string 20 arn *string 21 suffix string 22 }{ 23 { 24 name: "valid suffix", 25 arn: aws.String(`arn:aws:elasticloadbalancing:us-east-1:123456:loadbalancer/app/my-alb/abc123`), 26 suffix: `app/my-alb/abc123`, 27 }, 28 { 29 name: "no suffix", 30 arn: aws.String(`arn:aws:elasticloadbalancing:us-east-1:123456:loadbalancer`), 31 suffix: ``, 32 }, 33 { 34 name: "nil ARN", 35 arn: nil, 36 suffix: ``, 37 }, 38 } 39 40 for _, tc := range cases { 41 actual := albSuffixFromARN(tc.arn) 42 if actual != tc.suffix { 43 t.Fatalf("bad suffix: %q\nExpected: %s\n Got: %s", tc.name, tc.suffix, actual) 44 } 45 } 46 } 47 48 func TestAccAWSALB_basic(t *testing.T) { 49 var conf elbv2.LoadBalancer 50 albName := fmt.Sprintf("testaccawsalb-basic-%s", acctest.RandStringFromCharSet(10, acctest.CharSetAlphaNum)) 51 52 resource.Test(t, resource.TestCase{ 53 PreCheck: func() { testAccPreCheck(t) }, 54 IDRefreshName: "aws_alb.alb_test", 55 Providers: testAccProviders, 56 CheckDestroy: testAccCheckAWSALBDestroy, 57 Steps: []resource.TestStep{ 58 { 59 Config: testAccAWSALBConfig_basic(albName), 60 Check: resource.ComposeAggregateTestCheckFunc( 61 testAccCheckAWSALBExists("aws_alb.alb_test", &conf), 62 resource.TestCheckResourceAttr("aws_alb.alb_test", "name", albName), 63 resource.TestCheckResourceAttr("aws_alb.alb_test", "internal", "false"), 64 resource.TestCheckResourceAttr("aws_alb.alb_test", "subnets.#", "2"), 65 resource.TestCheckResourceAttr("aws_alb.alb_test", "security_groups.#", "1"), 66 resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.%", "1"), 67 resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.TestName", "TestAccAWSALB_basic"), 68 resource.TestCheckResourceAttr("aws_alb.alb_test", "enable_deletion_protection", "false"), 69 resource.TestCheckResourceAttr("aws_alb.alb_test", "idle_timeout", "30"), 70 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "vpc_id"), 71 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "zone_id"), 72 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "dns_name"), 73 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "arn"), 74 ), 75 }, 76 }, 77 }) 78 } 79 80 func TestAccAWSALB_generatedName(t *testing.T) { 81 var conf elbv2.LoadBalancer 82 83 resource.Test(t, resource.TestCase{ 84 PreCheck: func() { testAccPreCheck(t) }, 85 IDRefreshName: "aws_alb.alb_test", 86 Providers: testAccProviders, 87 CheckDestroy: testAccCheckAWSALBDestroy, 88 Steps: []resource.TestStep{ 89 { 90 Config: testAccAWSALBConfig_generatedName(), 91 Check: resource.ComposeAggregateTestCheckFunc( 92 testAccCheckAWSALBExists("aws_alb.alb_test", &conf), 93 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "name"), 94 ), 95 }, 96 }, 97 }) 98 } 99 100 func TestAccAWSALB_namePrefix(t *testing.T) { 101 var conf elbv2.LoadBalancer 102 103 resource.Test(t, resource.TestCase{ 104 PreCheck: func() { testAccPreCheck(t) }, 105 IDRefreshName: "aws_alb.alb_test", 106 Providers: testAccProviders, 107 CheckDestroy: testAccCheckAWSALBDestroy, 108 Steps: []resource.TestStep{ 109 { 110 Config: testAccAWSALBConfig_namePrefix(), 111 Check: resource.ComposeAggregateTestCheckFunc( 112 testAccCheckAWSALBExists("aws_alb.alb_test", &conf), 113 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "name"), 114 resource.TestMatchResourceAttr("aws_alb.alb_test", "name", 115 regexp.MustCompile("^tf-lb")), 116 ), 117 }, 118 }, 119 }) 120 } 121 122 func TestAccAWSALB_tags(t *testing.T) { 123 var conf elbv2.LoadBalancer 124 albName := fmt.Sprintf("testaccawsalb-basic-%s", acctest.RandStringFromCharSet(10, acctest.CharSetAlphaNum)) 125 126 resource.Test(t, resource.TestCase{ 127 PreCheck: func() { testAccPreCheck(t) }, 128 IDRefreshName: "aws_alb.alb_test", 129 Providers: testAccProviders, 130 CheckDestroy: testAccCheckAWSALBDestroy, 131 Steps: []resource.TestStep{ 132 { 133 Config: testAccAWSALBConfig_basic(albName), 134 Check: resource.ComposeAggregateTestCheckFunc( 135 testAccCheckAWSALBExists("aws_alb.alb_test", &conf), 136 resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.%", "1"), 137 resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.TestName", "TestAccAWSALB_basic"), 138 ), 139 }, 140 { 141 Config: testAccAWSALBConfig_updatedTags(albName), 142 Check: resource.ComposeAggregateTestCheckFunc( 143 testAccCheckAWSALBExists("aws_alb.alb_test", &conf), 144 resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.%", "2"), 145 resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.Type", "Sample Type Tag"), 146 resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.Environment", "Production"), 147 ), 148 }, 149 }, 150 }) 151 } 152 153 // TestAccAWSALB_noSecurityGroup regression tests the issue in #8264, 154 // where if an ALB is created without a security group, a default one 155 // is assigned. 156 func TestAccAWSALB_noSecurityGroup(t *testing.T) { 157 var conf elbv2.LoadBalancer 158 albName := fmt.Sprintf("testaccawsalb-nosg-%s", acctest.RandStringFromCharSet(10, acctest.CharSetAlphaNum)) 159 160 resource.Test(t, resource.TestCase{ 161 PreCheck: func() { testAccPreCheck(t) }, 162 IDRefreshName: "aws_alb.alb_test", 163 Providers: testAccProviders, 164 CheckDestroy: testAccCheckAWSALBDestroy, 165 Steps: []resource.TestStep{ 166 { 167 Config: testAccAWSALBConfig_nosg(albName), 168 Check: resource.ComposeAggregateTestCheckFunc( 169 testAccCheckAWSALBExists("aws_alb.alb_test", &conf), 170 resource.TestCheckResourceAttr("aws_alb.alb_test", "name", albName), 171 resource.TestCheckResourceAttr("aws_alb.alb_test", "internal", "false"), 172 resource.TestCheckResourceAttr("aws_alb.alb_test", "subnets.#", "2"), 173 resource.TestCheckResourceAttr("aws_alb.alb_test", "security_groups.#", "1"), 174 resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.%", "1"), 175 resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.TestName", "TestAccAWSALB_basic"), 176 resource.TestCheckResourceAttr("aws_alb.alb_test", "enable_deletion_protection", "false"), 177 resource.TestCheckResourceAttr("aws_alb.alb_test", "idle_timeout", "30"), 178 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "vpc_id"), 179 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "zone_id"), 180 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "dns_name"), 181 ), 182 }, 183 }, 184 }) 185 } 186 187 func TestAccAWSALB_accesslogs(t *testing.T) { 188 var conf elbv2.LoadBalancer 189 bucketName := fmt.Sprintf("testaccawsalbaccesslogs-%s", acctest.RandStringFromCharSet(6, acctest.CharSetAlphaNum)) 190 albName := fmt.Sprintf("testaccawsalbaccesslog-%s", acctest.RandStringFromCharSet(4, acctest.CharSetAlpha)) 191 192 resource.Test(t, resource.TestCase{ 193 PreCheck: func() { testAccPreCheck(t) }, 194 IDRefreshName: "aws_alb.alb_test", 195 Providers: testAccProviders, 196 CheckDestroy: testAccCheckAWSALBDestroy, 197 Steps: []resource.TestStep{ 198 { 199 Config: testAccAWSALBConfig_basic(albName), 200 Check: resource.ComposeAggregateTestCheckFunc( 201 testAccCheckAWSALBExists("aws_alb.alb_test", &conf), 202 resource.TestCheckResourceAttr("aws_alb.alb_test", "name", albName), 203 resource.TestCheckResourceAttr("aws_alb.alb_test", "internal", "false"), 204 resource.TestCheckResourceAttr("aws_alb.alb_test", "subnets.#", "2"), 205 resource.TestCheckResourceAttr("aws_alb.alb_test", "security_groups.#", "1"), 206 resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.%", "1"), 207 resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.TestName", "TestAccAWSALB_basic"), 208 resource.TestCheckResourceAttr("aws_alb.alb_test", "enable_deletion_protection", "false"), 209 resource.TestCheckResourceAttr("aws_alb.alb_test", "idle_timeout", "30"), 210 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "vpc_id"), 211 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "zone_id"), 212 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "dns_name"), 213 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "arn"), 214 ), 215 }, 216 217 { 218 Config: testAccAWSALBConfig_accessLogs(albName, bucketName), 219 Check: resource.ComposeAggregateTestCheckFunc( 220 testAccCheckAWSALBExists("aws_alb.alb_test", &conf), 221 resource.TestCheckResourceAttr("aws_alb.alb_test", "name", albName), 222 resource.TestCheckResourceAttr("aws_alb.alb_test", "internal", "false"), 223 resource.TestCheckResourceAttr("aws_alb.alb_test", "subnets.#", "2"), 224 resource.TestCheckResourceAttr("aws_alb.alb_test", "security_groups.#", "1"), 225 resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.%", "1"), 226 resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.TestName", "TestAccAWSALB_basic1"), 227 resource.TestCheckResourceAttr("aws_alb.alb_test", "enable_deletion_protection", "false"), 228 resource.TestCheckResourceAttr("aws_alb.alb_test", "idle_timeout", "50"), 229 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "vpc_id"), 230 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "zone_id"), 231 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "dns_name"), 232 resource.TestCheckResourceAttr("aws_alb.alb_test", "access_logs.#", "1"), 233 resource.TestCheckResourceAttr("aws_alb.alb_test", "access_logs.0.bucket", bucketName), 234 resource.TestCheckResourceAttr("aws_alb.alb_test", "access_logs.0.prefix", "testAccAWSALBConfig_accessLogs"), 235 resource.TestCheckResourceAttrSet("aws_alb.alb_test", "arn"), 236 ), 237 }, 238 }, 239 }) 240 } 241 242 func testAccCheckAWSALBExists(n string, res *elbv2.LoadBalancer) resource.TestCheckFunc { 243 return func(s *terraform.State) error { 244 rs, ok := s.RootModule().Resources[n] 245 if !ok { 246 return fmt.Errorf("Not found: %s", n) 247 } 248 249 if rs.Primary.ID == "" { 250 return errors.New("No ALB ID is set") 251 } 252 253 conn := testAccProvider.Meta().(*AWSClient).elbv2conn 254 255 describe, err := conn.DescribeLoadBalancers(&elbv2.DescribeLoadBalancersInput{ 256 LoadBalancerArns: []*string{aws.String(rs.Primary.ID)}, 257 }) 258 259 if err != nil { 260 return err 261 } 262 263 if len(describe.LoadBalancers) != 1 || 264 *describe.LoadBalancers[0].LoadBalancerArn != rs.Primary.ID { 265 return errors.New("ALB not found") 266 } 267 268 *res = *describe.LoadBalancers[0] 269 return nil 270 } 271 } 272 273 func testAccCheckAWSALBDestroy(s *terraform.State) error { 274 conn := testAccProvider.Meta().(*AWSClient).elbv2conn 275 276 for _, rs := range s.RootModule().Resources { 277 if rs.Type != "aws_alb" { 278 continue 279 } 280 281 describe, err := conn.DescribeLoadBalancers(&elbv2.DescribeLoadBalancersInput{ 282 LoadBalancerArns: []*string{aws.String(rs.Primary.ID)}, 283 }) 284 285 if err == nil { 286 if len(describe.LoadBalancers) != 0 && 287 *describe.LoadBalancers[0].LoadBalancerArn == rs.Primary.ID { 288 return fmt.Errorf("ALB %q still exists", rs.Primary.ID) 289 } 290 } 291 292 // Verify the error 293 if isLoadBalancerNotFound(err) { 294 return nil 295 } else { 296 return errwrap.Wrapf("Unexpected error checking ALB destroyed: {{err}}", err) 297 } 298 } 299 300 return nil 301 } 302 303 func testAccAWSALBConfig_basic(albName string) string { 304 return fmt.Sprintf(`resource "aws_alb" "alb_test" { 305 name = "%s" 306 internal = false 307 security_groups = ["${aws_security_group.alb_test.id}"] 308 subnets = ["${aws_subnet.alb_test.*.id}"] 309 310 idle_timeout = 30 311 enable_deletion_protection = false 312 313 tags { 314 TestName = "TestAccAWSALB_basic" 315 } 316 } 317 318 variable "subnets" { 319 default = ["10.0.1.0/24", "10.0.2.0/24"] 320 type = "list" 321 } 322 323 data "aws_availability_zones" "available" {} 324 325 resource "aws_vpc" "alb_test" { 326 cidr_block = "10.0.0.0/16" 327 328 tags { 329 TestName = "TestAccAWSALB_basic" 330 } 331 } 332 333 resource "aws_subnet" "alb_test" { 334 count = 2 335 vpc_id = "${aws_vpc.alb_test.id}" 336 cidr_block = "${element(var.subnets, count.index)}" 337 map_public_ip_on_launch = true 338 availability_zone = "${element(data.aws_availability_zones.available.names, count.index)}" 339 340 tags { 341 TestName = "TestAccAWSALB_basic" 342 } 343 } 344 345 resource "aws_security_group" "alb_test" { 346 name = "allow_all_alb_test" 347 description = "Used for ALB Testing" 348 vpc_id = "${aws_vpc.alb_test.id}" 349 350 ingress { 351 from_port = 0 352 to_port = 0 353 protocol = "-1" 354 cidr_blocks = ["0.0.0.0/0"] 355 } 356 357 egress { 358 from_port = 0 359 to_port = 0 360 protocol = "-1" 361 cidr_blocks = ["0.0.0.0/0"] 362 } 363 364 tags { 365 TestName = "TestAccAWSALB_basic" 366 } 367 }`, albName) 368 } 369 370 func testAccAWSALBConfig_generatedName() string { 371 return fmt.Sprintf(` 372 resource "aws_alb" "alb_test" { 373 internal = false 374 security_groups = ["${aws_security_group.alb_test.id}"] 375 subnets = ["${aws_subnet.alb_test.*.id}"] 376 377 idle_timeout = 30 378 enable_deletion_protection = false 379 380 tags { 381 TestName = "TestAccAWSALB_basic" 382 } 383 } 384 385 variable "subnets" { 386 default = ["10.0.1.0/24", "10.0.2.0/24"] 387 type = "list" 388 } 389 390 data "aws_availability_zones" "available" {} 391 392 resource "aws_vpc" "alb_test" { 393 cidr_block = "10.0.0.0/16" 394 395 tags { 396 TestName = "TestAccAWSALB_basic" 397 } 398 } 399 400 resource "aws_subnet" "alb_test" { 401 count = 2 402 vpc_id = "${aws_vpc.alb_test.id}" 403 cidr_block = "${element(var.subnets, count.index)}" 404 map_public_ip_on_launch = true 405 availability_zone = "${element(data.aws_availability_zones.available.names, count.index)}" 406 407 tags { 408 TestName = "TestAccAWSALB_basic" 409 } 410 } 411 412 resource "aws_security_group" "alb_test" { 413 name = "allow_all_alb_test" 414 description = "Used for ALB Testing" 415 vpc_id = "${aws_vpc.alb_test.id}" 416 417 ingress { 418 from_port = 0 419 to_port = 0 420 protocol = "-1" 421 cidr_blocks = ["0.0.0.0/0"] 422 } 423 424 egress { 425 from_port = 0 426 to_port = 0 427 protocol = "-1" 428 cidr_blocks = ["0.0.0.0/0"] 429 } 430 431 tags { 432 TestName = "TestAccAWSALB_basic" 433 } 434 }`) 435 } 436 437 func testAccAWSALBConfig_namePrefix() string { 438 return fmt.Sprintf(` 439 resource "aws_alb" "alb_test" { 440 name_prefix = "tf-lb" 441 internal = false 442 security_groups = ["${aws_security_group.alb_test.id}"] 443 subnets = ["${aws_subnet.alb_test.*.id}"] 444 445 idle_timeout = 30 446 enable_deletion_protection = false 447 448 tags { 449 TestName = "TestAccAWSALB_basic" 450 } 451 } 452 453 variable "subnets" { 454 default = ["10.0.1.0/24", "10.0.2.0/24"] 455 type = "list" 456 } 457 458 data "aws_availability_zones" "available" {} 459 460 resource "aws_vpc" "alb_test" { 461 cidr_block = "10.0.0.0/16" 462 463 tags { 464 TestName = "TestAccAWSALB_basic" 465 } 466 } 467 468 resource "aws_subnet" "alb_test" { 469 count = 2 470 vpc_id = "${aws_vpc.alb_test.id}" 471 cidr_block = "${element(var.subnets, count.index)}" 472 map_public_ip_on_launch = true 473 availability_zone = "${element(data.aws_availability_zones.available.names, count.index)}" 474 475 tags { 476 TestName = "TestAccAWSALB_basic" 477 } 478 } 479 480 resource "aws_security_group" "alb_test" { 481 name = "allow_all_alb_test" 482 description = "Used for ALB Testing" 483 vpc_id = "${aws_vpc.alb_test.id}" 484 485 ingress { 486 from_port = 0 487 to_port = 0 488 protocol = "-1" 489 cidr_blocks = ["0.0.0.0/0"] 490 } 491 492 egress { 493 from_port = 0 494 to_port = 0 495 protocol = "-1" 496 cidr_blocks = ["0.0.0.0/0"] 497 } 498 499 tags { 500 TestName = "TestAccAWSALB_basic" 501 } 502 }`) 503 } 504 func testAccAWSALBConfig_updatedTags(albName string) string { 505 return fmt.Sprintf(`resource "aws_alb" "alb_test" { 506 name = "%s" 507 internal = false 508 security_groups = ["${aws_security_group.alb_test.id}"] 509 subnets = ["${aws_subnet.alb_test.*.id}"] 510 511 idle_timeout = 30 512 enable_deletion_protection = false 513 514 tags { 515 Environment = "Production" 516 Type = "Sample Type Tag" 517 } 518 } 519 520 variable "subnets" { 521 default = ["10.0.1.0/24", "10.0.2.0/24"] 522 type = "list" 523 } 524 525 data "aws_availability_zones" "available" {} 526 527 resource "aws_vpc" "alb_test" { 528 cidr_block = "10.0.0.0/16" 529 530 tags { 531 TestName = "TestAccAWSALB_basic" 532 } 533 } 534 535 resource "aws_subnet" "alb_test" { 536 count = 2 537 vpc_id = "${aws_vpc.alb_test.id}" 538 cidr_block = "${element(var.subnets, count.index)}" 539 map_public_ip_on_launch = true 540 availability_zone = "${element(data.aws_availability_zones.available.names, count.index)}" 541 542 tags { 543 TestName = "TestAccAWSALB_basic" 544 } 545 } 546 547 resource "aws_security_group" "alb_test" { 548 name = "allow_all_alb_test" 549 description = "Used for ALB Testing" 550 vpc_id = "${aws_vpc.alb_test.id}" 551 552 ingress { 553 from_port = 0 554 to_port = 0 555 protocol = "-1" 556 cidr_blocks = ["0.0.0.0/0"] 557 } 558 559 egress { 560 from_port = 0 561 to_port = 0 562 protocol = "-1" 563 cidr_blocks = ["0.0.0.0/0"] 564 } 565 566 tags { 567 TestName = "TestAccAWSALB_basic" 568 } 569 }`, albName) 570 } 571 572 func testAccAWSALBConfig_accessLogs(albName, bucketName string) string { 573 return fmt.Sprintf(`resource "aws_alb" "alb_test" { 574 name = "%s" 575 internal = false 576 security_groups = ["${aws_security_group.alb_test.id}"] 577 subnets = ["${aws_subnet.alb_test.*.id}"] 578 579 idle_timeout = 50 580 enable_deletion_protection = false 581 582 access_logs { 583 bucket = "${aws_s3_bucket.logs.bucket}" 584 prefix = "${var.bucket_prefix}" 585 } 586 587 tags { 588 TestName = "TestAccAWSALB_basic1" 589 } 590 } 591 592 variable "bucket_name" { 593 type = "string" 594 default = "%s" 595 } 596 597 variable "bucket_prefix" { 598 type = "string" 599 default = "testAccAWSALBConfig_accessLogs" 600 } 601 602 resource "aws_s3_bucket" "logs" { 603 bucket = "${var.bucket_name}" 604 policy = "${data.aws_iam_policy_document.logs_bucket.json}" 605 # dangerous, only here for the test... 606 force_destroy = true 607 608 tags { 609 Name = "ALB Logs Bucket Test" 610 } 611 } 612 613 data "aws_caller_identity" "current" {} 614 615 data "aws_elb_service_account" "current" {} 616 617 data "aws_iam_policy_document" "logs_bucket" { 618 statement { 619 actions = ["s3:PutObject"] 620 effect = "Allow" 621 resources = ["arn:aws:s3:::${var.bucket_name}/${var.bucket_prefix}/AWSLogs/${data.aws_caller_identity.current.account_id}/*"] 622 623 principals = { 624 type = "AWS" 625 identifiers = ["arn:aws:iam::${data.aws_elb_service_account.current.id}:root"] 626 } 627 } 628 } 629 630 variable "subnets" { 631 default = ["10.0.1.0/24", "10.0.2.0/24"] 632 type = "list" 633 } 634 635 data "aws_availability_zones" "available" {} 636 637 resource "aws_vpc" "alb_test" { 638 cidr_block = "10.0.0.0/16" 639 640 tags { 641 TestName = "TestAccAWSALB_basic" 642 } 643 } 644 645 resource "aws_subnet" "alb_test" { 646 count = 2 647 vpc_id = "${aws_vpc.alb_test.id}" 648 cidr_block = "${element(var.subnets, count.index)}" 649 map_public_ip_on_launch = true 650 availability_zone = "${element(data.aws_availability_zones.available.names, count.index)}" 651 652 tags { 653 TestName = "TestAccAWSALB_basic" 654 } 655 } 656 657 resource "aws_security_group" "alb_test" { 658 name = "allow_all_alb_test" 659 description = "Used for ALB Testing" 660 vpc_id = "${aws_vpc.alb_test.id}" 661 662 ingress { 663 from_port = 0 664 to_port = 0 665 protocol = "-1" 666 cidr_blocks = ["0.0.0.0/0"] 667 } 668 669 egress { 670 from_port = 0 671 to_port = 0 672 protocol = "-1" 673 cidr_blocks = ["0.0.0.0/0"] 674 } 675 676 tags { 677 TestName = "TestAccAWSALB_basic" 678 } 679 }`, albName, bucketName) 680 } 681 682 func testAccAWSALBConfig_nosg(albName string) string { 683 return fmt.Sprintf(`resource "aws_alb" "alb_test" { 684 name = "%s" 685 internal = false 686 subnets = ["${aws_subnet.alb_test.*.id}"] 687 688 idle_timeout = 30 689 enable_deletion_protection = false 690 691 tags { 692 TestName = "TestAccAWSALB_basic" 693 } 694 } 695 696 variable "subnets" { 697 default = ["10.0.1.0/24", "10.0.2.0/24"] 698 type = "list" 699 } 700 701 data "aws_availability_zones" "available" {} 702 703 resource "aws_vpc" "alb_test" { 704 cidr_block = "10.0.0.0/16" 705 706 tags { 707 TestName = "TestAccAWSALB_basic" 708 } 709 } 710 711 resource "aws_subnet" "alb_test" { 712 count = 2 713 vpc_id = "${aws_vpc.alb_test.id}" 714 cidr_block = "${element(var.subnets, count.index)}" 715 map_public_ip_on_launch = true 716 availability_zone = "${element(data.aws_availability_zones.available.names, count.index)}" 717 718 tags { 719 TestName = "TestAccAWSALB_basic" 720 } 721 }`, albName) 722 }