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 }