github.com/andresvia/terraform@v0.6.15-0.20160412045437-d51c75946785/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_NETWORK_GATEWAY")
    38  	label := os.Getenv("VSPHERE_NETWORK_LABEL")
    39  	ip_address := os.Getenv("VSPHERE_NETWORK_IP_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  					datastoreOpt,
    54  					template,
    55  				),
    56  				Check: resource.ComposeTestCheckFunc(
    57  					testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.foo", &vm),
    58  					resource.TestCheckResourceAttr(
    59  						"vsphere_virtual_machine.foo", "name", "terraform-test"),
    60  					resource.TestCheckResourceAttr(
    61  						"vsphere_virtual_machine.foo", "vcpu", "2"),
    62  					resource.TestCheckResourceAttr(
    63  						"vsphere_virtual_machine.foo", "memory", "4096"),
    64  					resource.TestCheckResourceAttr(
    65  						"vsphere_virtual_machine.foo", "disk.#", "2"),
    66  					resource.TestCheckResourceAttr(
    67  						"vsphere_virtual_machine.foo", "disk.0.template", template),
    68  					resource.TestCheckResourceAttr(
    69  						"vsphere_virtual_machine.foo", "network_interface.#", "1"),
    70  					resource.TestCheckResourceAttr(
    71  						"vsphere_virtual_machine.foo", "network_interface.0.label", label),
    72  				),
    73  			},
    74  		},
    75  	})
    76  }
    77  
    78  func TestAccVSphereVirtualMachine_diskInitType(t *testing.T) {
    79  	var vm virtualMachine
    80  	var locationOpt string
    81  	var datastoreOpt string
    82  
    83  	if v := os.Getenv("VSPHERE_DATACENTER"); v != "" {
    84  		locationOpt += fmt.Sprintf("    datacenter = \"%s\"\n", v)
    85  	}
    86  	if v := os.Getenv("VSPHERE_CLUSTER"); v != "" {
    87  		locationOpt += fmt.Sprintf("    cluster = \"%s\"\n", v)
    88  	}
    89  	if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" {
    90  		locationOpt += fmt.Sprintf("    resource_pool = \"%s\"\n", v)
    91  	}
    92  	if v := os.Getenv("VSPHERE_DATASTORE"); v != "" {
    93  		datastoreOpt = fmt.Sprintf("        datastore = \"%s\"\n", v)
    94  	}
    95  	template := os.Getenv("VSPHERE_TEMPLATE")
    96  	gateway := os.Getenv("VSPHERE_NETWORK_GATEWAY")
    97  	label := os.Getenv("VSPHERE_NETWORK_LABEL")
    98  	ip_address := os.Getenv("VSPHERE_NETWORK_IP_ADDRESS")
    99  
   100  	resource.Test(t, resource.TestCase{
   101  		PreCheck:     func() { testAccPreCheck(t) },
   102  		Providers:    testAccProviders,
   103  		CheckDestroy: testAccCheckVSphereVirtualMachineDestroy,
   104  		Steps: []resource.TestStep{
   105  			resource.TestStep{
   106  				Config: fmt.Sprintf(
   107  					testAccCheckVSphereVirtualMachineConfig_initType,
   108  					locationOpt,
   109  					gateway,
   110  					label,
   111  					ip_address,
   112  					datastoreOpt,
   113  					template,
   114  				),
   115  				Check: resource.ComposeTestCheckFunc(
   116  					testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.thin", &vm),
   117  					resource.TestCheckResourceAttr(
   118  						"vsphere_virtual_machine.thin", "name", "terraform-test"),
   119  					resource.TestCheckResourceAttr(
   120  						"vsphere_virtual_machine.thin", "vcpu", "2"),
   121  					resource.TestCheckResourceAttr(
   122  						"vsphere_virtual_machine.thin", "memory", "4096"),
   123  					resource.TestCheckResourceAttr(
   124  						"vsphere_virtual_machine.thin", "disk.#", "2"),
   125  					resource.TestCheckResourceAttr(
   126  						"vsphere_virtual_machine.thin", "disk.0.template", template),
   127  					resource.TestCheckResourceAttr(
   128  						"vsphere_virtual_machine.thin", "disk.0.type", "thin"),
   129  					resource.TestCheckResourceAttr(
   130  						"vsphere_virtual_machine.thin", "disk.1.type", "eager_zeroed"),
   131  					resource.TestCheckResourceAttr(
   132  						"vsphere_virtual_machine.thin", "network_interface.#", "1"),
   133  					resource.TestCheckResourceAttr(
   134  						"vsphere_virtual_machine.thin", "network_interface.0.label", label),
   135  				),
   136  			},
   137  		},
   138  	})
   139  }
   140  
   141  func TestAccVSphereVirtualMachine_dhcp(t *testing.T) {
   142  	var vm virtualMachine
   143  	var locationOpt string
   144  	var datastoreOpt string
   145  
   146  	if v := os.Getenv("VSPHERE_DATACENTER"); v != "" {
   147  		locationOpt += fmt.Sprintf("    datacenter = \"%s\"\n", v)
   148  	}
   149  	if v := os.Getenv("VSPHERE_CLUSTER"); v != "" {
   150  		locationOpt += fmt.Sprintf("    cluster = \"%s\"\n", v)
   151  	}
   152  	if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" {
   153  		locationOpt += fmt.Sprintf("    resource_pool = \"%s\"\n", v)
   154  	}
   155  	if v := os.Getenv("VSPHERE_DATASTORE"); v != "" {
   156  		datastoreOpt = fmt.Sprintf("        datastore = \"%s\"\n", v)
   157  	}
   158  	template := os.Getenv("VSPHERE_TEMPLATE")
   159  	label := os.Getenv("VSPHERE_NETWORK_LABEL_DHCP")
   160  
   161  	resource.Test(t, resource.TestCase{
   162  		PreCheck:     func() { testAccPreCheck(t) },
   163  		Providers:    testAccProviders,
   164  		CheckDestroy: testAccCheckVSphereVirtualMachineDestroy,
   165  		Steps: []resource.TestStep{
   166  			resource.TestStep{
   167  				Config: fmt.Sprintf(
   168  					testAccCheckVSphereVirtualMachineConfig_dhcp,
   169  					locationOpt,
   170  					label,
   171  					datastoreOpt,
   172  					template,
   173  				),
   174  				Check: resource.ComposeTestCheckFunc(
   175  					testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.bar", &vm),
   176  					resource.TestCheckResourceAttr(
   177  						"vsphere_virtual_machine.bar", "name", "terraform-test"),
   178  					resource.TestCheckResourceAttr(
   179  						"vsphere_virtual_machine.bar", "vcpu", "2"),
   180  					resource.TestCheckResourceAttr(
   181  						"vsphere_virtual_machine.bar", "memory", "4096"),
   182  					resource.TestCheckResourceAttr(
   183  						"vsphere_virtual_machine.bar", "disk.#", "1"),
   184  					resource.TestCheckResourceAttr(
   185  						"vsphere_virtual_machine.bar", "disk.0.template", template),
   186  					resource.TestCheckResourceAttr(
   187  						"vsphere_virtual_machine.bar", "network_interface.#", "1"),
   188  					resource.TestCheckResourceAttr(
   189  						"vsphere_virtual_machine.bar", "network_interface.0.label", label),
   190  				),
   191  			},
   192  		},
   193  	})
   194  }
   195  
   196  func TestAccVSphereVirtualMachine_custom_configs(t *testing.T) {
   197  	var vm virtualMachine
   198  	var locationOpt string
   199  	var datastoreOpt string
   200  
   201  	if v := os.Getenv("VSPHERE_DATACENTER"); v != "" {
   202  		locationOpt += fmt.Sprintf("    datacenter = \"%s\"\n", v)
   203  	}
   204  	if v := os.Getenv("VSPHERE_CLUSTER"); v != "" {
   205  		locationOpt += fmt.Sprintf("    cluster = \"%s\"\n", v)
   206  	}
   207  	if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" {
   208  		locationOpt += fmt.Sprintf("    resource_pool = \"%s\"\n", v)
   209  	}
   210  	if v := os.Getenv("VSPHERE_DATASTORE"); v != "" {
   211  		datastoreOpt = fmt.Sprintf("        datastore = \"%s\"\n", v)
   212  	}
   213  	template := os.Getenv("VSPHERE_TEMPLATE")
   214  	label := os.Getenv("VSPHERE_NETWORK_LABEL_DHCP")
   215  
   216  	resource.Test(t, resource.TestCase{
   217  		PreCheck:     func() { testAccPreCheck(t) },
   218  		Providers:    testAccProviders,
   219  		CheckDestroy: testAccCheckVSphereVirtualMachineDestroy,
   220  		Steps: []resource.TestStep{
   221  			resource.TestStep{
   222  				Config: fmt.Sprintf(
   223  					testAccCheckVSphereVirtualMachineConfig_custom_configs,
   224  					locationOpt,
   225  					label,
   226  					datastoreOpt,
   227  					template,
   228  				),
   229  				Check: resource.ComposeTestCheckFunc(
   230  					testAccCheckVSphereVirtualMachineExistsHasCustomConfig("vsphere_virtual_machine.car", &vm),
   231  					resource.TestCheckResourceAttr(
   232  						"vsphere_virtual_machine.car", "name", "terraform-test-custom"),
   233  					resource.TestCheckResourceAttr(
   234  						"vsphere_virtual_machine.car", "vcpu", "2"),
   235  					resource.TestCheckResourceAttr(
   236  						"vsphere_virtual_machine.car", "memory", "4096"),
   237  					resource.TestCheckResourceAttr(
   238  						"vsphere_virtual_machine.car", "disk.#", "1"),
   239  					resource.TestCheckResourceAttr(
   240  						"vsphere_virtual_machine.car", "disk.0.template", template),
   241  					resource.TestCheckResourceAttr(
   242  						"vsphere_virtual_machine.car", "network_interface.#", "1"),
   243  					resource.TestCheckResourceAttr(
   244  						"vsphere_virtual_machine.car", "custom_configuration_parameters.foo", "bar"),
   245  					resource.TestCheckResourceAttr(
   246  						"vsphere_virtual_machine.car", "custom_configuration_parameters.car", "ferrari"),
   247  					resource.TestCheckResourceAttr(
   248  						"vsphere_virtual_machine.car", "custom_configuration_parameters.num", "42"),
   249  					resource.TestCheckResourceAttr(
   250  						"vsphere_virtual_machine.car", "network_interface.0.label", label),
   251  				),
   252  			},
   253  		},
   254  	})
   255  }
   256  
   257  func TestAccVSphereVirtualMachine_createInExistingFolder(t *testing.T) {
   258  	var vm virtualMachine
   259  	var locationOpt string
   260  	var datastoreOpt string
   261  	var datacenter string
   262  
   263  	folder := "tf_test_createInExistingFolder"
   264  
   265  	if v := os.Getenv("VSPHERE_DATACENTER"); v != "" {
   266  		locationOpt += fmt.Sprintf("    datacenter = \"%s\"\n", v)
   267  		datacenter = v
   268  	}
   269  	if v := os.Getenv("VSPHERE_CLUSTER"); v != "" {
   270  		locationOpt += fmt.Sprintf("    cluster = \"%s\"\n", v)
   271  	}
   272  	if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" {
   273  		locationOpt += fmt.Sprintf("    resource_pool = \"%s\"\n", v)
   274  	}
   275  	if v := os.Getenv("VSPHERE_DATASTORE"); v != "" {
   276  		datastoreOpt = fmt.Sprintf("        datastore = \"%s\"\n", v)
   277  	}
   278  	template := os.Getenv("VSPHERE_TEMPLATE")
   279  	label := os.Getenv("VSPHERE_NETWORK_LABEL_DHCP")
   280  
   281  	resource.Test(t, resource.TestCase{
   282  		PreCheck:  func() { testAccPreCheck(t) },
   283  		Providers: testAccProviders,
   284  		CheckDestroy: resource.ComposeTestCheckFunc(
   285  			testAccCheckVSphereVirtualMachineDestroy,
   286  			removeVSphereFolder(datacenter, folder, ""),
   287  		),
   288  		Steps: []resource.TestStep{
   289  			resource.TestStep{
   290  				PreConfig: func() { createVSphereFolder(datacenter, folder) },
   291  				Config: fmt.Sprintf(
   292  					testAccCheckVSphereVirtualMachineConfig_createInFolder,
   293  					folder,
   294  					locationOpt,
   295  					label,
   296  					datastoreOpt,
   297  					template,
   298  				),
   299  				Check: resource.ComposeTestCheckFunc(
   300  					testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.folder", &vm),
   301  					resource.TestCheckResourceAttr(
   302  						"vsphere_virtual_machine.folder", "name", "terraform-test-folder"),
   303  					resource.TestCheckResourceAttr(
   304  						"vsphere_virtual_machine.folder", "folder", folder),
   305  					resource.TestCheckResourceAttr(
   306  						"vsphere_virtual_machine.folder", "vcpu", "2"),
   307  					resource.TestCheckResourceAttr(
   308  						"vsphere_virtual_machine.folder", "memory", "4096"),
   309  					resource.TestCheckResourceAttr(
   310  						"vsphere_virtual_machine.folder", "disk.#", "1"),
   311  					resource.TestCheckResourceAttr(
   312  						"vsphere_virtual_machine.folder", "disk.0.template", template),
   313  					resource.TestCheckResourceAttr(
   314  						"vsphere_virtual_machine.folder", "network_interface.#", "1"),
   315  					resource.TestCheckResourceAttr(
   316  						"vsphere_virtual_machine.folder", "network_interface.0.label", label),
   317  				),
   318  			},
   319  		},
   320  	})
   321  }
   322  
   323  func TestAccVSphereVirtualMachine_createWithFolder(t *testing.T) {
   324  	var vm virtualMachine
   325  	var f folder
   326  	var locationOpt string
   327  	var folderLocationOpt string
   328  	var datastoreOpt string
   329  
   330  	folder := "tf_test_createWithFolder"
   331  
   332  	if v := os.Getenv("VSPHERE_DATACENTER"); v != "" {
   333  		folderLocationOpt = fmt.Sprintf("    datacenter = \"%s\"\n", v)
   334  		locationOpt += folderLocationOpt
   335  	}
   336  	if v := os.Getenv("VSPHERE_CLUSTER"); v != "" {
   337  		locationOpt += fmt.Sprintf("    cluster = \"%s\"\n", v)
   338  	}
   339  	if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" {
   340  		locationOpt += fmt.Sprintf("    resource_pool = \"%s\"\n", v)
   341  	}
   342  	if v := os.Getenv("VSPHERE_DATASTORE"); v != "" {
   343  		datastoreOpt = fmt.Sprintf("        datastore = \"%s\"\n", v)
   344  	}
   345  	template := os.Getenv("VSPHERE_TEMPLATE")
   346  	label := os.Getenv("VSPHERE_NETWORK_LABEL_DHCP")
   347  
   348  	resource.Test(t, resource.TestCase{
   349  		PreCheck:  func() { testAccPreCheck(t) },
   350  		Providers: testAccProviders,
   351  		CheckDestroy: resource.ComposeTestCheckFunc(
   352  			testAccCheckVSphereVirtualMachineDestroy,
   353  			testAccCheckVSphereFolderDestroy,
   354  		),
   355  		Steps: []resource.TestStep{
   356  			resource.TestStep{
   357  				Config: fmt.Sprintf(
   358  					testAccCheckVSphereVirtualMachineConfig_createWithFolder,
   359  					folder,
   360  					folderLocationOpt,
   361  					locationOpt,
   362  					label,
   363  					datastoreOpt,
   364  					template,
   365  				),
   366  				Check: resource.ComposeTestCheckFunc(
   367  					testAccCheckVSphereVirtualMachineExists("vsphere_virtual_machine.with_folder", &vm),
   368  					testAccCheckVSphereFolderExists("vsphere_folder.with_folder", &f),
   369  					resource.TestCheckResourceAttr(
   370  						"vsphere_virtual_machine.with_folder", "name", "terraform-test-with-folder"),
   371  					// resource.TestCheckResourceAttr(
   372  					// 	"vsphere_virtual_machine.with_folder", "folder", folder),
   373  					resource.TestCheckResourceAttr(
   374  						"vsphere_virtual_machine.with_folder", "vcpu", "2"),
   375  					resource.TestCheckResourceAttr(
   376  						"vsphere_virtual_machine.with_folder", "memory", "4096"),
   377  					resource.TestCheckResourceAttr(
   378  						"vsphere_virtual_machine.with_folder", "disk.#", "1"),
   379  					resource.TestCheckResourceAttr(
   380  						"vsphere_virtual_machine.with_folder", "disk.0.template", template),
   381  					resource.TestCheckResourceAttr(
   382  						"vsphere_virtual_machine.with_folder", "network_interface.#", "1"),
   383  					resource.TestCheckResourceAttr(
   384  						"vsphere_virtual_machine.with_folder", "network_interface.0.label", label),
   385  				),
   386  			},
   387  		},
   388  	})
   389  }
   390  
   391  func testAccCheckVSphereVirtualMachineDestroy(s *terraform.State) error {
   392  	client := testAccProvider.Meta().(*govmomi.Client)
   393  	finder := find.NewFinder(client.Client, true)
   394  
   395  	for _, rs := range s.RootModule().Resources {
   396  		if rs.Type != "vsphere_virtual_machine" {
   397  			continue
   398  		}
   399  
   400  		dc, err := finder.Datacenter(context.TODO(), rs.Primary.Attributes["datacenter"])
   401  		if err != nil {
   402  			return fmt.Errorf("error %s", err)
   403  		}
   404  
   405  		dcFolders, err := dc.Folders(context.TODO())
   406  		if err != nil {
   407  			return fmt.Errorf("error %s", err)
   408  		}
   409  
   410  		folder := dcFolders.VmFolder
   411  		if len(rs.Primary.Attributes["folder"]) > 0 {
   412  			si := object.NewSearchIndex(client.Client)
   413  			folderRef, err := si.FindByInventoryPath(
   414  				context.TODO(), fmt.Sprintf("%v/vm/%v", rs.Primary.Attributes["datacenter"], rs.Primary.Attributes["folder"]))
   415  			if err != nil {
   416  				return err
   417  			} else if folderRef != nil {
   418  				folder = folderRef.(*object.Folder)
   419  			}
   420  		}
   421  
   422  		v, err := object.NewSearchIndex(client.Client).FindChild(context.TODO(), folder, rs.Primary.Attributes["name"])
   423  
   424  		if v != nil {
   425  			return fmt.Errorf("Record still exists")
   426  		}
   427  	}
   428  
   429  	return nil
   430  }
   431  
   432  func testAccCheckVSphereVirtualMachineExistsHasCustomConfig(n string, vm *virtualMachine) resource.TestCheckFunc {
   433  	return func(s *terraform.State) error {
   434  
   435  		rs, ok := s.RootModule().Resources[n]
   436  		if !ok {
   437  			return fmt.Errorf("Not found: %s", n)
   438  		}
   439  
   440  		if rs.Primary.ID == "" {
   441  			return fmt.Errorf("No ID is set")
   442  		}
   443  
   444  		client := testAccProvider.Meta().(*govmomi.Client)
   445  		finder := find.NewFinder(client.Client, true)
   446  
   447  		dc, err := finder.Datacenter(context.TODO(), rs.Primary.Attributes["datacenter"])
   448  		if err != nil {
   449  			return fmt.Errorf("error %s", err)
   450  		}
   451  
   452  		dcFolders, err := dc.Folders(context.TODO())
   453  		if err != nil {
   454  			return fmt.Errorf("error %s", err)
   455  		}
   456  
   457  		_, err = object.NewSearchIndex(client.Client).FindChild(context.TODO(), dcFolders.VmFolder, rs.Primary.Attributes["name"])
   458  		if err != nil {
   459  			return fmt.Errorf("error %s", err)
   460  		}
   461  
   462  		finder = finder.SetDatacenter(dc)
   463  		instance, err := finder.VirtualMachine(context.TODO(), rs.Primary.Attributes["name"])
   464  		if err != nil {
   465  			return fmt.Errorf("error %s", err)
   466  		}
   467  
   468  		var mvm mo.VirtualMachine
   469  
   470  		collector := property.DefaultCollector(client.Client)
   471  
   472  		if err := collector.RetrieveOne(context.TODO(), instance.Reference(), []string{"config.extraConfig"}, &mvm); err != nil {
   473  			return fmt.Errorf("error %s", err)
   474  		}
   475  
   476  		var configMap = make(map[string]types.AnyType)
   477  		if mvm.Config != nil && mvm.Config.ExtraConfig != nil && len(mvm.Config.ExtraConfig) > 0 {
   478  			for _, v := range mvm.Config.ExtraConfig {
   479  				value := v.GetOptionValue()
   480  				configMap[value.Key] = value.Value
   481  			}
   482  		} else {
   483  			return fmt.Errorf("error no ExtraConfig")
   484  		}
   485  
   486  		if configMap["foo"] == nil {
   487  			return fmt.Errorf("error no ExtraConfig for 'foo'")
   488  		}
   489  
   490  		if configMap["foo"] != "bar" {
   491  			return fmt.Errorf("error ExtraConfig 'foo' != bar")
   492  		}
   493  
   494  		if configMap["car"] == nil {
   495  			return fmt.Errorf("error no ExtraConfig for 'car'")
   496  		}
   497  
   498  		if configMap["car"] != "ferrari" {
   499  			return fmt.Errorf("error ExtraConfig 'car' != ferrari")
   500  		}
   501  
   502  		if configMap["num"] == nil {
   503  			return fmt.Errorf("error no ExtraConfig for 'num'")
   504  		}
   505  
   506  		// todo this should be an int, getting back a string
   507  		if configMap["num"] != "42" {
   508  			return fmt.Errorf("error ExtraConfig 'num' != 42")
   509  		}
   510  		*vm = virtualMachine{
   511  			name: rs.Primary.ID,
   512  		}
   513  
   514  		return nil
   515  	}
   516  }
   517  
   518  func testAccCheckVSphereVirtualMachineExists(n string, vm *virtualMachine) resource.TestCheckFunc {
   519  	return func(s *terraform.State) error {
   520  		rs, ok := s.RootModule().Resources[n]
   521  		if !ok {
   522  			return fmt.Errorf("Not found: %s", n)
   523  		}
   524  
   525  		if rs.Primary.ID == "" {
   526  			return fmt.Errorf("No ID is set")
   527  		}
   528  
   529  		client := testAccProvider.Meta().(*govmomi.Client)
   530  		finder := find.NewFinder(client.Client, true)
   531  
   532  		dc, err := finder.Datacenter(context.TODO(), rs.Primary.Attributes["datacenter"])
   533  		if err != nil {
   534  			return fmt.Errorf("error %s", err)
   535  		}
   536  
   537  		dcFolders, err := dc.Folders(context.TODO())
   538  		if err != nil {
   539  			return fmt.Errorf("error %s", err)
   540  		}
   541  
   542  		folder := dcFolders.VmFolder
   543  		if len(rs.Primary.Attributes["folder"]) > 0 {
   544  			si := object.NewSearchIndex(client.Client)
   545  			folderRef, err := si.FindByInventoryPath(
   546  				context.TODO(), fmt.Sprintf("%v/vm/%v", rs.Primary.Attributes["datacenter"], rs.Primary.Attributes["folder"]))
   547  			if err != nil {
   548  				return err
   549  			} else if folderRef != nil {
   550  				folder = folderRef.(*object.Folder)
   551  			}
   552  		}
   553  
   554  		_, err = object.NewSearchIndex(client.Client).FindChild(context.TODO(), folder, rs.Primary.Attributes["name"])
   555  
   556  		*vm = virtualMachine{
   557  			name: rs.Primary.ID,
   558  		}
   559  
   560  		return nil
   561  	}
   562  }
   563  
   564  const testAccCheckVSphereVirtualMachineConfig_basic = `
   565  resource "vsphere_virtual_machine" "foo" {
   566      name = "terraform-test"
   567  %s
   568      vcpu = 2
   569      memory = 4096
   570      gateway = "%s"
   571      network_interface {
   572          label = "%s"
   573          ipv4_address = "%s"
   574          ipv4_prefix_length = 24
   575      }
   576      disk {
   577  %s
   578          template = "%s"
   579          iops = 500
   580      }
   581      disk {
   582          size = 1
   583          iops = 500
   584      }
   585  }
   586  `
   587  const testAccCheckVSphereVirtualMachineConfig_initType = `
   588  resource "vsphere_virtual_machine" "thin" {
   589      name = "terraform-test"
   590  %s
   591      vcpu = 2
   592      memory = 4096
   593      gateway = "%s"
   594      network_interface {
   595          label = "%s"
   596          ipv4_address = "%s"
   597          ipv4_prefix_length = 24
   598      }
   599      disk {
   600  %s
   601          template = "%s"
   602          iops = 500
   603          type = "thin"
   604      }
   605      disk {
   606          size = 1
   607          iops = 500
   608      }
   609  }
   610  `
   611  const testAccCheckVSphereVirtualMachineConfig_dhcp = `
   612  resource "vsphere_virtual_machine" "bar" {
   613      name = "terraform-test"
   614  %s
   615      vcpu = 2
   616      memory = 4096
   617      network_interface {
   618          label = "%s"
   619      }
   620      disk {
   621  %s
   622          template = "%s"
   623      }
   624  }
   625  `
   626  
   627  const testAccCheckVSphereVirtualMachineConfig_custom_configs = `
   628  resource "vsphere_virtual_machine" "car" {
   629      name = "terraform-test-custom"
   630  %s
   631      vcpu = 2
   632      memory = 4096
   633      network_interface {
   634          label = "%s"
   635      }
   636      custom_configuration_parameters {
   637  	"foo" = "bar"
   638  	"car" = "ferrari"
   639  	"num" = 42
   640      }
   641      disk {
   642  %s
   643          template = "%s"
   644      }
   645  }
   646  `
   647  
   648  const testAccCheckVSphereVirtualMachineConfig_createInFolder = `
   649  resource "vsphere_virtual_machine" "folder" {
   650      name = "terraform-test-folder"
   651      folder = "%s"
   652  %s
   653      vcpu = 2
   654      memory = 4096
   655      network_interface {
   656          label = "%s"
   657      }
   658      disk {
   659  %s
   660          template = "%s"
   661      }
   662  }
   663  `
   664  
   665  const testAccCheckVSphereVirtualMachineConfig_createWithFolder = `
   666  resource "vsphere_folder" "with_folder" {
   667  	path = "%s"	
   668  %s
   669  }
   670  resource "vsphere_virtual_machine" "with_folder" {
   671      name = "terraform-test-with-folder"
   672      folder = "${vsphere_folder.with_folder.path}"
   673  %s
   674      vcpu = 2
   675      memory = 4096
   676      network_interface {
   677          label = "%s"
   678      }
   679      disk {
   680  %s
   681          template = "%s"
   682      }
   683  }
   684  `