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  `