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  `