github.com/adrian-bl/terraform@v0.7.0-rc2.0.20160705220747-de0a34fc3517/builtin/providers/aws/resource_aws_codedeploy_deployment_group_test.go (about)

     1  package aws
     2  
     3  import (
     4  	"fmt"
     5  	"reflect"
     6  	"regexp"
     7  	"sort"
     8  	"testing"
     9  
    10  	"github.com/aws/aws-sdk-go/aws"
    11  	"github.com/aws/aws-sdk-go/aws/awserr"
    12  	"github.com/aws/aws-sdk-go/service/codedeploy"
    13  	"github.com/hashicorp/terraform/helper/acctest"
    14  	"github.com/hashicorp/terraform/helper/resource"
    15  	"github.com/hashicorp/terraform/helper/schema"
    16  	"github.com/hashicorp/terraform/terraform"
    17  )
    18  
    19  func TestAccAWSCodeDeployDeploymentGroup_basic(t *testing.T) {
    20  	var group codedeploy.DeploymentGroupInfo
    21  
    22  	rName := acctest.RandString(5)
    23  
    24  	resource.Test(t, resource.TestCase{
    25  		PreCheck:     func() { testAccPreCheck(t) },
    26  		Providers:    testAccProviders,
    27  		CheckDestroy: testAccCheckAWSCodeDeployDeploymentGroupDestroy,
    28  		Steps: []resource.TestStep{
    29  			resource.TestStep{
    30  				Config: testAccAWSCodeDeployDeploymentGroup(rName),
    31  				Check: resource.ComposeTestCheckFunc(
    32  					testAccCheckAWSCodeDeployDeploymentGroupExists("aws_codedeploy_deployment_group.foo", &group),
    33  					resource.TestCheckResourceAttr(
    34  						"aws_codedeploy_deployment_group.foo", "app_name", "foo_app_"+rName),
    35  					resource.TestCheckResourceAttr(
    36  						"aws_codedeploy_deployment_group.foo", "deployment_group_name", "foo_"+rName),
    37  					resource.TestCheckResourceAttr(
    38  						"aws_codedeploy_deployment_group.foo", "deployment_config_name", "CodeDeployDefault.OneAtATime"),
    39  
    40  					resource.TestCheckResourceAttr(
    41  						"aws_codedeploy_deployment_group.foo", "ec2_tag_filter.#", "1"),
    42  					resource.TestCheckResourceAttr(
    43  						"aws_codedeploy_deployment_group.foo", "ec2_tag_filter.2916377465.key", "filterkey"),
    44  					resource.TestCheckResourceAttr(
    45  						"aws_codedeploy_deployment_group.foo", "ec2_tag_filter.2916377465.type", "KEY_AND_VALUE"),
    46  					resource.TestCheckResourceAttr(
    47  						"aws_codedeploy_deployment_group.foo", "ec2_tag_filter.2916377465.value", "filtervalue"),
    48  				),
    49  			},
    50  			resource.TestStep{
    51  				Config: testAccAWSCodeDeployDeploymentGroupModified(rName),
    52  				Check: resource.ComposeTestCheckFunc(
    53  					testAccCheckAWSCodeDeployDeploymentGroupExists("aws_codedeploy_deployment_group.foo", &group),
    54  					resource.TestCheckResourceAttr(
    55  						"aws_codedeploy_deployment_group.foo", "app_name", "foo_app_"+rName),
    56  					resource.TestCheckResourceAttr(
    57  						"aws_codedeploy_deployment_group.foo", "deployment_group_name", "bar_"+rName),
    58  					resource.TestCheckResourceAttr(
    59  						"aws_codedeploy_deployment_group.foo", "deployment_config_name", "CodeDeployDefault.OneAtATime"),
    60  
    61  					resource.TestCheckResourceAttr(
    62  						"aws_codedeploy_deployment_group.foo", "ec2_tag_filter.#", "1"),
    63  					resource.TestCheckResourceAttr(
    64  						"aws_codedeploy_deployment_group.foo", "ec2_tag_filter.2369538975.key", "filterkey"),
    65  					resource.TestCheckResourceAttr(
    66  						"aws_codedeploy_deployment_group.foo", "ec2_tag_filter.2369538975.type", "KEY_AND_VALUE"),
    67  					resource.TestCheckResourceAttr(
    68  						"aws_codedeploy_deployment_group.foo", "ec2_tag_filter.2369538975.value", "anotherfiltervalue"),
    69  				),
    70  			},
    71  		},
    72  	})
    73  }
    74  
    75  func TestAccAWSCodeDeployDeploymentGroup_onPremiseTag(t *testing.T) {
    76  	var group codedeploy.DeploymentGroupInfo
    77  
    78  	rName := acctest.RandString(5)
    79  
    80  	resource.Test(t, resource.TestCase{
    81  		PreCheck:     func() { testAccPreCheck(t) },
    82  		Providers:    testAccProviders,
    83  		CheckDestroy: testAccCheckAWSCodeDeployDeploymentGroupDestroy,
    84  		Steps: []resource.TestStep{
    85  			resource.TestStep{
    86  				Config: testAccAWSCodeDeployDeploymentGroupOnPremiseTags(rName),
    87  				Check: resource.ComposeTestCheckFunc(
    88  					testAccCheckAWSCodeDeployDeploymentGroupExists("aws_codedeploy_deployment_group.foo", &group),
    89  					resource.TestCheckResourceAttr(
    90  						"aws_codedeploy_deployment_group.foo", "app_name", "foo_app_"+rName),
    91  					resource.TestCheckResourceAttr(
    92  						"aws_codedeploy_deployment_group.foo", "deployment_group_name", "foo_"+rName),
    93  					resource.TestCheckResourceAttr(
    94  						"aws_codedeploy_deployment_group.foo", "deployment_config_name", "CodeDeployDefault.OneAtATime"),
    95  
    96  					resource.TestCheckResourceAttr(
    97  						"aws_codedeploy_deployment_group.foo", "on_premises_instance_tag_filter.#", "1"),
    98  					resource.TestCheckResourceAttr(
    99  						"aws_codedeploy_deployment_group.foo", "on_premises_instance_tag_filter.2916377465.key", "filterkey"),
   100  					resource.TestCheckResourceAttr(
   101  						"aws_codedeploy_deployment_group.foo", "on_premises_instance_tag_filter.2916377465.type", "KEY_AND_VALUE"),
   102  					resource.TestCheckResourceAttr(
   103  						"aws_codedeploy_deployment_group.foo", "on_premises_instance_tag_filter.2916377465.value", "filtervalue"),
   104  				),
   105  			},
   106  		},
   107  	})
   108  }
   109  
   110  func TestAccAWSCodeDeployDeploymentGroup_triggerConfiguration_basic(t *testing.T) {
   111  	var group codedeploy.DeploymentGroupInfo
   112  
   113  	rName := acctest.RandString(5)
   114  
   115  	resource.Test(t, resource.TestCase{
   116  		PreCheck:     func() { testAccPreCheck(t) },
   117  		Providers:    testAccProviders,
   118  		CheckDestroy: testAccCheckAWSCodeDeployDeploymentGroupDestroy,
   119  		Steps: []resource.TestStep{
   120  			resource.TestStep{
   121  				Config: testAccAWSCodeDeployDeploymentGroup_triggerConfiguration_create(rName),
   122  				Check: resource.ComposeTestCheckFunc(
   123  					testAccCheckAWSCodeDeployDeploymentGroupExists("aws_codedeploy_deployment_group.foo_group", &group),
   124  					resource.TestCheckResourceAttr(
   125  						"aws_codedeploy_deployment_group.foo_group", "app_name", "foo-app-"+rName),
   126  					resource.TestCheckResourceAttr(
   127  						"aws_codedeploy_deployment_group.foo_group", "deployment_group_name", "foo-group-"+rName),
   128  					testAccCheckTriggerEvents(&group, "foo-trigger", []string{
   129  						"DeploymentFailure",
   130  					}),
   131  				),
   132  			},
   133  			resource.TestStep{
   134  				Config: testAccAWSCodeDeployDeploymentGroup_triggerConfiguration_update(rName),
   135  				Check: resource.ComposeTestCheckFunc(
   136  					testAccCheckAWSCodeDeployDeploymentGroupExists("aws_codedeploy_deployment_group.foo_group", &group),
   137  					resource.TestCheckResourceAttr(
   138  						"aws_codedeploy_deployment_group.foo_group", "app_name", "foo-app-"+rName),
   139  					resource.TestCheckResourceAttr(
   140  						"aws_codedeploy_deployment_group.foo_group", "deployment_group_name", "foo-group-"+rName),
   141  					testAccCheckTriggerEvents(&group, "foo-trigger", []string{
   142  						"DeploymentFailure",
   143  						"DeploymentSuccess",
   144  					}),
   145  				),
   146  			},
   147  		},
   148  	})
   149  }
   150  
   151  func TestAccAWSCodeDeployDeploymentGroup_triggerConfiguration_multiple(t *testing.T) {
   152  	var group codedeploy.DeploymentGroupInfo
   153  
   154  	rName := acctest.RandString(5)
   155  
   156  	resource.Test(t, resource.TestCase{
   157  		PreCheck:     func() { testAccPreCheck(t) },
   158  		Providers:    testAccProviders,
   159  		CheckDestroy: testAccCheckAWSCodeDeployDeploymentGroupDestroy,
   160  		Steps: []resource.TestStep{
   161  			resource.TestStep{
   162  				Config: testAccAWSCodeDeployDeploymentGroup_triggerConfiguration_createMultiple(rName),
   163  				Check: resource.ComposeTestCheckFunc(
   164  					testAccCheckAWSCodeDeployDeploymentGroupExists("aws_codedeploy_deployment_group.foo_group", &group),
   165  					resource.TestCheckResourceAttr(
   166  						"aws_codedeploy_deployment_group.foo_group", "app_name", "foo-app-"+rName),
   167  					resource.TestCheckResourceAttr(
   168  						"aws_codedeploy_deployment_group.foo_group", "deployment_group_name", "foo-group-"+rName),
   169  					testAccCheckTriggerEvents(&group, "foo-trigger", []string{
   170  						"DeploymentFailure",
   171  					}),
   172  					testAccCheckTriggerEvents(&group, "bar-trigger", []string{
   173  						"InstanceFailure",
   174  					}),
   175  					testAccCheckTriggerTargetArn(&group, "bar-trigger",
   176  						regexp.MustCompile("^arn:aws:sns:[^:]+:[0-9]{12}:bar-topic-"+rName+"$")),
   177  				),
   178  			},
   179  			resource.TestStep{
   180  				Config: testAccAWSCodeDeployDeploymentGroup_triggerConfiguration_updateMultiple(rName),
   181  				Check: resource.ComposeTestCheckFunc(
   182  					testAccCheckAWSCodeDeployDeploymentGroupExists("aws_codedeploy_deployment_group.foo_group", &group),
   183  					resource.TestCheckResourceAttr(
   184  						"aws_codedeploy_deployment_group.foo_group", "app_name", "foo-app-"+rName),
   185  					resource.TestCheckResourceAttr(
   186  						"aws_codedeploy_deployment_group.foo_group", "deployment_group_name", "foo-group-"+rName),
   187  					testAccCheckTriggerEvents(&group, "foo-trigger", []string{
   188  						"DeploymentFailure",
   189  						"DeploymentStart",
   190  						"DeploymentStop",
   191  						"DeploymentSuccess",
   192  					}),
   193  					testAccCheckTriggerEvents(&group, "bar-trigger", []string{
   194  						"InstanceFailure",
   195  					}),
   196  					testAccCheckTriggerTargetArn(&group, "bar-trigger",
   197  						regexp.MustCompile("^arn:aws:sns:[^:]+:[0-9]{12}:baz-topic-"+rName+"$")),
   198  				),
   199  			},
   200  		},
   201  	})
   202  }
   203  
   204  func TestValidateAWSCodeDeployTriggerEvent(t *testing.T) {
   205  	cases := []struct {
   206  		Value    string
   207  		ErrCount int
   208  	}{
   209  		{
   210  			Value:    "DeploymentStart",
   211  			ErrCount: 0,
   212  		},
   213  		{
   214  			Value:    "DeploymentStop",
   215  			ErrCount: 0,
   216  		},
   217  		{
   218  			Value:    "DeploymentSuccess",
   219  			ErrCount: 0,
   220  		},
   221  		{
   222  			Value:    "DeploymentFailure",
   223  			ErrCount: 0,
   224  		},
   225  		{
   226  			Value:    "InstanceStart",
   227  			ErrCount: 0,
   228  		},
   229  		{
   230  			Value:    "InstanceSuccess",
   231  			ErrCount: 0,
   232  		},
   233  		{
   234  			Value:    "InstanceFailure",
   235  			ErrCount: 0,
   236  		},
   237  		{
   238  			Value:    "DeploymentStarts",
   239  			ErrCount: 1,
   240  		},
   241  		{
   242  			Value:    "InstanceFail",
   243  			ErrCount: 1,
   244  		},
   245  		{
   246  			Value:    "Foo",
   247  			ErrCount: 1,
   248  		},
   249  		{
   250  			Value:    "",
   251  			ErrCount: 1,
   252  		},
   253  	}
   254  
   255  	for _, tc := range cases {
   256  		_, errors := validateTriggerEvent(tc.Value, "trigger_event")
   257  		if len(errors) != tc.ErrCount {
   258  			t.Fatalf("Trigger event validation failed for event type %q: %q", tc.Value, errors)
   259  		}
   260  	}
   261  }
   262  
   263  func TestBuildTriggerConfigs(t *testing.T) {
   264  	input := []interface{}{
   265  		map[string]interface{}{
   266  			"trigger_events": schema.NewSet(schema.HashString, []interface{}{
   267  				"DeploymentFailure",
   268  			}),
   269  			"trigger_name":       "foo-trigger",
   270  			"trigger_target_arn": "arn:aws:sns:us-west-2:123456789012:foo-topic",
   271  		},
   272  	}
   273  
   274  	expected := []*codedeploy.TriggerConfig{
   275  		&codedeploy.TriggerConfig{
   276  			TriggerEvents: []*string{
   277  				aws.String("DeploymentFailure"),
   278  			},
   279  			TriggerName:      aws.String("foo-trigger"),
   280  			TriggerTargetArn: aws.String("arn:aws:sns:us-west-2:123456789012:foo-topic"),
   281  		},
   282  	}
   283  
   284  	actual := buildTriggerConfigs(input)
   285  
   286  	if !reflect.DeepEqual(actual, expected) {
   287  		t.Fatalf("buildTriggerConfigs output is not correct.\nGot:\n%#v\nExpected:\n%#v\n",
   288  			actual, expected)
   289  	}
   290  }
   291  
   292  func TestTriggerConfigsToMap(t *testing.T) {
   293  	input := []*codedeploy.TriggerConfig{
   294  		&codedeploy.TriggerConfig{
   295  			TriggerEvents: []*string{
   296  				aws.String("DeploymentFailure"),
   297  				aws.String("InstanceFailure"),
   298  			},
   299  			TriggerName:      aws.String("bar-trigger"),
   300  			TriggerTargetArn: aws.String("arn:aws:sns:us-west-2:123456789012:bar-topic"),
   301  		},
   302  	}
   303  
   304  	expected := map[string]interface{}{
   305  		"trigger_events": schema.NewSet(schema.HashString, []interface{}{
   306  			"DeploymentFailure",
   307  			"InstanceFailure",
   308  		}),
   309  		"trigger_name":       "bar-trigger",
   310  		"trigger_target_arn": "arn:aws:sns:us-west-2:123456789012:bar-topic",
   311  	}
   312  
   313  	actual := triggerConfigsToMap(input)[0]
   314  
   315  	fatal := false
   316  
   317  	if actual["trigger_name"] != expected["trigger_name"] {
   318  		fatal = true
   319  	}
   320  
   321  	if actual["trigger_target_arn"] != expected["trigger_target_arn"] {
   322  		fatal = true
   323  	}
   324  
   325  	actualEvents := actual["trigger_events"].(*schema.Set)
   326  	expectedEvents := expected["trigger_events"].(*schema.Set)
   327  	if !actualEvents.Equal(expectedEvents) {
   328  		fatal = true
   329  	}
   330  
   331  	if fatal {
   332  		t.Fatalf("triggerConfigsToMap output is not correct.\nGot:\n%#v\nExpected:\n%#v\n",
   333  			actual, expected)
   334  	}
   335  }
   336  
   337  func testAccCheckTriggerEvents(group *codedeploy.DeploymentGroupInfo, triggerName string, expectedEvents []string) resource.TestCheckFunc {
   338  	return func(s *terraform.State) error {
   339  
   340  		for _, actual := range group.TriggerConfigurations {
   341  			if *actual.TriggerName == triggerName {
   342  
   343  				numberOfEvents := len(actual.TriggerEvents)
   344  				if numberOfEvents != len(expectedEvents) {
   345  					return fmt.Errorf("Trigger events do not match. Expected: %d. Got: %d.",
   346  						len(expectedEvents), numberOfEvents)
   347  				}
   348  
   349  				actualEvents := make([]string, 0, numberOfEvents)
   350  				for _, event := range actual.TriggerEvents {
   351  					actualEvents = append(actualEvents, *event)
   352  				}
   353  				sort.Strings(actualEvents)
   354  
   355  				if !reflect.DeepEqual(actualEvents, expectedEvents) {
   356  					return fmt.Errorf("Trigger events do not match.\nExpected: %v\nGot: %v\n",
   357  						expectedEvents, actualEvents)
   358  				}
   359  				break
   360  			}
   361  		}
   362  		return nil
   363  	}
   364  }
   365  
   366  func testAccCheckTriggerTargetArn(group *codedeploy.DeploymentGroupInfo, triggerName string, r *regexp.Regexp) resource.TestCheckFunc {
   367  	return func(s *terraform.State) error {
   368  		for _, actual := range group.TriggerConfigurations {
   369  			if *actual.TriggerName == triggerName {
   370  				if !r.MatchString(*actual.TriggerTargetArn) {
   371  					return fmt.Errorf("Trigger target arn does not match regular expression.\nRegex: %v\nTriggerTargetArn: %v\n",
   372  						r, *actual.TriggerTargetArn)
   373  				}
   374  				break
   375  			}
   376  		}
   377  		return nil
   378  	}
   379  }
   380  
   381  func testAccCheckAWSCodeDeployDeploymentGroupDestroy(s *terraform.State) error {
   382  	conn := testAccProvider.Meta().(*AWSClient).codedeployconn
   383  
   384  	for _, rs := range s.RootModule().Resources {
   385  		if rs.Type != "aws_codedeploy_deployment_group" {
   386  			continue
   387  		}
   388  
   389  		resp, err := conn.GetDeploymentGroup(&codedeploy.GetDeploymentGroupInput{
   390  			ApplicationName:     aws.String(rs.Primary.Attributes["app_name"]),
   391  			DeploymentGroupName: aws.String(rs.Primary.Attributes["deployment_group_name"]),
   392  		})
   393  
   394  		if ae, ok := err.(awserr.Error); ok && ae.Code() == "ApplicationDoesNotExistException" {
   395  			continue
   396  		}
   397  
   398  		if err == nil {
   399  			if resp.DeploymentGroupInfo.DeploymentGroupName != nil {
   400  				return fmt.Errorf("CodeDeploy deployment group still exists:\n%#v", *resp.DeploymentGroupInfo.DeploymentGroupName)
   401  			}
   402  		}
   403  
   404  		return err
   405  	}
   406  
   407  	return nil
   408  }
   409  
   410  func testAccCheckAWSCodeDeployDeploymentGroupExists(name string, group *codedeploy.DeploymentGroupInfo) resource.TestCheckFunc {
   411  	return func(s *terraform.State) error {
   412  		rs, ok := s.RootModule().Resources[name]
   413  		if !ok {
   414  			return fmt.Errorf("Not found: %s", name)
   415  		}
   416  
   417  		conn := testAccProvider.Meta().(*AWSClient).codedeployconn
   418  
   419  		resp, err := conn.GetDeploymentGroup(&codedeploy.GetDeploymentGroupInput{
   420  			ApplicationName:     aws.String(rs.Primary.Attributes["app_name"]),
   421  			DeploymentGroupName: aws.String(rs.Primary.Attributes["deployment_group_name"]),
   422  		})
   423  
   424  		if err != nil {
   425  			return err
   426  		}
   427  
   428  		*group = *resp.DeploymentGroupInfo
   429  
   430  		return nil
   431  	}
   432  }
   433  
   434  func testAccAWSCodeDeployDeploymentGroup(rName string) string {
   435  	return fmt.Sprintf(`
   436  resource "aws_codedeploy_app" "foo_app" {
   437  	name = "foo_app_%s"
   438  }
   439  
   440  resource "aws_iam_role_policy" "foo_policy" {
   441  	name = "foo_policy_%s"
   442  	role = "${aws_iam_role.foo_role.id}"
   443  	policy = <<EOF
   444  {
   445  	"Version": "2012-10-17",
   446  	"Statement": [
   447  		{
   448  			"Effect": "Allow",
   449  			"Action": [
   450  				"autoscaling:CompleteLifecycleAction",
   451  				"autoscaling:DeleteLifecycleHook",
   452  				"autoscaling:DescribeAutoScalingGroups",
   453  				"autoscaling:DescribeLifecycleHooks",
   454  				"autoscaling:PutLifecycleHook",
   455  				"autoscaling:RecordLifecycleActionHeartbeat",
   456  				"ec2:DescribeInstances",
   457  				"ec2:DescribeInstanceStatus",
   458  				"tag:GetTags",
   459  				"tag:GetResources"
   460  			],
   461  			"Resource": "*"
   462  		}
   463  	]
   464  }
   465  EOF
   466  }
   467  
   468  resource "aws_iam_role" "foo_role" {
   469  	name = "foo_role_%s"
   470  	assume_role_policy = <<EOF
   471  {
   472  	"Version": "2012-10-17",
   473  	"Statement": [
   474  		{
   475  			"Sid": "",
   476  			"Effect": "Allow",
   477  			"Principal": {
   478  				"Service": [
   479  					"codedeploy.amazonaws.com"
   480  				]
   481  			},
   482  			"Action": "sts:AssumeRole"
   483  		}
   484  	]
   485  }
   486  EOF
   487  }
   488  
   489  resource "aws_codedeploy_deployment_group" "foo" {
   490  	app_name = "${aws_codedeploy_app.foo_app.name}"
   491  	deployment_group_name = "foo_%s"
   492  	service_role_arn = "${aws_iam_role.foo_role.arn}"
   493  	ec2_tag_filter {
   494  		key = "filterkey"
   495  		type = "KEY_AND_VALUE"
   496  		value = "filtervalue"
   497  	}
   498  }`, rName, rName, rName, rName)
   499  }
   500  
   501  func testAccAWSCodeDeployDeploymentGroupModified(rName string) string {
   502  	return fmt.Sprintf(`
   503  resource "aws_codedeploy_app" "foo_app" {
   504  	name = "foo_app_%s"
   505  }
   506  
   507  resource "aws_iam_role_policy" "foo_policy" {
   508  	name = "foo_policy_%s"
   509  	role = "${aws_iam_role.foo_role.id}"
   510  	policy = <<EOF
   511  {
   512  	"Version": "2012-10-17",
   513  	"Statement": [
   514  		{
   515  			"Effect": "Allow",
   516  			"Action": [
   517  				"autoscaling:CompleteLifecycleAction",
   518  				"autoscaling:DeleteLifecycleHook",
   519  				"autoscaling:DescribeAutoScalingGroups",
   520  				"autoscaling:DescribeLifecycleHooks",
   521  				"autoscaling:PutLifecycleHook",
   522  				"autoscaling:RecordLifecycleActionHeartbeat",
   523  				"ec2:DescribeInstances",
   524  				"ec2:DescribeInstanceStatus",
   525  				"tag:GetTags",
   526  				"tag:GetResources"
   527  			],
   528  			"Resource": "*"
   529  		}
   530  	]
   531  }
   532  EOF
   533  }
   534  
   535  resource "aws_iam_role" "foo_role" {
   536  	name = "foo_role_%s"
   537  	assume_role_policy = <<EOF
   538  {
   539  	"Version": "2012-10-17",
   540  	"Statement": [
   541  		{
   542  			"Sid": "",
   543  			"Effect": "Allow",
   544  			"Principal": {
   545  				"Service": [
   546  					"codedeploy.amazonaws.com"
   547  				]
   548  			},
   549  			"Action": "sts:AssumeRole"
   550  		}
   551  	]
   552  }
   553  EOF
   554  }
   555  
   556  resource "aws_codedeploy_deployment_group" "foo" {
   557  	app_name = "${aws_codedeploy_app.foo_app.name}"
   558  	deployment_group_name = "bar_%s"
   559  	service_role_arn = "${aws_iam_role.foo_role.arn}"
   560  	ec2_tag_filter {
   561  		key = "filterkey"
   562  		type = "KEY_AND_VALUE"
   563  		value = "anotherfiltervalue"
   564  	}
   565  }`, rName, rName, rName, rName)
   566  }
   567  
   568  func testAccAWSCodeDeployDeploymentGroupOnPremiseTags(rName string) string {
   569  	return fmt.Sprintf(`
   570  resource "aws_codedeploy_app" "foo_app" {
   571  	name = "foo_app_%s"
   572  }
   573  
   574  resource "aws_iam_role_policy" "foo_policy" {
   575  	name = "foo_policy_%s"
   576  	role = "${aws_iam_role.foo_role.id}"
   577  	policy = <<EOF
   578  {
   579  	"Version": "2012-10-17",
   580  	"Statement": [
   581  		{
   582  			"Effect": "Allow",
   583  			"Action": [
   584  				"autoscaling:CompleteLifecycleAction",
   585  				"autoscaling:DeleteLifecycleHook",
   586  				"autoscaling:DescribeAutoScalingGroups",
   587  				"autoscaling:DescribeLifecycleHooks",
   588  				"autoscaling:PutLifecycleHook",
   589  				"autoscaling:RecordLifecycleActionHeartbeat",
   590  				"ec2:DescribeInstances",
   591  				"ec2:DescribeInstanceStatus",
   592  				"tag:GetTags",
   593  				"tag:GetResources"
   594  			],
   595  			"Resource": "*"
   596  		}
   597  	]
   598  }
   599  EOF
   600  }
   601  
   602  resource "aws_iam_role" "foo_role" {
   603  	name = "foo_role_%s"
   604  	assume_role_policy = <<EOF
   605  {
   606  	"Version": "2012-10-17",
   607  	"Statement": [
   608  		{
   609  			"Sid": "",
   610  			"Effect": "Allow",
   611  			"Principal": {
   612  				"Service": [
   613  					"codedeploy.amazonaws.com"
   614  				]
   615  			},
   616  			"Action": "sts:AssumeRole"
   617  		}
   618  	]
   619  }
   620  EOF
   621  }
   622  
   623  resource "aws_codedeploy_deployment_group" "foo" {
   624  	app_name = "${aws_codedeploy_app.foo_app.name}"
   625  	deployment_group_name = "foo_%s"
   626  	service_role_arn = "${aws_iam_role.foo_role.arn}"
   627  	on_premises_instance_tag_filter {
   628  		key = "filterkey"
   629  		type = "KEY_AND_VALUE"
   630  		value = "filtervalue"
   631  	}
   632  }`, rName, rName, rName, rName)
   633  }
   634  
   635  func baseCodeDeployConfig(rName string) string {
   636  	return fmt.Sprintf(`
   637  resource "aws_codedeploy_app" "foo_app" {
   638  	name = "foo-app-%s"
   639  }
   640  
   641  resource "aws_iam_role_policy" "foo_policy" {
   642  	name = "foo-policy-%s"
   643  	role = "${aws_iam_role.foo_role.id}"
   644  	policy = <<EOF
   645  {
   646  	"Version": "2012-10-17",
   647  	"Statement": [
   648  		{
   649  			"Effect": "Allow",
   650  			"Action": [
   651  				"autoscaling:CompleteLifecycleAction",
   652  				"autoscaling:DeleteLifecycleHook",
   653  				"autoscaling:DescribeAutoScalingGroups",
   654  				"autoscaling:DescribeLifecycleHooks",
   655  				"autoscaling:PutLifecycleHook",
   656  				"autoscaling:RecordLifecycleActionHeartbeat",
   657  				"codedeploy:*",
   658  				"ec2:DescribeInstances",
   659  				"ec2:DescribeInstanceStatus",
   660  				"tag:GetTags",
   661  				"tag:GetResources",
   662  				"sns:Publish"
   663  			],
   664  			"Resource": "*"
   665  		}
   666  	]
   667  }
   668  EOF
   669  }
   670  
   671  resource "aws_iam_role" "foo_role" {
   672  	name = "foo-role-%s"
   673  	assume_role_policy = <<EOF
   674  {
   675  	"Version": "2012-10-17",
   676  	"Statement": [
   677  		{
   678  			"Sid": "",
   679  			"Effect": "Allow",
   680  			"Principal": {
   681  				"Service": "codedeploy.amazonaws.com"
   682  			},
   683  			"Action": "sts:AssumeRole"
   684  		}
   685  	]
   686  }
   687  EOF
   688  }
   689  
   690  resource "aws_sns_topic" "foo_topic" {
   691  	name = "foo-topic-%s"
   692  }`, rName, rName, rName, rName)
   693  }
   694  
   695  func testAccAWSCodeDeployDeploymentGroup_triggerConfiguration_create(rName string) string {
   696  	return fmt.Sprintf(`
   697  
   698  	%s
   699  	
   700  resource "aws_codedeploy_deployment_group" "foo_group" {
   701  	app_name = "${aws_codedeploy_app.foo_app.name}"
   702  	deployment_group_name = "foo-group-%s"
   703  	service_role_arn = "${aws_iam_role.foo_role.arn}"
   704  
   705  	trigger_configuration {
   706  		trigger_events = ["DeploymentFailure"]
   707  		trigger_name = "foo-trigger"
   708  		trigger_target_arn = "${aws_sns_topic.foo_topic.arn}"
   709  	}
   710  }`, baseCodeDeployConfig(rName), rName)
   711  }
   712  
   713  func testAccAWSCodeDeployDeploymentGroup_triggerConfiguration_update(rName string) string {
   714  	return fmt.Sprintf(`
   715  
   716  	%s
   717  	
   718  resource "aws_codedeploy_deployment_group" "foo_group" {
   719  	app_name = "${aws_codedeploy_app.foo_app.name}"
   720  	deployment_group_name = "foo-group-%s"
   721  	service_role_arn = "${aws_iam_role.foo_role.arn}"
   722  
   723  	trigger_configuration {
   724  		trigger_events = ["DeploymentSuccess", "DeploymentFailure"]
   725  		trigger_name = "foo-trigger"
   726  		trigger_target_arn = "${aws_sns_topic.foo_topic.arn}"
   727  	}
   728  }`, baseCodeDeployConfig(rName), rName)
   729  }
   730  
   731  func testAccAWSCodeDeployDeploymentGroup_triggerConfiguration_createMultiple(rName string) string {
   732  	return fmt.Sprintf(`
   733  
   734  	%s
   735  	
   736  resource "aws_sns_topic" "bar_topic" {
   737  	name = "bar-topic-%s"
   738  }
   739  
   740  resource "aws_codedeploy_deployment_group" "foo_group" {
   741  	app_name = "${aws_codedeploy_app.foo_app.name}"
   742  	deployment_group_name = "foo-group-%s"
   743  	service_role_arn = "${aws_iam_role.foo_role.arn}"
   744  
   745  	trigger_configuration {
   746  		trigger_events = ["DeploymentFailure"]
   747  		trigger_name = "foo-trigger"
   748  		trigger_target_arn = "${aws_sns_topic.foo_topic.arn}"
   749  	}
   750  
   751  	trigger_configuration {
   752  		trigger_events = ["InstanceFailure"]
   753  		trigger_name = "bar-trigger"
   754  		trigger_target_arn = "${aws_sns_topic.bar_topic.arn}"
   755  	}
   756  }`, baseCodeDeployConfig(rName), rName, rName)
   757  }
   758  
   759  func testAccAWSCodeDeployDeploymentGroup_triggerConfiguration_updateMultiple(rName string) string {
   760  	return fmt.Sprintf(`
   761  
   762  	%s
   763  	
   764  resource "aws_sns_topic" "bar_topic" {
   765  	name = "bar-topic-%s"
   766  }
   767  
   768  resource "aws_sns_topic" "baz_topic" {
   769  	name = "baz-topic-%s"
   770  }
   771  
   772  resource "aws_codedeploy_deployment_group" "foo_group" {
   773  	app_name = "${aws_codedeploy_app.foo_app.name}"
   774  	deployment_group_name = "foo-group-%s"
   775  	service_role_arn = "${aws_iam_role.foo_role.arn}"
   776  
   777  	trigger_configuration {
   778  		trigger_events = ["DeploymentStart", "DeploymentSuccess", "DeploymentFailure", "DeploymentStop"]
   779  		trigger_name = "foo-trigger"
   780  		trigger_target_arn = "${aws_sns_topic.foo_topic.arn}"
   781  	}
   782  
   783  	trigger_configuration {
   784  		trigger_events = ["InstanceFailure"]
   785  		trigger_name = "bar-trigger"
   786  		trigger_target_arn = "${aws_sns_topic.baz_topic.arn}"
   787  	}
   788  }`, baseCodeDeployConfig(rName), rName, rName, rName)
   789  }