github.com/vmware/govmomi@v0.51.0/simulator/datacenter_test.go (about)

     1  // © Broadcom. All Rights Reserved.
     2  // The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
     3  // SPDX-License-Identifier: Apache-2.0
     4  
     5  package simulator
     6  
     7  import (
     8  	"context"
     9  	"testing"
    10  
    11  	"github.com/vmware/govmomi"
    12  	"github.com/vmware/govmomi/find"
    13  	"github.com/vmware/govmomi/object"
    14  	"github.com/vmware/govmomi/simulator/esx"
    15  	"github.com/vmware/govmomi/simulator/vpx"
    16  	"github.com/vmware/govmomi/vim25/mo"
    17  	"github.com/vmware/govmomi/vim25/types"
    18  )
    19  
    20  func TestDatacenterCreateFolders(t *testing.T) {
    21  	// For this test we only want the RootFolder, 1 Datacenter and its child folders
    22  	models := []Model{
    23  		{
    24  			ServiceContent: esx.ServiceContent,
    25  			RootFolder:     esx.RootFolder,
    26  		},
    27  		{
    28  			ServiceContent: vpx.ServiceContent,
    29  			RootFolder:     vpx.RootFolder,
    30  			Datacenter:     1,
    31  		},
    32  	}
    33  
    34  	for _, model := range models {
    35  		_ = model.Create()
    36  
    37  		dc := model.Map().Any("Datacenter").(*Datacenter)
    38  
    39  		folders := []types.ManagedObjectReference{
    40  			dc.VmFolder,
    41  			dc.HostFolder,
    42  			dc.DatastoreFolder,
    43  			dc.NetworkFolder,
    44  		}
    45  
    46  		for _, ref := range folders {
    47  			if ref.Type == "" || ref.Value == "" {
    48  				t.Errorf("invalid moref=%#v", ref)
    49  			}
    50  
    51  			e := model.Map().Get(ref).(mo.Entity)
    52  
    53  			if e.Entity().Name == "" {
    54  				t.Error("empty name")
    55  			}
    56  
    57  			if *e.Entity().Parent != dc.Self {
    58  				t.Fail()
    59  			}
    60  
    61  			f, ok := e.(*Folder)
    62  			if !ok {
    63  				t.Fatalf("unexpected type (%T) for %#v", e, ref)
    64  			}
    65  
    66  			if model.Map().IsVPX() {
    67  				if len(f.ChildType) < 2 {
    68  					t.Fail()
    69  				}
    70  			} else {
    71  				if len(f.ChildType) != 1 {
    72  					t.Fail()
    73  				}
    74  			}
    75  		}
    76  	}
    77  }
    78  
    79  func TestDatacenterPowerOnMultiVMs(t *testing.T) {
    80  	ctx := context.Background()
    81  
    82  	m := VPX()
    83  	defer m.Remove()
    84  	err := m.Create()
    85  	if err != nil {
    86  		t.Fatal(err)
    87  	}
    88  
    89  	s := m.Service.NewServer()
    90  	defer s.Close()
    91  
    92  	c, err := govmomi.NewClient(ctx, s.URL, true)
    93  	if err != nil {
    94  		t.Fatal(err)
    95  	}
    96  
    97  	finder := find.NewFinder(c.Client, false)
    98  	dc, err := finder.DefaultDatacenter(ctx)
    99  	if err != nil {
   100  		t.Fatal(err)
   101  	}
   102  
   103  	finder.SetDatacenter(dc)
   104  
   105  	vms, err := finder.VirtualMachineList(ctx, "*")
   106  	if err != nil {
   107  		t.Fatal(err)
   108  	}
   109  
   110  	// Default inventory could change in future to many VMs, ensure we have
   111  	// at least these many VMs to test.
   112  	numTestVMs := 2
   113  	if len(vms) < numTestVMs {
   114  		t.Fatalf("Need at least %v VMs in a datacenter for this test", numTestVMs)
   115  	}
   116  	testVMs := []types.ManagedObjectReference{}
   117  	for _, vm := range vms[:numTestVMs] {
   118  		testVMs = append(testVMs, vm.Reference())
   119  	}
   120  
   121  	// Ensure VMs are powered off first before testing multi-VM power-on.
   122  	for _, vm := range vms[:numTestVMs] {
   123  		task, err := vm.PowerOff(ctx)
   124  		if err != nil {
   125  			t.Fatal(err)
   126  		}
   127  		err = task.Wait(ctx)
   128  		if err != nil {
   129  			t.Fatal(err)
   130  		}
   131  	}
   132  
   133  	// real VC ignores unknown VM refs
   134  	unknown := types.ManagedObjectReference{Type: "VirtualMachine", Value: "unknown"}
   135  
   136  	dcTask, err := dc.PowerOnVM(ctx, append(testVMs, unknown))
   137  	if err != nil {
   138  		t.Fatal(err)
   139  	}
   140  	info, err := dcTask.WaitForResult(ctx, nil)
   141  	if err != nil {
   142  		t.Fatal(err)
   143  	}
   144  	switch dcResult := info.Result.(type) {
   145  	case types.ClusterPowerOnVmResult:
   146  		if len(dcResult.Attempted) != len(testVMs) {
   147  			t.Fatalf("Unexpected per-vm tasks in results, found %v, expected %v",
   148  				len(dcResult.Attempted), len(testVMs))
   149  		}
   150  		for i, vmResult := range dcResult.Attempted {
   151  			if vmResult.Task == nil {
   152  				t.Fatalf("Found per-vm task nil for VM #%v", i)
   153  			}
   154  			vmTask := object.NewTask(c.Client, *vmResult.Task)
   155  			err := vmTask.Wait(ctx)
   156  			if err != nil {
   157  				t.Fatalf("%v", err)
   158  			}
   159  		}
   160  	default:
   161  		t.Fatalf("Unexpected result type %T returned for DC PowerOnMultiVM", dcResult)
   162  	}
   163  }