github.com/jsoriano/terraform@v0.6.7-0.20151026070445-8b70867fdd95/builtin/providers/aws/resource_aws_s3_bucket_test.go (about) 1 package aws 2 3 import ( 4 "encoding/json" 5 "fmt" 6 "math/rand" 7 "reflect" 8 "strconv" 9 "testing" 10 "time" 11 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/service/s3" 17 ) 18 19 func TestAccAWSS3Bucket_basic(t *testing.T) { 20 resource.Test(t, resource.TestCase{ 21 PreCheck: func() { testAccPreCheck(t) }, 22 Providers: testAccProviders, 23 CheckDestroy: testAccCheckAWSS3BucketDestroy, 24 Steps: []resource.TestStep{ 25 resource.TestStep{ 26 Config: testAccAWSS3BucketConfig, 27 Check: resource.ComposeTestCheckFunc( 28 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 29 resource.TestCheckResourceAttr( 30 "aws_s3_bucket.bucket", "hosted_zone_id", HostedZoneIDForRegion("us-west-2")), 31 resource.TestCheckResourceAttr( 32 "aws_s3_bucket.bucket", "region", "us-west-2"), 33 resource.TestCheckResourceAttr( 34 "aws_s3_bucket.bucket", "website_endpoint", ""), 35 ), 36 }, 37 }, 38 }) 39 } 40 41 func TestAccAWSS3Bucket_Policy(t *testing.T) { 42 resource.Test(t, resource.TestCase{ 43 PreCheck: func() { testAccPreCheck(t) }, 44 Providers: testAccProviders, 45 CheckDestroy: testAccCheckAWSS3BucketDestroy, 46 Steps: []resource.TestStep{ 47 resource.TestStep{ 48 Config: testAccAWSS3BucketConfigWithPolicy, 49 Check: resource.ComposeTestCheckFunc( 50 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 51 testAccCheckAWSS3BucketPolicy( 52 "aws_s3_bucket.bucket", testAccAWSS3BucketPolicy), 53 ), 54 }, 55 resource.TestStep{ 56 Config: testAccAWSS3BucketConfig, 57 Check: resource.ComposeTestCheckFunc( 58 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 59 testAccCheckAWSS3BucketPolicy( 60 "aws_s3_bucket.bucket", ""), 61 ), 62 }, 63 }, 64 }) 65 } 66 67 func TestAccAWSS3Bucket_Website_Simple(t *testing.T) { 68 resource.Test(t, resource.TestCase{ 69 PreCheck: func() { testAccPreCheck(t) }, 70 Providers: testAccProviders, 71 CheckDestroy: testAccCheckAWSS3BucketDestroy, 72 Steps: []resource.TestStep{ 73 resource.TestStep{ 74 Config: testAccAWSS3BucketWebsiteConfig, 75 Check: resource.ComposeTestCheckFunc( 76 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 77 testAccCheckAWSS3BucketWebsite( 78 "aws_s3_bucket.bucket", "index.html", "", ""), 79 resource.TestCheckResourceAttr( 80 "aws_s3_bucket.bucket", "website_endpoint", testAccWebsiteEndpoint), 81 ), 82 }, 83 resource.TestStep{ 84 Config: testAccAWSS3BucketWebsiteConfigWithError, 85 Check: resource.ComposeTestCheckFunc( 86 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 87 testAccCheckAWSS3BucketWebsite( 88 "aws_s3_bucket.bucket", "index.html", "error.html", ""), 89 resource.TestCheckResourceAttr( 90 "aws_s3_bucket.bucket", "website_endpoint", testAccWebsiteEndpoint), 91 ), 92 }, 93 resource.TestStep{ 94 Config: testAccAWSS3BucketConfig, 95 Check: resource.ComposeTestCheckFunc( 96 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 97 testAccCheckAWSS3BucketWebsite( 98 "aws_s3_bucket.bucket", "", "", ""), 99 resource.TestCheckResourceAttr( 100 "aws_s3_bucket.bucket", "website_endpoint", ""), 101 ), 102 }, 103 }, 104 }) 105 } 106 107 func TestAccAWSS3Bucket_WebsiteRedirect(t *testing.T) { 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: testAccAWSS3BucketWebsiteConfigWithRedirect, 115 Check: resource.ComposeTestCheckFunc( 116 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 117 testAccCheckAWSS3BucketWebsite( 118 "aws_s3_bucket.bucket", "", "", "hashicorp.com"), 119 resource.TestCheckResourceAttr( 120 "aws_s3_bucket.bucket", "website_endpoint", testAccWebsiteEndpoint), 121 ), 122 }, 123 resource.TestStep{ 124 Config: testAccAWSS3BucketConfig, 125 Check: resource.ComposeTestCheckFunc( 126 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 127 testAccCheckAWSS3BucketWebsite( 128 "aws_s3_bucket.bucket", "", "", ""), 129 resource.TestCheckResourceAttr( 130 "aws_s3_bucket.bucket", "website_endpoint", ""), 131 ), 132 }, 133 }, 134 }) 135 } 136 137 // Test TestAccAWSS3Bucket_shouldFailNotFound is designed to fail with a "plan 138 // not empty" error in Terraform, to check against regresssions. 139 // See https://github.com/hashicorp/terraform/pull/2925 140 func TestAccAWSS3Bucket_shouldFailNotFound(t *testing.T) { 141 resource.Test(t, resource.TestCase{ 142 PreCheck: func() { testAccPreCheck(t) }, 143 Providers: testAccProviders, 144 CheckDestroy: testAccCheckAWSS3BucketDestroy, 145 Steps: []resource.TestStep{ 146 resource.TestStep{ 147 Config: testAccAWSS3BucketDestroyedConfig, 148 Check: resource.ComposeTestCheckFunc( 149 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 150 testAccCheckAWSS3DestroyBucket("aws_s3_bucket.bucket"), 151 ), 152 }, 153 }, 154 }) 155 } 156 157 func TestAccAWSS3Bucket_Versioning(t *testing.T) { 158 resource.Test(t, resource.TestCase{ 159 PreCheck: func() { testAccPreCheck(t) }, 160 Providers: testAccProviders, 161 CheckDestroy: testAccCheckAWSS3BucketDestroy, 162 Steps: []resource.TestStep{ 163 resource.TestStep{ 164 Config: testAccAWSS3BucketConfig, 165 Check: resource.ComposeTestCheckFunc( 166 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 167 testAccCheckAWSS3BucketVersioning( 168 "aws_s3_bucket.bucket", ""), 169 ), 170 }, 171 resource.TestStep{ 172 Config: testAccAWSS3BucketConfigWithVersioning, 173 Check: resource.ComposeTestCheckFunc( 174 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 175 testAccCheckAWSS3BucketVersioning( 176 "aws_s3_bucket.bucket", s3.BucketVersioningStatusEnabled), 177 ), 178 }, 179 resource.TestStep{ 180 Config: testAccAWSS3BucketConfigWithDisableVersioning, 181 Check: resource.ComposeTestCheckFunc( 182 testAccCheckAWSS3BucketExists("aws_s3_bucket.bucket"), 183 testAccCheckAWSS3BucketVersioning( 184 "aws_s3_bucket.bucket", s3.BucketVersioningStatusSuspended), 185 ), 186 }, 187 }, 188 }) 189 } 190 191 func testAccCheckAWSS3BucketDestroy(s *terraform.State) error { 192 conn := testAccProvider.Meta().(*AWSClient).s3conn 193 194 for _, rs := range s.RootModule().Resources { 195 if rs.Type != "aws_s3_bucket" { 196 continue 197 } 198 _, err := conn.DeleteBucket(&s3.DeleteBucketInput{ 199 Bucket: aws.String(rs.Primary.ID), 200 }) 201 if err != nil { 202 return err 203 } 204 } 205 return nil 206 } 207 208 func testAccCheckAWSS3BucketExists(n string) resource.TestCheckFunc { 209 return func(s *terraform.State) error { 210 rs, ok := s.RootModule().Resources[n] 211 if !ok { 212 return fmt.Errorf("Not found: %s", n) 213 } 214 215 if rs.Primary.ID == "" { 216 return fmt.Errorf("No S3 Bucket ID is set") 217 } 218 219 conn := testAccProvider.Meta().(*AWSClient).s3conn 220 _, err := conn.HeadBucket(&s3.HeadBucketInput{ 221 Bucket: aws.String(rs.Primary.ID), 222 }) 223 224 if err != nil { 225 return fmt.Errorf("S3Bucket error: %v", err) 226 } 227 return nil 228 } 229 } 230 231 func testAccCheckAWSS3DestroyBucket(n string) resource.TestCheckFunc { 232 return func(s *terraform.State) error { 233 rs, ok := s.RootModule().Resources[n] 234 if !ok { 235 return fmt.Errorf("Not found: %s", n) 236 } 237 238 if rs.Primary.ID == "" { 239 return fmt.Errorf("No S3 Bucket ID is set") 240 } 241 242 conn := testAccProvider.Meta().(*AWSClient).s3conn 243 _, err := conn.DeleteBucket(&s3.DeleteBucketInput{ 244 Bucket: aws.String(rs.Primary.ID), 245 }) 246 247 if err != nil { 248 return fmt.Errorf("Error destroying Bucket (%s) in testAccCheckAWSS3DestroyBucket: %s", rs.Primary.ID, err) 249 } 250 return nil 251 } 252 } 253 254 func testAccCheckAWSS3BucketPolicy(n string, policy string) resource.TestCheckFunc { 255 return func(s *terraform.State) error { 256 rs, _ := s.RootModule().Resources[n] 257 conn := testAccProvider.Meta().(*AWSClient).s3conn 258 259 out, err := conn.GetBucketPolicy(&s3.GetBucketPolicyInput{ 260 Bucket: aws.String(rs.Primary.ID), 261 }) 262 263 if err != nil { 264 if policy == "" { 265 // expected 266 return nil 267 } else { 268 return fmt.Errorf("GetBucketPolicy error: %v, expected %s", err, policy) 269 } 270 } 271 272 if v := out.Policy; v == nil { 273 if policy != "" { 274 return fmt.Errorf("bad policy, found nil, expected: %s", policy) 275 } 276 } else { 277 expected := make(map[string]interface{}) 278 if err := json.Unmarshal([]byte(policy), &expected); err != nil { 279 return err 280 } 281 actual := make(map[string]interface{}) 282 if err := json.Unmarshal([]byte(*v), &actual); err != nil { 283 return err 284 } 285 286 if !reflect.DeepEqual(expected, actual) { 287 return fmt.Errorf("bad policy, expected: %#v, got %#v", expected, actual) 288 } 289 } 290 291 return nil 292 } 293 } 294 func testAccCheckAWSS3BucketWebsite(n string, indexDoc string, errorDoc string, redirectTo string) resource.TestCheckFunc { 295 return func(s *terraform.State) error { 296 rs, _ := s.RootModule().Resources[n] 297 conn := testAccProvider.Meta().(*AWSClient).s3conn 298 299 out, err := conn.GetBucketWebsite(&s3.GetBucketWebsiteInput{ 300 Bucket: aws.String(rs.Primary.ID), 301 }) 302 303 if err != nil { 304 if indexDoc == "" { 305 // If we want to assert that the website is not there, than 306 // this error is expected 307 return nil 308 } else { 309 return fmt.Errorf("S3BucketWebsite error: %v", err) 310 } 311 } 312 313 if v := out.IndexDocument; v == nil { 314 if indexDoc != "" { 315 return fmt.Errorf("bad index doc, found nil, expected: %s", indexDoc) 316 } 317 } else { 318 if *v.Suffix != indexDoc { 319 return fmt.Errorf("bad index doc, expected: %s, got %#v", indexDoc, out.IndexDocument) 320 } 321 } 322 323 if v := out.ErrorDocument; v == nil { 324 if errorDoc != "" { 325 return fmt.Errorf("bad error doc, found nil, expected: %s", errorDoc) 326 } 327 } else { 328 if *v.Key != errorDoc { 329 return fmt.Errorf("bad error doc, expected: %s, got %#v", errorDoc, out.ErrorDocument) 330 } 331 } 332 333 if v := out.RedirectAllRequestsTo; v == nil { 334 if redirectTo != "" { 335 return fmt.Errorf("bad redirect to, found nil, expected: %s", redirectTo) 336 } 337 } else { 338 if *v.HostName != redirectTo { 339 return fmt.Errorf("bad redirect to, expected: %s, got %#v", redirectTo, out.RedirectAllRequestsTo) 340 } 341 } 342 343 return nil 344 } 345 } 346 347 func testAccCheckAWSS3BucketVersioning(n string, versioningStatus string) resource.TestCheckFunc { 348 return func(s *terraform.State) error { 349 rs, _ := s.RootModule().Resources[n] 350 conn := testAccProvider.Meta().(*AWSClient).s3conn 351 352 out, err := conn.GetBucketVersioning(&s3.GetBucketVersioningInput{ 353 Bucket: aws.String(rs.Primary.ID), 354 }) 355 356 if err != nil { 357 return fmt.Errorf("GetBucketVersioning error: %v", err) 358 } 359 360 if v := out.Status; v == nil { 361 if versioningStatus != "" { 362 return fmt.Errorf("bad error versioning status, found nil, expected: %s", versioningStatus) 363 } 364 } else { 365 if *v != versioningStatus { 366 return fmt.Errorf("bad error versioning status, expected: %s, got %s", versioningStatus, *v) 367 } 368 } 369 370 return nil 371 } 372 } 373 374 // These need a bit of randomness as the name can only be used once globally 375 // within AWS 376 var randInt = rand.New(rand.NewSource(time.Now().UnixNano())).Int() 377 var testAccWebsiteEndpoint = fmt.Sprintf("tf-test-bucket-%d.s3-website-us-west-2.amazonaws.com", randInt) 378 var testAccAWSS3BucketPolicy = fmt.Sprintf(`{ "Version": "2008-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "AWS": "*" }, "Action": "s3:GetObject", "Resource": "arn:aws:s3:::tf-test-bucket-%d/*" } ] }`, randInt) 379 380 var testAccAWSS3BucketConfig = fmt.Sprintf(` 381 resource "aws_s3_bucket" "bucket" { 382 bucket = "tf-test-bucket-%d" 383 acl = "public-read" 384 } 385 `, randInt) 386 387 var testAccAWSS3BucketWebsiteConfig = fmt.Sprintf(` 388 resource "aws_s3_bucket" "bucket" { 389 bucket = "tf-test-bucket-%d" 390 acl = "public-read" 391 392 website { 393 index_document = "index.html" 394 } 395 } 396 `, randInt) 397 398 var testAccAWSS3BucketWebsiteConfigWithError = fmt.Sprintf(` 399 resource "aws_s3_bucket" "bucket" { 400 bucket = "tf-test-bucket-%d" 401 acl = "public-read" 402 403 website { 404 index_document = "index.html" 405 error_document = "error.html" 406 } 407 } 408 `, randInt) 409 410 var testAccAWSS3BucketWebsiteConfigWithRedirect = fmt.Sprintf(` 411 resource "aws_s3_bucket" "bucket" { 412 bucket = "tf-test-bucket-%d" 413 acl = "public-read" 414 415 website { 416 redirect_all_requests_to = "hashicorp.com" 417 } 418 } 419 `, randInt) 420 421 var testAccAWSS3BucketConfigWithPolicy = fmt.Sprintf(` 422 resource "aws_s3_bucket" "bucket" { 423 bucket = "tf-test-bucket-%d" 424 acl = "public-read" 425 policy = %s 426 } 427 `, randInt, strconv.Quote(testAccAWSS3BucketPolicy)) 428 429 var destroyedName = fmt.Sprintf("tf-test-bucket-%d", randInt) 430 var testAccAWSS3BucketDestroyedConfig = fmt.Sprintf(` 431 resource "aws_s3_bucket" "bucket" { 432 bucket = "%s" 433 acl = "public-read" 434 } 435 `, destroyedName) 436 var testAccAWSS3BucketConfigWithVersioning = fmt.Sprintf(` 437 resource "aws_s3_bucket" "bucket" { 438 bucket = "tf-test-bucket-%d" 439 acl = "public-read" 440 versioning { 441 enabled = true 442 } 443 } 444 `, randInt) 445 446 var testAccAWSS3BucketConfigWithDisableVersioning = fmt.Sprintf(` 447 resource "aws_s3_bucket" "bucket" { 448 bucket = "tf-test-bucket-%d" 449 acl = "public-read" 450 versioning { 451 enabled = false 452 } 453 } 454 `, randInt)