Adding all the compute tests to magic modules

provider/terraform/tests/data_source_compute_lb_ip_ranges_test.go

@@ -0,0 +1,34 @@
+package google
+
+import (
+	"regexp"
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccDataSourceComputeLbIpRanges_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeLbIpRangesConfig,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestMatchResourceAttr("data.google_compute_lb_ip_ranges.some",
+						"network.#", regexp.MustCompile("^[1-9]+[0-9]*$")),
+					resource.TestMatchResourceAttr("data.google_compute_lb_ip_ranges.some",
+						"network.0", regexp.MustCompile("^[0-9./]+$")),
+					resource.TestMatchResourceAttr("data.google_compute_lb_ip_ranges.some",
+						"http_ssl_tcp_internal.#", regexp.MustCompile("^[1-9]+[0-9]*$")),
+					resource.TestMatchResourceAttr("data.google_compute_lb_ip_ranges.some",
+						"http_ssl_tcp_internal.0", regexp.MustCompile("^[0-9./]+$")),
+				),
+			},
+		},
+	})
+}
+
+const testAccComputeLbIpRangesConfig = `
+data "google_compute_lb_ip_ranges" "some" {}
+`

provider/terraform/tests/data_source_google_compute_address_test.go

@@ -0,0 +1,165 @@
+package google
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+func TestComputeAddressIdParsing(t *testing.T) {
+	cases := map[string]struct {
+		ImportId            string
+		ExpectedError       bool
+		ExpectedCanonicalId string
+		Config              *Config
+	}{
+		"id is a full self link": {
+			ImportId:            "https://www.googleapis.com/compute/v1/projects/test-project/regions/us-central1/addresses/test-address",
+			ExpectedError:       false,
+			ExpectedCanonicalId: "projects/test-project/regions/us-central1/addresses/test-address",
+		},
+		"id is a partial self link": {
+			ImportId:            "projects/test-project/regions/us-central1/addresses/test-address",
+			ExpectedError:       false,
+			ExpectedCanonicalId: "projects/test-project/regions/us-central1/addresses/test-address",
+		},
+		"id is project/region/address": {
+			ImportId:            "test-project/us-central1/test-address",
+			ExpectedError:       false,
+			ExpectedCanonicalId: "projects/test-project/regions/us-central1/addresses/test-address",
+		},
+		"id is region/address": {
+			ImportId:            "us-central1/test-address",
+			ExpectedError:       false,
+			ExpectedCanonicalId: "projects/default-project/regions/us-central1/addresses/test-address",
+			Config:              &Config{Project: "default-project"},
+		},
+		"id is address": {
+			ImportId:            "test-address",
+			ExpectedError:       false,
+			ExpectedCanonicalId: "projects/default-project/regions/us-east1/addresses/test-address",
+			Config:              &Config{Project: "default-project", Region: "us-east1"},
+		},
+		"id has invalid format": {
+			ImportId:      "i/n/v/a/l/i/d",
+			ExpectedError: true,
+		},
+	}
+
+	for tn, tc := range cases {
+		addressId, err := parseComputeAddressId(tc.ImportId, tc.Config)
+
+		if tc.ExpectedError && err == nil {
+			t.Fatalf("bad: %s, expected an error", tn)
+		}
+
+		if err != nil {
+			if tc.ExpectedError {
+				continue
+			}
+			t.Fatalf("bad: %s, err: %#v", tn, err)
+		}
+
+		if addressId.canonicalId() != tc.ExpectedCanonicalId {
+			t.Fatalf("bad: %s, expected canonical id to be `%s` but is `%s`", tn, tc.ExpectedCanonicalId, addressId.canonicalId())
+		}
+	}
+}
+
+func TestAccDataSourceComputeAddress(t *testing.T) {
+	t.Parallel()
+
+	rsName := "foobar"
+	rsFullName := fmt.Sprintf("google_compute_address.%s", rsName)
+	dsName := "my_address"
+	dsFullName := fmt.Sprintf("data.google_compute_address.%s", dsName)
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckDataSourceComputeAddressDestroy(rsFullName),
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccDataSourceComputeAddressConfig(rsName, dsName),
+				Check: resource.ComposeTestCheckFunc(
+					testAccDataSourceComputeAddressCheck(dsFullName, rsFullName),
+				),
+			},
+		},
+	})
+}
+
+func testAccDataSourceComputeAddressCheck(data_source_name string, resource_name string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		ds, ok := s.RootModule().Resources[data_source_name]
+		if !ok {
+			return fmt.Errorf("root module has no resource called %s", data_source_name)
+		}
+
+		rs, ok := s.RootModule().Resources[resource_name]
+		if !ok {
+			return fmt.Errorf("can't find %s in state", resource_name)
+		}
+
+		ds_attr := ds.Primary.Attributes
+		rs_attr := rs.Primary.Attributes
+
+		address_attrs_to_test := []string{
+			"self_link",
+			"name",
+			"address",
+		}
+
+		for _, attr_to_check := range address_attrs_to_test {
+			if ds_attr[attr_to_check] != rs_attr[attr_to_check] {
+				return fmt.Errorf(
+					"%s is %s; want %s",
+					attr_to_check,
+					ds_attr[attr_to_check],
+					rs_attr[attr_to_check],
+				)
+			}
+		}
+
+		if ds_attr["status"] != "RESERVED" {
+			return fmt.Errorf("status is %s; want RESERVED", ds_attr["status"])
+		}
+
+		return nil
+	}
+}
+
+func testAccCheckDataSourceComputeAddressDestroy(resource_name string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		config := testAccProvider.Meta().(*Config)
+
+		rs, ok := s.RootModule().Resources[resource_name]
+		if !ok {
+			return fmt.Errorf("can't find %s in state", resource_name)
+		}
+
+		addressId, err := parseComputeAddressId(rs.Primary.ID, nil)
+
+		_, err = config.clientCompute.Addresses.Get(
+			config.Project, addressId.Region, addressId.Name).Do()
+		if err == nil {
+			return fmt.Errorf("Address still exists")
+		}
+
+		return nil
+	}
+}
+
+func testAccDataSourceComputeAddressConfig(rsName, dsName string) string {
+	return fmt.Sprintf(`
+resource "google_compute_address" "%s" {
+	name = "address-test"
+}
+
+data "google_compute_address" "%s" {
+	name = "${google_compute_address.%s.name}"
+}
+`, rsName, dsName, rsName)
+}

