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 }