github.com/koding/terraform@v0.6.4-0.20170608090606-5d7e0339779d/builtin/providers/google/resource_compute_backend_service_test.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/hashicorp/terraform/helper/acctest"
     8  	"github.com/hashicorp/terraform/helper/resource"
     9  	"github.com/hashicorp/terraform/terraform"
    10  	"google.golang.org/api/compute/v1"
    11  )
    12  
    13  func TestAccComputeBackendService_basic(t *testing.T) {
    14  	serviceName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
    15  	checkName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
    16  	extraCheckName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
    17  	var svc compute.BackendService
    18  
    19  	resource.Test(t, resource.TestCase{
    20  		PreCheck:     func() { testAccPreCheck(t) },
    21  		Providers:    testAccProviders,
    22  		CheckDestroy: testAccCheckComputeBackendServiceDestroy,
    23  		Steps: []resource.TestStep{
    24  			resource.TestStep{
    25  				Config: testAccComputeBackendService_basic(serviceName, checkName),
    26  				Check: resource.ComposeTestCheckFunc(
    27  					testAccCheckComputeBackendServiceExists(
    28  						"google_compute_backend_service.foobar", &svc),
    29  				),
    30  			},
    31  			resource.TestStep{
    32  				Config: testAccComputeBackendService_basicModified(
    33  					serviceName, checkName, extraCheckName),
    34  				Check: resource.ComposeTestCheckFunc(
    35  					testAccCheckComputeBackendServiceExists(
    36  						"google_compute_backend_service.foobar", &svc),
    37  				),
    38  			},
    39  		},
    40  	})
    41  }
    42  
    43  func TestAccComputeBackendService_withBackend(t *testing.T) {
    44  	serviceName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
    45  	igName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
    46  	itName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
    47  	checkName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
    48  	var svc compute.BackendService
    49  	resource.Test(t, resource.TestCase{
    50  		PreCheck:     func() { testAccPreCheck(t) },
    51  		Providers:    testAccProviders,
    52  		CheckDestroy: testAccCheckComputeBackendServiceDestroy,
    53  		Steps: []resource.TestStep{
    54  			resource.TestStep{
    55  				Config: testAccComputeBackendService_withBackend(
    56  					serviceName, igName, itName, checkName, 10),
    57  				Check: resource.ComposeTestCheckFunc(
    58  					testAccCheckComputeBackendServiceExists(
    59  						"google_compute_backend_service.lipsum", &svc),
    60  				),
    61  			},
    62  		},
    63  	})
    64  
    65  	if svc.TimeoutSec != 10 {
    66  		t.Errorf("Expected TimeoutSec == 10, got %d", svc.TimeoutSec)
    67  	}
    68  	if svc.Protocol != "HTTP" {
    69  		t.Errorf("Expected Protocol to be HTTP, got %q", svc.Protocol)
    70  	}
    71  	if len(svc.Backends) != 1 {
    72  		t.Errorf("Expected 1 backend, got %d", len(svc.Backends))
    73  	}
    74  }
    75  
    76  func TestAccComputeBackendService_withBackendAndUpdate(t *testing.T) {
    77  	serviceName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
    78  	igName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
    79  	itName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
    80  	checkName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
    81  	var svc compute.BackendService
    82  	resource.Test(t, resource.TestCase{
    83  		PreCheck:     func() { testAccPreCheck(t) },
    84  		Providers:    testAccProviders,
    85  		CheckDestroy: testAccCheckComputeBackendServiceDestroy,
    86  		Steps: []resource.TestStep{
    87  			resource.TestStep{
    88  				Config: testAccComputeBackendService_withBackend(
    89  					serviceName, igName, itName, checkName, 10),
    90  				Check: resource.ComposeTestCheckFunc(
    91  					testAccCheckComputeBackendServiceExists(
    92  						"google_compute_backend_service.lipsum", &svc),
    93  				),
    94  			},
    95  			resource.TestStep{
    96  				Config: testAccComputeBackendService_withBackend(
    97  					serviceName, igName, itName, checkName, 20),
    98  				Check: resource.ComposeTestCheckFunc(
    99  					testAccCheckComputeBackendServiceExists(
   100  						"google_compute_backend_service.lipsum", &svc),
   101  				),
   102  			},
   103  		},
   104  	})
   105  
   106  	if svc.TimeoutSec != 20 {
   107  		t.Errorf("Expected TimeoutSec == 20, got %d", svc.TimeoutSec)
   108  	}
   109  	if svc.Protocol != "HTTP" {
   110  		t.Errorf("Expected Protocol to be HTTP, got %q", svc.Protocol)
   111  	}
   112  	if len(svc.Backends) != 1 {
   113  		t.Errorf("Expected 1 backend, got %d", len(svc.Backends))
   114  	}
   115  }
   116  
   117  func TestAccComputeBackendService_withConnectionDraining(t *testing.T) {
   118  	serviceName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
   119  	checkName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
   120  	var svc compute.BackendService
   121  
   122  	resource.Test(t, resource.TestCase{
   123  		PreCheck:     func() { testAccPreCheck(t) },
   124  		Providers:    testAccProviders,
   125  		CheckDestroy: testAccCheckComputeBackendServiceDestroy,
   126  		Steps: []resource.TestStep{
   127  			resource.TestStep{
   128  				Config: testAccComputeBackendService_withConnectionDraining(serviceName, checkName, 10),
   129  				Check: resource.ComposeTestCheckFunc(
   130  					testAccCheckComputeBackendServiceExists(
   131  						"google_compute_backend_service.foobar", &svc),
   132  				),
   133  			},
   134  		},
   135  	})
   136  
   137  	if svc.ConnectionDraining.DrainingTimeoutSec != 10 {
   138  		t.Errorf("Expected ConnectionDraining.DrainingTimeoutSec == 10, got %d", svc.ConnectionDraining.DrainingTimeoutSec)
   139  	}
   140  }
   141  
   142  func TestAccComputeBackendService_withConnectionDrainingAndUpdate(t *testing.T) {
   143  	serviceName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
   144  	checkName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
   145  	var svc compute.BackendService
   146  
   147  	resource.Test(t, resource.TestCase{
   148  		PreCheck:     func() { testAccPreCheck(t) },
   149  		Providers:    testAccProviders,
   150  		CheckDestroy: testAccCheckComputeBackendServiceDestroy,
   151  		Steps: []resource.TestStep{
   152  			resource.TestStep{
   153  				Config: testAccComputeBackendService_withConnectionDraining(serviceName, checkName, 10),
   154  				Check: resource.ComposeTestCheckFunc(
   155  					testAccCheckComputeBackendServiceExists(
   156  						"google_compute_backend_service.foobar", &svc),
   157  				),
   158  			},
   159  			resource.TestStep{
   160  				Config: testAccComputeBackendService_basic(serviceName, checkName),
   161  				Check: resource.ComposeTestCheckFunc(
   162  					testAccCheckComputeBackendServiceExists(
   163  						"google_compute_backend_service.foobar", &svc),
   164  				),
   165  			},
   166  		},
   167  	})
   168  
   169  	if svc.ConnectionDraining.DrainingTimeoutSec != 0 {
   170  		t.Errorf("Expected ConnectionDraining.DrainingTimeoutSec == 0, got %d", svc.ConnectionDraining.DrainingTimeoutSec)
   171  	}
   172  }
   173  
   174  func testAccCheckComputeBackendServiceDestroy(s *terraform.State) error {
   175  	config := testAccProvider.Meta().(*Config)
   176  
   177  	for _, rs := range s.RootModule().Resources {
   178  		if rs.Type != "google_compute_backend_service" {
   179  			continue
   180  		}
   181  
   182  		_, err := config.clientCompute.BackendServices.Get(
   183  			config.Project, rs.Primary.ID).Do()
   184  		if err == nil {
   185  			return fmt.Errorf("Backend service %s still exists", rs.Primary.ID)
   186  		}
   187  	}
   188  
   189  	return nil
   190  }
   191  
   192  func testAccCheckComputeBackendServiceExists(n string, svc *compute.BackendService) resource.TestCheckFunc {
   193  	return func(s *terraform.State) error {
   194  		rs, ok := s.RootModule().Resources[n]
   195  		if !ok {
   196  			return fmt.Errorf("Not found: %s", n)
   197  		}
   198  
   199  		if rs.Primary.ID == "" {
   200  			return fmt.Errorf("No ID is set")
   201  		}
   202  
   203  		config := testAccProvider.Meta().(*Config)
   204  
   205  		found, err := config.clientCompute.BackendServices.Get(
   206  			config.Project, rs.Primary.ID).Do()
   207  		if err != nil {
   208  			return err
   209  		}
   210  
   211  		if found.Name != rs.Primary.ID {
   212  			return fmt.Errorf("Backend service %s not found", rs.Primary.ID)
   213  		}
   214  
   215  		*svc = *found
   216  
   217  		return nil
   218  	}
   219  }
   220  
   221  func TestAccComputeBackendService_withCDNEnabled(t *testing.T) {
   222  	serviceName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
   223  	checkName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
   224  	var svc compute.BackendService
   225  
   226  	resource.Test(t, resource.TestCase{
   227  		PreCheck:     func() { testAccPreCheck(t) },
   228  		Providers:    testAccProviders,
   229  		CheckDestroy: testAccCheckComputeBackendServiceDestroy,
   230  		Steps: []resource.TestStep{
   231  			resource.TestStep{
   232  				Config: testAccComputeBackendService_withCDNEnabled(
   233  					serviceName, checkName),
   234  				Check: resource.ComposeTestCheckFunc(
   235  					testAccCheckComputeBackendServiceExists(
   236  						"google_compute_backend_service.foobar", &svc),
   237  				),
   238  			},
   239  		},
   240  	})
   241  
   242  	if svc.EnableCDN != true {
   243  		t.Errorf("Expected EnableCDN == true, got %t", svc.EnableCDN)
   244  	}
   245  }
   246  
   247  func TestAccComputeBackendService_withSessionAffinity(t *testing.T) {
   248  	serviceName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
   249  	checkName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
   250  	var svc compute.BackendService
   251  
   252  	resource.Test(t, resource.TestCase{
   253  		PreCheck:     func() { testAccPreCheck(t) },
   254  		Providers:    testAccProviders,
   255  		CheckDestroy: testAccCheckComputeBackendServiceDestroy,
   256  		Steps: []resource.TestStep{
   257  			resource.TestStep{
   258  				Config: testAccComputeBackendService_withSessionAffinity(
   259  					serviceName, checkName, "CLIENT_IP"),
   260  				Check: resource.ComposeTestCheckFunc(
   261  					testAccCheckComputeBackendServiceExists(
   262  						"google_compute_backend_service.foobar", &svc),
   263  				),
   264  			},
   265  			resource.TestStep{
   266  				Config: testAccComputeBackendService_withSessionAffinity(
   267  					serviceName, checkName, "GENERATED_COOKIE"),
   268  				Check: resource.ComposeTestCheckFunc(
   269  					testAccCheckComputeBackendServiceExists(
   270  						"google_compute_backend_service.foobar", &svc),
   271  				),
   272  			},
   273  		},
   274  	})
   275  
   276  	if svc.SessionAffinity != "GENERATED_COOKIE" {
   277  		t.Errorf("Expected SessionAffinity == \"GENERATED_COOKIE\", got %s", svc.SessionAffinity)
   278  	}
   279  }
   280  
   281  func testAccComputeBackendService_basic(serviceName, checkName string) string {
   282  	return fmt.Sprintf(`
   283  resource "google_compute_backend_service" "foobar" {
   284    name          = "%s"
   285    health_checks = ["${google_compute_http_health_check.zero.self_link}"]
   286  }
   287  
   288  resource "google_compute_http_health_check" "zero" {
   289    name               = "%s"
   290    request_path       = "/"
   291    check_interval_sec = 1
   292    timeout_sec        = 1
   293  }
   294  `, serviceName, checkName)
   295  }
   296  
   297  func testAccComputeBackendService_withCDNEnabled(serviceName, checkName string) string {
   298  	return fmt.Sprintf(`
   299  resource "google_compute_backend_service" "foobar" {
   300    name          = "%s"
   301    health_checks = ["${google_compute_http_health_check.zero.self_link}"]
   302    enable_cdn    = true
   303  }
   304  
   305  resource "google_compute_http_health_check" "zero" {
   306    name               = "%s"
   307    request_path       = "/"
   308    check_interval_sec = 1
   309    timeout_sec        = 1
   310  }
   311  `, serviceName, checkName)
   312  }
   313  
   314  func testAccComputeBackendService_basicModified(serviceName, checkOne, checkTwo string) string {
   315  	return fmt.Sprintf(`
   316  resource "google_compute_backend_service" "foobar" {
   317      name = "%s"
   318      health_checks = ["${google_compute_http_health_check.one.self_link}"]
   319  }
   320  
   321  resource "google_compute_http_health_check" "zero" {
   322      name = "%s"
   323      request_path = "/"
   324      check_interval_sec = 1
   325      timeout_sec = 1
   326  }
   327  
   328  resource "google_compute_http_health_check" "one" {
   329      name = "%s"
   330      request_path = "/one"
   331      check_interval_sec = 30
   332      timeout_sec = 30
   333  }
   334  `, serviceName, checkOne, checkTwo)
   335  }
   336  
   337  func testAccComputeBackendService_withBackend(
   338  	serviceName, igName, itName, checkName string, timeout int64) string {
   339  	return fmt.Sprintf(`
   340  resource "google_compute_backend_service" "lipsum" {
   341    name        = "%s"
   342    description = "Hello World 1234"
   343    port_name   = "http"
   344    protocol    = "HTTP"
   345    timeout_sec = %v
   346  
   347    backend {
   348      group = "${google_compute_instance_group_manager.foobar.instance_group}"
   349    }
   350  
   351    health_checks = ["${google_compute_http_health_check.default.self_link}"]
   352  }
   353  
   354  resource "google_compute_instance_group_manager" "foobar" {
   355    name               = "%s"
   356    instance_template  = "${google_compute_instance_template.foobar.self_link}"
   357    base_instance_name = "foobar"
   358    zone               = "us-central1-f"
   359    target_size        = 1
   360  }
   361  
   362  resource "google_compute_instance_template" "foobar" {
   363    name         = "%s"
   364    machine_type = "n1-standard-1"
   365  
   366    network_interface {
   367      network = "default"
   368    }
   369  
   370    disk {
   371      source_image = "debian-8-jessie-v20160803"
   372      auto_delete  = true
   373      boot         = true
   374    }
   375  }
   376  
   377  resource "google_compute_http_health_check" "default" {
   378    name               = "%s"
   379    request_path       = "/"
   380    check_interval_sec = 1
   381    timeout_sec        = 1
   382  }
   383  `, serviceName, timeout, igName, itName, checkName)
   384  }
   385  
   386  func testAccComputeBackendService_withSessionAffinity(serviceName, checkName, affinityName string) string {
   387  	return fmt.Sprintf(`
   388  resource "google_compute_backend_service" "foobar" {
   389    name             = "%s"
   390    health_checks    = ["${google_compute_http_health_check.zero.self_link}"]
   391    session_affinity = "%s"
   392  }
   393  
   394  resource "google_compute_http_health_check" "zero" {
   395    name               = "%s"
   396    request_path       = "/"
   397    check_interval_sec = 1
   398    timeout_sec        = 1
   399  }
   400  `, serviceName, affinityName, checkName)
   401  }
   402  
   403  func testAccComputeBackendService_withConnectionDraining(serviceName, checkName string, drainingTimeout int64) string {
   404  	return fmt.Sprintf(`
   405  resource "google_compute_backend_service" "foobar" {
   406    name          = "%s"
   407    health_checks = ["${google_compute_http_health_check.zero.self_link}"]
   408    connection_draining_timeout_sec = %v
   409  }
   410  
   411  resource "google_compute_http_health_check" "zero" {
   412    name               = "%s"
   413    request_path       = "/"
   414    check_interval_sec = 1
   415    timeout_sec        = 1
   416  }
   417  `, serviceName, drainingTimeout, checkName)
   418  }