github.com/nathanielks/terraform@v0.6.1-0.20170509030759-13e1a62319dc/builtin/providers/google/resource_storage_bucket_object_test.go (about) 1 package google 2 3 import ( 4 "crypto/md5" 5 "encoding/base64" 6 "fmt" 7 "io/ioutil" 8 "testing" 9 10 "github.com/hashicorp/terraform/helper/resource" 11 "github.com/hashicorp/terraform/terraform" 12 13 "google.golang.org/api/storage/v1" 14 ) 15 16 var tf, err = ioutil.TempFile("", "tf-gce-test") 17 var bucketName = "tf-gce-bucket-test" 18 var objectName = "tf-gce-test" 19 var content = "now this is content!" 20 21 func TestAccGoogleStorageObject_basic(t *testing.T) { 22 bucketName := testBucketName() 23 data := []byte("data data data") 24 h := md5.New() 25 h.Write(data) 26 data_md5 := base64.StdEncoding.EncodeToString(h.Sum(nil)) 27 28 ioutil.WriteFile(tf.Name(), data, 0644) 29 resource.Test(t, resource.TestCase{ 30 PreCheck: func() { 31 if err != nil { 32 panic(err) 33 } 34 testAccPreCheck(t) 35 }, 36 Providers: testAccProviders, 37 CheckDestroy: testAccGoogleStorageObjectDestroy, 38 Steps: []resource.TestStep{ 39 resource.TestStep{ 40 Config: testGoogleStorageBucketsObjectBasic(bucketName), 41 Check: testAccCheckGoogleStorageObject(bucketName, objectName, data_md5), 42 }, 43 }, 44 }) 45 } 46 47 func TestAccGoogleStorageObject_content(t *testing.T) { 48 bucketName := testBucketName() 49 data := []byte(content) 50 h := md5.New() 51 h.Write(data) 52 data_md5 := base64.StdEncoding.EncodeToString(h.Sum(nil)) 53 54 ioutil.WriteFile(tf.Name(), data, 0644) 55 resource.Test(t, resource.TestCase{ 56 PreCheck: func() { 57 if err != nil { 58 panic(err) 59 } 60 testAccPreCheck(t) 61 }, 62 Providers: testAccProviders, 63 CheckDestroy: testAccGoogleStorageObjectDestroy, 64 Steps: []resource.TestStep{ 65 resource.TestStep{ 66 Config: testGoogleStorageBucketsObjectContent(bucketName), 67 Check: resource.ComposeTestCheckFunc( 68 testAccCheckGoogleStorageObject(bucketName, objectName, data_md5), 69 resource.TestCheckResourceAttr( 70 "google_storage_bucket_object.object", "content_type", "text/plain; charset=utf-8"), 71 resource.TestCheckResourceAttr( 72 "google_storage_bucket_object.object", "storage_class", "STANDARD"), 73 ), 74 }, 75 }, 76 }) 77 } 78 79 func TestAccGoogleStorageObject_withContentCharacteristics(t *testing.T) { 80 bucketName := testBucketName() 81 data := []byte(content) 82 h := md5.New() 83 h.Write(data) 84 data_md5 := base64.StdEncoding.EncodeToString(h.Sum(nil)) 85 ioutil.WriteFile(tf.Name(), data, 0644) 86 87 disposition, encoding, language, content_type := "inline", "compress", "en", "binary/octet-stream" 88 resource.Test(t, resource.TestCase{ 89 PreCheck: func() { 90 if err != nil { 91 panic(err) 92 } 93 testAccPreCheck(t) 94 }, 95 Providers: testAccProviders, 96 CheckDestroy: testAccGoogleStorageObjectDestroy, 97 Steps: []resource.TestStep{ 98 resource.TestStep{ 99 Config: testGoogleStorageBucketsObject_optionalContentFields( 100 bucketName, disposition, encoding, language, content_type), 101 Check: resource.ComposeTestCheckFunc( 102 testAccCheckGoogleStorageObject(bucketName, objectName, data_md5), 103 resource.TestCheckResourceAttr( 104 "google_storage_bucket_object.object", "content_disposition", disposition), 105 resource.TestCheckResourceAttr( 106 "google_storage_bucket_object.object", "content_encoding", encoding), 107 resource.TestCheckResourceAttr( 108 "google_storage_bucket_object.object", "content_language", language), 109 resource.TestCheckResourceAttr( 110 "google_storage_bucket_object.object", "content_type", content_type), 111 ), 112 }, 113 }, 114 }) 115 } 116 117 func TestAccGoogleStorageObject_cacheControl(t *testing.T) { 118 bucketName := testBucketName() 119 data := []byte(content) 120 h := md5.New() 121 h.Write(data) 122 data_md5 := base64.StdEncoding.EncodeToString(h.Sum(nil)) 123 ioutil.WriteFile(tf.Name(), data, 0644) 124 125 cacheControl := "private" 126 resource.Test(t, resource.TestCase{ 127 PreCheck: func() { 128 if err != nil { 129 panic(err) 130 } 131 testAccPreCheck(t) 132 }, 133 Providers: testAccProviders, 134 CheckDestroy: testAccGoogleStorageObjectDestroy, 135 Steps: []resource.TestStep{ 136 resource.TestStep{ 137 Config: testGoogleStorageBucketsObject_cacheControl(bucketName, cacheControl), 138 Check: resource.ComposeTestCheckFunc( 139 testAccCheckGoogleStorageObject(bucketName, objectName, data_md5), 140 resource.TestCheckResourceAttr( 141 "google_storage_bucket_object.object", "cache_control", cacheControl), 142 ), 143 }, 144 }, 145 }) 146 } 147 148 func TestAccGoogleStorageObject_storageClass(t *testing.T) { 149 bucketName := testBucketName() 150 data := []byte(content) 151 h := md5.New() 152 h.Write(data) 153 data_md5 := base64.StdEncoding.EncodeToString(h.Sum(nil)) 154 ioutil.WriteFile(tf.Name(), data, 0644) 155 156 storageClass := "MULTI_REGIONAL" 157 resource.Test(t, resource.TestCase{ 158 PreCheck: func() { 159 if err != nil { 160 panic(err) 161 } 162 testAccPreCheck(t) 163 }, 164 Providers: testAccProviders, 165 CheckDestroy: testAccGoogleStorageObjectDestroy, 166 Steps: []resource.TestStep{ 167 resource.TestStep{ 168 Config: testGoogleStorageBucketsObject_storageClass(bucketName, storageClass), 169 Check: resource.ComposeTestCheckFunc( 170 testAccCheckGoogleStorageObject(bucketName, objectName, data_md5), 171 resource.TestCheckResourceAttr( 172 "google_storage_bucket_object.object", "storage_class", storageClass), 173 ), 174 }, 175 }, 176 }) 177 } 178 179 func testAccCheckGoogleStorageObject(bucket, object, md5 string) resource.TestCheckFunc { 180 return func(s *terraform.State) error { 181 config := testAccProvider.Meta().(*Config) 182 183 objectsService := storage.NewObjectsService(config.clientStorage) 184 185 getCall := objectsService.Get(bucket, object) 186 res, err := getCall.Do() 187 188 if err != nil { 189 return fmt.Errorf("Error retrieving contents of object %s: %s", object, err) 190 } 191 192 if md5 != res.Md5Hash { 193 return fmt.Errorf("Error contents of %s garbled, md5 hashes don't match (%s, %s)", object, md5, res.Md5Hash) 194 } 195 196 return nil 197 } 198 } 199 200 func testAccGoogleStorageObjectDestroy(s *terraform.State) error { 201 config := testAccProvider.Meta().(*Config) 202 203 for _, rs := range s.RootModule().Resources { 204 if rs.Type != "google_storage_bucket_object" { 205 continue 206 } 207 208 bucket := rs.Primary.Attributes["bucket"] 209 name := rs.Primary.Attributes["name"] 210 211 objectsService := storage.NewObjectsService(config.clientStorage) 212 213 getCall := objectsService.Get(bucket, name) 214 _, err := getCall.Do() 215 216 if err == nil { 217 return fmt.Errorf("Object %s still exists", name) 218 } 219 } 220 221 return nil 222 } 223 224 func testGoogleStorageBucketsObjectContent(bucketName string) string { 225 return fmt.Sprintf(` 226 resource "google_storage_bucket" "bucket" { 227 name = "%s" 228 } 229 230 resource "google_storage_bucket_object" "object" { 231 name = "%s" 232 bucket = "${google_storage_bucket.bucket.name}" 233 content = "%s" 234 predefined_acl = "projectPrivate" 235 } 236 `, bucketName, objectName, content) 237 } 238 239 func testGoogleStorageBucketsObjectBasic(bucketName string) string { 240 return fmt.Sprintf(` 241 resource "google_storage_bucket" "bucket" { 242 name = "%s" 243 } 244 245 resource "google_storage_bucket_object" "object" { 246 name = "%s" 247 bucket = "${google_storage_bucket.bucket.name}" 248 source = "%s" 249 predefined_acl = "projectPrivate" 250 } 251 `, bucketName, objectName, tf.Name()) 252 } 253 254 func testGoogleStorageBucketsObject_optionalContentFields( 255 bucketName, disposition, encoding, language, content_type string) string { 256 return fmt.Sprintf(` 257 resource "google_storage_bucket" "bucket" { 258 name = "%s" 259 } 260 261 resource "google_storage_bucket_object" "object" { 262 name = "%s" 263 bucket = "${google_storage_bucket.bucket.name}" 264 content = "%s" 265 content_disposition = "%s" 266 content_encoding = "%s" 267 content_language = "%s" 268 content_type = "%s" 269 } 270 `, bucketName, objectName, content, disposition, encoding, language, content_type) 271 } 272 273 func testGoogleStorageBucketsObject_cacheControl(bucketName, cacheControl string) string { 274 return fmt.Sprintf(` 275 resource "google_storage_bucket" "bucket" { 276 name = "%s" 277 } 278 279 resource "google_storage_bucket_object" "object" { 280 name = "%s" 281 bucket = "${google_storage_bucket.bucket.name}" 282 source = "%s" 283 cache_control = "%s" 284 } 285 `, bucketName, objectName, tf.Name(), cacheControl) 286 } 287 288 func testGoogleStorageBucketsObject_storageClass(bucketName string, storageClass string) string { 289 return fmt.Sprintf(` 290 resource "google_storage_bucket" "bucket" { 291 name = "%s" 292 } 293 294 resource "google_storage_bucket_object" "object" { 295 name = "%s" 296 bucket = "${google_storage_bucket.bucket.name}" 297 content = "%s" 298 storage_class = "%s" 299 } 300 `, bucketName, objectName, content, storageClass) 301 }