diff --git a/changelogs/unreleased/9130-blackpiglet b/changelogs/unreleased/9130-blackpiglet new file mode 100644 index 000000000..44bf261a9 --- /dev/null +++ b/changelogs/unreleased/9130-blackpiglet @@ -0,0 +1 @@ +Fix the dd and du's node affinity issue. diff --git a/pkg/controller/data_download_controller.go b/pkg/controller/data_download_controller.go index 476ac4c3a..c4b6f63ba 100644 --- a/pkg/controller/data_download_controller.go +++ b/pkg/controller/data_download_controller.go @@ -878,8 +878,6 @@ func (r *DataDownloadReconciler) setupExposeParam(dd *velerov2alpha1api.DataDown } } - affinity := kube.GetLoadAffinityByStorageClass(r.loadAffinity, dd.Spec.BackupStorageLocation, log) - return exposer.GenericRestoreExposeParam{ TargetPVCName: dd.Spec.TargetVolume.PVC, TargetNamespace: dd.Spec.TargetVolume.Namespace, @@ -891,7 +889,7 @@ func (r *DataDownloadReconciler) setupExposeParam(dd *velerov2alpha1api.DataDown ExposeTimeout: r.preparingTimeout, NodeOS: nodeOS, RestorePVCConfig: r.restorePVCConfig, - LoadAffinity: affinity, + LoadAffinity: r.loadAffinity, }, nil } diff --git a/pkg/controller/data_download_controller_test.go b/pkg/controller/data_download_controller_test.go index fd24162b2..4dc17ea9f 100644 --- a/pkg/controller/data_download_controller_test.go +++ b/pkg/controller/data_download_controller_test.go @@ -334,7 +334,7 @@ func TestDataDownloadReconcile(t *testing.T) { { name: "dd expose failed", dd: dataDownloadBuilder().Finalizers([]string{DataUploadDownloadFinalizer}).Result(), - targetPVC: builder.ForPersistentVolumeClaim("test-ns", "test-pvc").Result(), + targetPVC: builder.ForPersistentVolumeClaim("test-ns", "test-pvc").StorageClass("test-sc").Result(), isExposeErr: true, expected: dataDownloadBuilder().Finalizers([]string{DataUploadDownloadFinalizer}).Phase(velerov2alpha1api.DataDownloadPhaseFailed).Message("error to expose snapshot").Result(), expectedErr: "Error to expose restore exposer", @@ -465,6 +465,12 @@ func TestDataDownloadReconcile(t *testing.T) { expectDataPath: true, expectCancelRecord: true, }, + { + name: "pvc StorageClass is nil", + dd: dataDownloadBuilder().Finalizers([]string{DataUploadDownloadFinalizer}).Result(), + targetPVC: builder.ForPersistentVolumeClaim("test-ns", "test-pvc").Result(), + expected: dataDownloadBuilder().Finalizers([]string{DataUploadDownloadFinalizer}).Phase(velerov2alpha1api.DataDownloadPhaseAccepted).Result(), + }, } for _, test := range tests { @@ -536,9 +542,9 @@ func TestDataDownloadReconcile(t *testing.T) { r.restoreExposer = nil } else { r.restoreExposer = func() exposer.GenericRestoreExposer { - ep := exposermockes.NewGenericRestoreExposer(t) + ep := exposermockes.NewMockGenericRestoreExposer(t) if test.isExposeErr { - ep.On("Expose", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New("Error to expose restore exposer")) + ep.On("Expose", mock.Anything, mock.Anything, mock.Anything).Return(errors.New("Error to expose restore exposer")) } else if test.notNilExpose { hostingPod := builder.ForPod("test-ns", "test-name").Volumes(&corev1api.Volume{Name: "test-pvc"}).Result() hostingPod.ObjectMeta.SetUID("test-uid") @@ -699,7 +705,7 @@ func TestOnDataDownloadCompleted(t *testing.T) { needErrs := []bool{test.isGetErr, false, false, false} r, err := initDataDownloadReconciler(t, nil, needErrs...) r.restoreExposer = func() exposer.GenericRestoreExposer { - ep := exposermockes.NewGenericRestoreExposer(t) + ep := exposermockes.NewMockGenericRestoreExposer(t) if test.rebindVolumeErr { ep.On("RebindVolume", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New("Error to rebind volume")) } else { diff --git a/pkg/controller/data_upload_controller.go b/pkg/controller/data_upload_controller.go index 17b274db2..e5adecd63 100644 --- a/pkg/controller/data_upload_controller.go +++ b/pkg/controller/data_upload_controller.go @@ -956,8 +956,6 @@ func (r *DataUploadReconciler) setupExposeParam(du *velerov2alpha1api.DataUpload } } - affinity := kube.GetLoadAffinityByStorageClass(r.loadAffinity, du.Spec.CSISnapshot.SnapshotClass, log) - return &exposer.CSISnapshotExposeParam{ SnapshotName: du.Spec.CSISnapshot.VolumeSnapshot, SourceNamespace: du.Spec.SourceNamespace, @@ -969,7 +967,7 @@ func (r *DataUploadReconciler) setupExposeParam(du *velerov2alpha1api.DataUpload OperationTimeout: du.Spec.OperationTimeout.Duration, ExposeTimeout: r.preparingTimeout, VolumeSize: pvc.Spec.Resources.Requests[corev1api.ResourceStorage], - Affinity: affinity, + Affinity: r.loadAffinity, BackupPVCConfig: r.backupPVCConfig, Resources: r.podResources, NodeOS: nodeOS, diff --git a/pkg/controller/pod_volume_restore_controller_test.go b/pkg/controller/pod_volume_restore_controller_test.go index f748ba507..ee29d2b6c 100644 --- a/pkg/controller/pod_volume_restore_controller_test.go +++ b/pkg/controller/pod_volume_restore_controller_test.go @@ -989,7 +989,7 @@ func TestPodVolumeRestoreReconcile(t *testing.T) { r.exposer = nil } else { r.exposer = func() exposer.PodVolumeExposer { - ep := exposermockes.NewPodVolumeExposer(t) + ep := exposermockes.NewMockPodVolumeExposer(t) if test.mockExposeErr != nil { if boolptr.IsSetToTrue(test.mockExposeErr) { ep.On("Expose", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New("Error to expose restore exposer")) @@ -1156,7 +1156,7 @@ func TestOnPodVolumeRestoreCompleted(t *testing.T) { needErrs := []bool{test.isGetErr, false, false, false} r, err := initPodVolumeRestoreReconciler(nil, []client.Object{}, needErrs...) r.exposer = func() exposer.PodVolumeExposer { - ep := exposermockes.NewPodVolumeExposer(t) + ep := exposermockes.NewMockPodVolumeExposer(t) ep.On("CleanUp", mock.Anything, mock.Anything).Return() return ep }() diff --git a/pkg/exposer/csi_snapshot.go b/pkg/exposer/csi_snapshot.go index 4017ce4e8..0e514fe6c 100644 --- a/pkg/exposer/csi_snapshot.go +++ b/pkg/exposer/csi_snapshot.go @@ -72,7 +72,7 @@ type CSISnapshotExposeParam struct { VolumeSize resource.Quantity // Affinity specifies the node affinity of the backup pod - Affinity *kube.LoadAffinity + Affinity []*kube.LoadAffinity // BackupPVCConfig is the config for backupPVC (intermediate PVC) of snapshot data movement BackupPVCConfig map[string]nodeagent.BackupPVC @@ -211,6 +211,8 @@ func (e *csiSnapshotExposer) Expose(ctx context.Context, ownerObject corev1api.O } }() + affinity := kube.GetLoadAffinityByStorageClass(csiExposeParam.Affinity, backupPVCStorageClass, curLog) + backupPod, err := e.createBackupPod( ctx, ownerObject, @@ -219,7 +221,7 @@ func (e *csiSnapshotExposer) Expose(ctx context.Context, ownerObject corev1api.O csiExposeParam.HostingPodLabels, csiExposeParam.HostingPodAnnotations, csiExposeParam.HostingPodTolerations, - csiExposeParam.Affinity, + affinity, csiExposeParam.Resources, backupPVCReadOnly, spcNoRelabeling, diff --git a/pkg/exposer/csi_snapshot_test.go b/pkg/exposer/csi_snapshot_test.go index 09fb91ff2..d57d7699b 100644 --- a/pkg/exposer/csi_snapshot_test.go +++ b/pkg/exposer/csi_snapshot_test.go @@ -501,17 +501,19 @@ func TestExpose(t *testing.T) { AccessMode: AccessModeFileSystem, OperationTimeout: time.Millisecond, ExposeTimeout: time.Millisecond, - Affinity: &kube.LoadAffinity{ - NodeSelector: metav1.LabelSelector{ - MatchExpressions: []metav1.LabelSelectorRequirement{ - { - Key: "kubernetes.io/os", - Operator: metav1.LabelSelectorOpIn, - Values: []string{"Linux"}, + Affinity: []*kube.LoadAffinity{ + { + NodeSelector: metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "kubernetes.io/os", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"Linux"}, + }, }, }, + StorageClass: "fake-sc", }, - StorageClass: "fake-sc", }, }, snapshotClientObj: []runtime.Object{ @@ -554,17 +556,19 @@ func TestExpose(t *testing.T) { StorageClass: "fake-sc-read-only", }, }, - Affinity: &kube.LoadAffinity{ - NodeSelector: metav1.LabelSelector{ - MatchExpressions: []metav1.LabelSelectorRequirement{ - { - Key: "kubernetes.io/arch", - Operator: metav1.LabelSelectorOpIn, - Values: []string{"amd64"}, + Affinity: []*kube.LoadAffinity{ + { + NodeSelector: metav1.LabelSelector{ + MatchExpressions: []metav1.LabelSelectorRequirement{ + { + Key: "kubernetes.io/arch", + Operator: metav1.LabelSelectorOpIn, + Values: []string{"amd64"}, + }, }, }, + StorageClass: "fake-sc-read-only", }, - StorageClass: "fake-sc-read-only", }, }, snapshotClientObj: []runtime.Object{ diff --git a/pkg/exposer/generic_restore.go b/pkg/exposer/generic_restore.go index 42ba04c3e..f794ea2ed 100644 --- a/pkg/exposer/generic_restore.go +++ b/pkg/exposer/generic_restore.go @@ -68,7 +68,7 @@ type GenericRestoreExposeParam struct { RestorePVCConfig nodeagent.RestorePVC // LoadAffinity specifies the node affinity of the backup pod - LoadAffinity *kube.LoadAffinity + LoadAffinity []*kube.LoadAffinity } // GenericRestoreExposer is the interfaces for a generic restore exposer @@ -136,6 +136,14 @@ func (e *genericRestoreExposer) Expose(ctx context.Context, ownerObject corev1ap return errors.Errorf("Target PVC %s/%s has already been bound, abort", param.TargetNamespace, param.TargetPVCName) } + // Data mover allows the StorageClass name not set for PVC. + storageClassName := "" + if targetPVC.Spec.StorageClassName != nil { + storageClassName = *targetPVC.Spec.StorageClassName + } + + affinity := kube.GetLoadAffinityByStorageClass(param.LoadAffinity, storageClassName, curLog) + restorePod, err := e.createRestorePod( ctx, ownerObject, @@ -147,7 +155,7 @@ func (e *genericRestoreExposer) Expose(ctx context.Context, ownerObject corev1ap selectedNode, param.Resources, param.NodeOS, - param.LoadAffinity, + affinity, ) if err != nil { return errors.Wrapf(err, "error to create restore pod") diff --git a/pkg/exposer/mocks/GenericRestoreExposer.go b/pkg/exposer/mocks/GenericRestoreExposer.go index 9347ab2e6..7daae6d6d 100644 --- a/pkg/exposer/mocks/GenericRestoreExposer.go +++ b/pkg/exposer/mocks/GenericRestoreExposer.go @@ -1,70 +1,215 @@ -// Code generated by mockery v2.39.1. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - context "context" - - client "sigs.k8s.io/controller-runtime/pkg/client" - - exposer "github.com/vmware-tanzu/velero/pkg/exposer" + "context" + "time" mock "github.com/stretchr/testify/mock" - - time "time" - - corev1api "k8s.io/api/core/v1" + "github.com/vmware-tanzu/velero/pkg/exposer" + "k8s.io/api/core/v1" + "sigs.k8s.io/controller-runtime/pkg/client" ) -// GenericRestoreExposer is an autogenerated mock type for the GenericRestoreExposer type -type GenericRestoreExposer struct { +// NewMockGenericRestoreExposer creates a new instance of MockGenericRestoreExposer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockGenericRestoreExposer(t interface { + mock.TestingT + Cleanup(func()) +}) *MockGenericRestoreExposer { + mock := &MockGenericRestoreExposer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + +// MockGenericRestoreExposer is an autogenerated mock type for the GenericRestoreExposer type +type MockGenericRestoreExposer struct { mock.Mock } -// CleanUp provides a mock function with given fields: _a0, _a1 -func (_m *GenericRestoreExposer) CleanUp(_a0 context.Context, _a1 corev1api.ObjectReference) { - _m.Called(_a0, _a1) +type MockGenericRestoreExposer_Expecter struct { + mock *mock.Mock } -// DiagnoseExpose provides a mock function with given fields: _a0, _a1 -func (_m *GenericRestoreExposer) DiagnoseExpose(_a0 context.Context, _a1 corev1api.ObjectReference) string { - ret := _m.Called(_a0, _a1) +func (_m *MockGenericRestoreExposer) EXPECT() *MockGenericRestoreExposer_Expecter { + return &MockGenericRestoreExposer_Expecter{mock: &_m.Mock} +} + +// CleanUp provides a mock function for the type MockGenericRestoreExposer +func (_mock *MockGenericRestoreExposer) CleanUp(context1 context.Context, objectReference v1.ObjectReference) { + _mock.Called(context1, objectReference) + return +} + +// MockGenericRestoreExposer_CleanUp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanUp' +type MockGenericRestoreExposer_CleanUp_Call struct { + *mock.Call +} + +// CleanUp is a helper method to define mock.On call +// - context1 context.Context +// - objectReference v1.ObjectReference +func (_e *MockGenericRestoreExposer_Expecter) CleanUp(context1 interface{}, objectReference interface{}) *MockGenericRestoreExposer_CleanUp_Call { + return &MockGenericRestoreExposer_CleanUp_Call{Call: _e.mock.On("CleanUp", context1, objectReference)} +} + +func (_c *MockGenericRestoreExposer_CleanUp_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference)) *MockGenericRestoreExposer_CleanUp_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 v1.ObjectReference + if args[1] != nil { + arg1 = args[1].(v1.ObjectReference) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockGenericRestoreExposer_CleanUp_Call) Return() *MockGenericRestoreExposer_CleanUp_Call { + _c.Call.Return() + return _c +} + +func (_c *MockGenericRestoreExposer_CleanUp_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference)) *MockGenericRestoreExposer_CleanUp_Call { + _c.Run(run) + return _c +} + +// DiagnoseExpose provides a mock function for the type MockGenericRestoreExposer +func (_mock *MockGenericRestoreExposer) DiagnoseExpose(context1 context.Context, objectReference v1.ObjectReference) string { + ret := _mock.Called(context1, objectReference) if len(ret) == 0 { panic("no return value specified for DiagnoseExpose") } var r0 string - if rf, ok := ret.Get(0).(func(context.Context, corev1api.ObjectReference) string); ok { - r0 = rf(_a0, _a1) + if returnFunc, ok := ret.Get(0).(func(context.Context, v1.ObjectReference) string); ok { + r0 = returnFunc(context1, objectReference) } else { r0 = ret.Get(0).(string) } - return r0 } -// Expose provides a mock function with given fields: _a0, _a1, _a2 -func (_m *GenericRestoreExposer) Expose(_a0 context.Context, _a1 corev1api.ObjectReference, _a2 exposer.GenericRestoreExposeParam) error { - ret := _m.Called(_a0, _a1, _a2) +// MockGenericRestoreExposer_DiagnoseExpose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiagnoseExpose' +type MockGenericRestoreExposer_DiagnoseExpose_Call struct { + *mock.Call +} + +// DiagnoseExpose is a helper method to define mock.On call +// - context1 context.Context +// - objectReference v1.ObjectReference +func (_e *MockGenericRestoreExposer_Expecter) DiagnoseExpose(context1 interface{}, objectReference interface{}) *MockGenericRestoreExposer_DiagnoseExpose_Call { + return &MockGenericRestoreExposer_DiagnoseExpose_Call{Call: _e.mock.On("DiagnoseExpose", context1, objectReference)} +} + +func (_c *MockGenericRestoreExposer_DiagnoseExpose_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference)) *MockGenericRestoreExposer_DiagnoseExpose_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 v1.ObjectReference + if args[1] != nil { + arg1 = args[1].(v1.ObjectReference) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockGenericRestoreExposer_DiagnoseExpose_Call) Return(s string) *MockGenericRestoreExposer_DiagnoseExpose_Call { + _c.Call.Return(s) + return _c +} + +func (_c *MockGenericRestoreExposer_DiagnoseExpose_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference) string) *MockGenericRestoreExposer_DiagnoseExpose_Call { + _c.Call.Return(run) + return _c +} + +// Expose provides a mock function for the type MockGenericRestoreExposer +func (_mock *MockGenericRestoreExposer) Expose(context1 context.Context, objectReference v1.ObjectReference, genericRestoreExposeParam exposer.GenericRestoreExposeParam) error { + ret := _mock.Called(context1, objectReference, genericRestoreExposeParam) if len(ret) == 0 { panic("no return value specified for Expose") } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, corev1api.ObjectReference, exposer.GenericRestoreExposeParam) error); ok { - r0 = rf(_a0, _a1, _a2) + if returnFunc, ok := ret.Get(0).(func(context.Context, v1.ObjectReference, exposer.GenericRestoreExposeParam) error); ok { + r0 = returnFunc(context1, objectReference, genericRestoreExposeParam) } else { r0 = ret.Error(0) } - return r0 } -// GetExposed provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4 -func (_m *GenericRestoreExposer) GetExposed(_a0 context.Context, _a1 corev1api.ObjectReference, _a2 client.Client, _a3 string, _a4 time.Duration) (*exposer.ExposeResult, error) { - ret := _m.Called(_a0, _a1, _a2, _a3, _a4) +// MockGenericRestoreExposer_Expose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Expose' +type MockGenericRestoreExposer_Expose_Call struct { + *mock.Call +} + +// Expose is a helper method to define mock.On call +// - context1 context.Context +// - objectReference v1.ObjectReference +// - genericRestoreExposeParam exposer.GenericRestoreExposeParam +func (_e *MockGenericRestoreExposer_Expecter) Expose(context1 interface{}, objectReference interface{}, genericRestoreExposeParam interface{}) *MockGenericRestoreExposer_Expose_Call { + return &MockGenericRestoreExposer_Expose_Call{Call: _e.mock.On("Expose", context1, objectReference, genericRestoreExposeParam)} +} + +func (_c *MockGenericRestoreExposer_Expose_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference, genericRestoreExposeParam exposer.GenericRestoreExposeParam)) *MockGenericRestoreExposer_Expose_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 v1.ObjectReference + if args[1] != nil { + arg1 = args[1].(v1.ObjectReference) + } + var arg2 exposer.GenericRestoreExposeParam + if args[2] != nil { + arg2 = args[2].(exposer.GenericRestoreExposeParam) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockGenericRestoreExposer_Expose_Call) Return(err error) *MockGenericRestoreExposer_Expose_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockGenericRestoreExposer_Expose_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference, genericRestoreExposeParam exposer.GenericRestoreExposeParam) error) *MockGenericRestoreExposer_Expose_Call { + _c.Call.Return(run) + return _c +} + +// GetExposed provides a mock function for the type MockGenericRestoreExposer +func (_mock *MockGenericRestoreExposer) GetExposed(context1 context.Context, objectReference v1.ObjectReference, client1 client.Client, s string, duration time.Duration) (*exposer.ExposeResult, error) { + ret := _mock.Called(context1, objectReference, client1, s, duration) if len(ret) == 0 { panic("no return value specified for GetExposed") @@ -72,72 +217,210 @@ func (_m *GenericRestoreExposer) GetExposed(_a0 context.Context, _a1 corev1api.O var r0 *exposer.ExposeResult var r1 error - if rf, ok := ret.Get(0).(func(context.Context, corev1api.ObjectReference, client.Client, string, time.Duration) (*exposer.ExposeResult, error)); ok { - return rf(_a0, _a1, _a2, _a3, _a4) + if returnFunc, ok := ret.Get(0).(func(context.Context, v1.ObjectReference, client.Client, string, time.Duration) (*exposer.ExposeResult, error)); ok { + return returnFunc(context1, objectReference, client1, s, duration) } - if rf, ok := ret.Get(0).(func(context.Context, corev1api.ObjectReference, client.Client, string, time.Duration) *exposer.ExposeResult); ok { - r0 = rf(_a0, _a1, _a2, _a3, _a4) + if returnFunc, ok := ret.Get(0).(func(context.Context, v1.ObjectReference, client.Client, string, time.Duration) *exposer.ExposeResult); ok { + r0 = returnFunc(context1, objectReference, client1, s, duration) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*exposer.ExposeResult) } } - - if rf, ok := ret.Get(1).(func(context.Context, corev1api.ObjectReference, client.Client, string, time.Duration) error); ok { - r1 = rf(_a0, _a1, _a2, _a3, _a4) + if returnFunc, ok := ret.Get(1).(func(context.Context, v1.ObjectReference, client.Client, string, time.Duration) error); ok { + r1 = returnFunc(context1, objectReference, client1, s, duration) } else { r1 = ret.Error(1) } - return r0, r1 } -// PeekExposed provides a mock function with given fields: _a0, _a1 -func (_m *GenericRestoreExposer) PeekExposed(_a0 context.Context, _a1 corev1api.ObjectReference) error { - ret := _m.Called(_a0, _a1) +// MockGenericRestoreExposer_GetExposed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExposed' +type MockGenericRestoreExposer_GetExposed_Call struct { + *mock.Call +} + +// GetExposed is a helper method to define mock.On call +// - context1 context.Context +// - objectReference v1.ObjectReference +// - client1 client.Client +// - s string +// - duration time.Duration +func (_e *MockGenericRestoreExposer_Expecter) GetExposed(context1 interface{}, objectReference interface{}, client1 interface{}, s interface{}, duration interface{}) *MockGenericRestoreExposer_GetExposed_Call { + return &MockGenericRestoreExposer_GetExposed_Call{Call: _e.mock.On("GetExposed", context1, objectReference, client1, s, duration)} +} + +func (_c *MockGenericRestoreExposer_GetExposed_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference, client1 client.Client, s string, duration time.Duration)) *MockGenericRestoreExposer_GetExposed_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 v1.ObjectReference + if args[1] != nil { + arg1 = args[1].(v1.ObjectReference) + } + var arg2 client.Client + if args[2] != nil { + arg2 = args[2].(client.Client) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 time.Duration + if args[4] != nil { + arg4 = args[4].(time.Duration) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *MockGenericRestoreExposer_GetExposed_Call) Return(exposeResult *exposer.ExposeResult, err error) *MockGenericRestoreExposer_GetExposed_Call { + _c.Call.Return(exposeResult, err) + return _c +} + +func (_c *MockGenericRestoreExposer_GetExposed_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference, client1 client.Client, s string, duration time.Duration) (*exposer.ExposeResult, error)) *MockGenericRestoreExposer_GetExposed_Call { + _c.Call.Return(run) + return _c +} + +// PeekExposed provides a mock function for the type MockGenericRestoreExposer +func (_mock *MockGenericRestoreExposer) PeekExposed(context1 context.Context, objectReference v1.ObjectReference) error { + ret := _mock.Called(context1, objectReference) if len(ret) == 0 { panic("no return value specified for PeekExposed") } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, corev1api.ObjectReference) error); ok { - r0 = rf(_a0, _a1) + if returnFunc, ok := ret.Get(0).(func(context.Context, v1.ObjectReference) error); ok { + r0 = returnFunc(context1, objectReference) } else { r0 = ret.Error(0) } - return r0 } -// RebindVolume provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4 -func (_m *GenericRestoreExposer) RebindVolume(_a0 context.Context, _a1 corev1api.ObjectReference, _a2 string, _a3 string, _a4 time.Duration) error { - ret := _m.Called(_a0, _a1, _a2, _a3, _a4) +// MockGenericRestoreExposer_PeekExposed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PeekExposed' +type MockGenericRestoreExposer_PeekExposed_Call struct { + *mock.Call +} + +// PeekExposed is a helper method to define mock.On call +// - context1 context.Context +// - objectReference v1.ObjectReference +func (_e *MockGenericRestoreExposer_Expecter) PeekExposed(context1 interface{}, objectReference interface{}) *MockGenericRestoreExposer_PeekExposed_Call { + return &MockGenericRestoreExposer_PeekExposed_Call{Call: _e.mock.On("PeekExposed", context1, objectReference)} +} + +func (_c *MockGenericRestoreExposer_PeekExposed_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference)) *MockGenericRestoreExposer_PeekExposed_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 v1.ObjectReference + if args[1] != nil { + arg1 = args[1].(v1.ObjectReference) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockGenericRestoreExposer_PeekExposed_Call) Return(err error) *MockGenericRestoreExposer_PeekExposed_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockGenericRestoreExposer_PeekExposed_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference) error) *MockGenericRestoreExposer_PeekExposed_Call { + _c.Call.Return(run) + return _c +} + +// RebindVolume provides a mock function for the type MockGenericRestoreExposer +func (_mock *MockGenericRestoreExposer) RebindVolume(context1 context.Context, objectReference v1.ObjectReference, s string, s1 string, duration time.Duration) error { + ret := _mock.Called(context1, objectReference, s, s1, duration) if len(ret) == 0 { panic("no return value specified for RebindVolume") } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, corev1api.ObjectReference, string, string, time.Duration) error); ok { - r0 = rf(_a0, _a1, _a2, _a3, _a4) + if returnFunc, ok := ret.Get(0).(func(context.Context, v1.ObjectReference, string, string, time.Duration) error); ok { + r0 = returnFunc(context1, objectReference, s, s1, duration) } else { r0 = ret.Error(0) } - return r0 } -// NewGenericRestoreExposer creates a new instance of GenericRestoreExposer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewGenericRestoreExposer(t interface { - mock.TestingT - Cleanup(func()) -}) *GenericRestoreExposer { - mock := &GenericRestoreExposer{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock +// MockGenericRestoreExposer_RebindVolume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RebindVolume' +type MockGenericRestoreExposer_RebindVolume_Call struct { + *mock.Call +} + +// RebindVolume is a helper method to define mock.On call +// - context1 context.Context +// - objectReference v1.ObjectReference +// - s string +// - s1 string +// - duration time.Duration +func (_e *MockGenericRestoreExposer_Expecter) RebindVolume(context1 interface{}, objectReference interface{}, s interface{}, s1 interface{}, duration interface{}) *MockGenericRestoreExposer_RebindVolume_Call { + return &MockGenericRestoreExposer_RebindVolume_Call{Call: _e.mock.On("RebindVolume", context1, objectReference, s, s1, duration)} +} + +func (_c *MockGenericRestoreExposer_RebindVolume_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference, s string, s1 string, duration time.Duration)) *MockGenericRestoreExposer_RebindVolume_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 v1.ObjectReference + if args[1] != nil { + arg1 = args[1].(v1.ObjectReference) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 time.Duration + if args[4] != nil { + arg4 = args[4].(time.Duration) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *MockGenericRestoreExposer_RebindVolume_Call) Return(err error) *MockGenericRestoreExposer_RebindVolume_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockGenericRestoreExposer_RebindVolume_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference, s string, s1 string, duration time.Duration) error) *MockGenericRestoreExposer_RebindVolume_Call { + _c.Call.Return(run) + return _c } diff --git a/pkg/exposer/mocks/PodVolumeExposer.go b/pkg/exposer/mocks/PodVolumeExposer.go index fbd5749ba..d601e5c5b 100644 --- a/pkg/exposer/mocks/PodVolumeExposer.go +++ b/pkg/exposer/mocks/PodVolumeExposer.go @@ -1,70 +1,215 @@ -// Code generated by mockery v2.39.1. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - context "context" - - client "sigs.k8s.io/controller-runtime/pkg/client" - - exposer "github.com/vmware-tanzu/velero/pkg/exposer" + "context" + "time" mock "github.com/stretchr/testify/mock" - - time "time" - - corev1api "k8s.io/api/core/v1" + "github.com/vmware-tanzu/velero/pkg/exposer" + "k8s.io/api/core/v1" + "sigs.k8s.io/controller-runtime/pkg/client" ) -// PodVolumeExposer is an autogenerated mock type for the PodVolumeExposer type -type PodVolumeExposer struct { +// NewMockPodVolumeExposer creates a new instance of MockPodVolumeExposer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockPodVolumeExposer(t interface { + mock.TestingT + Cleanup(func()) +}) *MockPodVolumeExposer { + mock := &MockPodVolumeExposer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + +// MockPodVolumeExposer is an autogenerated mock type for the PodVolumeExposer type +type MockPodVolumeExposer struct { mock.Mock } -// CleanUp provides a mock function with given fields: _a0, _a1 -func (_m *PodVolumeExposer) CleanUp(_a0 context.Context, _a1 corev1api.ObjectReference) { - _m.Called(_a0, _a1) +type MockPodVolumeExposer_Expecter struct { + mock *mock.Mock } -// DiagnoseExpose provides a mock function with given fields: _a0, _a1 -func (_m *PodVolumeExposer) DiagnoseExpose(_a0 context.Context, _a1 corev1api.ObjectReference) string { - ret := _m.Called(_a0, _a1) +func (_m *MockPodVolumeExposer) EXPECT() *MockPodVolumeExposer_Expecter { + return &MockPodVolumeExposer_Expecter{mock: &_m.Mock} +} + +// CleanUp provides a mock function for the type MockPodVolumeExposer +func (_mock *MockPodVolumeExposer) CleanUp(context1 context.Context, objectReference v1.ObjectReference) { + _mock.Called(context1, objectReference) + return +} + +// MockPodVolumeExposer_CleanUp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanUp' +type MockPodVolumeExposer_CleanUp_Call struct { + *mock.Call +} + +// CleanUp is a helper method to define mock.On call +// - context1 context.Context +// - objectReference v1.ObjectReference +func (_e *MockPodVolumeExposer_Expecter) CleanUp(context1 interface{}, objectReference interface{}) *MockPodVolumeExposer_CleanUp_Call { + return &MockPodVolumeExposer_CleanUp_Call{Call: _e.mock.On("CleanUp", context1, objectReference)} +} + +func (_c *MockPodVolumeExposer_CleanUp_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference)) *MockPodVolumeExposer_CleanUp_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 v1.ObjectReference + if args[1] != nil { + arg1 = args[1].(v1.ObjectReference) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockPodVolumeExposer_CleanUp_Call) Return() *MockPodVolumeExposer_CleanUp_Call { + _c.Call.Return() + return _c +} + +func (_c *MockPodVolumeExposer_CleanUp_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference)) *MockPodVolumeExposer_CleanUp_Call { + _c.Run(run) + return _c +} + +// DiagnoseExpose provides a mock function for the type MockPodVolumeExposer +func (_mock *MockPodVolumeExposer) DiagnoseExpose(context1 context.Context, objectReference v1.ObjectReference) string { + ret := _mock.Called(context1, objectReference) if len(ret) == 0 { panic("no return value specified for DiagnoseExpose") } var r0 string - if rf, ok := ret.Get(0).(func(context.Context, corev1api.ObjectReference) string); ok { - r0 = rf(_a0, _a1) + if returnFunc, ok := ret.Get(0).(func(context.Context, v1.ObjectReference) string); ok { + r0 = returnFunc(context1, objectReference) } else { r0 = ret.Get(0).(string) } - return r0 } -// Expose provides a mock function with given fields: _a0, _a1, _a2 -func (_m *PodVolumeExposer) Expose(_a0 context.Context, _a1 corev1api.ObjectReference, _a2 exposer.PodVolumeExposeParam) error { - ret := _m.Called(_a0, _a1, _a2) +// MockPodVolumeExposer_DiagnoseExpose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiagnoseExpose' +type MockPodVolumeExposer_DiagnoseExpose_Call struct { + *mock.Call +} + +// DiagnoseExpose is a helper method to define mock.On call +// - context1 context.Context +// - objectReference v1.ObjectReference +func (_e *MockPodVolumeExposer_Expecter) DiagnoseExpose(context1 interface{}, objectReference interface{}) *MockPodVolumeExposer_DiagnoseExpose_Call { + return &MockPodVolumeExposer_DiagnoseExpose_Call{Call: _e.mock.On("DiagnoseExpose", context1, objectReference)} +} + +func (_c *MockPodVolumeExposer_DiagnoseExpose_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference)) *MockPodVolumeExposer_DiagnoseExpose_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 v1.ObjectReference + if args[1] != nil { + arg1 = args[1].(v1.ObjectReference) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockPodVolumeExposer_DiagnoseExpose_Call) Return(s string) *MockPodVolumeExposer_DiagnoseExpose_Call { + _c.Call.Return(s) + return _c +} + +func (_c *MockPodVolumeExposer_DiagnoseExpose_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference) string) *MockPodVolumeExposer_DiagnoseExpose_Call { + _c.Call.Return(run) + return _c +} + +// Expose provides a mock function for the type MockPodVolumeExposer +func (_mock *MockPodVolumeExposer) Expose(context1 context.Context, objectReference v1.ObjectReference, podVolumeExposeParam exposer.PodVolumeExposeParam) error { + ret := _mock.Called(context1, objectReference, podVolumeExposeParam) if len(ret) == 0 { panic("no return value specified for Expose") } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, corev1api.ObjectReference, exposer.PodVolumeExposeParam) error); ok { - r0 = rf(_a0, _a1, _a2) + if returnFunc, ok := ret.Get(0).(func(context.Context, v1.ObjectReference, exposer.PodVolumeExposeParam) error); ok { + r0 = returnFunc(context1, objectReference, podVolumeExposeParam) } else { r0 = ret.Error(0) } - return r0 } -// GetExposed provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4 -func (_m *PodVolumeExposer) GetExposed(_a0 context.Context, _a1 corev1api.ObjectReference, _a2 client.Client, _a3 string, _a4 time.Duration) (*exposer.ExposeResult, error) { - ret := _m.Called(_a0, _a1, _a2, _a3, _a4) +// MockPodVolumeExposer_Expose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Expose' +type MockPodVolumeExposer_Expose_Call struct { + *mock.Call +} + +// Expose is a helper method to define mock.On call +// - context1 context.Context +// - objectReference v1.ObjectReference +// - podVolumeExposeParam exposer.PodVolumeExposeParam +func (_e *MockPodVolumeExposer_Expecter) Expose(context1 interface{}, objectReference interface{}, podVolumeExposeParam interface{}) *MockPodVolumeExposer_Expose_Call { + return &MockPodVolumeExposer_Expose_Call{Call: _e.mock.On("Expose", context1, objectReference, podVolumeExposeParam)} +} + +func (_c *MockPodVolumeExposer_Expose_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference, podVolumeExposeParam exposer.PodVolumeExposeParam)) *MockPodVolumeExposer_Expose_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 v1.ObjectReference + if args[1] != nil { + arg1 = args[1].(v1.ObjectReference) + } + var arg2 exposer.PodVolumeExposeParam + if args[2] != nil { + arg2 = args[2].(exposer.PodVolumeExposeParam) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockPodVolumeExposer_Expose_Call) Return(err error) *MockPodVolumeExposer_Expose_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockPodVolumeExposer_Expose_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference, podVolumeExposeParam exposer.PodVolumeExposeParam) error) *MockPodVolumeExposer_Expose_Call { + _c.Call.Return(run) + return _c +} + +// GetExposed provides a mock function for the type MockPodVolumeExposer +func (_mock *MockPodVolumeExposer) GetExposed(context1 context.Context, objectReference v1.ObjectReference, client1 client.Client, s string, duration time.Duration) (*exposer.ExposeResult, error) { + ret := _mock.Called(context1, objectReference, client1, s, duration) if len(ret) == 0 { panic("no return value specified for GetExposed") @@ -72,54 +217,135 @@ func (_m *PodVolumeExposer) GetExposed(_a0 context.Context, _a1 corev1api.Object var r0 *exposer.ExposeResult var r1 error - if rf, ok := ret.Get(0).(func(context.Context, corev1api.ObjectReference, client.Client, string, time.Duration) (*exposer.ExposeResult, error)); ok { - return rf(_a0, _a1, _a2, _a3, _a4) + if returnFunc, ok := ret.Get(0).(func(context.Context, v1.ObjectReference, client.Client, string, time.Duration) (*exposer.ExposeResult, error)); ok { + return returnFunc(context1, objectReference, client1, s, duration) } - if rf, ok := ret.Get(0).(func(context.Context, corev1api.ObjectReference, client.Client, string, time.Duration) *exposer.ExposeResult); ok { - r0 = rf(_a0, _a1, _a2, _a3, _a4) + if returnFunc, ok := ret.Get(0).(func(context.Context, v1.ObjectReference, client.Client, string, time.Duration) *exposer.ExposeResult); ok { + r0 = returnFunc(context1, objectReference, client1, s, duration) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*exposer.ExposeResult) } } - - if rf, ok := ret.Get(1).(func(context.Context, corev1api.ObjectReference, client.Client, string, time.Duration) error); ok { - r1 = rf(_a0, _a1, _a2, _a3, _a4) + if returnFunc, ok := ret.Get(1).(func(context.Context, v1.ObjectReference, client.Client, string, time.Duration) error); ok { + r1 = returnFunc(context1, objectReference, client1, s, duration) } else { r1 = ret.Error(1) } - return r0, r1 } -// PeekExposed provides a mock function with given fields: _a0, _a1 -func (_m *PodVolumeExposer) PeekExposed(_a0 context.Context, _a1 corev1api.ObjectReference) error { - ret := _m.Called(_a0, _a1) +// MockPodVolumeExposer_GetExposed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExposed' +type MockPodVolumeExposer_GetExposed_Call struct { + *mock.Call +} + +// GetExposed is a helper method to define mock.On call +// - context1 context.Context +// - objectReference v1.ObjectReference +// - client1 client.Client +// - s string +// - duration time.Duration +func (_e *MockPodVolumeExposer_Expecter) GetExposed(context1 interface{}, objectReference interface{}, client1 interface{}, s interface{}, duration interface{}) *MockPodVolumeExposer_GetExposed_Call { + return &MockPodVolumeExposer_GetExposed_Call{Call: _e.mock.On("GetExposed", context1, objectReference, client1, s, duration)} +} + +func (_c *MockPodVolumeExposer_GetExposed_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference, client1 client.Client, s string, duration time.Duration)) *MockPodVolumeExposer_GetExposed_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 v1.ObjectReference + if args[1] != nil { + arg1 = args[1].(v1.ObjectReference) + } + var arg2 client.Client + if args[2] != nil { + arg2 = args[2].(client.Client) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 time.Duration + if args[4] != nil { + arg4 = args[4].(time.Duration) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *MockPodVolumeExposer_GetExposed_Call) Return(exposeResult *exposer.ExposeResult, err error) *MockPodVolumeExposer_GetExposed_Call { + _c.Call.Return(exposeResult, err) + return _c +} + +func (_c *MockPodVolumeExposer_GetExposed_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference, client1 client.Client, s string, duration time.Duration) (*exposer.ExposeResult, error)) *MockPodVolumeExposer_GetExposed_Call { + _c.Call.Return(run) + return _c +} + +// PeekExposed provides a mock function for the type MockPodVolumeExposer +func (_mock *MockPodVolumeExposer) PeekExposed(context1 context.Context, objectReference v1.ObjectReference) error { + ret := _mock.Called(context1, objectReference) if len(ret) == 0 { panic("no return value specified for PeekExposed") } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, corev1api.ObjectReference) error); ok { - r0 = rf(_a0, _a1) + if returnFunc, ok := ret.Get(0).(func(context.Context, v1.ObjectReference) error); ok { + r0 = returnFunc(context1, objectReference) } else { r0 = ret.Error(0) } - return r0 } -// NewPodVolumeExposer creates a new instance of PodVolumeExposer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewPodVolumeExposer(t interface { - mock.TestingT - Cleanup(func()) -}) *PodVolumeExposer { - mock := &PodVolumeExposer{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock +// MockPodVolumeExposer_PeekExposed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PeekExposed' +type MockPodVolumeExposer_PeekExposed_Call struct { + *mock.Call +} + +// PeekExposed is a helper method to define mock.On call +// - context1 context.Context +// - objectReference v1.ObjectReference +func (_e *MockPodVolumeExposer_Expecter) PeekExposed(context1 interface{}, objectReference interface{}) *MockPodVolumeExposer_PeekExposed_Call { + return &MockPodVolumeExposer_PeekExposed_Call{Call: _e.mock.On("PeekExposed", context1, objectReference)} +} + +func (_c *MockPodVolumeExposer_PeekExposed_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference)) *MockPodVolumeExposer_PeekExposed_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 v1.ObjectReference + if args[1] != nil { + arg1 = args[1].(v1.ObjectReference) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockPodVolumeExposer_PeekExposed_Call) Return(err error) *MockPodVolumeExposer_PeekExposed_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockPodVolumeExposer_PeekExposed_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference) error) *MockPodVolumeExposer_PeekExposed_Call { + _c.Call.Return(run) + return _c } diff --git a/pkg/util/kube/pod.go b/pkg/util/kube/pod.go index 4e20c5f1c..6b9cf7d58 100644 --- a/pkg/util/kube/pod.go +++ b/pkg/util/kube/pod.go @@ -317,7 +317,7 @@ func GetLoadAffinityByStorageClass( for _, affinity := range affinityList { if affinity.StorageClass == scName { - logger.WithField("StorageClass", scName).Info("Found backup pod's affinity setting per StorageClass.") + logger.WithField("StorageClass", scName).Info("Found pod's affinity setting per StorageClass.") return affinity } @@ -327,9 +327,9 @@ func GetLoadAffinityByStorageClass( } if globalAffinity != nil { - logger.Info("Use the Global affinity for backup pod.") + logger.Info("Use the Global affinity for pod.") } else { - logger.Info("No Affinity is found for backup pod.") + logger.Info("No Affinity is found for pod.") } return globalAffinity diff --git a/pkg/util/kube/pod_test.go b/pkg/util/kube/pod_test.go index b162894e1..f01d5ab35 100644 --- a/pkg/util/kube/pod_test.go +++ b/pkg/util/kube/pod_test.go @@ -1209,6 +1209,12 @@ func TestGetLoadAffinityByStorageClass(t *testing.T) { scName: "storage-class-01", expectedAffinity: nil, }, + { + name: "affinityList is nil", + affinityList: nil, + scName: "storage-class-01", + expectedAffinity: nil, + }, } for _, test := range tests {