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  }