github.com/jrasell/terraform@v0.6.17-0.20160523115548-2652f5232949/builtin/providers/vsphere/resource_vsphere_virtual_machine_test.go (about) 1 package vsphere 2 3 import ( 4 "fmt" 5 "os" 6 "testing" 7 8 "github.com/hashicorp/terraform/helper/resource" 9 "github.com/hashicorp/terraform/terraform" 10 "github.com/vmware/govmomi" 11 "github.com/vmware/govmomi/find" 12 "github.com/vmware/govmomi/object" 13 "github.com/vmware/govmomi/property" 14 "github.com/vmware/govmomi/vim25/mo" 15 "github.com/vmware/govmomi/vim25/types" 16 "golang.org/x/net/context" 17 ) 18 19 func TestAccVSphereVirtualMachine_basic(t *testing.T) { 20 var vm virtualMachine 21 var locationOpt string 22 var datastoreOpt string 23 24 if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { 25 locationOpt += fmt.Sprintf(" datacenter = \"%s\"\n", v) 26 } 27 if v := os.Getenv("VSPHERE_CLUSTER"); v != "" { 28 locationOpt += fmt.Sprintf(" cluster = \"%s\"\n", v) 29 } 30 if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" { 31 locationOpt += fmt.Sprintf(" resource_pool = \"%s\"\n", v) 32 } 33 if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { 34 datastoreOpt = fmt.Sprintf(" datastore = \"%s\"\n", v) 35 } 36 template := os.Getenv("VSPHERE_TEMPLATE") 37 gateway := os.Getenv("VSPHERE_IPV4_GATEWAY") 38 label := os.Getenv("VSPHERE_NETWORK_LABEL") 39 ip_address := os.Getenv("VSPHERE_IPV4_ADDRESS") 40 41 resource.Test(t, resource.TestCase{ 42 PreCheck: func() { testAccPreCheck(t) }, 43 Providers: testAccProviders, 44 CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, 45 Steps: []resource.TestStep{ 46 resource.TestStep{ 47 Config: fmt.Sprintf( 48 testAccCheckVSphereVirtualMachineConfig_basic, 49 locationOpt, 50 gateway, 51 label, 52 ip_address, 53 gateway, 54 datastoreOpt, 55 template, 56 ), 57 Check: resource.ComposeTestCheckFunc( 58 testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.foo", &vm), 59 resource.TestCheckResourceAttr( 60 "vsphere_virtual_machine.foo", "name", "terraform-test"), 61 resource.TestCheckResourceAttr( 62 "vsphere_virtual_machine.foo", "vcpu", "2"), 63 resource.TestCheckResourceAttr( 64 "vsphere_virtual_machine.foo", "memory", "4096"), 65 resource.TestCheckResourceAttr( 66 "vsphere_virtual_machine.foo", "memory_reservation", "4096"), 67 resource.TestCheckResourceAttr( 68 "vsphere_virtual_machine.foo", "disk.#", "2"), 69 resource.TestCheckResourceAttr( 70 "vsphere_virtual_machine.foo", "disk.0.template", template), 71 resource.TestCheckResourceAttr( 72 "vsphere_virtual_machine.foo", "network_interface.#", "1"), 73 resource.TestCheckResourceAttr( 74 "vsphere_virtual_machine.foo", "network_interface.0.label", label), 75 ), 76 }, 77 }, 78 }) 79 } 80 81 func TestAccVSphereVirtualMachine_diskInitType(t *testing.T) { 82 var vm virtualMachine 83 var locationOpt string 84 var datastoreOpt string 85 86 if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { 87 locationOpt += fmt.Sprintf(" datacenter = \"%s\"\n", v) 88 } 89 if v := os.Getenv("VSPHERE_CLUSTER"); v != "" { 90 locationOpt += fmt.Sprintf(" cluster = \"%s\"\n", v) 91 } 92 if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" { 93 locationOpt += fmt.Sprintf(" resource_pool = \"%s\"\n", v) 94 } 95 if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { 96 datastoreOpt = fmt.Sprintf(" datastore = \"%s\"\n", v) 97 } 98 template := os.Getenv("VSPHERE_TEMPLATE") 99 gateway := os.Getenv("VSPHERE_IPV4_GATEWAY") 100 label := os.Getenv("VSPHERE_NETWORK_LABEL") 101 ip_address := os.Getenv("VSPHERE_IPV4_ADDRESS") 102 103 resource.Test(t, resource.TestCase{ 104 PreCheck: func() { testAccPreCheck(t) }, 105 Providers: testAccProviders, 106 CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, 107 Steps: []resource.TestStep{ 108 resource.TestStep{ 109 Config: fmt.Sprintf( 110 testAccCheckVSphereVirtualMachineConfig_initType, 111 locationOpt, 112 gateway, 113 label, 114 ip_address, 115 gateway, 116 datastoreOpt, 117 template, 118 ), 119 Check: resource.ComposeTestCheckFunc( 120 testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.thin", &vm), 121 resource.TestCheckResourceAttr( 122 "vsphere_virtual_machine.thin", "name", "terraform-test"), 123 resource.TestCheckResourceAttr( 124 "vsphere_virtual_machine.thin", "vcpu", "2"), 125 resource.TestCheckResourceAttr( 126 "vsphere_virtual_machine.thin", "memory", "4096"), 127 resource.TestCheckResourceAttr( 128 "vsphere_virtual_machine.thin", "disk.#", "3"), 129 resource.TestCheckResourceAttr( 130 "vsphere_virtual_machine.thin", "disk.0.template", template), 131 resource.TestCheckResourceAttr( 132 "vsphere_virtual_machine.thin", "disk.0.type", "thin"), 133 resource.TestCheckResourceAttr( 134 "vsphere_virtual_machine.thin", "disk.1.type", "eager_zeroed"), 135 resource.TestCheckResourceAttr( 136 "vsphere_virtual_machine.thin", "disk.1.controller_type", "scsi"), 137 resource.TestCheckResourceAttr( 138 "vsphere_virtual_machine.thin", "disk.2.controller_type", "ide"), 139 resource.TestCheckResourceAttr( 140 "vsphere_virtual_machine.thin", "network_interface.#", "1"), 141 resource.TestCheckResourceAttr( 142 "vsphere_virtual_machine.thin", "network_interface.0.label", label), 143 ), 144 }, 145 }, 146 }) 147 } 148 149 func TestAccVSphereVirtualMachine_dhcp(t *testing.T) { 150 var vm virtualMachine 151 var locationOpt string 152 var datastoreOpt string 153 154 if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { 155 locationOpt += fmt.Sprintf(" datacenter = \"%s\"\n", v) 156 } 157 if v := os.Getenv("VSPHERE_CLUSTER"); v != "" { 158 locationOpt += fmt.Sprintf(" cluster = \"%s\"\n", v) 159 } 160 if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" { 161 locationOpt += fmt.Sprintf(" resource_pool = \"%s\"\n", v) 162 } 163 if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { 164 datastoreOpt = fmt.Sprintf(" datastore = \"%s\"\n", v) 165 } 166 template := os.Getenv("VSPHERE_TEMPLATE") 167 label := os.Getenv("VSPHERE_NETWORK_LABEL_DHCP") 168 169 resource.Test(t, resource.TestCase{ 170 PreCheck: func() { testAccPreCheck(t) }, 171 Providers: testAccProviders, 172 CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, 173 Steps: []resource.TestStep{ 174 resource.TestStep{ 175 Config: fmt.Sprintf( 176 testAccCheckVSphereVirtualMachineConfig_dhcp, 177 locationOpt, 178 label, 179 datastoreOpt, 180 template, 181 ), 182 Check: resource.ComposeTestCheckFunc( 183 testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.bar", &vm), 184 resource.TestCheckResourceAttr( 185 "vsphere_virtual_machine.bar", "name", "terraform-test"), 186 resource.TestCheckResourceAttr( 187 "vsphere_virtual_machine.bar", "vcpu", "2"), 188 resource.TestCheckResourceAttr( 189 "vsphere_virtual_machine.bar", "memory", "4096"), 190 resource.TestCheckResourceAttr( 191 "vsphere_virtual_machine.bar", "disk.#", "1"), 192 resource.TestCheckResourceAttr( 193 "vsphere_virtual_machine.bar", "disk.0.template", template), 194 resource.TestCheckResourceAttr( 195 "vsphere_virtual_machine.bar", "network_interface.#", "1"), 196 resource.TestCheckResourceAttr( 197 "vsphere_virtual_machine.bar", "network_interface.0.label", label), 198 ), 199 }, 200 }, 201 }) 202 } 203 204 func TestAccVSphereVirtualMachine_custom_configs(t *testing.T) { 205 var vm virtualMachine 206 var locationOpt string 207 var datastoreOpt string 208 209 if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { 210 locationOpt += fmt.Sprintf(" datacenter = \"%s\"\n", v) 211 } 212 if v := os.Getenv("VSPHERE_CLUSTER"); v != "" { 213 locationOpt += fmt.Sprintf(" cluster = \"%s\"\n", v) 214 } 215 if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" { 216 locationOpt += fmt.Sprintf(" resource_pool = \"%s\"\n", v) 217 } 218 if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { 219 datastoreOpt = fmt.Sprintf(" datastore = \"%s\"\n", v) 220 } 221 template := os.Getenv("VSPHERE_TEMPLATE") 222 label := os.Getenv("VSPHERE_NETWORK_LABEL_DHCP") 223 224 resource.Test(t, resource.TestCase{ 225 PreCheck: func() { testAccPreCheck(t) }, 226 Providers: testAccProviders, 227 CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, 228 Steps: []resource.TestStep{ 229 resource.TestStep{ 230 Config: fmt.Sprintf( 231 testAccCheckVSphereVirtualMachineConfig_custom_configs, 232 locationOpt, 233 label, 234 datastoreOpt, 235 template, 236 ), 237 Check: resource.ComposeTestCheckFunc( 238 testAccCheckVSphereVirtualMachineExistsHasCustomConfig("vsphere_virtual_machine.car", &vm), 239 resource.TestCheckResourceAttr( 240 "vsphere_virtual_machine.car", "name", "terraform-test-custom"), 241 resource.TestCheckResourceAttr( 242 "vsphere_virtual_machine.car", "vcpu", "2"), 243 resource.TestCheckResourceAttr( 244 "vsphere_virtual_machine.car", "memory", "4096"), 245 resource.TestCheckResourceAttr( 246 "vsphere_virtual_machine.car", "disk.#", "1"), 247 resource.TestCheckResourceAttr( 248 "vsphere_virtual_machine.car", "disk.0.template", template), 249 resource.TestCheckResourceAttr( 250 "vsphere_virtual_machine.car", "network_interface.#", "1"), 251 resource.TestCheckResourceAttr( 252 "vsphere_virtual_machine.car", "custom_configuration_parameters.foo", "bar"), 253 resource.TestCheckResourceAttr( 254 "vsphere_virtual_machine.car", "custom_configuration_parameters.car", "ferrari"), 255 resource.TestCheckResourceAttr( 256 "vsphere_virtual_machine.car", "custom_configuration_parameters.num", "42"), 257 resource.TestCheckResourceAttr( 258 "vsphere_virtual_machine.car", "network_interface.0.label", label), 259 ), 260 }, 261 }, 262 }) 263 } 264 265 func TestAccVSphereVirtualMachine_createInExistingFolder(t *testing.T) { 266 var vm virtualMachine 267 var locationOpt string 268 var datastoreOpt string 269 var datacenter string 270 271 folder := "tf_test_createInExistingFolder" 272 273 if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { 274 locationOpt += fmt.Sprintf(" datacenter = \"%s\"\n", v) 275 datacenter = v 276 } 277 if v := os.Getenv("VSPHERE_CLUSTER"); v != "" { 278 locationOpt += fmt.Sprintf(" cluster = \"%s\"\n", v) 279 } 280 if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" { 281 locationOpt += fmt.Sprintf(" resource_pool = \"%s\"\n", v) 282 } 283 if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { 284 datastoreOpt = fmt.Sprintf(" datastore = \"%s\"\n", v) 285 } 286 template := os.Getenv("VSPHERE_TEMPLATE") 287 label := os.Getenv("VSPHERE_NETWORK_LABEL_DHCP") 288 289 resource.Test(t, resource.TestCase{ 290 PreCheck: func() { testAccPreCheck(t) }, 291 Providers: testAccProviders, 292 CheckDestroy: resource.ComposeTestCheckFunc( 293 testAccCheckVSphereVirtualMachineDestroy, 294 removeVSphereFolder(datacenter, folder, ""), 295 ), 296 Steps: []resource.TestStep{ 297 resource.TestStep{ 298 PreConfig: func() { createVSphereFolder(datacenter, folder) }, 299 Config: fmt.Sprintf( 300 testAccCheckVSphereVirtualMachineConfig_createInFolder, 301 folder, 302 locationOpt, 303 label, 304 datastoreOpt, 305 template, 306 ), 307 Check: resource.ComposeTestCheckFunc( 308 testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.folder", &vm), 309 resource.TestCheckResourceAttr( 310 "vsphere_virtual_machine.folder", "name", "terraform-test-folder"), 311 resource.TestCheckResourceAttr( 312 "vsphere_virtual_machine.folder", "folder", folder), 313 resource.TestCheckResourceAttr( 314 "vsphere_virtual_machine.folder", "vcpu", "2"), 315 resource.TestCheckResourceAttr( 316 "vsphere_virtual_machine.folder", "memory", "4096"), 317 resource.TestCheckResourceAttr( 318 "vsphere_virtual_machine.folder", "disk.#", "1"), 319 resource.TestCheckResourceAttr( 320 "vsphere_virtual_machine.folder", "disk.0.template", template), 321 resource.TestCheckResourceAttr( 322 "vsphere_virtual_machine.folder", "network_interface.#", "1"), 323 resource.TestCheckResourceAttr( 324 "vsphere_virtual_machine.folder", "network_interface.0.label", label), 325 ), 326 }, 327 }, 328 }) 329 } 330 331 func TestAccVSphereVirtualMachine_createWithFolder(t *testing.T) { 332 var vm virtualMachine 333 var f folder 334 var locationOpt string 335 var folderLocationOpt string 336 var datastoreOpt string 337 338 folder := "tf_test_createWithFolder" 339 340 if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { 341 folderLocationOpt = fmt.Sprintf(" datacenter = \"%s\"\n", v) 342 locationOpt += folderLocationOpt 343 } 344 if v := os.Getenv("VSPHERE_CLUSTER"); v != "" { 345 locationOpt += fmt.Sprintf(" cluster = \"%s\"\n", v) 346 } 347 if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" { 348 locationOpt += fmt.Sprintf(" resource_pool = \"%s\"\n", v) 349 } 350 if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { 351 datastoreOpt = fmt.Sprintf(" datastore = \"%s\"\n", v) 352 } 353 template := os.Getenv("VSPHERE_TEMPLATE") 354 label := os.Getenv("VSPHERE_NETWORK_LABEL_DHCP") 355 356 resource.Test(t, resource.TestCase{ 357 PreCheck: func() { testAccPreCheck(t) }, 358 Providers: testAccProviders, 359 CheckDestroy: resource.ComposeTestCheckFunc( 360 testAccCheckVSphereVirtualMachineDestroy, 361 testAccCheckVSphereFolderDestroy, 362 ), 363 Steps: []resource.TestStep{ 364 resource.TestStep{ 365 Config: fmt.Sprintf( 366 testAccCheckVSphereVirtualMachineConfig_createWithFolder, 367 folder, 368 folderLocationOpt, 369 locationOpt, 370 label, 371 datastoreOpt, 372 template, 373 ), 374 Check: resource.ComposeTestCheckFunc( 375 testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.with_folder", &vm), 376 testAccCheckVSphereFolderExists("vsphere_folder.with_folder", &f), 377 resource.TestCheckResourceAttr( 378 "vsphere_virtual_machine.with_folder", "name", "terraform-test-with-folder"), 379 // resource.TestCheckResourceAttr( 380 // "vsphere_virtual_machine.with_folder", "folder", folder), 381 resource.TestCheckResourceAttr( 382 "vsphere_virtual_machine.with_folder", "vcpu", "2"), 383 resource.TestCheckResourceAttr( 384 "vsphere_virtual_machine.with_folder", "memory", "4096"), 385 resource.TestCheckResourceAttr( 386 "vsphere_virtual_machine.with_folder", "disk.#", "1"), 387 resource.TestCheckResourceAttr( 388 "vsphere_virtual_machine.with_folder", "disk.0.template", template), 389 resource.TestCheckResourceAttr( 390 "vsphere_virtual_machine.with_folder", "network_interface.#", "1"), 391 resource.TestCheckResourceAttr( 392 "vsphere_virtual_machine.with_folder", "network_interface.0.label", label), 393 ), 394 }, 395 }, 396 }) 397 } 398 399 func TestAccVSphereVirtualMachine_createWithCdrom(t *testing.T) { 400 var vm virtualMachine 401 var locationOpt string 402 var datastoreOpt string 403 404 if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { 405 locationOpt += fmt.Sprintf(" datacenter = \"%s\"\n", v) 406 } 407 if v := os.Getenv("VSPHERE_CLUSTER"); v != "" { 408 locationOpt += fmt.Sprintf(" cluster = \"%s\"\n", v) 409 } 410 if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" { 411 locationOpt += fmt.Sprintf(" resource_pool = \"%s\"\n", v) 412 } 413 if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { 414 datastoreOpt = fmt.Sprintf(" datastore = \"%s\"\n", v) 415 } 416 template := os.Getenv("VSPHERE_TEMPLATE") 417 label := os.Getenv("VSPHERE_NETWORK_LABEL_DHCP") 418 cdromDatastore := os.Getenv("VSPHERE_CDROM_DATASTORE") 419 cdromPath := os.Getenv("VSPHERE_CDROM_PATH") 420 421 resource.Test(t, resource.TestCase{ 422 PreCheck: func() { testAccPreCheck(t) }, 423 Providers: testAccProviders, 424 CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, 425 Steps: []resource.TestStep{ 426 resource.TestStep{ 427 Config: fmt.Sprintf( 428 testAccCheckVsphereVirtualMachineConfig_cdrom, 429 locationOpt, 430 label, 431 datastoreOpt, 432 template, 433 cdromDatastore, 434 cdromPath, 435 ), 436 Check: resource.ComposeTestCheckFunc( 437 testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.with_cdrom", &vm), 438 resource.TestCheckResourceAttr( 439 "vsphere_virtual_machine.with_cdrom", "name", "terraform-test-with-cdrom"), 440 resource.TestCheckResourceAttr( 441 "vsphere_virtual_machine.with_cdrom", "vcpu", "2"), 442 resource.TestCheckResourceAttr( 443 "vsphere_virtual_machine.with_cdrom", "memory", "4096"), 444 resource.TestCheckResourceAttr( 445 "vsphere_virtual_machine.with_cdrom", "disk.#", "1"), 446 resource.TestCheckResourceAttr( 447 "vsphere_virtual_machine.with_cdrom", "disk.0.template", template), 448 resource.TestCheckResourceAttr( 449 "vsphere_virtual_machine.with_cdrom", "cdrom.#", "1"), 450 resource.TestCheckResourceAttr( 451 "vsphere_virtual_machine.with_cdrom", "cdrom.0.datastore", cdromDatastore), 452 resource.TestCheckResourceAttr( 453 "vsphere_virtual_machine.with_cdrom", "cdrom.0.path", cdromPath), 454 resource.TestCheckResourceAttr( 455 "vsphere_virtual_machine.with_cdrom", "network_interface.#", "1"), 456 resource.TestCheckResourceAttr( 457 "vsphere_virtual_machine.with_cdrom", "network_interface.0.label", label), 458 ), 459 }, 460 }, 461 }) 462 } 463 464 func TestAccVSphereVirtualMachine_createWithExistingVmdk(t *testing.T) { 465 vmdk_path := os.Getenv("VSPHERE_VMDK_PATH") 466 label := os.Getenv("VSPHERE_NETWORK_LABEL") 467 468 var vm virtualMachine 469 var locationOpt string 470 var datastoreOpt string 471 472 if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { 473 locationOpt += fmt.Sprintf(" datacenter = \"%s\"\n", v) 474 } 475 if v := os.Getenv("VSPHERE_CLUSTER"); v != "" { 476 locationOpt += fmt.Sprintf(" cluster = \"%s\"\n", v) 477 } 478 if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" { 479 locationOpt += fmt.Sprintf(" resource_pool = \"%s\"\n", v) 480 } 481 if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { 482 datastoreOpt = fmt.Sprintf(" datastore = \"%s\"\n", v) 483 } 484 485 resource.Test(t, resource.TestCase{ 486 PreCheck: func() { testAccPreCheck(t) }, 487 Providers: testAccProviders, 488 CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, 489 Steps: []resource.TestStep{ 490 resource.TestStep{ 491 Config: fmt.Sprintf( 492 testAccCheckVSphereVirtualMachineConfig_withExistingVmdk, 493 locationOpt, 494 label, 495 datastoreOpt, 496 vmdk_path, 497 ), 498 Check: resource.ComposeTestCheckFunc( 499 testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.with_existing_vmdk", &vm), 500 resource.TestCheckResourceAttr( 501 "vsphere_virtual_machine.with_existing_vmdk", "name", "terraform-test-with-existing-vmdk"), 502 resource.TestCheckResourceAttr( 503 "vsphere_virtual_machine.with_existing_vmdk", "vcpu", "2"), 504 resource.TestCheckResourceAttr( 505 "vsphere_virtual_machine.with_existing_vmdk", "memory", "4096"), 506 resource.TestCheckResourceAttr( 507 "vsphere_virtual_machine.with_existing_vmdk", "disk.#", "1"), 508 resource.TestCheckResourceAttr( 509 "vsphere_virtual_machine.with_existing_vmdk", "disk.0.vmdk", vmdk_path), 510 resource.TestCheckResourceAttr( 511 "vsphere_virtual_machine.with_existing_vmdk", "disk.0.bootable", "true"), 512 resource.TestCheckResourceAttr( 513 "vsphere_virtual_machine.with_existing_vmdk", "network_interface.#", "1"), 514 resource.TestCheckResourceAttr( 515 "vsphere_virtual_machine.with_existing_vmdk", "network_interface.0.label", label), 516 ), 517 }, 518 }, 519 }) 520 } 521 522 func TestAccVSphereVirtualMachine_updateMemory(t *testing.T) { 523 var vm virtualMachine 524 var locationOpt string 525 var datastoreOpt string 526 527 if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { 528 locationOpt += fmt.Sprintf(" datacenter = \"%s\"\n", v) 529 } 530 if v := os.Getenv("VSPHERE_CLUSTER"); v != "" { 531 locationOpt += fmt.Sprintf(" cluster = \"%s\"\n", v) 532 } 533 if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" { 534 locationOpt += fmt.Sprintf(" resource_pool = \"%s\"\n", v) 535 } 536 if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { 537 datastoreOpt = fmt.Sprintf(" datastore = \"%s\"\n", v) 538 } 539 template := os.Getenv("VSPHERE_TEMPLATE") 540 label := os.Getenv("VSPHERE_NETWORK_LABEL_DHCP") 541 542 resource.Test(t, resource.TestCase{ 543 PreCheck: func() { testAccPreCheck(t) }, 544 Providers: testAccProviders, 545 CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, 546 Steps: []resource.TestStep{ 547 resource.TestStep{ 548 Config: fmt.Sprintf( 549 testAccCheckVSphereVirtualMachineConfig_updateMemoryInitial, 550 locationOpt, 551 label, 552 datastoreOpt, 553 template, 554 ), 555 Check: resource.ComposeTestCheckFunc( 556 testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.bar", &vm), 557 resource.TestCheckResourceAttr( 558 "vsphere_virtual_machine.bar", "name", "terraform-test"), 559 resource.TestCheckResourceAttr( 560 "vsphere_virtual_machine.bar", "vcpu", "2"), 561 resource.TestCheckResourceAttr( 562 "vsphere_virtual_machine.bar", "memory", "4096"), 563 resource.TestCheckResourceAttr( 564 "vsphere_virtual_machine.bar", "disk.#", "1"), 565 resource.TestCheckResourceAttr( 566 "vsphere_virtual_machine.bar", "disk.0.template", template), 567 resource.TestCheckResourceAttr( 568 "vsphere_virtual_machine.bar", "network_interface.#", "1"), 569 resource.TestCheckResourceAttr( 570 "vsphere_virtual_machine.bar", "network_interface.0.label", label), 571 ), 572 }, 573 resource.TestStep{ 574 Config: fmt.Sprintf( 575 testAccCheckVSphereVirtualMachineConfig_updateMemoryUpdate, 576 locationOpt, 577 label, 578 datastoreOpt, 579 template, 580 ), 581 Check: resource.ComposeTestCheckFunc( 582 testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.bar", &vm), 583 resource.TestCheckResourceAttr( 584 "vsphere_virtual_machine.bar", "name", "terraform-test"), 585 resource.TestCheckResourceAttr( 586 "vsphere_virtual_machine.bar", "vcpu", "2"), 587 resource.TestCheckResourceAttr( 588 "vsphere_virtual_machine.bar", "memory", "2048"), 589 resource.TestCheckResourceAttr( 590 "vsphere_virtual_machine.bar", "disk.#", "1"), 591 resource.TestCheckResourceAttr( 592 "vsphere_virtual_machine.bar", "disk.0.template", template), 593 resource.TestCheckResourceAttr( 594 "vsphere_virtual_machine.bar", "network_interface.#", "1"), 595 resource.TestCheckResourceAttr( 596 "vsphere_virtual_machine.bar", "network_interface.0.label", label), 597 ), 598 }, 599 }, 600 }) 601 } 602 603 func TestAccVSphereVirtualMachine_updateVcpu(t *testing.T) { 604 var vm virtualMachine 605 var locationOpt string 606 var datastoreOpt string 607 608 if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { 609 locationOpt += fmt.Sprintf(" datacenter = \"%s\"\n", v) 610 } 611 if v := os.Getenv("VSPHERE_CLUSTER"); v != "" { 612 locationOpt += fmt.Sprintf(" cluster = \"%s\"\n", v) 613 } 614 if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" { 615 locationOpt += fmt.Sprintf(" resource_pool = \"%s\"\n", v) 616 } 617 if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { 618 datastoreOpt = fmt.Sprintf(" datastore = \"%s\"\n", v) 619 } 620 template := os.Getenv("VSPHERE_TEMPLATE") 621 label := os.Getenv("VSPHERE_NETWORK_LABEL_DHCP") 622 623 resource.Test(t, resource.TestCase{ 624 PreCheck: func() { testAccPreCheck(t) }, 625 Providers: testAccProviders, 626 CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, 627 Steps: []resource.TestStep{ 628 resource.TestStep{ 629 Config: fmt.Sprintf( 630 testAccCheckVSphereVirtualMachineConfig_updateVcpuInitial, 631 locationOpt, 632 label, 633 datastoreOpt, 634 template, 635 ), 636 Check: resource.ComposeTestCheckFunc( 637 testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.bar", &vm), 638 resource.TestCheckResourceAttr( 639 "vsphere_virtual_machine.bar", "name", "terraform-test"), 640 resource.TestCheckResourceAttr( 641 "vsphere_virtual_machine.bar", "vcpu", "2"), 642 resource.TestCheckResourceAttr( 643 "vsphere_virtual_machine.bar", "memory", "4096"), 644 resource.TestCheckResourceAttr( 645 "vsphere_virtual_machine.bar", "disk.#", "1"), 646 resource.TestCheckResourceAttr( 647 "vsphere_virtual_machine.bar", "disk.0.template", template), 648 resource.TestCheckResourceAttr( 649 "vsphere_virtual_machine.bar", "network_interface.#", "1"), 650 resource.TestCheckResourceAttr( 651 "vsphere_virtual_machine.bar", "network_interface.0.label", label), 652 ), 653 }, 654 resource.TestStep{ 655 Config: fmt.Sprintf( 656 testAccCheckVSphereVirtualMachineConfig_updateVcpuUpdate, 657 locationOpt, 658 label, 659 datastoreOpt, 660 template, 661 ), 662 Check: resource.ComposeTestCheckFunc( 663 testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.bar", &vm), 664 resource.TestCheckResourceAttr( 665 "vsphere_virtual_machine.bar", "name", "terraform-test"), 666 resource.TestCheckResourceAttr( 667 "vsphere_virtual_machine.bar", "vcpu", "4"), 668 resource.TestCheckResourceAttr( 669 "vsphere_virtual_machine.bar", "memory", "4096"), 670 resource.TestCheckResourceAttr( 671 "vsphere_virtual_machine.bar", "disk.#", "1"), 672 resource.TestCheckResourceAttr( 673 "vsphere_virtual_machine.bar", "disk.0.template", template), 674 resource.TestCheckResourceAttr( 675 "vsphere_virtual_machine.bar", "network_interface.#", "1"), 676 resource.TestCheckResourceAttr( 677 "vsphere_virtual_machine.bar", "network_interface.0.label", label), 678 ), 679 }, 680 }, 681 }) 682 } 683 684 func TestAccVSphereVirtualMachine_ipv4Andipv6(t *testing.T) { 685 var vm virtualMachine 686 var locationOpt string 687 var datastoreOpt string 688 689 if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { 690 locationOpt += fmt.Sprintf(" datacenter = \"%s\"\n", v) 691 } 692 if v := os.Getenv("VSPHERE_CLUSTER"); v != "" { 693 locationOpt += fmt.Sprintf(" cluster = \"%s\"\n", v) 694 } 695 if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" { 696 locationOpt += fmt.Sprintf(" resource_pool = \"%s\"\n", v) 697 } 698 if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { 699 datastoreOpt = fmt.Sprintf(" datastore = \"%s\"\n", v) 700 } 701 template := os.Getenv("VSPHERE_TEMPLATE") 702 label := os.Getenv("VSPHERE_NETWORK_LABEL") 703 ipv4Address := os.Getenv("VSPHERE_IPV4_ADDRESS") 704 ipv4Gateway := os.Getenv("VSPHERE_IPV4_GATEWAY") 705 ipv6Address := os.Getenv("VSPHERE_IPV6_ADDRESS") 706 ipv6Gateway := os.Getenv("VSPHERE_IPV6_GATEWAY") 707 708 resource.Test(t, resource.TestCase{ 709 PreCheck: func() { testAccPreCheck(t) }, 710 Providers: testAccProviders, 711 CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, 712 Steps: []resource.TestStep{ 713 resource.TestStep{ 714 Config: fmt.Sprintf( 715 testAccCheckVSphereVirtualMachineConfig_ipv4Andipv6, 716 locationOpt, 717 label, 718 ipv4Address, 719 ipv4Gateway, 720 ipv6Address, 721 ipv6Gateway, 722 datastoreOpt, 723 template, 724 ), 725 Check: resource.ComposeTestCheckFunc( 726 testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.ipv4ipv6", &vm), 727 resource.TestCheckResourceAttr( 728 "vsphere_virtual_machine.ipv4ipv6", "name", "terraform-test-ipv4-ipv6"), 729 resource.TestCheckResourceAttr( 730 "vsphere_virtual_machine.ipv4ipv6", "vcpu", "2"), 731 resource.TestCheckResourceAttr( 732 "vsphere_virtual_machine.ipv4ipv6", "memory", "4096"), 733 resource.TestCheckResourceAttr( 734 "vsphere_virtual_machine.ipv4ipv6", "disk.#", "2"), 735 resource.TestCheckResourceAttr( 736 "vsphere_virtual_machine.ipv4ipv6", "disk.0.template", template), 737 resource.TestCheckResourceAttr( 738 "vsphere_virtual_machine.ipv4ipv6", "network_interface.#", "1"), 739 resource.TestCheckResourceAttr( 740 "vsphere_virtual_machine.ipv4ipv6", "network_interface.0.label", label), 741 resource.TestCheckResourceAttr( 742 "vsphere_virtual_machine.ipv4ipv6", "network_interface.0.ipv4_address", ipv4Address), 743 resource.TestCheckResourceAttr( 744 "vsphere_virtual_machine.ipv4ipv6", "network_interface.0.ipv4_gateway", ipv4Gateway), 745 resource.TestCheckResourceAttr( 746 "vsphere_virtual_machine.ipv4ipv6", "network_interface.0.ipv6_address", ipv6Address), 747 resource.TestCheckResourceAttr( 748 "vsphere_virtual_machine.ipv4ipv6", "network_interface.0.ipv6_gateway", ipv6Gateway), 749 ), 750 }, 751 }, 752 }) 753 } 754 755 func testAccCheckVSphereVirtualMachineDestroy(s *terraform.State) error { 756 client := testAccProvider.Meta().(*govmomi.Client) 757 finder := find.NewFinder(client.Client, true) 758 759 for _, rs := range s.RootModule().Resources { 760 if rs.Type != "vsphere_virtual_machine" { 761 continue 762 } 763 764 dc, err := finder.Datacenter(context.TODO(), rs.Primary.Attributes["datacenter"]) 765 if err != nil { 766 return fmt.Errorf("error %s", err) 767 } 768 769 dcFolders, err := dc.Folders(context.TODO()) 770 if err != nil { 771 return fmt.Errorf("error %s", err) 772 } 773 774 folder := dcFolders.VmFolder 775 if len(rs.Primary.Attributes["folder"]) > 0 { 776 si := object.NewSearchIndex(client.Client) 777 folderRef, err := si.FindByInventoryPath( 778 context.TODO(), fmt.Sprintf("%v/vm/%v", rs.Primary.Attributes["datacenter"], rs.Primary.Attributes["folder"])) 779 if err != nil { 780 return err 781 } else if folderRef != nil { 782 folder = folderRef.(*object.Folder) 783 } 784 } 785 786 v, err := object.NewSearchIndex(client.Client).FindChild(context.TODO(), folder, rs.Primary.Attributes["name"]) 787 788 if v != nil { 789 return fmt.Errorf("Record still exists") 790 } 791 } 792 793 return nil 794 } 795 796 func testAccCheckVSphereVirtualMachineExistsHasCustomConfig(n string, vm *virtualMachine) resource.TestCheckFunc { 797 return func(s *terraform.State) error { 798 799 rs, ok := s.RootModule().Resources[n] 800 if !ok { 801 return fmt.Errorf("Not found: %s", n) 802 } 803 804 if rs.Primary.ID == "" { 805 return fmt.Errorf("No ID is set") 806 } 807 808 client := testAccProvider.Meta().(*govmomi.Client) 809 finder := find.NewFinder(client.Client, true) 810 811 dc, err := finder.Datacenter(context.TODO(), rs.Primary.Attributes["datacenter"]) 812 if err != nil { 813 return fmt.Errorf("error %s", err) 814 } 815 816 dcFolders, err := dc.Folders(context.TODO()) 817 if err != nil { 818 return fmt.Errorf("error %s", err) 819 } 820 821 _, err = object.NewSearchIndex(client.Client).FindChild(context.TODO(), dcFolders.VmFolder, rs.Primary.Attributes["name"]) 822 if err != nil { 823 return fmt.Errorf("error %s", err) 824 } 825 826 finder = finder.SetDatacenter(dc) 827 instance, err := finder.VirtualMachine(context.TODO(), rs.Primary.Attributes["name"]) 828 if err != nil { 829 return fmt.Errorf("error %s", err) 830 } 831 832 var mvm mo.VirtualMachine 833 834 collector := property.DefaultCollector(client.Client) 835 836 if err := collector.RetrieveOne(context.TODO(), instance.Reference(), []string{"config.extraConfig"}, &mvm); err != nil { 837 return fmt.Errorf("error %s", err) 838 } 839 840 var configMap = make(map[string]types.AnyType) 841 if mvm.Config != nil && mvm.Config.ExtraConfig != nil && len(mvm.Config.ExtraConfig) > 0 { 842 for _, v := range mvm.Config.ExtraConfig { 843 value := v.GetOptionValue() 844 configMap[value.Key] = value.Value 845 } 846 } else { 847 return fmt.Errorf("error no ExtraConfig") 848 } 849 850 if configMap["foo"] == nil { 851 return fmt.Errorf("error no ExtraConfig for 'foo'") 852 } 853 854 if configMap["foo"] != "bar" { 855 return fmt.Errorf("error ExtraConfig 'foo' != bar") 856 } 857 858 if configMap["car"] == nil { 859 return fmt.Errorf("error no ExtraConfig for 'car'") 860 } 861 862 if configMap["car"] != "ferrari" { 863 return fmt.Errorf("error ExtraConfig 'car' != ferrari") 864 } 865 866 if configMap["num"] == nil { 867 return fmt.Errorf("error no ExtraConfig for 'num'") 868 } 869 870 // todo this should be an int, getting back a string 871 if configMap["num"] != "42" { 872 return fmt.Errorf("error ExtraConfig 'num' != 42") 873 } 874 *vm = virtualMachine{ 875 name: rs.Primary.ID, 876 } 877 878 return nil 879 } 880 } 881 882 func testAccCheckVSphereVirtualMachineExists(n string, vm *virtualMachine) resource.TestCheckFunc { 883 return func(s *terraform.State) error { 884 rs, ok := s.RootModule().Resources[n] 885 if !ok { 886 return fmt.Errorf("Not found: %s", n) 887 } 888 889 if rs.Primary.ID == "" { 890 return fmt.Errorf("No ID is set") 891 } 892 893 client := testAccProvider.Meta().(*govmomi.Client) 894 finder := find.NewFinder(client.Client, true) 895 896 dc, err := finder.Datacenter(context.TODO(), rs.Primary.Attributes["datacenter"]) 897 if err != nil { 898 return fmt.Errorf("error %s", err) 899 } 900 901 dcFolders, err := dc.Folders(context.TODO()) 902 if err != nil { 903 return fmt.Errorf("error %s", err) 904 } 905 906 folder := dcFolders.VmFolder 907 if len(rs.Primary.Attributes["folder"]) > 0 { 908 si := object.NewSearchIndex(client.Client) 909 folderRef, err := si.FindByInventoryPath( 910 context.TODO(), fmt.Sprintf("%v/vm/%v", rs.Primary.Attributes["datacenter"], rs.Primary.Attributes["folder"])) 911 if err != nil { 912 return err 913 } else if folderRef != nil { 914 folder = folderRef.(*object.Folder) 915 } 916 } 917 918 _, err = object.NewSearchIndex(client.Client).FindChild(context.TODO(), folder, rs.Primary.Attributes["name"]) 919 920 *vm = virtualMachine{ 921 name: rs.Primary.ID, 922 } 923 924 return nil 925 } 926 } 927 928 const testAccCheckVSphereVirtualMachineConfig_basic = ` 929 resource "vsphere_virtual_machine" "foo" { 930 name = "terraform-test" 931 %s 932 vcpu = 2 933 memory = 4096 934 memory_reservation = 4096 935 gateway = "%s" 936 network_interface { 937 label = "%s" 938 ipv4_address = "%s" 939 ipv4_prefix_length = 24 940 ipv4_gateway = "%s" 941 } 942 disk { 943 %s 944 template = "%s" 945 iops = 500 946 } 947 disk { 948 size = 1 949 iops = 500 950 } 951 } 952 ` 953 const testAccCheckVSphereVirtualMachineConfig_initType = ` 954 resource "vsphere_virtual_machine" "thin" { 955 name = "terraform-test" 956 %s 957 vcpu = 2 958 memory = 4096 959 gateway = "%s" 960 network_interface { 961 label = "%s" 962 ipv4_address = "%s" 963 ipv4_prefix_length = 24 964 ipv4_gateway = "%s" 965 } 966 disk { 967 %s 968 template = "%s" 969 iops = 500 970 type = "thin" 971 } 972 disk { 973 size = 1 974 iops = 500 975 controller_type = "scsi" 976 } 977 disk { 978 size = 1 979 controller_type = "ide" 980 } 981 } 982 ` 983 const testAccCheckVSphereVirtualMachineConfig_dhcp = ` 984 resource "vsphere_virtual_machine" "bar" { 985 name = "terraform-test" 986 %s 987 vcpu = 2 988 memory = 4096 989 network_interface { 990 label = "%s" 991 } 992 disk { 993 %s 994 template = "%s" 995 } 996 } 997 ` 998 999 const testAccCheckVSphereVirtualMachineConfig_custom_configs = ` 1000 resource "vsphere_virtual_machine" "car" { 1001 name = "terraform-test-custom" 1002 %s 1003 vcpu = 2 1004 memory = 4096 1005 network_interface { 1006 label = "%s" 1007 } 1008 custom_configuration_parameters { 1009 "foo" = "bar" 1010 "car" = "ferrari" 1011 "num" = 42 1012 } 1013 disk { 1014 %s 1015 template = "%s" 1016 } 1017 } 1018 ` 1019 1020 const testAccCheckVSphereVirtualMachineConfig_createInFolder = ` 1021 resource "vsphere_virtual_machine" "folder" { 1022 name = "terraform-test-folder" 1023 folder = "%s" 1024 %s 1025 vcpu = 2 1026 memory = 4096 1027 network_interface { 1028 label = "%s" 1029 } 1030 disk { 1031 %s 1032 template = "%s" 1033 } 1034 } 1035 ` 1036 1037 const testAccCheckVSphereVirtualMachineConfig_createWithFolder = ` 1038 resource "vsphere_folder" "with_folder" { 1039 path = "%s" 1040 %s 1041 } 1042 resource "vsphere_virtual_machine" "with_folder" { 1043 name = "terraform-test-with-folder" 1044 folder = "${vsphere_folder.with_folder.path}" 1045 %s 1046 vcpu = 2 1047 memory = 4096 1048 network_interface { 1049 label = "%s" 1050 } 1051 disk { 1052 %s 1053 template = "%s" 1054 } 1055 } 1056 ` 1057 1058 const testAccCheckVsphereVirtualMachineConfig_cdrom = ` 1059 resource "vsphere_virtual_machine" "with_cdrom" { 1060 name = "terraform-test-with-cdrom" 1061 %s 1062 vcpu = 2 1063 memory = 4096 1064 network_interface { 1065 label = "%s" 1066 } 1067 disk { 1068 %s 1069 template = "%s" 1070 } 1071 1072 cdrom { 1073 datastore = "%s" 1074 path = "%s" 1075 } 1076 } 1077 ` 1078 1079 const testAccCheckVSphereVirtualMachineConfig_withExistingVmdk = ` 1080 resource "vsphere_virtual_machine" "with_existing_vmdk" { 1081 name = "terraform-test-with-existing-vmdk" 1082 %s 1083 vcpu = 2 1084 memory = 4096 1085 network_interface { 1086 label = "%s" 1087 } 1088 disk { 1089 %s 1090 vmdk = "%s" 1091 bootable = true 1092 } 1093 } 1094 ` 1095 1096 const testAccCheckVSphereVirtualMachineConfig_updateMemoryInitial = ` 1097 resource "vsphere_virtual_machine" "bar" { 1098 name = "terraform-test" 1099 %s 1100 vcpu = 2 1101 memory = 4096 1102 network_interface { 1103 label = "%s" 1104 } 1105 disk { 1106 %s 1107 template = "%s" 1108 } 1109 } 1110 ` 1111 1112 const testAccCheckVSphereVirtualMachineConfig_updateMemoryUpdate = ` 1113 resource "vsphere_virtual_machine" "bar" { 1114 name = "terraform-test" 1115 %s 1116 vcpu = 2 1117 memory = 2048 1118 network_interface { 1119 label = "%s" 1120 } 1121 disk { 1122 %s 1123 template = "%s" 1124 } 1125 } 1126 ` 1127 1128 const testAccCheckVSphereVirtualMachineConfig_updateVcpuInitial = ` 1129 resource "vsphere_virtual_machine" "bar" { 1130 name = "terraform-test" 1131 %s 1132 vcpu = 2 1133 memory = 4096 1134 network_interface { 1135 label = "%s" 1136 } 1137 disk { 1138 %s 1139 template = "%s" 1140 } 1141 } 1142 ` 1143 1144 const testAccCheckVSphereVirtualMachineConfig_updateVcpuUpdate = ` 1145 resource "vsphere_virtual_machine" "bar" { 1146 name = "terraform-test" 1147 %s 1148 vcpu = 4 1149 memory = 4096 1150 network_interface { 1151 label = "%s" 1152 } 1153 disk { 1154 %s 1155 template = "%s" 1156 } 1157 } 1158 ` 1159 1160 const testAccCheckVSphereVirtualMachineConfig_ipv4Andipv6 = ` 1161 resource "vsphere_virtual_machine" "ipv4ipv6" { 1162 name = "terraform-test-ipv4-ipv6" 1163 %s 1164 vcpu = 2 1165 memory = 4096 1166 network_interface { 1167 label = "%s" 1168 ipv4_address = "%s" 1169 ipv4_prefix_length = 24 1170 ipv4_gateway = "%s" 1171 ipv6_address = "%s" 1172 ipv6_prefix_length = 64 1173 ipv6_gateway = "%s" 1174 } 1175 disk { 1176 %s 1177 template = "%s" 1178 iops = 500 1179 } 1180 disk { 1181 size = 1 1182 iops = 500 1183 } 1184 } 1185 `