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  `