provider/terraform/tests/data_source_google_compute_backend_service_test.go

@@ -0,0 +1,85 @@
+package google
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/acctest"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+func TestAccDataSourceComputeBackendService_basic(t *testing.T) {
+	t.Parallel()
+
+	serviceName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
+	checkName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeBackendServiceDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccDataSourceComputeBackendService_basic(serviceName, checkName),
+				Check:  testAccDataSourceComputeBackendServiceCheck("data.google_compute_backend_service.baz", "google_compute_backend_service.foobar"),
+			},
+		},
+	})
+}
+
+func testAccDataSourceComputeBackendServiceCheck(dsName, rsName string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[rsName]
+		if !ok {
+			return fmt.Errorf("can't find resource called %s in state", rsName)
+		}
+
+		ds, ok := s.RootModule().Resources[dsName]
+		if !ok {
+			return fmt.Errorf("can't find data source called %s in state", dsName)
+		}
+
+		dsAttr := ds.Primary.Attributes
+		rsAttr := rs.Primary.Attributes
+
+		attrsToTest := []string{
+			"id",
+			"name",
+			"description",
+			"self_link",
+			"fingerprint",
+			"port_name",
+			"protocol",
+		}
+
+		for _, attrToTest := range attrsToTest {
+			if dsAttr[attrToTest] != rsAttr[attrToTest] {
+				return fmt.Errorf("%s is %s; want %s", attrToTest, dsAttr[attrToTest], rsAttr[attrToTest])
+			}
+		}
+
+		return nil
+	}
+}
+
+func testAccDataSourceComputeBackendService_basic(serviceName, checkName string) string {
+	return fmt.Sprintf(`
+resource "google_compute_backend_service" "foobar" {
+  name          = "%s"
+  description   = "foobar backend service"
+  health_checks = ["${google_compute_http_health_check.zero.self_link}"]
+}
+
+resource "google_compute_http_health_check" "zero" {
+  name               = "%s"
+  request_path       = "/"
+  check_interval_sec = 1
+  timeout_sec        = 1
+}
+
+data "google_compute_backend_service" "baz" {
+  name = "${google_compute_backend_service.foobar.name}"
+}
+`, serviceName, checkName)
+}

provider/terraform/tests/data_source_google_compute_default_service_account_test.go

@@ -0,0 +1,31 @@
+package google
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccDataSourceGoogleComputeDefaultServiceAccount_basic(t *testing.T) {
+	t.Parallel()
+
+	resourceName := "data.google_compute_default_service_account.default"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCheckGoogleComputeDefaultServiceAccount_basic,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttrSet(resourceName, "id"),
+					resource.TestCheckResourceAttrSet(resourceName, "email"),
+				),
+			},
+		},
+	})
+}
+
+const testAccCheckGoogleComputeDefaultServiceAccount_basic = `
+data "google_compute_default_service_account" "default" { }
+`