github.com/sarguru/terraform@v0.6.17-0.20160525232901-8fcdfd7e3dc9/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.1554349037.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.3770202010.template", template),
   131  					resource.TestCheckResourceAttr(
   132  						"vsphere_virtual_machine.thin", "disk.3770202010.type", "thin"),
   133  					resource.TestCheckResourceAttr(
   134  						"vsphere_virtual_machine.thin", "disk.294918912.type", "eager_zeroed"),
   135  					resource.TestCheckResourceAttr(
   136  						"vsphere_virtual_machine.thin", "disk.1380467090.controller_type", "scsi"),
   137  					resource.TestCheckResourceAttr(
   138  						"vsphere_virtual_machine.thin", "disk.294918912.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.2166312600.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.2166312600.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.2166312600.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.2166312600.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.2166312600.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.2393891804.vmdk", vmdk_path),
   510  					resource.TestCheckResourceAttr(
   511  						"vsphere_virtual_machine.with_existing_vmdk", "disk.2393891804.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.2166312600.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.2166312600.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.2166312600.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.2166312600.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.3582676876.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  func TestAccVSphereVirtualMachine_updateDisks(t *testing.T) {
   929  	var vm virtualMachine
   930  	var locationOpt string
   931  	var datastoreOpt string
   932  
   933  	if v := os.Getenv("VSPHERE_DATACENTER"); v != "" {
   934  		locationOpt += fmt.Sprintf("    datacenter = \"%s\"\n", v)
   935  	}
   936  	if v := os.Getenv("VSPHERE_CLUSTER"); v != "" {
   937  		locationOpt += fmt.Sprintf("    cluster = \"%s\"\n", v)
   938  	}
   939  	if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" {
   940  		locationOpt += fmt.Sprintf("    resource_pool = \"%s\"\n", v)
   941  	}
   942  	if v := os.Getenv("VSPHERE_DATASTORE"); v != "" {
   943  		datastoreOpt = fmt.Sprintf("        datastore = \"%s\"\n", v)
   944  	}
   945  	template := os.Getenv("VSPHERE_TEMPLATE")
   946  	gateway := os.Getenv("VSPHERE_IPV4_GATEWAY")
   947  	label := os.Getenv("VSPHERE_NETWORK_LABEL")
   948  	ip_address := os.Getenv("VSPHERE_IPV4_ADDRESS")
   949  
   950  	resource.Test(t, resource.TestCase{
   951  		PreCheck:     func() { testAccPreCheck(t) },
   952  		Providers:    testAccProviders,
   953  		CheckDestroy: testAccCheckVSphereVirtualMachineDestroy,
   954  		Steps: []resource.TestStep{
   955  			resource.TestStep{
   956  				Config: fmt.Sprintf(
   957  					testAccCheckVSphereVirtualMachineConfig_basic,
   958  					locationOpt,
   959  					gateway,
   960  					label,
   961  					ip_address,
   962  					gateway,
   963  					datastoreOpt,
   964  					template,
   965  				),
   966  				Check: resource.ComposeTestCheckFunc(
   967  					testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.foo", &vm),
   968  					resource.TestCheckResourceAttr(
   969  						"vsphere_virtual_machine.foo", "name", "terraform-test"),
   970  					resource.TestCheckResourceAttr(
   971  						"vsphere_virtual_machine.foo", "vcpu", "2"),
   972  					resource.TestCheckResourceAttr(
   973  						"vsphere_virtual_machine.foo", "memory", "4096"),
   974  					resource.TestCheckResourceAttr(
   975  						"vsphere_virtual_machine.foo", "memory_reservation", "4096"),
   976  					resource.TestCheckResourceAttr(
   977  						"vsphere_virtual_machine.foo", "disk.#", "2"),
   978  					resource.TestCheckResourceAttr(
   979  						"vsphere_virtual_machine.foo", "disk.1554349037.template", template),
   980  					resource.TestCheckResourceAttr(
   981  						"vsphere_virtual_machine.foo", "network_interface.#", "1"),
   982  					resource.TestCheckResourceAttr(
   983  						"vsphere_virtual_machine.foo", "network_interface.0.label", label),
   984  				),
   985  			},
   986  			resource.TestStep{
   987  				Config: fmt.Sprintf(
   988  					testAccCheckVSphereVirtualMachineConfig_updateAddDisks,
   989  					locationOpt,
   990  					gateway,
   991  					label,
   992  					ip_address,
   993  					gateway,
   994  					datastoreOpt,
   995  					template,
   996  				),
   997  				Check: resource.ComposeTestCheckFunc(
   998  					testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.foo", &vm),
   999  					resource.TestCheckResourceAttr(
  1000  						"vsphere_virtual_machine.foo", "name", "terraform-test"),
  1001  					resource.TestCheckResourceAttr(
  1002  						"vsphere_virtual_machine.foo", "vcpu", "2"),
  1003  					resource.TestCheckResourceAttr(
  1004  						"vsphere_virtual_machine.foo", "memory", "4096"),
  1005  					resource.TestCheckResourceAttr(
  1006  						"vsphere_virtual_machine.foo", "memory_reservation", "4096"),
  1007  					resource.TestCheckResourceAttr(
  1008  						"vsphere_virtual_machine.foo", "disk.#", "4"),
  1009  					resource.TestCheckResourceAttr(
  1010  						"vsphere_virtual_machine.foo", "disk.1554349037.template", template),
  1011  					resource.TestCheckResourceAttr(
  1012  						"vsphere_virtual_machine.foo", "network_interface.#", "1"),
  1013  					resource.TestCheckResourceAttr(
  1014  						"vsphere_virtual_machine.foo", "network_interface.0.label", label),
  1015  				),
  1016  			},
  1017  			resource.TestStep{
  1018  				Config: fmt.Sprintf(
  1019  					testAccCheckVSphereVirtualMachineConfig_updateRemoveDisks,
  1020  					locationOpt,
  1021  					gateway,
  1022  					label,
  1023  					ip_address,
  1024  					gateway,
  1025  					datastoreOpt,
  1026  					template,
  1027  				),
  1028  				Check: resource.ComposeTestCheckFunc(
  1029  					testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.foo", &vm),
  1030  					resource.TestCheckResourceAttr(
  1031  						"vsphere_virtual_machine.foo", "name", "terraform-test"),
  1032  					resource.TestCheckResourceAttr(
  1033  						"vsphere_virtual_machine.foo", "vcpu", "2"),
  1034  					resource.TestCheckResourceAttr(
  1035  						"vsphere_virtual_machine.foo", "memory", "4096"),
  1036  					resource.TestCheckResourceAttr(
  1037  						"vsphere_virtual_machine.foo", "memory_reservation", "4096"),
  1038  					resource.TestCheckResourceAttr(
  1039  						"vsphere_virtual_machine.foo", "disk.#", "1"),
  1040  					resource.TestCheckResourceAttr(
  1041  						"vsphere_virtual_machine.foo", "disk.1554349037.template", template),
  1042  					resource.TestCheckResourceAttr(
  1043  						"vsphere_virtual_machine.foo", "network_interface.#", "1"),
  1044  					resource.TestCheckResourceAttr(
  1045  						"vsphere_virtual_machine.foo", "network_interface.0.label", label),
  1046  				),
  1047  			},
  1048  		},
  1049  	})
  1050  }
  1051  
  1052  const testAccCheckVSphereVirtualMachineConfig_basic = `
  1053  resource "vsphere_virtual_machine" "foo" {
  1054      name = "terraform-test"
  1055  %s
  1056      vcpu = 2
  1057      memory = 4096
  1058      memory_reservation = 4096
  1059      gateway = "%s"
  1060      network_interface {
  1061          label = "%s"
  1062          ipv4_address = "%s"
  1063          ipv4_prefix_length = 24
  1064          ipv4_gateway = "%s"
  1065      }
  1066      disk {
  1067  %s
  1068          template = "%s"
  1069          iops = 500
  1070      }
  1071      disk {
  1072          size = 1
  1073          iops = 500
  1074  		name = "one"
  1075      }
  1076  }
  1077  `
  1078  const testAccCheckVSphereVirtualMachineConfig_updateAddDisks = `
  1079  resource "vsphere_virtual_machine" "foo" {
  1080      name = "terraform-test"
  1081  %s
  1082      vcpu = 2
  1083      memory = 4096
  1084      memory_reservation = 4096
  1085      gateway = "%s"
  1086      network_interface {
  1087          label = "%s"
  1088          ipv4_address = "%s"
  1089          ipv4_prefix_length = 24
  1090          ipv4_gateway = "%s"
  1091      }
  1092      disk {
  1093  %s
  1094          template = "%s"
  1095          iops = 500
  1096      }
  1097      disk {
  1098          size = 1
  1099          iops = 500
  1100  		name = "one"
  1101      }
  1102  	disk {
  1103          size = 1
  1104          iops = 500
  1105  		name = "two"
  1106      }
  1107  	disk {
  1108          size = 1
  1109          iops = 500
  1110  		name = "three"
  1111      }
  1112  }
  1113  `
  1114  const testAccCheckVSphereVirtualMachineConfig_updateRemoveDisks = `
  1115  resource "vsphere_virtual_machine" "foo" {
  1116      name = "terraform-test"
  1117  %s
  1118      vcpu = 2
  1119      memory = 4096
  1120      memory_reservation = 4096
  1121      gateway = "%s"
  1122      network_interface {
  1123          label = "%s"
  1124          ipv4_address = "%s"
  1125          ipv4_prefix_length = 24
  1126          ipv4_gateway = "%s"
  1127      }
  1128      disk {
  1129  %s
  1130          template = "%s"
  1131          iops = 500
  1132      }
  1133  }
  1134  `
  1135  const testAccCheckVSphereVirtualMachineConfig_initType = `
  1136  resource "vsphere_virtual_machine" "thin" {
  1137      name = "terraform-test"
  1138  %s
  1139      vcpu = 2
  1140      memory = 4096
  1141      gateway = "%s"
  1142      network_interface {
  1143          label = "%s"
  1144          ipv4_address = "%s"
  1145          ipv4_prefix_length = 24
  1146          ipv4_gateway = "%s"
  1147      }
  1148      disk {
  1149  %s
  1150          template = "%s"
  1151          iops = 500
  1152          type = "thin"
  1153      }
  1154      disk {
  1155          size = 1
  1156          iops = 500
  1157  		controller_type = "scsi"
  1158  		name = "one"
  1159      }
  1160  	disk {
  1161          size = 1
  1162  		controller_type = "ide"
  1163  		type = "eager_zeroed"
  1164  		name = "two"
  1165      }
  1166  }
  1167  `
  1168  const testAccCheckVSphereVirtualMachineConfig_dhcp = `
  1169  resource "vsphere_virtual_machine" "bar" {
  1170      name = "terraform-test"
  1171  %s
  1172      vcpu = 2
  1173      memory = 4096
  1174      network_interface {
  1175          label = "%s"
  1176      }
  1177      disk {
  1178  %s
  1179          template = "%s"
  1180      }
  1181  }
  1182  `
  1183  
  1184  const testAccCheckVSphereVirtualMachineConfig_custom_configs = `
  1185  resource "vsphere_virtual_machine" "car" {
  1186      name = "terraform-test-custom"
  1187  %s
  1188      vcpu = 2
  1189      memory = 4096
  1190      network_interface {
  1191          label = "%s"
  1192      }
  1193      custom_configuration_parameters {
  1194  	"foo" = "bar"
  1195  	"car" = "ferrari"
  1196  	"num" = 42
  1197      }
  1198      disk {
  1199  %s
  1200          template = "%s"
  1201      }
  1202  }
  1203  `
  1204  
  1205  const testAccCheckVSphereVirtualMachineConfig_createInFolder = `
  1206  resource "vsphere_virtual_machine" "folder" {
  1207      name = "terraform-test-folder"
  1208      folder = "%s"
  1209  %s
  1210      vcpu = 2
  1211      memory = 4096
  1212      network_interface {
  1213          label = "%s"
  1214      }
  1215      disk {
  1216  %s
  1217          template = "%s"
  1218      }
  1219  }
  1220  `
  1221  
  1222  const testAccCheckVSphereVirtualMachineConfig_createWithFolder = `
  1223  resource "vsphere_folder" "with_folder" {
  1224  	path = "%s"
  1225  %s
  1226  }
  1227  resource "vsphere_virtual_machine" "with_folder" {
  1228      name = "terraform-test-with-folder"
  1229      folder = "${vsphere_folder.with_folder.path}"
  1230  %s
  1231      vcpu = 2
  1232      memory = 4096
  1233      network_interface {
  1234          label = "%s"
  1235      }
  1236      disk {
  1237  %s
  1238          template = "%s"
  1239      }
  1240  }
  1241  `
  1242  
  1243  const testAccCheckVsphereVirtualMachineConfig_cdrom = `
  1244  resource "vsphere_virtual_machine" "with_cdrom" {
  1245      name = "terraform-test-with-cdrom"
  1246  %s
  1247      vcpu = 2
  1248      memory = 4096
  1249      network_interface {
  1250          label = "%s"
  1251      }
  1252      disk {
  1253  %s
  1254          template = "%s"
  1255      }
  1256  
  1257      cdrom {
  1258          datastore = "%s"
  1259          path = "%s"
  1260      }
  1261  }
  1262  `
  1263  
  1264  const testAccCheckVSphereVirtualMachineConfig_withExistingVmdk = `
  1265  resource "vsphere_virtual_machine" "with_existing_vmdk" {
  1266      name = "terraform-test-with-existing-vmdk"
  1267  %s
  1268      vcpu = 2
  1269      memory = 4096
  1270      network_interface {
  1271          label = "%s"
  1272      }
  1273      disk {
  1274  %s
  1275          vmdk = "%s"
  1276  		bootable = true
  1277      }
  1278  }
  1279  `
  1280  
  1281  const testAccCheckVSphereVirtualMachineConfig_updateMemoryInitial = `
  1282  resource "vsphere_virtual_machine" "bar" {
  1283      name = "terraform-test"
  1284  %s
  1285      vcpu = 2
  1286      memory = 4096
  1287      network_interface {
  1288          label = "%s"
  1289      }
  1290      disk {
  1291  %s
  1292          template = "%s"
  1293      }
  1294  }
  1295  `
  1296  
  1297  const testAccCheckVSphereVirtualMachineConfig_updateMemoryUpdate = `
  1298  resource "vsphere_virtual_machine" "bar" {
  1299      name = "terraform-test"
  1300  %s
  1301      vcpu = 2
  1302      memory = 2048
  1303      network_interface {
  1304          label = "%s"
  1305      }
  1306      disk {
  1307  %s
  1308          template = "%s"
  1309      }
  1310  }
  1311  `
  1312  
  1313  const testAccCheckVSphereVirtualMachineConfig_updateVcpuInitial = `
  1314  resource "vsphere_virtual_machine" "bar" {
  1315      name = "terraform-test"
  1316  %s
  1317      vcpu = 2
  1318      memory = 4096
  1319      network_interface {
  1320          label = "%s"
  1321      }
  1322      disk {
  1323  %s
  1324          template = "%s"
  1325      }
  1326  }
  1327  `
  1328  
  1329  const testAccCheckVSphereVirtualMachineConfig_updateVcpuUpdate = `
  1330  resource "vsphere_virtual_machine" "bar" {
  1331      name = "terraform-test"
  1332  %s
  1333      vcpu = 4
  1334      memory = 4096
  1335      network_interface {
  1336          label = "%s"
  1337      }
  1338      disk {
  1339  %s
  1340          template = "%s"
  1341      }
  1342  }
  1343  `
  1344  
  1345  const testAccCheckVSphereVirtualMachineConfig_ipv4Andipv6 = `
  1346  resource "vsphere_virtual_machine" "ipv4ipv6" {
  1347      name = "terraform-test-ipv4-ipv6"
  1348  %s
  1349      vcpu = 2
  1350      memory = 4096
  1351      network_interface {
  1352          label = "%s"
  1353          ipv4_address = "%s"
  1354          ipv4_prefix_length = 24
  1355          ipv4_gateway = "%s"
  1356          ipv6_address = "%s"
  1357          ipv6_prefix_length = 64
  1358          ipv6_gateway = "%s"
  1359      }
  1360      disk {
  1361  %s
  1362          template = "%s"
  1363          iops = 500
  1364      }
  1365      disk {
  1366          size = 1
  1367          iops = 500
  1368  		name = "one"
  1369      }
  1370  }
  1371  `