Fix the dd and du's node affinity issue. (#9130)

Signed-off-by: Xun Jiang <xun.jiang@broadcom.com>

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
 }
 

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 {

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,

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
 			}()

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,

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{

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")

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
 }

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
 }

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

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 {