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

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