github.com/nathanielks/terraform@v0.6.1-0.20170509030759-13e1a62319dc/builtin/providers/google/resource_compute_instance_template_test.go (about) 1 package google 2 3 import ( 4 "fmt" 5 "os" 6 "strings" 7 "testing" 8 9 "github.com/hashicorp/terraform/helper/acctest" 10 "github.com/hashicorp/terraform/helper/resource" 11 "github.com/hashicorp/terraform/terraform" 12 "google.golang.org/api/compute/v1" 13 ) 14 15 func TestAccComputeInstanceTemplate_basic(t *testing.T) { 16 var instanceTemplate compute.InstanceTemplate 17 18 resource.Test(t, resource.TestCase{ 19 PreCheck: func() { testAccPreCheck(t) }, 20 Providers: testAccProviders, 21 CheckDestroy: testAccCheckComputeInstanceTemplateDestroy, 22 Steps: []resource.TestStep{ 23 resource.TestStep{ 24 Config: testAccComputeInstanceTemplate_basic, 25 Check: resource.ComposeTestCheckFunc( 26 testAccCheckComputeInstanceTemplateExists( 27 "google_compute_instance_template.foobar", &instanceTemplate), 28 testAccCheckComputeInstanceTemplateTag(&instanceTemplate, "foo"), 29 testAccCheckComputeInstanceTemplateMetadata(&instanceTemplate, "foo", "bar"), 30 testAccCheckComputeInstanceTemplateDisk(&instanceTemplate, "projects/debian-cloud/global/images/debian-8-jessie-v20160803", true, true), 31 ), 32 }, 33 }, 34 }) 35 } 36 37 func TestAccComputeInstanceTemplate_IP(t *testing.T) { 38 var instanceTemplate compute.InstanceTemplate 39 40 resource.Test(t, resource.TestCase{ 41 PreCheck: func() { testAccPreCheck(t) }, 42 Providers: testAccProviders, 43 CheckDestroy: testAccCheckComputeInstanceTemplateDestroy, 44 Steps: []resource.TestStep{ 45 resource.TestStep{ 46 Config: testAccComputeInstanceTemplate_ip, 47 Check: resource.ComposeTestCheckFunc( 48 testAccCheckComputeInstanceTemplateExists( 49 "google_compute_instance_template.foobar", &instanceTemplate), 50 testAccCheckComputeInstanceTemplateNetwork(&instanceTemplate), 51 ), 52 }, 53 }, 54 }) 55 } 56 57 func TestAccComputeInstanceTemplate_networkIP(t *testing.T) { 58 var instanceTemplate compute.InstanceTemplate 59 networkIP := "10.128.0.2" 60 61 resource.Test(t, resource.TestCase{ 62 PreCheck: func() { testAccPreCheck(t) }, 63 Providers: testAccProviders, 64 CheckDestroy: testAccCheckComputeInstanceTemplateDestroy, 65 Steps: []resource.TestStep{ 66 resource.TestStep{ 67 Config: testAccComputeInstanceTemplate_networkIP(networkIP), 68 Check: resource.ComposeTestCheckFunc( 69 testAccCheckComputeInstanceTemplateExists( 70 "google_compute_instance_template.foobar", &instanceTemplate), 71 testAccCheckComputeInstanceTemplateNetwork(&instanceTemplate), 72 testAccCheckComputeInstanceTemplateNetworkIP( 73 "google_compute_instance_template.foobar", networkIP, &instanceTemplate), 74 ), 75 }, 76 }, 77 }) 78 } 79 80 func TestAccComputeInstanceTemplate_disks(t *testing.T) { 81 var instanceTemplate compute.InstanceTemplate 82 83 resource.Test(t, resource.TestCase{ 84 PreCheck: func() { testAccPreCheck(t) }, 85 Providers: testAccProviders, 86 CheckDestroy: testAccCheckComputeInstanceTemplateDestroy, 87 Steps: []resource.TestStep{ 88 resource.TestStep{ 89 Config: testAccComputeInstanceTemplate_disks, 90 Check: resource.ComposeTestCheckFunc( 91 testAccCheckComputeInstanceTemplateExists( 92 "google_compute_instance_template.foobar", &instanceTemplate), 93 testAccCheckComputeInstanceTemplateDisk(&instanceTemplate, "projects/debian-cloud/global/images/debian-8-jessie-v20160803", true, true), 94 testAccCheckComputeInstanceTemplateDisk(&instanceTemplate, "terraform-test-foobar", false, false), 95 ), 96 }, 97 }, 98 }) 99 } 100 101 func TestAccComputeInstanceTemplate_subnet_auto(t *testing.T) { 102 var instanceTemplate compute.InstanceTemplate 103 network := "network-" + acctest.RandString(10) 104 105 resource.Test(t, resource.TestCase{ 106 PreCheck: func() { testAccPreCheck(t) }, 107 Providers: testAccProviders, 108 CheckDestroy: testAccCheckComputeInstanceTemplateDestroy, 109 Steps: []resource.TestStep{ 110 resource.TestStep{ 111 Config: testAccComputeInstanceTemplate_subnet_auto(network), 112 Check: resource.ComposeTestCheckFunc( 113 testAccCheckComputeInstanceTemplateExists( 114 "google_compute_instance_template.foobar", &instanceTemplate), 115 testAccCheckComputeInstanceTemplateNetworkName(&instanceTemplate, network), 116 ), 117 }, 118 }, 119 }) 120 } 121 122 func TestAccComputeInstanceTemplate_subnet_custom(t *testing.T) { 123 var instanceTemplate compute.InstanceTemplate 124 125 resource.Test(t, resource.TestCase{ 126 PreCheck: func() { testAccPreCheck(t) }, 127 Providers: testAccProviders, 128 CheckDestroy: testAccCheckComputeInstanceTemplateDestroy, 129 Steps: []resource.TestStep{ 130 resource.TestStep{ 131 Config: testAccComputeInstanceTemplate_subnet_custom, 132 Check: resource.ComposeTestCheckFunc( 133 testAccCheckComputeInstanceTemplateExists( 134 "google_compute_instance_template.foobar", &instanceTemplate), 135 testAccCheckComputeInstanceTemplateSubnetwork(&instanceTemplate), 136 ), 137 }, 138 }, 139 }) 140 } 141 142 func TestAccComputeInstanceTemplate_subnet_xpn(t *testing.T) { 143 var instanceTemplate compute.InstanceTemplate 144 var xpn_host = os.Getenv("GOOGLE_XPN_HOST_PROJECT") 145 146 resource.Test(t, resource.TestCase{ 147 PreCheck: func() { testAccPreCheck(t) }, 148 Providers: testAccProviders, 149 CheckDestroy: testAccCheckComputeInstanceTemplateDestroy, 150 Steps: []resource.TestStep{ 151 resource.TestStep{ 152 Config: testAccComputeInstanceTemplate_subnet_xpn(xpn_host), 153 Check: resource.ComposeTestCheckFunc( 154 testAccCheckComputeInstanceTemplateExists( 155 "google_compute_instance_template.foobar", &instanceTemplate), 156 testAccCheckComputeInstanceTemplateSubnetwork(&instanceTemplate), 157 ), 158 }, 159 }, 160 }) 161 } 162 163 func TestAccComputeInstanceTemplate_metadata_startup_script(t *testing.T) { 164 var instanceTemplate compute.InstanceTemplate 165 166 resource.Test(t, resource.TestCase{ 167 PreCheck: func() { testAccPreCheck(t) }, 168 Providers: testAccProviders, 169 CheckDestroy: testAccCheckComputeInstanceTemplateDestroy, 170 Steps: []resource.TestStep{ 171 resource.TestStep{ 172 Config: testAccComputeInstanceTemplate_startup_script, 173 Check: resource.ComposeTestCheckFunc( 174 testAccCheckComputeInstanceTemplateExists( 175 "google_compute_instance_template.foobar", &instanceTemplate), 176 testAccCheckComputeInstanceTemplateStartupScript(&instanceTemplate, "echo 'Hello'"), 177 ), 178 }, 179 }, 180 }) 181 } 182 183 func testAccCheckComputeInstanceTemplateDestroy(s *terraform.State) error { 184 config := testAccProvider.Meta().(*Config) 185 186 for _, rs := range s.RootModule().Resources { 187 if rs.Type != "google_compute_instance_template" { 188 continue 189 } 190 191 _, err := config.clientCompute.InstanceTemplates.Get( 192 config.Project, rs.Primary.ID).Do() 193 if err == nil { 194 return fmt.Errorf("Instance template still exists") 195 } 196 } 197 198 return nil 199 } 200 201 func testAccCheckComputeInstanceTemplateExists(n string, instanceTemplate *compute.InstanceTemplate) resource.TestCheckFunc { 202 return func(s *terraform.State) error { 203 rs, ok := s.RootModule().Resources[n] 204 if !ok { 205 return fmt.Errorf("Not found: %s", n) 206 } 207 208 if rs.Primary.ID == "" { 209 return fmt.Errorf("No ID is set") 210 } 211 212 config := testAccProvider.Meta().(*Config) 213 214 found, err := config.clientCompute.InstanceTemplates.Get( 215 config.Project, rs.Primary.ID).Do() 216 if err != nil { 217 return err 218 } 219 220 if found.Name != rs.Primary.ID { 221 return fmt.Errorf("Instance template not found") 222 } 223 224 *instanceTemplate = *found 225 226 return nil 227 } 228 } 229 230 func testAccCheckComputeInstanceTemplateMetadata( 231 instanceTemplate *compute.InstanceTemplate, 232 k string, v string) resource.TestCheckFunc { 233 return func(s *terraform.State) error { 234 if instanceTemplate.Properties.Metadata == nil { 235 return fmt.Errorf("no metadata") 236 } 237 238 for _, item := range instanceTemplate.Properties.Metadata.Items { 239 if k != item.Key { 240 continue 241 } 242 243 if item.Value != nil && v == *item.Value { 244 return nil 245 } 246 247 return fmt.Errorf("bad value for %s: %s", k, *item.Value) 248 } 249 250 return fmt.Errorf("metadata not found: %s", k) 251 } 252 } 253 254 func testAccCheckComputeInstanceTemplateNetwork(instanceTemplate *compute.InstanceTemplate) resource.TestCheckFunc { 255 return func(s *terraform.State) error { 256 for _, i := range instanceTemplate.Properties.NetworkInterfaces { 257 for _, c := range i.AccessConfigs { 258 if c.NatIP == "" { 259 return fmt.Errorf("no NAT IP") 260 } 261 } 262 } 263 264 return nil 265 } 266 } 267 268 func testAccCheckComputeInstanceTemplateNetworkName(instanceTemplate *compute.InstanceTemplate, network string) resource.TestCheckFunc { 269 return func(s *terraform.State) error { 270 for _, i := range instanceTemplate.Properties.NetworkInterfaces { 271 if !strings.Contains(i.Network, network) { 272 return fmt.Errorf("Network doesn't match expected value, Expected: %s Actual: %s", network, i.Network[strings.LastIndex("/", i.Network)+1:]) 273 } 274 } 275 276 return nil 277 } 278 } 279 280 func testAccCheckComputeInstanceTemplateDisk(instanceTemplate *compute.InstanceTemplate, source string, delete bool, boot bool) resource.TestCheckFunc { 281 return func(s *terraform.State) error { 282 if instanceTemplate.Properties.Disks == nil { 283 return fmt.Errorf("no disks") 284 } 285 286 for _, disk := range instanceTemplate.Properties.Disks { 287 if disk.InitializeParams == nil { 288 // Check disk source 289 if disk.Source == source { 290 if disk.AutoDelete == delete && disk.Boot == boot { 291 return nil 292 } 293 } 294 } else { 295 // Check source image 296 if disk.InitializeParams.SourceImage == source { 297 if disk.AutoDelete == delete && disk.Boot == boot { 298 return nil 299 } 300 } 301 } 302 } 303 304 return fmt.Errorf("Disk not found: %s", source) 305 } 306 } 307 308 func testAccCheckComputeInstanceTemplateSubnetwork(instanceTemplate *compute.InstanceTemplate) resource.TestCheckFunc { 309 return func(s *terraform.State) error { 310 for _, i := range instanceTemplate.Properties.NetworkInterfaces { 311 if i.Subnetwork == "" { 312 return fmt.Errorf("no subnet") 313 } 314 } 315 316 return nil 317 } 318 } 319 320 func testAccCheckComputeInstanceTemplateTag(instanceTemplate *compute.InstanceTemplate, n string) resource.TestCheckFunc { 321 return func(s *terraform.State) error { 322 if instanceTemplate.Properties.Tags == nil { 323 return fmt.Errorf("no tags") 324 } 325 326 for _, k := range instanceTemplate.Properties.Tags.Items { 327 if k == n { 328 return nil 329 } 330 } 331 332 return fmt.Errorf("tag not found: %s", n) 333 } 334 } 335 336 func testAccCheckComputeInstanceTemplateStartupScript(instanceTemplate *compute.InstanceTemplate, n string) resource.TestCheckFunc { 337 return func(s *terraform.State) error { 338 if instanceTemplate.Properties.Metadata == nil && n == "" { 339 return nil 340 } else if instanceTemplate.Properties.Metadata == nil && n != "" { 341 return fmt.Errorf("Expected metadata.startup-script to be '%s', metadata wasn't set at all", n) 342 } 343 for _, item := range instanceTemplate.Properties.Metadata.Items { 344 if item.Key != "startup-script" { 345 continue 346 } 347 if item.Value != nil && *item.Value == n { 348 return nil 349 } else if item.Value == nil && n == "" { 350 return nil 351 } else if item.Value == nil && n != "" { 352 return fmt.Errorf("Expected metadata.startup-script to be '%s', wasn't set", n) 353 } else if *item.Value != n { 354 return fmt.Errorf("Expected metadata.startup-script to be '%s', got '%s'", n, *item.Value) 355 } 356 } 357 return fmt.Errorf("This should never be reached.") 358 } 359 } 360 361 func testAccCheckComputeInstanceTemplateNetworkIP(n, networkIP string, instanceTemplate *compute.InstanceTemplate) resource.TestCheckFunc { 362 return func(s *terraform.State) error { 363 ip := instanceTemplate.Properties.NetworkInterfaces[0].NetworkIP 364 err := resource.TestCheckResourceAttr(n, "network_interface.0.network_ip", ip)(s) 365 if err != nil { 366 return err 367 } 368 return resource.TestCheckResourceAttr(n, "network_interface.0.network_ip", networkIP)(s) 369 } 370 } 371 372 var testAccComputeInstanceTemplate_basic = fmt.Sprintf(` 373 resource "google_compute_instance_template" "foobar" { 374 name = "instancet-test-%s" 375 machine_type = "n1-standard-1" 376 can_ip_forward = false 377 tags = ["foo", "bar"] 378 379 disk { 380 source_image = "debian-8-jessie-v20160803" 381 auto_delete = true 382 boot = true 383 } 384 385 network_interface { 386 network = "default" 387 } 388 389 scheduling { 390 preemptible = false 391 automatic_restart = true 392 } 393 394 metadata { 395 foo = "bar" 396 } 397 398 service_account { 399 scopes = ["userinfo-email", "compute-ro", "storage-ro"] 400 } 401 }`, acctest.RandString(10)) 402 403 var testAccComputeInstanceTemplate_ip = fmt.Sprintf(` 404 resource "google_compute_address" "foo" { 405 name = "instancet-test-%s" 406 } 407 408 resource "google_compute_instance_template" "foobar" { 409 name = "instancet-test-%s" 410 machine_type = "n1-standard-1" 411 tags = ["foo", "bar"] 412 413 disk { 414 source_image = "debian-8-jessie-v20160803" 415 } 416 417 network_interface { 418 network = "default" 419 access_config { 420 nat_ip = "${google_compute_address.foo.address}" 421 } 422 } 423 424 metadata { 425 foo = "bar" 426 } 427 }`, acctest.RandString(10), acctest.RandString(10)) 428 429 func testAccComputeInstanceTemplate_networkIP(networkIP string) string { 430 return fmt.Sprintf(` 431 resource "google_compute_instance_template" "foobar" { 432 name = "instancet-test-%s" 433 machine_type = "n1-standard-1" 434 tags = ["foo", "bar"] 435 436 disk { 437 source_image = "debian-8-jessie-v20160803" 438 } 439 440 network_interface { 441 network = "default" 442 network_ip = "%s" 443 } 444 445 metadata { 446 foo = "bar" 447 } 448 }`, acctest.RandString(10), networkIP) 449 } 450 451 var testAccComputeInstanceTemplate_disks = fmt.Sprintf(` 452 resource "google_compute_disk" "foobar" { 453 name = "instancet-test-%s" 454 image = "debian-8-jessie-v20160803" 455 size = 10 456 type = "pd-ssd" 457 zone = "us-central1-a" 458 } 459 460 resource "google_compute_instance_template" "foobar" { 461 name = "instancet-test-%s" 462 machine_type = "n1-standard-1" 463 464 disk { 465 source_image = "debian-8-jessie-v20160803" 466 auto_delete = true 467 disk_size_gb = 100 468 boot = true 469 } 470 471 disk { 472 source = "terraform-test-foobar" 473 auto_delete = false 474 boot = false 475 } 476 477 network_interface { 478 network = "default" 479 } 480 481 metadata { 482 foo = "bar" 483 } 484 }`, acctest.RandString(10), acctest.RandString(10)) 485 486 func testAccComputeInstanceTemplate_subnet_auto(network string) string { 487 return fmt.Sprintf(` 488 resource "google_compute_network" "auto-network" { 489 name = "%s" 490 auto_create_subnetworks = true 491 } 492 493 resource "google_compute_instance_template" "foobar" { 494 name = "instance-tpl-%s" 495 machine_type = "n1-standard-1" 496 497 disk { 498 source_image = "debian-8-jessie-v20160803" 499 auto_delete = true 500 disk_size_gb = 10 501 boot = true 502 } 503 504 network_interface { 505 network = "${google_compute_network.auto-network.name}" 506 } 507 508 metadata { 509 foo = "bar" 510 } 511 }`, network, acctest.RandString(10)) 512 } 513 514 var testAccComputeInstanceTemplate_subnet_custom = fmt.Sprintf(` 515 resource "google_compute_network" "network" { 516 name = "network-%s" 517 auto_create_subnetworks = false 518 } 519 520 resource "google_compute_subnetwork" "subnetwork" { 521 name = "subnetwork-%s" 522 ip_cidr_range = "10.0.0.0/24" 523 region = "us-central1" 524 network = "${google_compute_network.network.self_link}" 525 } 526 527 resource "google_compute_instance_template" "foobar" { 528 name = "instance-test-%s" 529 machine_type = "n1-standard-1" 530 region = "us-central1" 531 532 disk { 533 source_image = "debian-8-jessie-v20160803" 534 auto_delete = true 535 disk_size_gb = 10 536 boot = true 537 } 538 539 network_interface { 540 subnetwork = "${google_compute_subnetwork.subnetwork.name}" 541 } 542 543 metadata { 544 foo = "bar" 545 } 546 }`, acctest.RandString(10), acctest.RandString(10), acctest.RandString(10)) 547 548 func testAccComputeInstanceTemplate_subnet_xpn(xpn_host string) string { 549 return fmt.Sprintf(` 550 resource "google_compute_network" "network" { 551 name = "network-%s" 552 auto_create_subnetworks = false 553 project = "%s" 554 } 555 556 resource "google_compute_subnetwork" "subnetwork" { 557 name = "subnetwork-%s" 558 ip_cidr_range = "10.0.0.0/24" 559 region = "us-central1" 560 network = "${google_compute_network.network.self_link}" 561 project = "%s" 562 } 563 564 resource "google_compute_instance_template" "foobar" { 565 name = "instance-test-%s" 566 machine_type = "n1-standard-1" 567 region = "us-central1" 568 569 disk { 570 source_image = "debian-8-jessie-v20160803" 571 auto_delete = true 572 disk_size_gb = 10 573 boot = true 574 } 575 576 network_interface { 577 subnetwork = "${google_compute_subnetwork.subnetwork.name}" 578 subnetwork_project = "${google_compute_subnetwork.subnetwork.project}" 579 } 580 581 metadata { 582 foo = "bar" 583 } 584 }`, acctest.RandString(10), xpn_host, acctest.RandString(10), xpn_host, acctest.RandString(10)) 585 } 586 587 var testAccComputeInstanceTemplate_startup_script = fmt.Sprintf(` 588 resource "google_compute_instance_template" "foobar" { 589 name = "instance-test-%s" 590 machine_type = "n1-standard-1" 591 592 disk { 593 source_image = "debian-8-jessie-v20160803" 594 auto_delete = true 595 disk_size_gb = 10 596 boot = true 597 } 598 599 metadata { 600 foo = "bar" 601 } 602 603 network_interface{ 604 network = "default" 605 } 606 607 metadata_startup_script = "echo 'Hello'" 608 }`, acctest.RandString(10))