github.com/koding/terraform@v0.6.4-0.20170608090606-5d7e0339779d/builtin/providers/google/resource_storage_bucket_test.go (about) 1 package google 2 3 import ( 4 "bytes" 5 "fmt" 6 "log" 7 "testing" 8 9 "github.com/hashicorp/terraform/helper/acctest" 10 "github.com/hashicorp/terraform/helper/resource" 11 "github.com/hashicorp/terraform/terraform" 12 13 "google.golang.org/api/googleapi" 14 storage "google.golang.org/api/storage/v1" 15 ) 16 17 func TestAccStorageBucket_basic(t *testing.T) { 18 var bucket storage.Bucket 19 bucketName := fmt.Sprintf("tf-test-acl-bucket-%d", acctest.RandInt()) 20 21 resource.Test(t, resource.TestCase{ 22 PreCheck: func() { testAccPreCheck(t) }, 23 Providers: testAccProviders, 24 CheckDestroy: testAccStorageBucketDestroy, 25 Steps: []resource.TestStep{ 26 resource.TestStep{ 27 Config: testAccStorageBucket_basic(bucketName), 28 Check: resource.ComposeTestCheckFunc( 29 testAccCheckStorageBucketExists( 30 "google_storage_bucket.bucket", bucketName, &bucket), 31 resource.TestCheckResourceAttr( 32 "google_storage_bucket.bucket", "location", "US"), 33 resource.TestCheckResourceAttr( 34 "google_storage_bucket.bucket", "force_destroy", "false"), 35 ), 36 }, 37 }, 38 }) 39 } 40 41 func TestAccStorageBucket_customAttributes(t *testing.T) { 42 var bucket storage.Bucket 43 bucketName := fmt.Sprintf("tf-test-acl-bucket-%d", acctest.RandInt()) 44 45 resource.Test(t, resource.TestCase{ 46 PreCheck: func() { testAccPreCheck(t) }, 47 Providers: testAccProviders, 48 CheckDestroy: testAccStorageBucketDestroy, 49 Steps: []resource.TestStep{ 50 resource.TestStep{ 51 Config: testAccStorageBucket_customAttributes(bucketName), 52 Check: resource.ComposeTestCheckFunc( 53 testAccCheckStorageBucketExists( 54 "google_storage_bucket.bucket", bucketName, &bucket), 55 resource.TestCheckResourceAttr( 56 "google_storage_bucket.bucket", "location", "EU"), 57 resource.TestCheckResourceAttr( 58 "google_storage_bucket.bucket", "force_destroy", "true"), 59 ), 60 }, 61 }, 62 }) 63 } 64 65 func TestAccStorageBucket_storageClass(t *testing.T) { 66 var bucket storage.Bucket 67 bucketName := fmt.Sprintf("tf-test-acc-bucket-%d", acctest.RandInt()) 68 69 resource.Test(t, resource.TestCase{ 70 PreCheck: func() { testAccPreCheck(t) }, 71 Providers: testAccProviders, 72 CheckDestroy: testAccStorageBucketDestroy, 73 Steps: []resource.TestStep{ 74 { 75 Config: testAccStorageBucket_storageClass(bucketName, "MULTI_REGIONAL", ""), 76 Check: resource.ComposeTestCheckFunc( 77 testAccCheckStorageBucketExists( 78 "google_storage_bucket.bucket", bucketName, &bucket), 79 resource.TestCheckResourceAttr( 80 "google_storage_bucket.bucket", "storage_class", "MULTI_REGIONAL"), 81 ), 82 }, 83 { 84 Config: testAccStorageBucket_storageClass(bucketName, "NEARLINE", ""), 85 Check: resource.ComposeTestCheckFunc( 86 testAccCheckStorageBucketExists( 87 "google_storage_bucket.bucket", bucketName, &bucket), 88 resource.TestCheckResourceAttr( 89 "google_storage_bucket.bucket", "storage_class", "NEARLINE"), 90 ), 91 }, 92 { 93 Config: testAccStorageBucket_storageClass(bucketName, "REGIONAL", "US-CENTRAL1"), 94 Check: resource.ComposeTestCheckFunc( 95 testAccCheckStorageBucketExists( 96 "google_storage_bucket.bucket", bucketName, &bucket), 97 resource.TestCheckResourceAttr( 98 "google_storage_bucket.bucket", "storage_class", "REGIONAL"), 99 resource.TestCheckResourceAttr( 100 "google_storage_bucket.bucket", "location", "US-CENTRAL1"), 101 ), 102 }, 103 }, 104 }) 105 } 106 107 func TestAccStorageBucket_update(t *testing.T) { 108 var bucket storage.Bucket 109 bucketName := fmt.Sprintf("tf-test-acl-bucket-%d", acctest.RandInt()) 110 111 resource.Test(t, resource.TestCase{ 112 PreCheck: func() { testAccPreCheck(t) }, 113 Providers: testAccProviders, 114 CheckDestroy: testAccStorageBucketDestroy, 115 Steps: []resource.TestStep{ 116 resource.TestStep{ 117 Config: testAccStorageBucket_basic(bucketName), 118 Check: resource.ComposeTestCheckFunc( 119 testAccCheckStorageBucketExists( 120 "google_storage_bucket.bucket", bucketName, &bucket), 121 resource.TestCheckResourceAttr( 122 "google_storage_bucket.bucket", "location", "US"), 123 resource.TestCheckResourceAttr( 124 "google_storage_bucket.bucket", "force_destroy", "false"), 125 ), 126 }, 127 resource.TestStep{ 128 Config: testAccStorageBucket_customAttributes(bucketName), 129 Check: resource.ComposeTestCheckFunc( 130 testAccCheckStorageBucketExists( 131 "google_storage_bucket.bucket", bucketName, &bucket), 132 resource.TestCheckResourceAttr( 133 "google_storage_bucket.bucket", "predefined_acl", "publicReadWrite"), 134 resource.TestCheckResourceAttr( 135 "google_storage_bucket.bucket", "location", "EU"), 136 resource.TestCheckResourceAttr( 137 "google_storage_bucket.bucket", "force_destroy", "true"), 138 ), 139 }, 140 }, 141 }) 142 } 143 144 func TestAccStorageBucket_forceDestroy(t *testing.T) { 145 var bucket storage.Bucket 146 bucketName := fmt.Sprintf("tf-test-acl-bucket-%d", acctest.RandInt()) 147 148 resource.Test(t, resource.TestCase{ 149 PreCheck: func() { testAccPreCheck(t) }, 150 Providers: testAccProviders, 151 CheckDestroy: testAccStorageBucketDestroy, 152 Steps: []resource.TestStep{ 153 resource.TestStep{ 154 Config: testAccStorageBucket_customAttributes(bucketName), 155 Check: resource.ComposeTestCheckFunc( 156 testAccCheckStorageBucketExists( 157 "google_storage_bucket.bucket", bucketName, &bucket), 158 ), 159 }, 160 resource.TestStep{ 161 Config: testAccStorageBucket_customAttributes(bucketName), 162 Check: resource.ComposeTestCheckFunc( 163 testAccCheckStorageBucketPutItem(bucketName), 164 ), 165 }, 166 resource.TestStep{ 167 Config: testAccStorageBucket_customAttributes("idontexist"), 168 Check: resource.ComposeTestCheckFunc( 169 testAccCheckStorageBucketMissing(bucketName), 170 ), 171 }, 172 }, 173 }) 174 } 175 176 func TestAccStorageBucket_cors(t *testing.T) { 177 var bucket storage.Bucket 178 bucketName := fmt.Sprintf("tf-test-acl-bucket-%d", acctest.RandInt()) 179 180 resource.Test(t, resource.TestCase{ 181 PreCheck: func() { testAccPreCheck(t) }, 182 Providers: testAccProviders, 183 CheckDestroy: testAccStorageBucketDestroy, 184 Steps: []resource.TestStep{ 185 resource.TestStep{ 186 Config: testGoogleStorageBucketsCors(bucketName), 187 Check: resource.ComposeTestCheckFunc( 188 testAccCheckStorageBucketExists( 189 "google_storage_bucket.bucket", bucketName, &bucket), 190 ), 191 }, 192 }, 193 }) 194 195 if len(bucket.Cors) != 2 { 196 t.Errorf("Expected # of cors elements to be 2, got %d", len(bucket.Cors)) 197 } 198 199 firstArr := bucket.Cors[0] 200 if firstArr.MaxAgeSeconds != 10 { 201 t.Errorf("Expected first block's MaxAgeSeconds to be 10, got %d", firstArr.MaxAgeSeconds) 202 } 203 204 for i, v := range []string{"abc", "def"} { 205 if firstArr.Origin[i] != v { 206 t.Errorf("Expected value in first block origin to be to be %v, got %v", v, firstArr.Origin[i]) 207 } 208 } 209 210 for i, v := range []string{"a1a"} { 211 if firstArr.Method[i] != v { 212 t.Errorf("Expected value in first block method to be to be %v, got %v", v, firstArr.Method[i]) 213 } 214 } 215 216 for i, v := range []string{"123", "456", "789"} { 217 if firstArr.ResponseHeader[i] != v { 218 t.Errorf("Expected value in first block response headerto be to be %v, got %v", v, firstArr.ResponseHeader[i]) 219 } 220 } 221 222 secondArr := bucket.Cors[1] 223 if secondArr.MaxAgeSeconds != 5 { 224 t.Errorf("Expected second block's MaxAgeSeconds to be 5, got %d", secondArr.MaxAgeSeconds) 225 } 226 227 for i, v := range []string{"ghi", "jkl"} { 228 if secondArr.Origin[i] != v { 229 t.Errorf("Expected value in second block origin to be to be %v, got %v", v, secondArr.Origin[i]) 230 } 231 } 232 233 for i, v := range []string{"z9z"} { 234 if secondArr.Method[i] != v { 235 t.Errorf("Expected value in second block method to be to be %v, got %v", v, secondArr.Method[i]) 236 } 237 } 238 239 for i, v := range []string{"000"} { 240 if secondArr.ResponseHeader[i] != v { 241 t.Errorf("Expected value in second block response headerto be to be %v, got %v", v, secondArr.ResponseHeader[i]) 242 } 243 } 244 } 245 246 func testAccCheckStorageBucketExists(n string, bucketName string, bucket *storage.Bucket) resource.TestCheckFunc { 247 return func(s *terraform.State) error { 248 rs, ok := s.RootModule().Resources[n] 249 if !ok { 250 return fmt.Errorf("Not found: %s", n) 251 } 252 253 if rs.Primary.ID == "" { 254 return fmt.Errorf("No Project_ID is set") 255 } 256 257 config := testAccProvider.Meta().(*Config) 258 259 found, err := config.clientStorage.Buckets.Get(rs.Primary.ID).Do() 260 if err != nil { 261 return err 262 } 263 264 if found.Id != rs.Primary.ID { 265 return fmt.Errorf("Bucket not found") 266 } 267 268 if found.Name != bucketName { 269 return fmt.Errorf("expected name %s, got %s", bucketName, found.Name) 270 } 271 272 *bucket = *found 273 return nil 274 } 275 } 276 277 func testAccCheckStorageBucketPutItem(bucketName string) resource.TestCheckFunc { 278 return func(s *terraform.State) error { 279 config := testAccProvider.Meta().(*Config) 280 281 data := bytes.NewBufferString("test") 282 dataReader := bytes.NewReader(data.Bytes()) 283 object := &storage.Object{Name: "bucketDestroyTestFile"} 284 285 // This needs to use Media(io.Reader) call, otherwise it does not go to /upload API and fails 286 if res, err := config.clientStorage.Objects.Insert(bucketName, object).Media(dataReader).Do(); err == nil { 287 log.Printf("[INFO] Created object %v at location %v\n\n", res.Name, res.SelfLink) 288 } else { 289 return fmt.Errorf("Objects.Insert failed: %v", err) 290 } 291 292 return nil 293 } 294 } 295 296 func testAccCheckStorageBucketMissing(bucketName string) resource.TestCheckFunc { 297 return func(s *terraform.State) error { 298 config := testAccProvider.Meta().(*Config) 299 300 _, err := config.clientStorage.Buckets.Get(bucketName).Do() 301 if err == nil { 302 return fmt.Errorf("Found %s", bucketName) 303 } 304 305 if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 { 306 return nil 307 } 308 309 return err 310 } 311 } 312 313 func testAccStorageBucketDestroy(s *terraform.State) error { 314 config := testAccProvider.Meta().(*Config) 315 316 for _, rs := range s.RootModule().Resources { 317 if rs.Type != "google_storage_bucket" { 318 continue 319 } 320 321 _, err := config.clientStorage.Buckets.Get(rs.Primary.ID).Do() 322 if err == nil { 323 return fmt.Errorf("Bucket still exists") 324 } 325 } 326 327 return nil 328 } 329 330 func testAccStorageBucket_basic(bucketName string) string { 331 return fmt.Sprintf(` 332 resource "google_storage_bucket" "bucket" { 333 name = "%s" 334 } 335 `, bucketName) 336 } 337 338 func testAccStorageBucket_customAttributes(bucketName string) string { 339 return fmt.Sprintf(` 340 resource "google_storage_bucket" "bucket" { 341 name = "%s" 342 predefined_acl = "publicReadWrite" 343 location = "EU" 344 force_destroy = "true" 345 } 346 `, bucketName) 347 } 348 349 func testAccStorageBucket_storageClass(bucketName, storageClass, location string) string { 350 var locationBlock string 351 if location != "" { 352 locationBlock = fmt.Sprintf(` 353 location = "%s"`, location) 354 } 355 return fmt.Sprintf(` 356 resource "google_storage_bucket" "bucket" { 357 name = "%s" 358 storage_class = "%s"%s 359 } 360 `, bucketName, storageClass, locationBlock) 361 } 362 363 func testGoogleStorageBucketsCors(bucketName string) string { 364 return fmt.Sprintf(` 365 resource "google_storage_bucket" "bucket" { 366 name = "%s" 367 cors { 368 origin = ["abc", "def"] 369 method = ["a1a"] 370 response_header = ["123", "456", "789"] 371 max_age_seconds = 10 372 } 373 374 cors { 375 origin = ["ghi", "jkl"] 376 method = ["z9z"] 377 response_header = ["000"] 378 max_age_seconds = 5 379 } 380 } 381 `, bucketName) 382 }