github.com/erriapo/terraform@v0.6.12-0.20160203182612-0340ea72354f/builtin/providers/aws/resource_aws_s3_bucket_test.go (about) 1 package aws 2 3 import ( 4 "encoding/json" 5 "fmt" 6 "reflect" 7 "regexp" 8 "strconv" 9 "testing" 10 11 "github.com/hashicorp/terraform/helper/acctest" 12 "github.com/hashicorp/terraform/helper/resource" 13 "github.com/hashicorp/terraform/terraform" 14 15 "github.com/aws/aws-sdk-go/aws" 16 "github.com/aws/aws-sdk-go/aws/awserr" 17 "github.com/aws/aws-sdk-go/service/s3" 18 ) 19 20 func TestAccAWSS3Bucket_basic(t *testing.T) { 21 rInt := acctest.RandInt() 22 arnRegexp := regexp.MustCompile( 23 "^arn:aws:s3:::") 24 25 resource.Test(t, resource.TestCase{ 26 PreCheck: func() { testAccPreCheck(t) }, 27 Providers: testAccProviders, 28 CheckDestroy: testAccCheckAWSS3BucketDestroy, 29 Steps: []resource.TestStep{ 30 resource.TestStep{ 31 Config: testAccAWSS3BucketConfig(rInt), 32 Check: resource.ComposeTestCheckFunc( 33 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 34 resource.TestCheckResourceAttr( 35 "aws_s3_bucket.bucket", "hosted_zone_id", HostedZoneIDForRegion("us-west-2")), 36 resource.TestCheckResourceAttr( 37 "aws_s3_bucket.bucket", "region", "us-west-2"), 38 resource.TestCheckResourceAttr( 39 "aws_s3_bucket.bucket", "website_endpoint", ""), 40 resource.TestMatchResourceAttr( 41 "aws_s3_bucket.bucket", "arn", arnRegexp), 42 ), 43 }, 44 }, 45 }) 46 } 47 48 func TestAccAWSS3Bucket_Policy(t *testing.T) { 49 rInt := acctest.RandInt() 50 51 resource.Test(t, resource.TestCase{ 52 PreCheck: func() { testAccPreCheck(t) }, 53 Providers: testAccProviders, 54 CheckDestroy: testAccCheckAWSS3BucketDestroy, 55 Steps: []resource.TestStep{ 56 resource.TestStep{ 57 Config: testAccAWSS3BucketConfigWithPolicy(rInt), 58 Check: resource.ComposeTestCheckFunc( 59 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 60 testAccCheckAWSS3BucketPolicy( 61 "aws_s3_bucket.bucket", testAccAWSS3BucketPolicy(rInt)), 62 ), 63 }, 64 resource.TestStep{ 65 Config: testAccAWSS3BucketConfig(rInt), 66 Check: resource.ComposeTestCheckFunc( 67 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 68 testAccCheckAWSS3BucketPolicy( 69 "aws_s3_bucket.bucket", ""), 70 ), 71 }, 72 }, 73 }) 74 } 75 76 func TestAccAWSS3Bucket_UpdateAcl(t *testing.T) { 77 ri := genRandInt() 78 preConfig := fmt.Sprintf(testAccAWSS3BucketConfigWithAcl, ri) 79 postConfig := fmt.Sprintf(testAccAWSS3BucketConfigWithAclUpdate, ri) 80 81 resource.Test(t, resource.TestCase{ 82 PreCheck: func() { testAccPreCheck(t) }, 83 Providers: testAccProviders, 84 CheckDestroy: testAccCheckAWSS3BucketDestroy, 85 Steps: []resource.TestStep{ 86 resource.TestStep{ 87 Config: preConfig, 88 Check: resource.ComposeTestCheckFunc( 89 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 90 resource.TestCheckResourceAttr( 91 "aws_s3_bucket.bucket", "acl", "public-read"), 92 ), 93 }, 94 resource.TestStep{ 95 Config: postConfig, 96 Check: resource.ComposeTestCheckFunc( 97 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 98 resource.TestCheckResourceAttr( 99 "aws_s3_bucket.bucket", "acl", "private"), 100 ), 101 }, 102 }, 103 }) 104 } 105 106 func TestAccAWSS3Bucket_Website_Simple(t *testing.T) { 107 rInt := acctest.RandInt() 108 resource.Test(t, resource.TestCase{ 109 PreCheck: func() { testAccPreCheck(t) }, 110 Providers: testAccProviders, 111 CheckDestroy: testAccCheckAWSS3BucketDestroy, 112 Steps: []resource.TestStep{ 113 resource.TestStep{ 114 Config: testAccAWSS3BucketWebsiteConfig(rInt), 115 Check: resource.ComposeTestCheckFunc( 116 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 117 testAccCheckAWSS3BucketWebsite( 118 "aws_s3_bucket.bucket", "index.html", "", "", ""), 119 resource.TestCheckResourceAttr( 120 "aws_s3_bucket.bucket", "website_endpoint", testAccWebsiteEndpoint(rInt)), 121 ), 122 }, 123 resource.TestStep{ 124 Config: testAccAWSS3BucketWebsiteConfigWithError(rInt), 125 Check: resource.ComposeTestCheckFunc( 126 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 127 testAccCheckAWSS3BucketWebsite( 128 "aws_s3_bucket.bucket", "index.html", "error.html", "", ""), 129 resource.TestCheckResourceAttr( 130 "aws_s3_bucket.bucket", "website_endpoint", testAccWebsiteEndpoint(rInt)), 131 ), 132 }, 133 resource.TestStep{ 134 Config: testAccAWSS3BucketConfig(rInt), 135 Check: resource.ComposeTestCheckFunc( 136 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 137 testAccCheckAWSS3BucketWebsite( 138 "aws_s3_bucket.bucket", "", "", "", ""), 139 resource.TestCheckResourceAttr( 140 "aws_s3_bucket.bucket", "website_endpoint", ""), 141 ), 142 }, 143 }, 144 }) 145 } 146 147 func TestAccAWSS3Bucket_WebsiteRedirect(t *testing.T) { 148 rInt := acctest.RandInt() 149 resource.Test(t, resource.TestCase{ 150 PreCheck: func() { testAccPreCheck(t) }, 151 Providers: testAccProviders, 152 CheckDestroy: testAccCheckAWSS3BucketDestroy, 153 Steps: []resource.TestStep{ 154 resource.TestStep{ 155 Config: testAccAWSS3BucketWebsiteConfigWithRedirect(rInt), 156 Check: resource.ComposeTestCheckFunc( 157 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 158 testAccCheckAWSS3BucketWebsite( 159 "aws_s3_bucket.bucket", "", "", "", "hashicorp.com"), 160 resource.TestCheckResourceAttr( 161 "aws_s3_bucket.bucket", "website_endpoint", testAccWebsiteEndpoint(rInt)), 162 ), 163 }, 164 resource.TestStep{ 165 Config: testAccAWSS3BucketWebsiteConfigWithHttpsRedirect(rInt), 166 Check: resource.ComposeTestCheckFunc( 167 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 168 testAccCheckAWSS3BucketWebsite( 169 "aws_s3_bucket.bucket", "", "", "https", "hashicorp.com"), 170 resource.TestCheckResourceAttr( 171 "aws_s3_bucket.bucket", "website_endpoint", testAccWebsiteEndpoint(rInt)), 172 ), 173 }, 174 resource.TestStep{ 175 Config: testAccAWSS3BucketConfig(rInt), 176 Check: resource.ComposeTestCheckFunc( 177 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 178 testAccCheckAWSS3BucketWebsite( 179 "aws_s3_bucket.bucket", "", "", "", ""), 180 resource.TestCheckResourceAttr( 181 "aws_s3_bucket.bucket", "website_endpoint", ""), 182 ), 183 }, 184 }, 185 }) 186 } 187 188 // Test TestAccAWSS3Bucket_shouldFailNotFound is designed to fail with a "plan 189 // not empty" error in Terraform, to check against regresssions. 190 // See https://github.com/hashicorp/terraform/pull/2925 191 func TestAccAWSS3Bucket_shouldFailNotFound(t *testing.T) { 192 rInt := acctest.RandInt() 193 resource.Test(t, resource.TestCase{ 194 PreCheck: func() { testAccPreCheck(t) }, 195 Providers: testAccProviders, 196 CheckDestroy: testAccCheckAWSS3BucketDestroy, 197 Steps: []resource.TestStep{ 198 resource.TestStep{ 199 Config: testAccAWSS3BucketDestroyedConfig(rInt), 200 Check: resource.ComposeTestCheckFunc( 201 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 202 testAccCheckAWSS3DestroyBucket("aws_s3_bucket.bucket"), 203 ), 204 ExpectNonEmptyPlan: true, 205 }, 206 }, 207 }) 208 } 209 210 func TestAccAWSS3Bucket_Versioning(t *testing.T) { 211 rInt := acctest.RandInt() 212 resource.Test(t, resource.TestCase{ 213 PreCheck: func() { testAccPreCheck(t) }, 214 Providers: testAccProviders, 215 CheckDestroy: testAccCheckAWSS3BucketDestroy, 216 Steps: []resource.TestStep{ 217 resource.TestStep{ 218 Config: testAccAWSS3BucketConfig(rInt), 219 Check: resource.ComposeTestCheckFunc( 220 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 221 testAccCheckAWSS3BucketVersioning( 222 "aws_s3_bucket.bucket", ""), 223 ), 224 }, 225 resource.TestStep{ 226 Config: testAccAWSS3BucketConfigWithVersioning(rInt), 227 Check: resource.ComposeTestCheckFunc( 228 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 229 testAccCheckAWSS3BucketVersioning( 230 "aws_s3_bucket.bucket", s3.BucketVersioningStatusEnabled), 231 ), 232 }, 233 resource.TestStep{ 234 Config: testAccAWSS3BucketConfigWithDisableVersioning(rInt), 235 Check: resource.ComposeTestCheckFunc( 236 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 237 testAccCheckAWSS3BucketVersioning( 238 "aws_s3_bucket.bucket", s3.BucketVersioningStatusSuspended), 239 ), 240 }, 241 }, 242 }) 243 } 244 245 func TestAccAWSS3Bucket_Cors(t *testing.T) { 246 rInt := acctest.RandInt() 247 resource.Test(t, resource.TestCase{ 248 PreCheck: func() { testAccPreCheck(t) }, 249 Providers: testAccProviders, 250 CheckDestroy: testAccCheckAWSS3BucketDestroy, 251 Steps: []resource.TestStep{ 252 resource.TestStep{ 253 Config: testAccAWSS3BucketConfigWithCORS(rInt), 254 Check: resource.ComposeTestCheckFunc( 255 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 256 testAccCheckAWSS3BucketCors( 257 "aws_s3_bucket.bucket", 258 []*s3.CORSRule{ 259 &s3.CORSRule{ 260 AllowedHeaders: []*string{aws.String("*")}, 261 AllowedMethods: []*string{aws.String("PUT"), aws.String("POST")}, 262 AllowedOrigins: []*string{aws.String("https://www.example.com")}, 263 ExposeHeaders: []*string{aws.String("x-amz-server-side-encryption"), aws.String("ETag")}, 264 MaxAgeSeconds: aws.Int64(3000), 265 }, 266 }, 267 ), 268 ), 269 }, 270 }, 271 }) 272 } 273 274 func TestAccAWSS3Bucket_Logging(t *testing.T) { 275 rInt := acctest.RandInt() 276 resource.Test(t, resource.TestCase{ 277 PreCheck: func() { testAccPreCheck(t) }, 278 Providers: testAccProviders, 279 CheckDestroy: testAccCheckAWSS3BucketDestroy, 280 Steps: []resource.TestStep{ 281 resource.TestStep{ 282 Config: testAccAWSS3BucketConfigWithLogging(rInt), 283 Check: resource.ComposeTestCheckFunc( 284 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 285 testAccCheckAWSS3BucketLogging( 286 "aws_s3_bucket.bucket", "aws_s3_bucket.log_bucket", "log/"), 287 ), 288 }, 289 }, 290 }) 291 } 292 293 func testAccCheckAWSS3BucketDestroy(s *terraform.State) error { 294 conn := testAccProvider.Meta().(*AWSClient).s3conn 295 296 for _, rs := range s.RootModule().Resources { 297 if rs.Type != "aws_s3_bucket" { 298 continue 299 } 300 _, err := conn.DeleteBucket(&s3.DeleteBucketInput{ 301 Bucket: aws.String(rs.Primary.ID), 302 }) 303 if err != nil { 304 if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == "NoSuchBucket" { 305 return nil 306 } 307 return err 308 } 309 } 310 return nil 311 } 312 313 func testAccCheckAWSS3BucketExists(n string) resource.TestCheckFunc { 314 return func(s *terraform.State) error { 315 rs, ok := s.RootModule().Resources[n] 316 if !ok { 317 return fmt.Errorf("Not found: %s", n) 318 } 319 320 if rs.Primary.ID == "" { 321 return fmt.Errorf("No S3 Bucket ID is set") 322 } 323 324 conn := testAccProvider.Meta().(*AWSClient).s3conn 325 _, err := conn.HeadBucket(&s3.HeadBucketInput{ 326 Bucket: aws.String(rs.Primary.ID), 327 }) 328 329 if err != nil { 330 return fmt.Errorf("S3Bucket error: %v", err) 331 } 332 return nil 333 } 334 } 335 336 func testAccCheckAWSS3DestroyBucket(n string) resource.TestCheckFunc { 337 return func(s *terraform.State) error { 338 rs, ok := s.RootModule().Resources[n] 339 if !ok { 340 return fmt.Errorf("Not found: %s", n) 341 } 342 343 if rs.Primary.ID == "" { 344 return fmt.Errorf("No S3 Bucket ID is set") 345 } 346 347 conn := testAccProvider.Meta().(*AWSClient).s3conn 348 _, err := conn.DeleteBucket(&s3.DeleteBucketInput{ 349 Bucket: aws.String(rs.Primary.ID), 350 }) 351 352 if err != nil { 353 return fmt.Errorf("Error destroying Bucket (%s) in testAccCheckAWSS3DestroyBucket: %s", rs.Primary.ID, err) 354 } 355 return nil 356 } 357 } 358 359 func testAccCheckAWSS3BucketPolicy(n string, policy string) resource.TestCheckFunc { 360 return func(s *terraform.State) error { 361 rs, _ := s.RootModule().Resources[n] 362 conn := testAccProvider.Meta().(*AWSClient).s3conn 363 364 out, err := conn.GetBucketPolicy(&s3.GetBucketPolicyInput{ 365 Bucket: aws.String(rs.Primary.ID), 366 }) 367 368 if err != nil { 369 if policy == "" { 370 // expected 371 return nil 372 } else { 373 return fmt.Errorf("GetBucketPolicy error: %v, expected %s", err, policy) 374 } 375 } 376 377 if v := out.Policy; v == nil { 378 if policy != "" { 379 return fmt.Errorf("bad policy, found nil, expected: %s", policy) 380 } 381 } else { 382 expected := make(map[string]interface{}) 383 if err := json.Unmarshal([]byte(policy), &expected); err != nil { 384 return err 385 } 386 actual := make(map[string]interface{}) 387 if err := json.Unmarshal([]byte(*v), &actual); err != nil { 388 return err 389 } 390 391 if !reflect.DeepEqual(expected, actual) { 392 return fmt.Errorf("bad policy, expected: %#v, got %#v", expected, actual) 393 } 394 } 395 396 return nil 397 } 398 } 399 func testAccCheckAWSS3BucketWebsite(n string, indexDoc string, errorDoc string, redirectProtocol string, redirectTo string) resource.TestCheckFunc { 400 return func(s *terraform.State) error { 401 rs, _ := s.RootModule().Resources[n] 402 conn := testAccProvider.Meta().(*AWSClient).s3conn 403 404 out, err := conn.GetBucketWebsite(&s3.GetBucketWebsiteInput{ 405 Bucket: aws.String(rs.Primary.ID), 406 }) 407 408 if err != nil { 409 if indexDoc == "" { 410 // If we want to assert that the website is not there, than 411 // this error is expected 412 return nil 413 } else { 414 return fmt.Errorf("S3BucketWebsite error: %v", err) 415 } 416 } 417 418 if v := out.IndexDocument; v == nil { 419 if indexDoc != "" { 420 return fmt.Errorf("bad index doc, found nil, expected: %s", indexDoc) 421 } 422 } else { 423 if *v.Suffix != indexDoc { 424 return fmt.Errorf("bad index doc, expected: %s, got %#v", indexDoc, out.IndexDocument) 425 } 426 } 427 428 if v := out.ErrorDocument; v == nil { 429 if errorDoc != "" { 430 return fmt.Errorf("bad error doc, found nil, expected: %s", errorDoc) 431 } 432 } else { 433 if *v.Key != errorDoc { 434 return fmt.Errorf("bad error doc, expected: %s, got %#v", errorDoc, out.ErrorDocument) 435 } 436 } 437 438 if v := out.RedirectAllRequestsTo; v == nil { 439 if redirectTo != "" { 440 return fmt.Errorf("bad redirect to, found nil, expected: %s", redirectTo) 441 } 442 } else { 443 if *v.HostName != redirectTo { 444 return fmt.Errorf("bad redirect to, expected: %s, got %#v", redirectTo, out.RedirectAllRequestsTo) 445 } 446 if redirectProtocol != "" && v.Protocol != nil && *v.Protocol != redirectProtocol { 447 return fmt.Errorf("bad redirect protocol to, expected: %s, got %#v", redirectProtocol, out.RedirectAllRequestsTo) 448 } 449 } 450 451 return nil 452 } 453 } 454 455 func testAccCheckAWSS3BucketVersioning(n string, versioningStatus string) resource.TestCheckFunc { 456 return func(s *terraform.State) error { 457 rs, _ := s.RootModule().Resources[n] 458 conn := testAccProvider.Meta().(*AWSClient).s3conn 459 460 out, err := conn.GetBucketVersioning(&s3.GetBucketVersioningInput{ 461 Bucket: aws.String(rs.Primary.ID), 462 }) 463 464 if err != nil { 465 return fmt.Errorf("GetBucketVersioning error: %v", err) 466 } 467 468 if v := out.Status; v == nil { 469 if versioningStatus != "" { 470 return fmt.Errorf("bad error versioning status, found nil, expected: %s", versioningStatus) 471 } 472 } else { 473 if *v != versioningStatus { 474 return fmt.Errorf("bad error versioning status, expected: %s, got %s", versioningStatus, *v) 475 } 476 } 477 478 return nil 479 } 480 } 481 func testAccCheckAWSS3BucketCors(n string, corsRules []*s3.CORSRule) resource.TestCheckFunc { 482 return func(s *terraform.State) error { 483 rs, _ := s.RootModule().Resources[n] 484 conn := testAccProvider.Meta().(*AWSClient).s3conn 485 486 out, err := conn.GetBucketCors(&s3.GetBucketCorsInput{ 487 Bucket: aws.String(rs.Primary.ID), 488 }) 489 490 if err != nil { 491 return fmt.Errorf("GetBucketCors error: %v", err) 492 } 493 494 if !reflect.DeepEqual(out.CORSRules, corsRules) { 495 return fmt.Errorf("bad error cors rule, expected: %v, got %v", corsRules, out.CORSRules) 496 } 497 498 return nil 499 } 500 } 501 502 func testAccCheckAWSS3BucketLogging(n, b, p string) resource.TestCheckFunc { 503 return func(s *terraform.State) error { 504 rs, _ := s.RootModule().Resources[n] 505 conn := testAccProvider.Meta().(*AWSClient).s3conn 506 507 out, err := conn.GetBucketLogging(&s3.GetBucketLoggingInput{ 508 Bucket: aws.String(rs.Primary.ID), 509 }) 510 511 if err != nil { 512 return fmt.Errorf("GetBucketLogging error: %v", err) 513 } 514 515 tb, _ := s.RootModule().Resources[b] 516 517 if v := out.LoggingEnabled.TargetBucket; v == nil { 518 if tb.Primary.ID != "" { 519 return fmt.Errorf("bad target bucket, found nil, expected: %s", tb.Primary.ID) 520 } 521 } else { 522 if *v != tb.Primary.ID { 523 return fmt.Errorf("bad target bucket, expected: %s, got %s", tb.Primary.ID, *v) 524 } 525 } 526 527 if v := out.LoggingEnabled.TargetPrefix; v == nil { 528 if p != "" { 529 return fmt.Errorf("bad target prefix, found nil, expected: %s", p) 530 } 531 } else { 532 if *v != p { 533 return fmt.Errorf("bad target prefix, expected: %s, got %s", p, *v) 534 } 535 } 536 537 return nil 538 } 539 } 540 541 // These need a bit of randomness as the name can only be used once globally 542 // within AWS 543 func testAccWebsiteEndpoint(randInt int) string { 544 return fmt.Sprintf("tf-test-bucket-%d.s3-website-us-west-2.amazonaws.com", randInt) 545 } 546 547 func testAccAWSS3BucketPolicy(randInt int) string { 548 return fmt.Sprintf(`{ "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "AWS": "*" }, "Action": "s3:GetObject", "Resource": "arn:aws:s3:::tf-test-bucket-%d/*" } ] }`, randInt) 549 } 550 551 func testAccAWSS3BucketConfig(randInt int) string { 552 return fmt.Sprintf(` 553 resource "aws_s3_bucket" "bucket" { 554 bucket = "tf-test-bucket-%d" 555 acl = "public-read" 556 } 557 `, randInt) 558 } 559 560 func testAccAWSS3BucketWebsiteConfig(randInt int) string { 561 return fmt.Sprintf(` 562 resource "aws_s3_bucket" "bucket" { 563 bucket = "tf-test-bucket-%d" 564 acl = "public-read" 565 566 website { 567 index_document = "index.html" 568 } 569 } 570 `, randInt) 571 } 572 573 func testAccAWSS3BucketWebsiteConfigWithError(randInt int) string { 574 return fmt.Sprintf(` 575 resource "aws_s3_bucket" "bucket" { 576 bucket = "tf-test-bucket-%d" 577 acl = "public-read" 578 579 website { 580 index_document = "index.html" 581 error_document = "error.html" 582 } 583 } 584 `, randInt) 585 } 586 587 func testAccAWSS3BucketWebsiteConfigWithRedirect(randInt int) string { 588 return fmt.Sprintf(` 589 resource "aws_s3_bucket" "bucket" { 590 bucket = "tf-test-bucket-%d" 591 acl = "public-read" 592 593 website { 594 redirect_all_requests_to = "hashicorp.com" 595 } 596 } 597 `, randInt) 598 } 599 600 func testAccAWSS3BucketWebsiteConfigWithHttpsRedirect(randInt int) string { 601 return fmt.Sprintf(` 602 resource "aws_s3_bucket" "bucket" { 603 bucket = "tf-test-bucket-%d" 604 acl = "public-read" 605 606 website { 607 redirect_all_requests_to = "https://hashicorp.com" 608 } 609 } 610 `, randInt) 611 } 612 613 func testAccAWSS3BucketConfigWithPolicy(randInt int) string { 614 return fmt.Sprintf(` 615 resource "aws_s3_bucket" "bucket" { 616 bucket = "tf-test-bucket-%d" 617 acl = "public-read" 618 policy = %s 619 } 620 `, randInt, strconv.Quote(testAccAWSS3BucketPolicy(randInt))) 621 } 622 623 func testAccAWSS3BucketDestroyedConfig(randInt int) string { 624 return fmt.Sprintf(` 625 resource "aws_s3_bucket" "bucket" { 626 bucket = "tf-test-bucket-%d" 627 acl = "public-read" 628 } 629 `, randInt) 630 } 631 632 func testAccAWSS3BucketConfigWithVersioning(randInt int) string { 633 return fmt.Sprintf(` 634 resource "aws_s3_bucket" "bucket" { 635 bucket = "tf-test-bucket-%d" 636 acl = "public-read" 637 versioning { 638 enabled = true 639 } 640 } 641 `, randInt) 642 } 643 644 func testAccAWSS3BucketConfigWithDisableVersioning(randInt int) string { 645 return fmt.Sprintf(` 646 resource "aws_s3_bucket" "bucket" { 647 bucket = "tf-test-bucket-%d" 648 acl = "public-read" 649 versioning { 650 enabled = false 651 } 652 } 653 `, randInt) 654 } 655 656 func testAccAWSS3BucketConfigWithCORS(randInt int) string { 657 return fmt.Sprintf(` 658 resource "aws_s3_bucket" "bucket" { 659 bucket = "tf-test-bucket-%d" 660 acl = "public-read" 661 cors_rule { 662 allowed_headers = ["*"] 663 allowed_methods = ["PUT","POST"] 664 allowed_origins = ["https://www.example.com"] 665 expose_headers = ["x-amz-server-side-encryption","ETag"] 666 max_age_seconds = 3000 667 } 668 } 669 `, randInt) 670 } 671 672 var testAccAWSS3BucketConfigWithAcl = ` 673 resource "aws_s3_bucket" "bucket" { 674 bucket = "tf-test-bucket-%d" 675 acl = "public-read" 676 } 677 ` 678 679 var testAccAWSS3BucketConfigWithAclUpdate = ` 680 resource "aws_s3_bucket" "bucket" { 681 bucket = "tf-test-bucket-%d" 682 acl = "private" 683 } 684 ` 685 686 func testAccAWSS3BucketConfigWithLogging(randInt int) string { 687 return fmt.Sprintf(` 688 resource "aws_s3_bucket" "log_bucket" { 689 bucket = "tf-test-log-bucket-%d" 690 acl = "log-delivery-write" 691 } 692 resource "aws_s3_bucket" "bucket" { 693 bucket = "tf-test-bucket-%d" 694 acl = "private" 695 logging { 696 target_bucket = "${aws_s3_bucket.log_bucket.id}" 697 target_prefix = "log/" 698 } 699 } 700 `, randInt, randInt) 701 }