github.com/vmware/govmomi@v0.43.0/simulator/task_manager_test.go (about)

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