public/terraform-provider-google
0
0
Fork 0
mirror of https://github.com/letic/terraform-provider-google.git synced 2024-06-29 06:42:36 +00:00
Code Issues Projects Releases Wiki Activity

move all remaining import_ tests into resource-specific tests (#2060)

Browse Source 
I also did a bit of cleanup while I was here and noticed things that I thought could be improved in the files (wording changes, removing tests that aren't quite necessary, etc.) Take a look and make sure I didn't actually remove anything important!
This commit is contained in:
Dana Hoffman 2018-09-17 11:15:11 -07:00 committed by GitHub
parent 548f3685b1
commit cc98692acd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 269 additions and 1255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
google/data_source_google_service_account_test.go
View File

@ -21,7 +21,6 @@ func TestAccDatasourceGoogleServiceAccount_basic(t *testing.T) {
{
Config: testAccCheckGoogleServiceAccount_basic(account),
Check: resource.ComposeTestCheckFunc(
testAccCheckGoogleServiceAccountExists(resourceName),
resource.TestCheckResourceAttr(
resourceName, "id", fmt.Sprintf("projects/%s/serviceAccounts/%s@%s.iam.gserviceaccount.com", getTestProjectFromEnv(), account, getTestProjectFromEnv())),
resource.TestCheckResourceAttrSet(resourceName, "email"),

57
google/import_bigquery_dataset_test.go
View File

@ -1,57 +0,0 @@
package google
import (
"fmt"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
)
func TestAccBigQueryDataset_importBasic(t *testing.T) {
t.Parallel()
resourceName := "google_bigquery_dataset.test"
datasetID := fmt.Sprintf("tf_test_%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckBigQueryDatasetDestroy,
Steps: []resource.TestStep{
{
Config: testAccBigQueryDataset(datasetID),
},
{
ResourceName: resourceName,
ImportState: true,
ImportStateVerify: true,
},
},
})
}
func TestAccBigQueryDataset_importAccess(t *testing.T) {
t.Parallel()
resourceName := "google_bigquery_dataset.access_test"
datasetID := fmt.Sprintf("tf_test_%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckBigQueryDatasetDestroy,
Steps: []resource.TestStep{
{
Config: testAccBigQueryDatasetWithTwoAccess(datasetID),
},
{
ResourceName: resourceName,
ImportState: true,
ImportStateVerify: true,
},
},
})
}

34
google/import_bigquery_table_test.go
View File

@ -1,34 +0,0 @@
package google
import (
"fmt"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
)
func TestAccBigQueryTable_importBasic(t *testing.T) {
t.Parallel()
resourceName := "google_bigquery_table.test"
datasetID := fmt.Sprintf("tf_test_%s", acctest.RandString(10))
tableID := fmt.Sprintf("tf_test_%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckBigQueryTableDestroy,
Steps: []resource.TestStep{
{
Config: testAccBigQueryTable(datasetID, tableID),
},
{
ResourceName: resourceName,
ImportState: true,
ImportStateVerify: true,
},
},
})
}

30
google/import_google_project_iam_custom_role_test.go
View File

@ -1,30 +0,0 @@
package google
import (
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
)
func TestAccProjectIamCustomRole_import(t *testing.T) {
t.Parallel()
roleId := "tfIamRole" + acctest.RandString(10)
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckGoogleProjectIamCustomRoleDestroy,
Steps: []resource.TestStep{
{
Config: testAccCheckGoogleProjectIamCustomRole_update(roleId),
},
{
ResourceName: "google_project_iam_custom_role.foo",
ImportState: true,
ImportStateVerify: true,
},
},
})
}

66
google/import_google_service_account_test.go
View File

@ -1,66 +0,0 @@
package google
import (
"fmt"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
)
func TestAccServiceAccount_importBasic(t *testing.T) {
t.Parallel()
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccServiceAccount_import("terraform-" + acctest.RandString(10)),
},
resource.TestStep{
ResourceName: "google_service_account.acceptance",
ImportState: true,
ImportStateVerify: true,
},
},
})
}
func testAccServiceAccount_import(saName string) string {
return fmt.Sprintf(`
resource "google_service_account" "acceptance" {
account_id = "%s"
display_name = "%s"
}`, saName, saName)
}
func TestAccServiceAccount_importWithProject(t *testing.T) {
t.Parallel()
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccServiceAccount_importWithProject(getTestProjectFromEnv(), "terraform-"+acctest.RandString(10)),
},
resource.TestStep{
ResourceName: "google_service_account.acceptance",
ImportState: true,
ImportStateVerify: true,
},
},
})
}
func testAccServiceAccount_importWithProject(project, saName string) string {
return fmt.Sprintf(`
resource "google_service_account" "acceptance" {
project = "%s"
account_id = "%s"
display_name = "%s"
}`, project, saName, saName)
}

37
google/import_kms_crypto_key_test.go
View File

@ -1,37 +0,0 @@
package google
import (
"fmt"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
)
func TestAccKmsCryptoKey_importBasic(t *testing.T) {
t.Parallel()
resourceName := "google_kms_crypto_key.crypto_key"
projectId := "terraform-" + acctest.RandString(10)
projectOrg := getTestOrgFromEnv(t)
projectBillingAccount := getTestBillingAccountFromEnv(t)
keyRingName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
cryptoKeyName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
Steps: []resource.TestStep{
resource.TestStep{
Config: testGoogleKmsCryptoKey_basic(projectId, projectOrg, projectBillingAccount, keyRingName, cryptoKeyName),
},
resource.TestStep{
ResourceName: resourceName,
ImportState: true,
ImportStateVerify: true,
},
},
})
}

34
google/import_kms_key_ring_test.go
View File

@ -1,34 +0,0 @@
package google
import (
"fmt"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
)
func TestAccKmsKeyRing_importBasic(t *testing.T) {
resourceName := "google_kms_key_ring.key_ring"
projectId := "terraform-" + acctest.RandString(10)
projectOrg := getTestOrgFromEnv(t)
projectBillingAccount := getTestBillingAccountFromEnv(t)
keyRingName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
Steps: []resource.TestStep{
resource.TestStep{
Config: testGoogleKmsKeyRing_basic(projectId, projectOrg, projectBillingAccount, keyRingName),
},
resource.TestStep{
ResourceName: resourceName,
ImportState: true,
ImportStateVerify: true,
},
},
})
}

31
google/import_logging_project_sink_test.go
View File

@ -1,31 +0,0 @@
package google
import (
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
)
func TestAccLoggingProjectSink_importBasic(t *testing.T) {
t.Parallel()
sinkName := "tf-test-sink-" + acctest.RandString(10)
bucketName := "tf-test-sink-bucket-" + acctest.RandString(10)
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccLoggingProjectSink_basic(sinkName, getTestProjectFromEnv(), bucketName),
},
resource.TestStep{
ResourceName: "google_logging_project_sink.basic",
ImportState: true,
ImportStateVerify: true,
},
},
})
}

61
google/import_spanner_database_test.go
View File

@ -1,61 +0,0 @@
package google
import (
"fmt"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
)
func TestAccSpannerDatabase_importInstanceDatabase(t *testing.T) {
t.Parallel()
resourceName := "google_spanner_database.basic"
instanceName := fmt.Sprintf("span-iname-%s", acctest.RandString(10))
dbName := fmt.Sprintf("span-dbname-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckSpannerDatabaseDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccSpannerDatabase_basicImport(instanceName, dbName),
},
resource.TestStep{
ResourceName: resourceName,
ImportStateId: instanceName + "/" + dbName,
ImportState: true,
ImportStateVerify: true,
},
},
})
}
func TestAccSpannerDatabase_importProjectInstanceDatabase(t *testing.T) {
t.Parallel()
resourceName := "google_spanner_database.basic"
instanceName := fmt.Sprintf("span-iname-%s", acctest.RandString(10))
dbName := fmt.Sprintf("span-dbname-%s", acctest.RandString(10))
projectId := getTestProjectFromEnv()
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckSpannerDatabaseDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccSpannerDatabase_basicImportWithProject(projectId, instanceName, dbName),
},
resource.TestStep{
ResourceName: resourceName,
ImportState: true,
ImportStateVerify: true,
},
},
})
}

