github.com/vmware/govmomi@v0.51.0/simulator/task_manager_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_test
     6  
     7  import (
     8  	"context"
     9  	"testing"
    10  
    11  	"github.com/vmware/govmomi/object"
    12  	"github.com/vmware/govmomi/property"
    13  	"github.com/vmware/govmomi/simulator"
    14  	"github.com/vmware/govmomi/task"
    15  	"github.com/vmware/govmomi/vim25"
    16  	"github.com/vmware/govmomi/vim25/mo"
    17  	"github.com/vmware/govmomi/vim25/types"
    18  )
    19  
    20  func TestTaskManagerRecent(t *testing.T) {
    21  	simulator.Test(func(ctx context.Context, c *vim25.Client) {
    22  		ref := simulator.Map(ctx).Any("VirtualMachine").Reference()
    23  		vm := object.NewVirtualMachine(c, ref)
    24  
    25  		tasks := func() int {
    26  			var m mo.TaskManager
    27  			pc := property.DefaultCollector(c)
    28  			err := pc.RetrieveOne(ctx, *c.ServiceContent.TaskManager, nil, &m)
    29  			if err != nil {
    30  				t.Fatal(err)
    31  			}
    32  			return len(m.RecentTask)
    33  		}
    34  
    35  		start := tasks()
    36  		if start == 0 {
    37  			t.Fatal("recentTask is empty")
    38  		}
    39  
    40  		task, err := vm.PowerOff(ctx)
    41  		if err != nil {
    42  			t.Fatal(err)
    43  		}
    44  		if err = task.WaitEx(ctx); err != nil {
    45  			t.Fatal(err)
    46  		}
    47  
    48  		end := tasks()
    49  		if end == 0 {
    50  			t.Fatal("recentTask is empty")
    51  		}
    52  		if start == end {
    53  			t.Fatal("recentTask not updated")
    54  		}
    55  	})
    56  }
    57  
    58  func TestTaskManagerRead(t *testing.T) {
    59  	simulator.Test(func(ctx context.Context, vc *vim25.Client) {
    60  		spec := types.TaskFilterSpec{
    61  			Entity: &types.TaskFilterSpecByEntity{
    62  				Entity:    vc.ServiceContent.RootFolder,
    63  				Recursion: types.TaskFilterSpecRecursionOptionAll,
    64  			},
    65  		}
    66  		tm := task.NewManager(vc)
    67  		c, err := tm.CreateCollectorForTasks(ctx, spec)
    68  		if err != nil {
    69  			t.Fatal(err)
    70  		}
    71  
    72  		page, err := c.LatestPage(ctx)
    73  		if err != nil {
    74  			t.Fatal(err)
    75  		}
    76  		ntasks := len(page)
    77  		if ntasks == 0 {
    78  			t.Fatal("no recent tasks")
    79  		}
    80  		tests := []struct {
    81  			max    int
    82  			rewind bool
    83  			order  bool
    84  			read   func(context.Context, int32) ([]types.TaskInfo, error)
    85  		}{
    86  			{ntasks, true, true, c.ReadNextTasks},
    87  			{ntasks / 3, true, true, c.ReadNextTasks},
    88  			{ntasks * 3, false, true, c.ReadNextTasks},
    89  			{3, false, false, c.ReadPreviousTasks},
    90  			{ntasks * 3, false, true, c.ReadNextTasks},
    91  		}
    92  
    93  		for _, test := range tests {
    94  			var all []types.TaskInfo
    95  			count := 0
    96  			for {
    97  				tasks, err := test.read(ctx, int32(test.max))
    98  				if err != nil {
    99  					t.Fatal(err)
   100  				}
   101  				if len(tasks) == 0 {
   102  					// expecting 0 below as we've read all tasks in the page
   103  					ztasks, nerr := test.read(ctx, int32(test.max))
   104  					if nerr != nil {
   105  						t.Fatal(nerr)
   106  					}
   107  					if len(ztasks) != 0 {
   108  						t.Errorf("ztasks=%d", len(ztasks))
   109  					}
   110  					break
   111  				}
   112  				count += len(tasks)
   113  				all = append(all, tasks...)
   114  			}
   115  			if count < len(page) {
   116  				t.Errorf("expected at least %d tasks, got: %d", len(page), count)
   117  			}
   118  
   119  			if test.rewind {
   120  				if err = c.Rewind(ctx); err != nil {
   121  					t.Error(err)
   122  				}
   123  			}
   124  		}
   125  
   126  		// after Reset() we should only get tasks via ReadPreviousTasks
   127  		if err = c.Reset(ctx); err != nil {
   128  			t.Fatal(err)
   129  		}
   130  
   131  		tasks, err := c.ReadNextTasks(ctx, int32(ntasks))
   132  		if err != nil {
   133  			t.Fatal(err)
   134  		}
   135  		if len(tasks) != 0 {
   136  			t.Errorf("expected 0 tasks, got %d", len(tasks))
   137  		}
   138  
   139  		ref := simulator.Map(ctx).Any("VirtualMachine").Reference()
   140  		vm := object.NewVirtualMachine(vc, ref)
   141  		if _, err = vm.PowerOff(ctx); err != nil {
   142  			t.Fatal(err)
   143  		}
   144  
   145  		tasks, err = c.ReadNextTasks(ctx, int32(ntasks))
   146  		if err != nil {
   147  			t.Fatal(err)
   148  		}
   149  		if len(tasks) != 1 {
   150  			t.Errorf("expected 1 tasks, got %d", len(tasks))
   151  		}
   152  
   153  		count := 0
   154  		for {
   155  			tasks, err = c.ReadPreviousTasks(ctx, 3)
   156  			if err != nil {
   157  				t.Fatal(err)
   158  			}
   159  			if len(tasks) == 0 {
   160  				break
   161  			}
   162  			count += len(tasks)
   163  		}
   164  		if count < ntasks {
   165  			t.Errorf("expected %d tasks, got %d", ntasks, count)
   166  		}
   167  	})
   168  }