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  }