63
google/import_spanner_instance_test.go
View File

@ -1,63 +0,0 @@
package google
import (
"fmt"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
)
func TestAccSpannerInstance_importInstance(t *testing.T) {
t.Parallel()
resourceName := "google_spanner_instance.basic"
instanceName := fmt.Sprintf("span-itest-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckSpannerInstanceDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccSpannerInstance_basic(instanceName),
},
resource.TestStep{
ResourceName: resourceName,
ImportStateId: instanceName,
ImportState: true,
ImportStateVerify: true,
},
},
})
}
func TestAccSpannerInstance_importProjectInstance(t *testing.T) {
t.Parallel()
resourceName := "google_spanner_instance.basic"
instanceName := fmt.Sprintf("span-itest-%s", acctest.RandString(10))
projectId := getTestProjectFromEnv()
if projectId == "" {
t.Skip("Unable to locate projectId via environment variables ... skipping ")
return
}
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckSpannerInstanceDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccSpannerInstance_basicWithProject(projectId, instanceName),
},
resource.TestStep{
ResourceName: resourceName,
ImportState: true,
ImportStateVerify: true,
},
},
})
}

84
google/resource_bigquery_dataset_test.go
View File

@ -21,18 +21,19 @@ func TestAccBigQueryDataset_basic(t *testing.T) {
Steps: []resource.TestStep{
{
Config: testAccBigQueryDataset(datasetID),
Check: resource.ComposeTestCheckFunc(
testAccCheckBigQueryDatasetExists(
"google_bigquery_dataset.test"),
),
},
{
ResourceName: "google_bigquery_dataset.test",
ImportState: true,
ImportStateVerify: true,
},
{
Config: testAccBigQueryDatasetUpdated(datasetID),
Check: resource.ComposeTestCheckFunc(
testAccCheckBigQueryDatasetExists(
"google_bigquery_dataset.test"),
),
},
{
ResourceName: "google_bigquery_dataset.test",
ImportState: true,
ImportStateVerify: true,
},
},
})
@ -52,34 +53,35 @@ func TestAccBigQueryDataset_access(t *testing.T) {
Steps: []resource.TestStep{
{
Config: testAccBigQueryDatasetWithOneAccess(datasetID),
Check: resource.ComposeTestCheckFunc(
testAccCheckBigQueryDatasetExists(
"google_bigquery_dataset.access_test"),
),
},
{
ResourceName: "google_bigquery_dataset.access_test",
ImportState: true,
ImportStateVerify: true,
},
{
Config: testAccBigQueryDatasetWithTwoAccess(datasetID),
Check: resource.ComposeTestCheckFunc(
testAccCheckBigQueryDatasetExists(
"google_bigquery_dataset.access_test"),
),
},
{
ResourceName: "google_bigquery_dataset.access_test",
ImportState: true,
ImportStateVerify: true,
},
{
Config: testAccBigQueryDatasetWithOneAccess(datasetID),
Check: resource.ComposeTestCheckFunc(
testAccCheckBigQueryDatasetExists(
"google_bigquery_dataset.access_test"),
),
},
{
ResourceName: "google_bigquery_dataset.access_test",
ImportState: true,
ImportStateVerify: true,
},
{
Config: testAccBigQueryDatasetWithViewAccess(datasetID, otherDatasetID, otherTableID),
Check: resource.ComposeTestCheckFunc(
testAccCheckBigQueryDatasetExists(
"google_bigquery_dataset.access_test"),
),
},
{
ResourceName: "google_bigquery_dataset.access_test",
ImportState: true,
ImportStateVerify: true,
},
},
})
@ -102,32 +104,6 @@ func testAccCheckBigQueryDatasetDestroy(s *terraform.State) error {
return nil
}
func testAccCheckBigQueryDatasetExists(n string) resource.TestCheckFunc {
return func(s *terraform.State) error {
rs, ok := s.RootModule().Resources[n]
if !ok {
return fmt.Errorf("Not found: %s", n)
}
if rs.Primary.ID == "" {
return fmt.Errorf("No ID is set")
}
config := testAccProvider.Meta().(*Config)
found, err := config.clientBigQuery.Datasets.Get(config.Project, rs.Primary.Attributes["dataset_id"]).Do()
if err != nil {
return err
}
if found.Id != rs.Primary.ID {
return fmt.Errorf("Dataset not found")
}
return nil
}
}
func testAccBigQueryDataset(datasetID string) string {
return fmt.Sprintf(`
resource "google_bigquery_dataset" "test" {

122
google/resource_bigquery_table_test.go
View File

@ -2,7 +2,6 @@ package google
import (
"fmt"
"strings"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
@ -13,7 +12,6 @@ import (
func TestAccBigQueryTable_Basic(t *testing.T) {
t.Parallel()
resourceName := "google_bigquery_table.test"
datasetID := fmt.Sprintf("tf_test_%s", acctest.RandString(10))
tableID := fmt.Sprintf("tf_test_%s", acctest.RandString(10))
@ -24,20 +22,17 @@ func TestAccBigQueryTable_Basic(t *testing.T) {
Steps: []resource.TestStep{
{
Config: testAccBigQueryTable(datasetID, tableID),
Check: resource.ComposeTestCheckFunc(
testAccBigQueryTableExists(resourceName),
),
},
{
ResourceName: "google_bigquery_table.test",
ImportState: true,
ImportStateVerify: true,
},
{
Config: testAccBigQueryTableUpdated(datasetID, tableID),
Check: resource.ComposeTestCheckFunc(
testAccBigQueryTableExists(resourceName),
),
},
{
ResourceName: resourceName,
ResourceName: "google_bigquery_table.test",
ImportState: true,
ImportStateVerify: true,
},
@ -58,10 +53,11 @@ func TestAccBigQueryTable_View(t *testing.T) {
Steps: []resource.TestStep{
{
Config: testAccBigQueryTableWithView(datasetID, tableID),
Check: resource.ComposeTestCheckFunc(
testAccBigQueryTableExistsWithView(
"google_bigquery_table.test"),
),
},
{
ResourceName: "google_bigquery_table.test",
ImportState: true,
ImportStateVerify: true,
},
},
})
@ -80,17 +76,19 @@ func TestAccBigQueryTable_ViewWithLegacySQL(t *testing.T) {
Steps: []resource.TestStep{
{
Config: testAccBigQueryTableWithView(datasetID, tableID),
Check: resource.ComposeTestCheckFunc(
testAccBigQueryTableExistsWithLegacySql(
"google_bigquery_table.test", true),
),
},
{
ResourceName: "google_bigquery_table.test",
ImportState: true,
ImportStateVerify: true,
},
{
Config: testAccBigQueryTableWithNewSqlView(datasetID, tableID),
Check: resource.ComposeTestCheckFunc(
testAccBigQueryTableExistsWithLegacySql(
"google_bigquery_table.test", false),
),
},
{
ResourceName: "google_bigquery_table.test",
ImportState: true,
ImportStateVerify: true,
},
},
})
@ -112,84 +110,6 @@ func testAccCheckBigQueryTableDestroy(s *terraform.State) error {
return nil
}
func testAccBigQueryTableExists(n string) resource.TestCheckFunc {
return func(s *terraform.State) error {
rs, ok := s.RootModule().Resources[n]
if !ok {
return fmt.Errorf("Not found: %s", n)
}
if rs.Primary.ID == "" {
return fmt.Errorf("No ID is set")
}
config := testAccProvider.Meta().(*Config)
table, err := config.clientBigQuery.Tables.Get(config.Project, rs.Primary.Attributes["dataset_id"], rs.Primary.Attributes["table_id"]).Do()
if err != nil {
return fmt.Errorf("BigQuery Table not present")
}
if !strings.HasSuffix(table.Id, rs.Primary.Attributes["table_id"]) {
return fmt.Errorf("BigQuery Table ID does not match expected value")
}
return nil
}
}
func testAccBigQueryTableExistsWithView(n string) resource.TestCheckFunc {
return func(s *terraform.State) error {
rs, ok := s.RootModule().Resources[n]
if !ok {
return fmt.Errorf("Not found: %s", n)
}
if rs.Primary.ID == "" {
return fmt.Errorf("No ID is set")
}
config := testAccProvider.Meta().(*Config)
table, err := config.clientBigQuery.Tables.Get(config.Project, rs.Primary.Attributes["dataset_id"], rs.Primary.Attributes["table_id"]).Do()
if err != nil {
return fmt.Errorf("BigQuery Table not present")
}
if table.View == nil {
return fmt.Errorf("View object missing on table")
}
return nil
}
}
func testAccBigQueryTableExistsWithLegacySql(n string, useLegacySql bool) resource.TestCheckFunc {
return func(s *terraform.State) error {
rs, ok := s.RootModule().Resources[n]
if !ok {
return fmt.Errorf("Not found: %s", n)
}
if rs.Primary.ID == "" {
return fmt.Errorf("No ID is set")
}
config := testAccProvider.Meta().(*Config)
table, err := config.clientBigQuery.Tables.Get(config.Project, rs.Primary.Attributes["dataset_id"], rs.Primary.Attributes["table_id"]).Do()
if err != nil {
return fmt.Errorf("BigQuery Table not present")
}
if table.View == nil {
return fmt.Errorf("View object missing on table")
}
if table.View.UseLegacySql != useLegacySql {
return fmt.Errorf("Value of UseLegacySQL does not match expected value")
}
return nil
}
}
func testAccBigQueryTable(datasetID, tableID string) string {
return fmt.Sprintf(`
resource "google_bigquery_dataset" "test" {

134
google/resource_google_project_iam_custom_role_test.go
View File

@ -2,8 +2,6 @@ package google
import (
"fmt"
"reflect"
"sort"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
@ -23,21 +21,20 @@ func TestAccProjectIamCustomRole_basic(t *testing.T) {
Steps: []resource.TestStep{
{
Config: testAccCheckGoogleProjectIamCustomRole_basic(roleId),
Check: testAccCheckGoogleProjectIamCustomRole(
"google_project_iam_custom_role.foo",
"My Custom Role",
"foo",
"GA",
[]string{"iam.roles.list"}),
Check: resource.TestCheckResourceAttr("google_project_iam_custom_role.foo", "stage", "GA"),
},
{
ResourceName: "google_project_iam_custom_role.foo",
ImportState: true,
ImportStateVerify: true,
},
{
Config: testAccCheckGoogleProjectIamCustomRole_update(roleId),
Check: testAccCheckGoogleProjectIamCustomRole(
"google_project_iam_custom_role.foo",
"My Custom Role Updated",
"bar",
"BETA",
[]string{"iam.roles.list", "iam.roles.create", "iam.roles.delete"}),
},
{
ResourceName: "google_project_iam_custom_role.foo",
ImportState: true,
ImportStateVerify: true,
},
},
})
@ -55,17 +52,32 @@ func TestAccProjectIamCustomRole_undelete(t *testing.T) {
Steps: []resource.TestStep{
{
Config: testAccCheckGoogleProjectIamCustomRole_basic(roleId),
Check: testAccCheckGoogleProjectIamCustomRoleDeletionStatus("google_project_iam_custom_role.foo", false),
Check: resource.TestCheckResourceAttr("google_project_iam_custom_role.foo", "deleted", "false"),
},
{
ResourceName: "google_project_iam_custom_role.foo",
ImportState: true,
ImportStateVerify: true,
},
// Soft-delete
{
Config: testAccCheckGoogleProjectIamCustomRole_deleted(roleId),
Check: testAccCheckGoogleProjectIamCustomRoleDeletionStatus("google_project_iam_custom_role.foo", true),
Check: resource.TestCheckResourceAttr("google_project_iam_custom_role.foo", "deleted", "true"),
},
{
ResourceName: "google_project_iam_custom_role.foo",
ImportState: true,
ImportStateVerify: true,
},
// Undelete
{
Config: testAccCheckGoogleProjectIamCustomRole_basic(roleId),
Check: testAccCheckGoogleProjectIamCustomRoleDeletionStatus("google_project_iam_custom_role.foo", false),
Check: resource.TestCheckResourceAttr("google_project_iam_custom_role.foo", "deleted", "false"),
},
{
ResourceName: "google_project_iam_custom_role.foo",
ImportState: true,
ImportStateVerify: true,
},
},
})
@ -82,12 +94,11 @@ func TestAccProjectIamCustomRole_createAfterDestroy(t *testing.T) {
Steps: []resource.TestStep{
{
Config: testAccCheckGoogleProjectIamCustomRole_basic(roleId),
Check: testAccCheckGoogleProjectIamCustomRole(
"google_project_iam_custom_role.foo",
"My Custom Role",
"foo",
"GA",
[]string{"iam.roles.list"}),
},
{
ResourceName: "google_project_iam_custom_role.foo",
ImportState: true,
ImportStateVerify: true,
},
// Destroy resources
{
@ -97,12 +108,11 @@ func TestAccProjectIamCustomRole_createAfterDestroy(t *testing.T) {
// Re-create with no existing state
{
Config: testAccCheckGoogleProjectIamCustomRole_basic(roleId),
Check: testAccCheckGoogleProjectIamCustomRole(
"google_project_iam_custom_role.foo",
"My Custom Role",
"foo",
"GA",
[]string{"iam.roles.list"}),
},
{
ResourceName: "google_project_iam_custom_role.foo",
ImportState: true,
ImportStateVerify: true,
},
},
})
@ -131,72 +141,6 @@ func testAccCheckGoogleProjectIamCustomRoleDestroy(s *terraform.State) error {
return nil
}
func testAccCheckGoogleProjectIamCustomRole(n, title, description, stage string, permissions []string) resource.TestCheckFunc {
return func(s *terraform.State) error {
rs, ok := s.RootModule().Resources[n]
if !ok {
return fmt.Errorf("Not found: %s", n)
}
if rs.Primary.ID == "" {
return fmt.Errorf("No ID is set")
}
config := testAccProvider.Meta().(*Config)
role, err := config.clientIAM.Projects.Roles.Get(rs.Primary.ID).Do()
if err != nil {
return err
}
if title != role.Title {
return fmt.Errorf("Incorrect title. Expected %q, got %q", title, role.Title)
}
if description != role.Description {
return fmt.Errorf("Incorrect description. Expected %q, got %q", description, role.Description)
}
if stage != role.Stage {
return fmt.Errorf("Incorrect stage. Expected %q, got %q", stage, role.Stage)
}
sort.Strings(permissions)
sort.Strings(role.IncludedPermissions)
if !reflect.DeepEqual(permissions, role.IncludedPermissions) {
return fmt.Errorf("Incorrect permissions. Expected %q, got %q", permissions, role.IncludedPermissions)
}
return nil
}
}
func testAccCheckGoogleProjectIamCustomRoleDeletionStatus(n string, deleted bool) resource.TestCheckFunc {
return func(s *terraform.State) error {
rs, ok := s.RootModule().Resources[n]
if !ok {
return fmt.Errorf("Not found: %s", n)
}
if rs.Primary.ID == "" {
return fmt.Errorf("No ID is set")
}
config := testAccProvider.Meta().(*Config)
role, err := config.clientIAM.Projects.Roles.Get(rs.Primary.ID).Do()
if err != nil {
return err
}
if deleted != role.Deleted {
return fmt.Errorf("Incorrect deletion status. Expected %t, got %t", deleted, role.Deleted)
}
return nil
}
}
func testAccCheckGoogleProjectIamCustomRole_basic(roleId string) string {
return fmt.Sprintf(`
resource "google_project_iam_custom_role" "foo" {

104
google/resource_google_service_account_test.go
View File

@ -26,33 +26,45 @@ func TestAccServiceAccount_basic(t *testing.T) {
resource.TestStep{
Config: testAccServiceAccountBasic(accountId, displayName),
Check: resource.ComposeTestCheckFunc(
testAccCheckGoogleServiceAccountExists("google_service_account.acceptance"),
resource.TestCheckResourceAttr(
"google_service_account.acceptance", "project", project),
),
},
resource.TestStep{
ResourceName: "google_service_account.acceptance",
ImportState: true,
ImportStateVerify: true,
},
// The second step updates the service account
resource.TestStep{
Config: testAccServiceAccountBasic(accountId, displayName2),
Check: resource.ComposeTestCheckFunc(
testAccCheckGoogleServiceAccountNameModified("google_service_account.acceptance", displayName2),
resource.TestCheckResourceAttr(
"google_service_account.acceptance", "project", project),
testAccStoreServiceAccountUniqueId(&uniqueId),
),
},
resource.TestStep{
ResourceName: "google_service_account.acceptance",
ImportState: true,
ImportStateVerify: true,
},
// The third step explicitely adds the same default project to the service account configuration
// and ensure the service account is not recreated by comparing the value of its unique_id with the one from the previous step
resource.TestStep{
Config: testAccServiceAccountWithProject(project, accountId, displayName2),
Check: resource.ComposeTestCheckFunc(
testAccCheckGoogleServiceAccountNameModified("google_service_account.acceptance", displayName2),
resource.TestCheckResourceAttr(
"google_service_account.acceptance", "project", project),
resource.TestCheckResourceAttrPtr(
"google_service_account.acceptance", "unique_id", &uniqueId),
),
},
resource.TestStep{
ResourceName: "google_service_account.acceptance",
ImportState: true,
ImportStateVerify: true,
},
},
})
}
@ -75,6 +87,13 @@ func TestAccServiceAccount_createPolicy(t *testing.T) {
testAccCheckGoogleServiceAccountPolicyCount("google_service_account.acceptance", 1),
),
},
resource.TestStep{
ResourceName: "google_service_account.acceptance",
ImportState: true,
ImportStateVerify: true,
// policy_data isn't a field on the service account object, and so isn't set in state.
ImportStateVerifyIgnore: []string{"policy_data"},
},
// The second step updates the service account with no IAM policy
resource.TestStep{
Config: testAccServiceAccountBasic(accountId, displayName),
@ -82,6 +101,12 @@ func TestAccServiceAccount_createPolicy(t *testing.T) {
testAccCheckGoogleServiceAccountPolicyCount("google_service_account.acceptance", 0),
),
},
resource.TestStep{
ResourceName: "google_service_account.acceptance",
ImportState: true,
ImportStateVerify: true,
ImportStateVerifyIgnore: []string{"policy_data"},
},
// The final step re-applies the IAM policy
resource.TestStep{
Config: testAccServiceAccountPolicy(accountId, getTestProjectFromEnv()),
@ -89,6 +114,12 @@ func TestAccServiceAccount_createPolicy(t *testing.T) {
testAccCheckGoogleServiceAccountPolicyCount("google_service_account.acceptance", 1),
),
},
resource.TestStep{
ResourceName: "google_service_account.acceptance",
ImportState: true,
ImportStateVerify: true,
ImportStateVerifyIgnore: []string{"policy_data"},
},
},
})
}
@ -114,69 +145,40 @@ func testAccCheckGoogleServiceAccountPolicyCount(r string, n int) resource.TestC
}
}
func testAccCheckGoogleServiceAccountExists(r string) resource.TestCheckFunc {
return func(s *terraform.State) error {
rs, ok := s.RootModule().Resources[r]
if !ok {
return fmt.Errorf("Not found: %s", r)
}
if rs.Primary.ID == "" {
return fmt.Errorf("No ID is set")
}
return nil
}
}
func testAccCheckGoogleServiceAccountNameModified(r, n string) resource.TestCheckFunc {
return func(s *terraform.State) error {
rs, ok := s.RootModule().Resources[r]
if !ok {
return fmt.Errorf("Not found: %s", r)
}
if rs.Primary.Attributes["display_name"] != n {
return fmt.Errorf("display_name is %q expected %q", rs.Primary.Attributes["display_name"], n)
}
return nil
}
}
func testAccServiceAccountBasic(account, name string) string {
t := `resource "google_service_account" "acceptance" {
return fmt.Sprintf(`
resource "google_service_account" "acceptance" {
account_id = "%v"
display_name = "%v"
}`
return fmt.Sprintf(t, account, name)
display_name = "%v"
}
`, account, name)
}
func testAccServiceAccountWithProject(project, account, name string) string {
t := `resource "google_service_account" "acceptance" {
return fmt.Sprintf(`
resource "google_service_account" "acceptance" {
project = "%v"
account_id = "%v"
display_name = "%v"
}`
return fmt.Sprintf(t, project, account, name)
}
`, project, account, name)
}
func testAccServiceAccountPolicy(account, project string) string {
t := `resource "google_service_account" "acceptance" {
return fmt.Sprintf(`
resource "google_service_account" "acceptance" {
account_id = "%v"
display_name = "%v"
policy_data = "${data.google_iam_policy.service_account.policy_data}"
}
data "google_iam_policy" "service_account" {
binding {
role = "roles/iam.serviceAccountActor"
members = [
"serviceAccount:%v@%v.iam.gserviceaccount.com",
]
}
}`
return fmt.Sprintf(t, account, account, account, project)
binding {
role = "roles/iam.serviceAccountActor"
members = [
"serviceAccount:%v@%v.iam.gserviceaccount.com",
]
}
}
`, account, account, account, project)
}

117
google/resource_kms_crypto_key_test.go
View File

@ -2,7 +2,6 @@ package google
import (
"fmt"
"log"
"testing"
"time"
@ -126,9 +125,11 @@ func TestAccKmsCryptoKey_basic(t *testing.T) {
Steps: []resource.TestStep{
resource.TestStep{
Config: testGoogleKmsCryptoKey_basic(projectId, projectOrg, projectBillingAccount, keyRingName, cryptoKeyName),
Check: resource.ComposeTestCheckFunc(
testAccCheckGoogleKmsCryptoKeyExists("google_kms_crypto_key.crypto_key"),
),
},
resource.TestStep{
ResourceName: "google_kms_crypto_key.crypto_key",
ImportState: true,
ImportStateVerify: true,
},
// Use a separate TestStep rather than a CheckDestroy because we need the project to still exist.
resource.TestStep{
@ -160,24 +161,27 @@ func TestAccKmsCryptoKey_rotation(t *testing.T) {
Steps: []resource.TestStep{
resource.TestStep{
Config: testGoogleKmsCryptoKey_rotation(projectId, projectOrg, projectBillingAccount, keyRingName, cryptoKeyName, rotationPeriod),
Check: resource.ComposeTestCheckFunc(
testAccCheckGoogleKmsCryptoKeyExists("google_kms_crypto_key.crypto_key"),
testAccCheckGoogleKmsCryptoKeyHasRotationParams(rotationPeriod, "google_kms_crypto_key.crypto_key"),
),
},
resource.TestStep{
ResourceName: "google_kms_crypto_key.crypto_key",
ImportState: true,
ImportStateVerify: true,
},
resource.TestStep{
Config: testGoogleKmsCryptoKey_rotation(projectId, projectOrg, projectBillingAccount, keyRingName, cryptoKeyName, updatedRotationPeriod),
Check: resource.ComposeTestCheckFunc(
testAccCheckGoogleKmsCryptoKeyExists("google_kms_crypto_key.crypto_key"),
testAccCheckGoogleKmsCryptoKeyHasRotationParams(updatedRotationPeriod, "google_kms_crypto_key.crypto_key"),
),
},
resource.TestStep{
ResourceName: "google_kms_crypto_key.crypto_key",
ImportState: true,
ImportStateVerify: true,
},
resource.TestStep{
Config: testGoogleKmsCryptoKey_rotationRemoved(projectId, projectOrg, projectBillingAccount, keyRingName, cryptoKeyName),
Check: resource.ComposeTestCheckFunc(
testAccCheckGoogleKmsCryptoKeyExists("google_kms_crypto_key.crypto_key"),
testAccCheckGoogleKmsCryptoKeyHasRotationParams("", "google_kms_crypto_key.crypto_key"),
),
},
resource.TestStep{
ResourceName: "google_kms_crypto_key.crypto_key",
ImportState: true,
ImportStateVerify: true,
},
// Use a separate TestStep rather than a CheckDestroy because we need the project to still exist.
resource.TestStep{
@ -191,87 +195,6 @@ func TestAccKmsCryptoKey_rotation(t *testing.T) {
})
}
func testAccCheckGoogleKmsCryptoKeyExists(resourceName string) resource.TestCheckFunc {
return func(s *terraform.State) error {
config := testAccProvider.Meta().(*Config)
rs, ok := s.RootModule().Resources[resourceName]
if !ok {
return fmt.Errorf("Resource not found: %s", resourceName)
}
keyRingId, err := parseKmsKeyRingId(rs.Primary.Attributes["key_ring"], config)
if err != nil {
return err
}
cryptoKeyId := &kmsCryptoKeyId{
KeyRingId: *keyRingId,
Name: rs.Primary.Attributes["name"],
}
listCryptoKeysResponse, err := config.clientKms.Projects.Locations.KeyRings.CryptoKeys.List(cryptoKeyId.parentId()).Do()
if err != nil {
return fmt.Errorf("Error listing KeyRings: %s", err)
}
for _, cryptoKey := range listCryptoKeysResponse.CryptoKeys {
log.Printf("[DEBUG] Found CryptoKey: %s", cryptoKey.Name)
if cryptoKey.Name == cryptoKeyId.cryptoKeyId() {
return nil
}
}
return fmt.Errorf("CryptoKey not found: %s", cryptoKeyId.cryptoKeyId())
}
}
func testAccCheckGoogleKmsCryptoKeyHasRotationParams(rotationPeriod, resourceName string) resource.TestCheckFunc {
return func(s *terraform.State) error {
config := testAccProvider.Meta().(*Config)
rs, ok := s.RootModule().Resources[resourceName]
if !ok {
return fmt.Errorf("Resource not found: %s", resourceName)
}
keyRingId, err := parseKmsKeyRingId(rs.Primary.Attributes["key_ring"], config)
if err != nil {
return err
}
cryptoKeyId := &kmsCryptoKeyId{
KeyRingId: *keyRingId,
Name: rs.Primary.Attributes["name"],
}
getCryptoKeyResponse, err := config.clientKms.Projects.Locations.KeyRings.CryptoKeys.Get(cryptoKeyId.cryptoKeyId()).Do()
if err != nil {
return err
}
if rotationPeriod != getCryptoKeyResponse.RotationPeriod {
return fmt.Errorf("Expected rotation period %s to match input %s", getCryptoKeyResponse.RotationPeriod, rotationPeriod)
}
if getCryptoKeyResponse.NextRotationTime == "" {
return nil
}
_, err = time.Parse(time.RFC3339Nano, getCryptoKeyResponse.NextRotationTime)
if err != nil {
return fmt.Errorf("Failed to parse NextRotationTime timestamp: %s", err)
}
return nil
}
}
/*
KMS KeyRings cannot be deleted. This ensures that the CryptoKey resource was removed from state,
even though the server-side resource was not removed.

41
google/resource_kms_key_ring_test.go
View File

@ -2,7 +2,6 @@ package google
import (
"fmt"
"log"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
@ -85,9 +84,11 @@ func TestAccKmsKeyRing_basic(t *testing.T) {
Steps: []resource.TestStep{
resource.TestStep{
Config: testGoogleKmsKeyRing_basic(projectId, projectOrg, projectBillingAccount, keyRingName),
Check: resource.ComposeTestCheckFunc(
testAccCheckGoogleKmsKeyRingExists("google_kms_key_ring.key_ring"),
),
},
resource.TestStep{
ResourceName: "google_kms_key_ring.key_ring",
ImportState: true,
ImportStateVerify: true,
},
resource.TestStep{
Config: testGoogleKmsKeyRing_removed(projectId, projectOrg, projectBillingAccount),
@ -99,38 +100,6 @@ func TestAccKmsKeyRing_basic(t *testing.T) {
})
}
func testAccCheckGoogleKmsKeyRingExists(resourceName string) resource.TestCheckFunc {
return func(s *terraform.State) error {
config := testAccProvider.Meta().(*Config)
rs, ok := s.RootModule().Resources[resourceName]
if !ok {
return fmt.Errorf("Resource not found: %s", resourceName)
}
keyRingId := &kmsKeyRingId{
Project: rs.Primary.Attributes["project"],
Location: rs.Primary.Attributes["location"],
Name: rs.Primary.Attributes["name"],
}
listKeyRingsResponse, err := config.clientKms.Projects.Locations.KeyRings.List(keyRingId.parentId()).Do()
if err != nil {
return fmt.Errorf("Error listing KeyRings: %s", err)
}
for _, keyRing := range listKeyRingsResponse.KeyRings {
log.Printf("[DEBUG] Found KeyRing: %s", keyRing.Name)
if keyRing.Name == keyRingId.keyRingId() {
return nil
}
}
return fmt.Errorf("KeyRing not found: %s", keyRingId.keyRingId())
}
}
/*
KMS KeyRings cannot be deleted. This ensures that the KeyRing resource was removed from state,
even though the server-side resource was not removed.

168
google/resource_logging_project_sink_test.go
View File

@ -2,13 +2,11 @@ package google
import (
"fmt"
"strconv"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
"github.com/hashicorp/terraform/terraform"
"google.golang.org/api/logging/v2"
)
func TestAccLoggingProjectSink_basic(t *testing.T) {
@ -17,8 +15,6 @@ func TestAccLoggingProjectSink_basic(t *testing.T) {
sinkName := "tf-test-sink-" + acctest.RandString(10)
bucketName := "tf-test-sink-bucket-" + acctest.RandString(10)
var sink logging.LogSink
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
@ -26,34 +22,11 @@ func TestAccLoggingProjectSink_basic(t *testing.T) {
Steps: []resource.TestStep{
{
Config: testAccLoggingProjectSink_basic(sinkName, getTestProjectFromEnv(), bucketName),
Check: resource.ComposeTestCheckFunc(
testAccCheckLoggingProjectSinkExists("google_logging_project_sink.basic", &sink),
testAccCheckLoggingProjectSink(&sink, "google_logging_project_sink.basic"),
),
},
},
})
}
func TestAccLoggingProjectSink_uniqueWriter(t *testing.T) {
t.Parallel()
sinkName := "tf-test-sink-" + acctest.RandString(10)
bucketName := "tf-test-sink-bucket-" + acctest.RandString(10)
var sink logging.LogSink
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckLoggingProjectSinkDestroy,
Steps: []resource.TestStep{
{
Config: testAccLoggingProjectSink_uniqueWriter(sinkName, bucketName),
Check: resource.ComposeTestCheckFunc(
testAccCheckLoggingProjectSinkExists("google_logging_project_sink.unique_writer", &sink),
testAccCheckLoggingProjectSink(&sink, "google_logging_project_sink.unique_writer"),
),
ResourceName: "google_logging_project_sink.basic",
ImportState: true,
ImportStateVerify: true,
},
},
})
@ -66,8 +39,6 @@ func TestAccLoggingProjectSink_updatePreservesUniqueWriter(t *testing.T) {
bucketName := "tf-test-sink-bucket-" + acctest.RandString(10)
updatedBucketName := "tf-test-sink-bucket-" + acctest.RandString(10)
var sinkBefore, sinkAfter logging.LogSink
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
@ -75,31 +46,22 @@ func TestAccLoggingProjectSink_updatePreservesUniqueWriter(t *testing.T) {
Steps: []resource.TestStep{
{
Config: testAccLoggingProjectSink_uniqueWriter(sinkName, bucketName),
Check: resource.ComposeTestCheckFunc(
testAccCheckLoggingProjectSinkExists("google_logging_project_sink.unique_writer", &sinkBefore),
testAccCheckLoggingProjectSink(&sinkBefore, "google_logging_project_sink.unique_writer"),
),
}, {
},
{
ResourceName: "google_logging_project_sink.unique_writer",
ImportState: true,
ImportStateVerify: true,
},
{
Config: testAccLoggingProjectSink_uniqueWriterUpdated(sinkName, updatedBucketName),
Check: resource.ComposeTestCheckFunc(
testAccCheckLoggingProjectSinkExists("google_logging_project_sink.unique_writer", &sinkAfter),
testAccCheckLoggingProjectSink(&sinkAfter, "google_logging_project_sink.unique_writer"),
),
},
{
ResourceName: "google_logging_project_sink.unique_writer",
ImportState: true,
ImportStateVerify: true,
},
},
})
// Destination and Filter should have changed, but WriterIdentity should be the same
if sinkBefore.Destination == sinkAfter.Destination {
t.Errorf("Expected Destination to change, but it didn't: Destination = %#v", sinkBefore.Destination)
}
if sinkBefore.Filter == sinkAfter.Filter {
t.Errorf("Expected Filter to change, but it didn't: Filter = %#v", sinkBefore.Filter)
}
if sinkBefore.WriterIdentity != sinkAfter.WriterIdentity {
t.Errorf("Expected WriterIdentity to be the same, but it differs: before = %#v, after = %#v",
sinkBefore.WriterIdentity, sinkAfter.WriterIdentity)
}
}
func TestAccLoggingProjectSink_heredoc(t *testing.T) {
@ -108,8 +70,6 @@ func TestAccLoggingProjectSink_heredoc(t *testing.T) {
sinkName := "tf-test-sink-" + acctest.RandString(10)
bucketName := "tf-test-sink-bucket-" + acctest.RandString(10)
var sink logging.LogSink
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
@ -117,11 +77,8 @@ func TestAccLoggingProjectSink_heredoc(t *testing.T) {
Steps: []resource.TestStep{
{
Config: testAccLoggingProjectSink_heredoc(sinkName, getTestProjectFromEnv(), bucketName),
Check: resource.ComposeTestCheckFunc(
testAccCheckLoggingProjectSinkExists("google_logging_project_sink.heredoc", &sink),
testAccCheckLoggingProjectSink(&sink, "google_logging_project_sink.heredoc"),
),
}, {
},
{
ResourceName: "google_logging_project_sink.heredoc",
ImportState: true,
ImportStateVerify: true,
@ -149,113 +106,74 @@ func testAccCheckLoggingProjectSinkDestroy(s *terraform.State) error {
return nil
}
func testAccCheckLoggingProjectSinkExists(n string, sink *logging.LogSink) resource.TestCheckFunc {
return func(s *terraform.State) error {
attributes, err := getResourceAttributes(n, s)
if err != nil {
return err
}
config := testAccProvider.Meta().(*Config)
si, err := config.clientLogging.Projects.Sinks.Get(attributes["id"]).Do()
if err != nil {
return err
}
*sink = *si
return nil
}
}
func testAccCheckLoggingProjectSink(sink *logging.LogSink, n string) resource.TestCheckFunc {
return func(s *terraform.State) error {
attributes, err := getResourceAttributes(n, s)
if err != nil {
return err
}
if sink.Destination != attributes["destination"] {
return fmt.Errorf("mismatch on destination: api has %s but client has %s", sink.Destination, attributes["destination"])
}
if sink.Filter != attributes["filter"] {
return fmt.Errorf("mismatch on filter: api has %s but client has %s", sink.Filter, attributes["filter"])
}
apiLooksUnique := strconv.FormatBool(nonUniqueWriterAccount != attributes["writer_identity"])
if apiLooksUnique != attributes["unique_writer_identity"] {
return fmt.Errorf("mismatch on unique_writer_identity: api looks like %s but client has %s", apiLooksUnique, attributes["unique_writer_identity"])
}
if sink.WriterIdentity != attributes["writer_identity"] {
return fmt.Errorf("mismatch on writer_identity: api has %s but client has %s", sink.WriterIdentity, attributes["writer_identity"])
}
return nil
}
}
func testAccLoggingProjectSink_basic(name, project, bucketName string) string {
return fmt.Sprintf(`
resource "google_logging_project_sink" "basic" {
name = "%s"
project = "%s"
name = "%s"
project = "%s"
destination = "storage.googleapis.com/${google_storage_bucket.log-bucket.name}"
filter = "logName=\"projects/%s/logs/compute.googleapis.com%%2Factivity_log\" AND severity>=ERROR"
filter = "logName=\"projects/%s/logs/compute.googleapis.com%%2Factivity_log\" AND severity>=ERROR"
unique_writer_identity = false
}
resource "google_storage_bucket" "log-bucket" {
name = "%s"
}`, name, project, project, bucketName)
name = "%s"
}
`, name, project, project, bucketName)
}
func testAccLoggingProjectSink_uniqueWriter(name, bucketName string) string {
return fmt.Sprintf(`
resource "google_logging_project_sink" "unique_writer" {
name = "%s"
name = "%s"
destination = "storage.googleapis.com/${google_storage_bucket.log-bucket.name}"
filter = "logName=\"projects/%s/logs/compute.googleapis.com%%2Factivity_log\" AND severity>=ERROR"
filter = "logName=\"projects/%s/logs/compute.googleapis.com%%2Factivity_log\" AND severity>=ERROR"
unique_writer_identity = true
}
resource "google_storage_bucket" "log-bucket" {
name = "%s"
}`, name, getTestProjectFromEnv(), bucketName)
name = "%s"
}
`, name, getTestProjectFromEnv(), bucketName)
}
func testAccLoggingProjectSink_uniqueWriterUpdated(name, bucketName string) string {
return fmt.Sprintf(`
resource "google_logging_project_sink" "unique_writer" {
name = "%s"
name = "%s"
destination = "storage.googleapis.com/${google_storage_bucket.log-bucket.name}"
filter = "logName=\"projects/%s/logs/compute.googleapis.com%%2Factivity_log\" AND severity>=WARNING"
filter = "logName=\"projects/%s/logs/compute.googleapis.com%%2Factivity_log\" AND severity>=WARNING"
unique_writer_identity = true
}
resource "google_storage_bucket" "log-bucket" {
name = "%s"
}`, name, getTestProjectFromEnv(), bucketName)
name = "%s"
}
`, name, getTestProjectFromEnv(), bucketName)
}
func testAccLoggingProjectSink_heredoc(name, project, bucketName string) string {
return fmt.Sprintf(`
resource "google_logging_project_sink" "heredoc" {
name = "%s"
project = "%s"
name = "%s"
project = "%s"
destination = "storage.googleapis.com/${google_storage_bucket.log-bucket.name}"
filter = <<EOS
logName="projects/%s/logs/compute.googleapis.com%%2Factivity_log"
AND severity>=ERROR
EOS
EOS
unique_writer_identity = false
}
resource "google_storage_bucket" "log-bucket" {
name = "%s"
}`, name, project, project, bucketName)
name = "%s"
}
`, name, project, project, bucketName)
}

172
google/resource_spanner_database_test.go
View File

@ -3,16 +3,15 @@ package google
import (
"fmt"
"net/http"
"regexp"
"strings"
"testing"
"github.com/hashicorp/errwrap"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
"github.com/hashicorp/terraform/terraform"
"google.golang.org/api/googleapi"
"google.golang.org/api/spanner/v1"
)
// Unit Tests
@ -118,24 +117,23 @@ func expectInvalidSpannerDbImportId(t *testing.T, id *spannerDatabaseId, e error
func TestAccSpannerDatabase_basic(t *testing.T) {
t.Parallel()
var db spanner.Database
rnd := acctest.RandString(10)
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: resource.ComposeTestCheckFunc(
testAccCheckSpannerInstanceDestroy,
testAccCheckSpannerDatabaseDestroy),
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckSpannerDatabaseDestroy,
Steps: []resource.TestStep{
{
Config: testAccSpannerDatabase_basic(rnd),
Check: resource.ComposeTestCheckFunc(
testAccCheckSpannerDatabaseExists("google_spanner_database.basic", &db),
resource.TestCheckResourceAttr("google_spanner_database.basic", "name", "my-db-"+rnd),
resource.TestCheckResourceAttrSet("google_spanner_database.basic", "state"),
),
},
{
ResourceName: "google_spanner_database.basic",
ImportState: true,
ImportStateVerify: true,
},
},
})
}
@ -143,48 +141,23 @@ func TestAccSpannerDatabase_basic(t *testing.T) {
func TestAccSpannerDatabase_basicWithInitialDDL(t *testing.T) {
t.Parallel()
var db spanner.Database
rnd := acctest.RandString(10)
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: resource.ComposeTestCheckFunc(
testAccCheckSpannerInstanceDestroy,
testAccCheckSpannerDatabaseDestroy),
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckSpannerDatabaseDestroy,
Steps: []resource.TestStep{
{
Config: testAccSpannerDatabase_basicWithInitialDDL(rnd),
Check: resource.ComposeTestCheckFunc(
testAccCheckSpannerDatabaseExists("google_spanner_database.basic", &db),
),
},
},
})
}
func TestAccSpannerDatabase_duplicateNameError(t *testing.T) {
t.Parallel()
var db spanner.Database
rnd := acctest.RandString(10)
dbName := fmt.Sprintf("spanner-test-%s", rnd)
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: resource.ComposeTestCheckFunc(
testAccCheckSpannerInstanceDestroy,
testAccCheckSpannerDatabaseDestroy),
Steps: []resource.TestStep{
{
Config: testAccSpannerDatabase_duplicateNameError_part1(rnd, dbName),
Check: resource.ComposeTestCheckFunc(
testAccCheckSpannerDatabaseExists("google_spanner_database.basic1", &db),
),
},
{
Config: testAccSpannerDatabase_duplicateNameError_part2(rnd, dbName),
ExpectError: regexp.MustCompile(
fmt.Sprintf(".*A database with name %s already exists", dbName)),
ResourceName: "google_spanner_database.basic",
ImportState: true,
ImportStateVerify: true,
// DDL statements get issued at the time the create/update
// occurs, which means storing them in state isn't really
// necessary.
ImportStateVerifyIgnore: []string{"ddl"},
},
},
})
@ -215,47 +188,19 @@ func testAccCheckSpannerDatabaseDestroy(s *terraform.State) error {
_, err = config.clientSpanner.Projects.Instances.Databases.Get(
id.databaseUri()).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == http.StatusNotFound {
return nil
}
return fmt.Errorf("Error make GCP platform call to verify spanner database deleted: %s", err.Error())
if err == nil {
return fmt.Errorf("Spanner database still exists")
}
return fmt.Errorf("Spanner database not destroyed - still exists")
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == http.StatusNotFound {
return nil
}
return errwrap.Wrapf("Error verifying spanner database deleted: {{err}}", err)
}
return nil
}
func testAccCheckSpannerDatabaseExists(n string, instance *spanner.Database) resource.TestCheckFunc {
return func(s *terraform.State) error {
config := testAccProvider.Meta().(*Config)
rs, ok := s.RootModule().Resources[n]
if !ok {
return fmt.Errorf("Terraform resource Not found: %s", n)
}
if rs.Primary.ID == "" {
return fmt.Errorf("No ID is set for Spanner instance")
}
id, err := extractSpannerDatabaseId(rs.Primary.ID)
found, err := config.clientSpanner.Projects.Instances.Databases.Get(
id.databaseUri()).Do()
if err != nil {
return err
}
if fName := GetResourceNameFromSelfLink(found.Name); fName != id.Database {
return fmt.Errorf("Spanner database %s not found, found %s instead", id.Database, fName)
}
*instance = *found
return nil
}
}
func testAccSpannerDatabase_basic(rnd string) string {
return fmt.Sprintf(`
resource "google_spanner_instance" "basic" {
@ -268,7 +213,6 @@ resource "google_spanner_instance" "basic" {
resource "google_spanner_database" "basic" {
instance = "${google_spanner_instance.basic.name}"
name = "my-db-%s"
}
`, rnd, rnd, rnd)
}
@ -291,67 +235,3 @@ resource "google_spanner_database" "basic" {
}
`, rnd, rnd, rnd)
}
func testAccSpannerDatabase_duplicateNameError_part1(rnd, dbName string) string {
return fmt.Sprintf(`
resource "google_spanner_instance" "basic" {
name = "my-instance-%s"
config = "regional-us-central1"
display_name = "my-displayname-%s"
num_nodes = 1
}
resource "google_spanner_database" "basic1" {
instance = "${google_spanner_instance.basic.name}"
name = "%s"
}
`, rnd, rnd, dbName)
}
func testAccSpannerDatabase_duplicateNameError_part2(rnd, dbName string) string {
return fmt.Sprintf(`
%s
resource "google_spanner_database" "basic2" {
instance = "${google_spanner_instance.basic.name}"
name = "%s"
}
`, testAccSpannerDatabase_duplicateNameError_part1(rnd, dbName), dbName)
}
func testAccSpannerDatabase_basicImport(iname, dbname string) string {
return fmt.Sprintf(`
resource "google_spanner_instance" "basic" {
name = "%s"
config = "regional-us-central1"
display_name = "%s"
num_nodes = 1
}
resource "google_spanner_database" "basic" {
instance = "${google_spanner_instance.basic.name}"
name = "%s"
}
`, iname, iname, dbname)
}
func testAccSpannerDatabase_basicImportWithProject(project, iname, dbname string) string {
return fmt.Sprintf(`
resource "google_spanner_instance" "basic" {
project = "%s"
name = "%s"
config = "regional-us-central1"
display_name = "%s"
num_nodes = 1
}
resource "google_spanner_database" "basic" {
project = "%s"
instance = "${google_spanner_instance.basic.name}"
name = "%s"
}
`, project, iname, iname, project, dbname)
}

167
google/resource_spanner_instance_test.go
View File

@ -3,16 +3,16 @@ package google
import (
"fmt"
"net/http"
"regexp"
"testing"
"github.com/hashicorp/errwrap"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
"github.com/hashicorp/terraform/terraform"
"google.golang.org/api/googleapi"
"google.golang.org/api/spanner/v1"
"strings"
"google.golang.org/api/googleapi"
)
// Unit Tests
@ -147,9 +147,7 @@ func expectEquals(t *testing.T, expected, actual string) {
func TestAccSpannerInstance_basic(t *testing.T) {
t.Parallel()
var instance spanner.Instance
rnd := acctest.RandString(10)
idName := fmt.Sprintf("spanner-test-%s", rnd)
idName := fmt.Sprintf("spanner-test-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
@ -158,14 +156,14 @@ func TestAccSpannerInstance_basic(t *testing.T) {
{
Config: testAccSpannerInstance_basic(idName),
Check: resource.ComposeTestCheckFunc(
testAccCheckSpannerInstanceExists("google_spanner_instance.basic", &instance),
resource.TestCheckResourceAttr("google_spanner_instance.basic", "name", idName),
resource.TestCheckResourceAttr("google_spanner_instance.basic", "display_name", idName+"-dname"),
resource.TestCheckResourceAttr("google_spanner_instance.basic", "num_nodes", "1"),
resource.TestCheckResourceAttrSet("google_spanner_instance.basic", "state"),
),
},
{
ResourceName: "google_spanner_instance.basic",
ImportState: true,
ImportStateVerify: true,
},
},
})
}
@ -173,9 +171,7 @@ func TestAccSpannerInstance_basic(t *testing.T) {
func TestAccSpannerInstance_basicWithAutogenName(t *testing.T) {
t.Parallel()
var instance spanner.Instance
rnd := acctest.RandString(10)
displayName := fmt.Sprintf("spanner-test-%s-dname", rnd)
displayName := fmt.Sprintf("spanner-test-%s-dname", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
@ -184,37 +180,13 @@ func TestAccSpannerInstance_basicWithAutogenName(t *testing.T) {
{
Config: testAccSpannerInstance_basicWithAutogenName(displayName),
Check: resource.ComposeTestCheckFunc(
testAccCheckSpannerInstanceExists("google_spanner_instance.basic", &instance),
resource.TestCheckResourceAttr("google_spanner_instance.basic", "display_name", displayName),
resource.TestCheckResourceAttrSet("google_spanner_instance.basic", "name"),
),
},
},
})
}
func TestAccSpannerInstance_duplicateNameError(t *testing.T) {
t.Parallel()
var instance spanner.Instance
rnd := acctest.RandString(10)
idName := fmt.Sprintf("spanner-test-%s", rnd)
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckSpannerInstanceDestroy,
Steps: []resource.TestStep{
{
Config: testAccSpannerInstance_duplicateNameError_part1(idName),
Check: resource.ComposeTestCheckFunc(
testAccCheckSpannerInstanceExists("google_spanner_instance.basic1", &instance),
),
},
{
Config: testAccSpannerInstance_duplicateNameError_part2(idName),
ExpectError: regexp.MustCompile(
fmt.Sprintf("Error, the name %s is not unique within project", idName)),
ResourceName: "google_spanner_instance.basic",
ImportState: true,
ImportStateVerify: true,
},
},
})
@ -223,10 +195,8 @@ func TestAccSpannerInstance_duplicateNameError(t *testing.T) {
func TestAccSpannerInstance_update(t *testing.T) {
t.Parallel()
var instance spanner.Instance
rnd := acctest.RandString(10)
dName1 := fmt.Sprintf("spanner-dname1-%s", rnd)
dName2 := fmt.Sprintf("spanner-dname2-%s", rnd)
dName1 := fmt.Sprintf("spanner-dname1-%s", acctest.RandString(10))
dName2 := fmt.Sprintf("spanner-dname2-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
@ -234,21 +204,19 @@ func TestAccSpannerInstance_update(t *testing.T) {
Steps: []resource.TestStep{
{
Config: testAccSpannerInstance_update(dName1, 1, false),
Check: resource.ComposeTestCheckFunc(
testAccCheckSpannerInstanceExists("google_spanner_instance.updater", &instance),
resource.TestCheckResourceAttr("google_spanner_instance.updater", "display_name", dName1),
resource.TestCheckResourceAttr("google_spanner_instance.updater", "num_nodes", "1"),
resource.TestCheckResourceAttr("google_spanner_instance.updater", "labels.%", "1"),
),
},
{
ResourceName: "google_spanner_instance.updater",
ImportState: true,
ImportStateVerify: true,
},
{
Config: testAccSpannerInstance_update(dName2, 2, true),
Check: resource.ComposeTestCheckFunc(
testAccCheckSpannerInstanceExists("google_spanner_instance.updater", &instance),
resource.TestCheckResourceAttr("google_spanner_instance.updater", "display_name", dName2),
resource.TestCheckResourceAttr("google_spanner_instance.updater", "num_nodes", "2"),
resource.TestCheckResourceAttr("google_spanner_instance.updater", "labels.%", "2"),
),
},
{
ResourceName: "google_spanner_instance.updater",
ImportState: true,
ImportStateVerify: true,
},
},
})
@ -279,52 +247,19 @@ func testAccCheckSpannerInstanceDestroy(s *terraform.State) error {
_, err = config.clientSpanner.Projects.Instances.Get(
id.instanceUri()).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == http.StatusNotFound {
return nil
}
return fmt.Errorf("Error make GCP platform call to verify spanner instance deleted: %s", err.Error())
if err == nil {
return fmt.Errorf("Spanner instance still exists")
}
return fmt.Errorf("Spanner instance not destroyed - still exists")
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == http.StatusNotFound {
return nil
}
return errwrap.Wrapf("Error verifying spanner instance deleted: {{err}}", err)
}
return nil
}
func testAccCheckSpannerInstanceExists(n string, instance *spanner.Instance) resource.TestCheckFunc {
return func(s *terraform.State) error {
config := testAccProvider.Meta().(*Config)
rs, ok := s.RootModule().Resources[n]
if !ok {
return fmt.Errorf("Terraform resource Not found: %s", n)
}
if rs.Primary.ID == "" {
return fmt.Errorf("No ID is set for Spanner instance")
}
id, err := extractSpannerInstanceId(rs.Primary.ID)
if err != nil {
return err
}
found, err := config.clientSpanner.Projects.Instances.Get(
id.instanceUri()).Do()
if err != nil {
return err
}
fName := GetResourceNameFromSelfLink(found.Name)
if fName != GetResourceNameFromSelfLink(rs.Primary.ID) {
return fmt.Errorf("Spanner instance %s not found, found %s instead", rs.Primary.ID, fName)
}
*instance = *found
return nil
}
}
func testAccSpannerInstance_basic(name string) string {
return fmt.Sprintf(`
resource "google_spanner_instance" "basic" {
@ -336,18 +271,6 @@ resource "google_spanner_instance" "basic" {
`, name, name)
}
func testAccSpannerInstance_basicWithProject(project, name string) string {
return fmt.Sprintf(`
resource "google_spanner_instance" "basic" {
project = "%s"
name = "%s"
config = "regional-us-central1"
display_name = "%s-dname"
num_nodes = 1
}
`, project, name, name)
}
func testAccSpannerInstance_basicWithAutogenName(name string) string {
return fmt.Sprintf(`
resource "google_spanner_instance" "basic" {
@ -358,33 +281,7 @@ resource "google_spanner_instance" "basic" {
`, name)
}
func testAccSpannerInstance_duplicateNameError_part1(name string) string {
return fmt.Sprintf(`
resource "google_spanner_instance" "basic1" {
name = "%s"
config = "regional-us-central1"
display_name = "%s-dname"
num_nodes = 1
}
`, name, name)
}
func testAccSpannerInstance_duplicateNameError_part2(name string) string {
return fmt.Sprintf(`
%s
resource "google_spanner_instance" "basic2" {
name = "%s"
config = "regional-us-central1"
display_name = "%s-dname"
num_nodes = 1
}
`, testAccSpannerInstance_duplicateNameError_part1(name), name, name)
}
func testAccSpannerInstance_update(name string, nodes int, addLabel bool) string {
extraLabel := ""
if addLabel {
extraLabel = "\"key2\" = \"value2\""

1
google/resource_storage_bucket_test.go
View File

@ -565,7 +565,6 @@ func TestAccStorageBucket_encryption(t *testing.T) {
resource.TestStep{
Config: testAccStorageBucket_encryption(projectId, projectOrg, projectBillingAccount, keyRingName, cryptoKeyName, bucketName),
Check: resource.ComposeTestCheckFunc(
testAccCheckGoogleKmsCryptoKeyExists("google_kms_crypto_key.crypto_key"),
testAccCheckStorageBucketExists(
"google_storage_bucket.bucket", bucketName, &bucket),
),