github.com/nathanielks/terraform@v0.6.1-0.20170509030759-13e1a62319dc/builtin/providers/aws/resource_aws_cloudwatch_event_target_test.go (about) 1 package aws 2 3 import ( 4 "fmt" 5 "regexp" 6 "testing" 7 8 events "github.com/aws/aws-sdk-go/service/cloudwatchevents" 9 "github.com/hashicorp/terraform/helper/acctest" 10 "github.com/hashicorp/terraform/helper/resource" 11 "github.com/hashicorp/terraform/terraform" 12 ) 13 14 func TestAccAWSCloudWatchEventTarget_basic(t *testing.T) { 15 var target events.Target 16 17 resource.Test(t, resource.TestCase{ 18 PreCheck: func() { testAccPreCheck(t) }, 19 Providers: testAccProviders, 20 CheckDestroy: testAccCheckAWSCloudWatchEventTargetDestroy, 21 Steps: []resource.TestStep{ 22 { 23 Config: testAccAWSCloudWatchEventTargetConfig, 24 Check: resource.ComposeTestCheckFunc( 25 testAccCheckCloudWatchEventTargetExists("aws_cloudwatch_event_target.moobar", &target), 26 resource.TestCheckResourceAttr("aws_cloudwatch_event_target.moobar", "rule", "tf-acc-cw-event-rule-basic"), 27 resource.TestCheckResourceAttr("aws_cloudwatch_event_target.moobar", "target_id", "tf-acc-cw-target-basic"), 28 resource.TestMatchResourceAttr("aws_cloudwatch_event_target.moobar", "arn", 29 regexp.MustCompile(":tf-acc-moon$")), 30 ), 31 }, 32 { 33 Config: testAccAWSCloudWatchEventTargetConfigModified, 34 Check: resource.ComposeTestCheckFunc( 35 testAccCheckCloudWatchEventTargetExists("aws_cloudwatch_event_target.moobar", &target), 36 resource.TestCheckResourceAttr("aws_cloudwatch_event_target.moobar", "rule", "tf-acc-cw-event-rule-basic"), 37 resource.TestCheckResourceAttr("aws_cloudwatch_event_target.moobar", "target_id", "tf-acc-cw-target-modified"), 38 resource.TestMatchResourceAttr("aws_cloudwatch_event_target.moobar", "arn", 39 regexp.MustCompile(":tf-acc-sun$")), 40 ), 41 }, 42 }, 43 }) 44 } 45 46 func TestAccAWSCloudWatchEventTarget_missingTargetId(t *testing.T) { 47 var target events.Target 48 49 resource.Test(t, resource.TestCase{ 50 PreCheck: func() { testAccPreCheck(t) }, 51 Providers: testAccProviders, 52 CheckDestroy: testAccCheckAWSCloudWatchEventTargetDestroy, 53 Steps: []resource.TestStep{ 54 { 55 Config: testAccAWSCloudWatchEventTargetConfigMissingTargetId, 56 Check: resource.ComposeTestCheckFunc( 57 testAccCheckCloudWatchEventTargetExists("aws_cloudwatch_event_target.moobar", &target), 58 resource.TestCheckResourceAttr("aws_cloudwatch_event_target.moobar", "rule", "tf-acc-cw-event-rule-missing-target-id"), 59 resource.TestMatchResourceAttr("aws_cloudwatch_event_target.moobar", "arn", 60 regexp.MustCompile(":tf-acc-moon$")), 61 ), 62 }, 63 }, 64 }) 65 } 66 67 func TestAccAWSCloudWatchEventTarget_full(t *testing.T) { 68 var target events.Target 69 rName := acctest.RandomWithPrefix("tf_ssm_Document") 70 71 resource.Test(t, resource.TestCase{ 72 PreCheck: func() { testAccPreCheck(t) }, 73 Providers: testAccProviders, 74 CheckDestroy: testAccCheckAWSCloudWatchEventTargetDestroy, 75 Steps: []resource.TestStep{ 76 { 77 Config: testAccAWSCloudWatchEventTargetConfig_full(rName), 78 Check: resource.ComposeTestCheckFunc( 79 testAccCheckCloudWatchEventTargetExists("aws_cloudwatch_event_target.foobar", &target), 80 resource.TestCheckResourceAttr("aws_cloudwatch_event_target.foobar", "rule", "tf-acc-cw-event-rule-full"), 81 resource.TestCheckResourceAttr("aws_cloudwatch_event_target.foobar", "target_id", "tf-acc-cw-target-full"), 82 resource.TestMatchResourceAttr("aws_cloudwatch_event_target.foobar", "arn", 83 regexp.MustCompile("^arn:aws:kinesis:.*:stream/tf_ssm_Document")), 84 resource.TestCheckResourceAttr("aws_cloudwatch_event_target.foobar", "input", "{ \"source\": [\"aws.cloudtrail\"] }\n"), 85 resource.TestCheckResourceAttr("aws_cloudwatch_event_target.foobar", "input_path", ""), 86 ), 87 }, 88 }, 89 }) 90 } 91 92 func TestAccAWSCloudWatchEventTarget_ssmDocument(t *testing.T) { 93 var target events.Target 94 rName := acctest.RandomWithPrefix("tf_ssm_Document") 95 96 resource.Test(t, resource.TestCase{ 97 PreCheck: func() { testAccPreCheck(t) }, 98 Providers: testAccProviders, 99 CheckDestroy: testAccCheckAWSCloudWatchEventTargetDestroy, 100 Steps: []resource.TestStep{ 101 { 102 Config: testAccAWSCloudWatchEventTargetConfigSsmDocument(rName), 103 Check: resource.ComposeTestCheckFunc( 104 testAccCheckCloudWatchEventTargetExists("aws_cloudwatch_event_target.test", &target), 105 ), 106 }, 107 }, 108 }) 109 } 110 111 func testAccCheckCloudWatchEventTargetExists(n string, rule *events.Target) resource.TestCheckFunc { 112 return func(s *terraform.State) error { 113 rs, ok := s.RootModule().Resources[n] 114 if !ok { 115 return fmt.Errorf("Not found: %s", n) 116 } 117 118 conn := testAccProvider.Meta().(*AWSClient).cloudwatcheventsconn 119 t, err := findEventTargetById(rs.Primary.Attributes["target_id"], 120 rs.Primary.Attributes["rule"], nil, conn) 121 if err != nil { 122 return fmt.Errorf("Event Target not found: %s", err) 123 } 124 125 *rule = *t 126 127 return nil 128 } 129 } 130 131 func testAccCheckAWSCloudWatchEventTargetDestroy(s *terraform.State) error { 132 conn := testAccProvider.Meta().(*AWSClient).cloudwatcheventsconn 133 134 for _, rs := range s.RootModule().Resources { 135 if rs.Type != "aws_cloudwatch_event_target" { 136 continue 137 } 138 139 t, err := findEventTargetById(rs.Primary.Attributes["target_id"], 140 rs.Primary.Attributes["rule"], nil, conn) 141 if err == nil { 142 return fmt.Errorf("CloudWatch Event Target %q still exists: %s", 143 rs.Primary.ID, t) 144 } 145 } 146 147 return nil 148 } 149 150 var testAccAWSCloudWatchEventTargetConfig = ` 151 resource "aws_cloudwatch_event_rule" "foo" { 152 name = "tf-acc-cw-event-rule-basic" 153 schedule_expression = "rate(1 hour)" 154 } 155 156 resource "aws_cloudwatch_event_target" "moobar" { 157 rule = "${aws_cloudwatch_event_rule.foo.name}" 158 target_id = "tf-acc-cw-target-basic" 159 arn = "${aws_sns_topic.moon.arn}" 160 } 161 162 resource "aws_sns_topic" "moon" { 163 name = "tf-acc-moon" 164 } 165 ` 166 167 var testAccAWSCloudWatchEventTargetConfigMissingTargetId = ` 168 resource "aws_cloudwatch_event_rule" "foo" { 169 name = "tf-acc-cw-event-rule-missing-target-id" 170 schedule_expression = "rate(1 hour)" 171 } 172 173 resource "aws_cloudwatch_event_target" "moobar" { 174 rule = "${aws_cloudwatch_event_rule.foo.name}" 175 arn = "${aws_sns_topic.moon.arn}" 176 } 177 178 resource "aws_sns_topic" "moon" { 179 name = "tf-acc-moon" 180 } 181 ` 182 183 var testAccAWSCloudWatchEventTargetConfigModified = ` 184 resource "aws_cloudwatch_event_rule" "foo" { 185 name = "tf-acc-cw-event-rule-basic" 186 schedule_expression = "rate(1 hour)" 187 } 188 189 resource "aws_cloudwatch_event_target" "moobar" { 190 rule = "${aws_cloudwatch_event_rule.foo.name}" 191 target_id = "tf-acc-cw-target-modified" 192 arn = "${aws_sns_topic.sun.arn}" 193 } 194 195 resource "aws_sns_topic" "sun" { 196 name = "tf-acc-sun" 197 } 198 ` 199 200 func testAccAWSCloudWatchEventTargetConfig_full(rName string) string { 201 return fmt.Sprintf(` 202 resource "aws_cloudwatch_event_rule" "foo" { 203 name = "tf-acc-cw-event-rule-full" 204 schedule_expression = "rate(1 hour)" 205 role_arn = "${aws_iam_role.role.arn}" 206 } 207 208 resource "aws_iam_role" "role" { 209 name = "%s" 210 assume_role_policy = <<POLICY 211 { 212 "Version": "2012-10-17", 213 "Statement": [ 214 { 215 "Action": "sts:AssumeRole", 216 "Principal": { 217 "Service": "events.amazonaws.com" 218 }, 219 "Effect": "Allow", 220 "Sid": "" 221 } 222 ] 223 } 224 POLICY 225 } 226 227 resource "aws_iam_role_policy" "test_policy" { 228 name = "%s_policy" 229 role = "${aws_iam_role.role.id}" 230 policy = <<EOF 231 { 232 "Version": "2012-10-17", 233 "Statement": [ 234 { 235 "Action": [ 236 "kinesis:PutRecord", 237 "kinesis:PutRecords" 238 ], 239 "Resource": [ 240 "*" 241 ], 242 "Effect": "Allow" 243 } 244 ] 245 } 246 EOF 247 } 248 249 resource "aws_cloudwatch_event_target" "foobar" { 250 rule = "${aws_cloudwatch_event_rule.foo.name}" 251 target_id = "tf-acc-cw-target-full" 252 input = <<INPUT 253 { "source": ["aws.cloudtrail"] } 254 INPUT 255 arn = "${aws_kinesis_stream.test_stream.arn}" 256 } 257 258 resource "aws_kinesis_stream" "test_stream" { 259 name = "%s_kinesis_test" 260 shard_count = 1 261 }`, rName, rName, rName) 262 } 263 264 func testAccAWSCloudWatchEventTargetConfigSsmDocument(rName string) string { 265 return fmt.Sprintf(` 266 resource "aws_ssm_document" "foo" { 267 name = "%s" 268 document_type = "Command" 269 270 content = <<DOC 271 { 272 "schemaVersion": "1.2", 273 "description": "Check ip configuration of a Linux instance.", 274 "parameters": { 275 276 }, 277 "runtimeConfig": { 278 "aws:runShellScript": { 279 "properties": [ 280 { 281 "id": "0.aws:runShellScript", 282 "runCommand": ["ifconfig"] 283 } 284 ] 285 } 286 } 287 } 288 DOC 289 } 290 291 resource "aws_cloudwatch_event_rule" "console" { 292 name = "%s" 293 description = "another_test" 294 295 event_pattern = <<PATTERN 296 { 297 "source": [ 298 "aws.autoscaling" 299 ] 300 } 301 PATTERN 302 } 303 304 resource "aws_cloudwatch_event_target" "test" { 305 306 arn = "${aws_ssm_document.foo.arn}" 307 rule = "${aws_cloudwatch_event_rule.console.id}" 308 role_arn = "${aws_iam_role.test_role.arn}" 309 310 run_command_targets { 311 key = "tag:Name" 312 values = ["acceptance_test"] 313 } 314 } 315 316 resource "aws_iam_role" "test_role" { 317 name = "%s" 318 319 assume_role_policy = <<EOF 320 { 321 "Version": "2012-10-17", 322 "Statement": [ 323 { 324 "Action": "sts:AssumeRole", 325 "Principal": { 326 "Service": "events.amazonaws.com" 327 }, 328 "Effect": "Allow", 329 "Sid": "" 330 } 331 ] 332 } 333 EOF 334 } 335 336 resource "aws_iam_role_policy" "test_policy" { 337 name = "%s" 338 role = "${aws_iam_role.test_role.id}" 339 340 policy = <<EOF 341 { 342 "Version": "2012-10-17", 343 "Statement": [ 344 { 345 "Action": "ssm:*", 346 "Effect": "Allow", 347 "Resource": [ 348 "*" 349 ] 350 } 351 ] 352 } 353 EOF 354 }`, rName, rName, rName, rName) 355 }