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