fix require-error rule from testifylint

Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>

.golangci.yaml

@@ -262,7 +262,6 @@ linters:
       disable:
         - float-compare
         - go-require
-        - require-error
       enable-all: true
 
     testpackage:

internal/hook/hook_tracker_test.go

@@ -21,6 +21,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNewHookTracker(t *testing.T) {
@@ -65,13 +66,13 @@ func TestHookTracker_Record(t *testing.T) {
 	info := tracker.tracker[key]
 	assert.True(t, info.hookFailed)
 	assert.True(t, info.hookExecuted)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = tracker.Record("ns2", "pod2", "container1", HookSourceAnnotation, "h1", "", true, fmt.Errorf("err"))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = tracker.Record("ns1", "pod1", "container1", HookSourceAnnotation, "h1", "", false, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, info.hookFailed)
 }
 
@@ -141,10 +142,10 @@ func TestMultiHookTracker_Record(t *testing.T) {
 	info := mht.trackers["restore1"].tracker[key]
 	assert.True(t, info.hookFailed)
 	assert.True(t, info.hookExecuted)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = mht.Record("restore1", "ns2", "pod2", "container1", HookSourceAnnotation, "h1", "", true, fmt.Errorf("err"))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = mht.Record("restore2", "ns2", "pod2", "container1", HookSourceAnnotation, "h1", "", true, fmt.Errorf("err"))
 	assert.Error(t, err)

internal/hook/item_hook_handler_test.go

@@ -120,7 +120,7 @@ func TestHandleHooksSkips(t *testing.T) {
 
 			groupResource := schema.ParseGroupResource(test.groupResource)
 			err := h.HandleHooks(velerotest.NewLogger(), groupResource, test.item, test.hooks, PhasePre, hookTracker)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 		})
 	}
 }
@@ -1199,7 +1199,7 @@ func TestGroupRestoreExecHooks(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			actual, err := GroupRestoreExecHooks("restore1", tc.resourceRestoreHooks, tc.pod, velerotest.NewLogger(), hookTracker)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, tc.expected, actual)
 		})
 	}
@@ -1955,13 +1955,13 @@ func TestHandleRestoreHooks(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			handler := InitContainerRestoreHookHandler{}
 			podMap, err := runtime.DefaultUnstructuredConverter.ToUnstructured(&tc.podInput)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			actual, err := handler.HandleRestoreHooks(velerotest.NewLogger(), kuberesource.Pods, &unstructured.Unstructured{Object: podMap}, tc.restoreHooks, tc.namespaceMapping)
 			assert.Equal(t, tc.expectedError, err)
 			if actual != nil {
 				actualPod := new(corev1api.Pod)
 				err = runtime.DefaultUnstructuredConverter.FromUnstructured(actual.UnstructuredContent(), actualPod)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tc.expectedPod, actualPod)
 			}
 		})
@@ -1976,7 +1976,7 @@ func TestValidateContainer(t *testing.T) {
 	expectedError := fmt.Errorf("invalid InitContainer in restore hook, it doesn't have Command, Name or Image field")
 
 	// valid string should return nil as result.
-	assert.NoError(t, ValidateContainer([]byte(valid)))
+	require.NoError(t, ValidateContainer([]byte(valid)))
 
 	// noName string should return expected error as result.
 	assert.Equal(t, expectedError, ValidateContainer([]byte(noName)))

internal/hook/wait_exec_hook_handler_test.go

@@ -732,7 +732,7 @@ func TestWaitExecHandleHooks(t *testing.T) {
 
 			for _, e := range test.expectedExecutions {
 				obj, err := runtime.DefaultUnstructuredConverter.ToUnstructured(e.pod)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				podCommandExecutor.On("ExecutePodCommand", mock.Anything, obj, e.pod.Namespace, e.pod.Name, e.name, e.hook).Return(e.error)
 			}
 
@@ -1264,7 +1264,7 @@ func TestRestoreHookTrackerUpdate(t *testing.T) {
 
 			for _, e := range test.expectedExecutions {
 				obj, err := runtime.DefaultUnstructuredConverter.ToUnstructured(e.pod)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				podCommandExecutor.On("ExecutePodCommand", mock.Anything, obj, e.pod.Namespace, e.pod.Name, e.name, e.hook).Return(e.error)
 			}
 

internal/resourcemodifiers/json_merge_patch_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
@@ -28,7 +29,7 @@ func TestJsonMergePatchFailure(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			scheme := runtime.NewScheme()
 			err := clientgoscheme.AddToScheme(scheme)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			pt := &JSONMergePatcher{
 				patches: []JSONMergePatch{{PatchData: tt.data}},
 			}

internal/resourcemodifiers/resource_modifiers_test.go

@@ -21,6 +21,7 @@ import (
 
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	corev1api "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -1303,27 +1304,27 @@ func TestResourceModifiers_ApplyResourceModifierRules_StrategicMergePatch(t *tes
 	utilruntime.Must(clientgoscheme.AddToScheme(scheme))
 	unstructuredSerializer := yaml.NewDecodingSerializer(unstructured.UnstructuredJSONScheme)
 	o1, _, err := unstructuredSerializer.Decode([]byte(podYAMLWithNFSVolume), nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	podWithNFSVolume := o1.(*unstructured.Unstructured)
 
 	o2, _, err := unstructuredSerializer.Decode([]byte(podYAMLWithPVCVolume), nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	podWithPVCVolume := o2.(*unstructured.Unstructured)
 
 	o3, _, err := unstructuredSerializer.Decode([]byte(svcYAMLWithPort8000), nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	svcWithPort8000 := o3.(*unstructured.Unstructured)
 
 	o4, _, err := unstructuredSerializer.Decode([]byte(svcYAMLWithPort9000), nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	svcWithPort9000 := o4.(*unstructured.Unstructured)
 
 	o5, _, err := unstructuredSerializer.Decode([]byte(podYAMLWithNginxImage), nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	podWithNginxImage := o5.(*unstructured.Unstructured)
 
 	o6, _, err := unstructuredSerializer.Decode([]byte(podYAMLWithNginx1Image), nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	podWithNginx1Image := o6.(*unstructured.Unstructured)
 
 	tests := []struct {
@@ -1467,15 +1468,15 @@ func TestResourceModifiers_ApplyResourceModifierRules_StrategicMergePatch(t *tes
 func TestResourceModifiers_ApplyResourceModifierRules_JSONMergePatch(t *testing.T) {
 	unstructuredSerializer := yaml.NewDecodingSerializer(unstructured.UnstructuredJSONScheme)
 	o1, _, err := unstructuredSerializer.Decode([]byte(cmYAMLWithLabelAToB), nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	cmWithLabelAToB := o1.(*unstructured.Unstructured)
 
 	o2, _, err := unstructuredSerializer.Decode([]byte(cmYAMLWithLabelAToC), nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	cmWithLabelAToC := o2.(*unstructured.Unstructured)
 
 	o3, _, err := unstructuredSerializer.Decode([]byte(cmYAMLWithoutLabelA), nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	cmWithoutLabelA := o3.(*unstructured.Unstructured)
 
 	tests := []struct {
@@ -1618,11 +1619,11 @@ func TestResourceModifiers_ApplyResourceModifierRules_JSONMergePatch(t *testing.
 func TestResourceModifiers_wildcard_in_GroupResource(t *testing.T) {
 	unstructuredSerializer := yaml.NewDecodingSerializer(unstructured.UnstructuredJSONScheme)
 	o1, _, err := unstructuredSerializer.Decode([]byte(cmYAMLWithLabelAToB), nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	cmWithLabelAToB := o1.(*unstructured.Unstructured)
 
 	o2, _, err := unstructuredSerializer.Decode([]byte(cmYAMLWithLabelAToC), nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	cmWithLabelAToC := o2.(*unstructured.Unstructured)
 
 	tests := []struct {
@@ -1694,11 +1695,11 @@ func TestResourceModifiers_wildcard_in_GroupResource(t *testing.T) {
 func TestResourceModifiers_conditional_patches(t *testing.T) {
 	unstructuredSerializer := yaml.NewDecodingSerializer(unstructured.UnstructuredJSONScheme)
 	o1, _, err := unstructuredSerializer.Decode([]byte(cmYAMLWithLabelAToB), nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	cmWithLabelAToB := o1.(*unstructured.Unstructured)
 
 	o2, _, err := unstructuredSerializer.Decode([]byte(cmYAMLWithLabelAToC), nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	cmWithLabelAToC := o2.(*unstructured.Unstructured)
 
 	tests := []struct {

internal/resourcemodifiers/strategic_merge_patch_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -37,7 +38,7 @@ func TestStrategicMergePatchFailure(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			scheme := runtime.NewScheme()
 			err := clientgoscheme.AddToScheme(scheme)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			pt := &StrategicMergePatcher{
 				patches: []StrategicMergePatch{{PatchData: tt.data}},
 				scheme:  scheme,

internal/resourcepolicies/resource_policies_test.go

@@ -19,6 +19,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	corev1api "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -360,7 +361,7 @@ volumePolicies:
 
 	// Call the function and check for errors
 	resPolicies, err := getResourcePoliciesFromConfig(cm)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Check that the returned resourcePolicies object contains the expected data
 	assert.Equal(t, "v1", resPolicies.version)
@@ -964,10 +965,10 @@ volumePolicies:
 			if err != nil {
 				t.Fatalf("got error when get match action %v", err)
 			}
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			policies := &Policies{}
 			err = policies.BuildPolicy(resPolicies)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			vfd := VolumeFilterData{}
 			if tc.pvc != nil {
 				vfd.PVC = tc.pvc
@@ -982,7 +983,7 @@ volumePolicies:
 			}
 
 			action, err := policies.GetMatchAction(vfd)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			if tc.skip {
 				if action.Type != Skip {
@@ -1022,8 +1023,7 @@ func TestGetMatchAction_Errors(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			action, err := p.GetMatchAction(tc.input)
-			assert.Error(t, err)
-			assert.Contains(t, err.Error(), tc.expectedErr)
+			require.ErrorContains(t, err, tc.expectedErr)
 			assert.Nil(t, action)
 		})
 	}

internal/restartabletest/restartable_delegate.go

@@ -115,7 +115,7 @@ func RunRestartableDelegateTests(
 					expectedErr, expectedErrOk := expected[i].(error)
 					// If both are errors, use EqualError
 					if actualErrOk && expectedErrOk {
-						assert.EqualError(t, actualErr, expectedErr.Error())
+						require.EqualError(t, actualErr, expectedErr.Error())
 						continue
 					}
 

internal/volumehelper/volume_policy_helper_test.go

@@ -717,7 +717,7 @@ func TestGetVolumeFromResource(t *testing.T) {
 			},
 		}
 		outPV, outPod, err := helper.getVolumeFromResource(pv)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, outPV)
 		assert.Nil(t, outPod)
 		assert.Equal(t, "test-pv", outPV.Name)
@@ -728,7 +728,7 @@ func TestGetVolumeFromResource(t *testing.T) {
 			Name: "test-volume",
 		}
 		outPV, outPod, err := helper.getVolumeFromResource(vol)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, outPV)
 		assert.NotNil(t, outPod)
 		assert.Equal(t, "test-volume", outPod.Name)
@@ -736,7 +736,6 @@ func TestGetVolumeFromResource(t *testing.T) {
 
 	t.Run("Invalid input", func(t *testing.T) {
 		_, _, err := helper.getVolumeFromResource("invalid")
-		assert.Error(t, err)
-		assert.Contains(t, err.Error(), "resource is not a PersistentVolume or Volume")
+		assert.ErrorContains(t, err, "resource is not a PersistentVolume or Volume")
 	})
 }

pkg/archive/parser_test.go

@@ -112,7 +112,7 @@ func TestParse(t *testing.T) {
 			if tc.wantErrMsg != nil {
 				assert.ErrorIs(t, err, tc.wantErrMsg, "Error should be: %v, got: %v", tc.wantErrMsg, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tc.want, res)
 			}
 		})
@@ -226,7 +226,7 @@ func TestParseGroupVersions(t *testing.T) {
 			if tc.wantErrMsg != nil {
 				assert.ErrorIs(t, err, tc.wantErrMsg, "Error should be: %v, got: %v", tc.wantErrMsg, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tc.want, res)
 			}
 		})

pkg/backup/actions/backup_pv_action_test.go

@@ -48,14 +48,14 @@ func TestBackupPVAction(t *testing.T) {
 	// no spec.volumeName should result in no error
 	// and no additional items
 	_, additional, err := a.Execute(pvc, backup)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, additional)
 
 	// empty spec.volumeName should result in no error
 	// and no additional items
 	pvc.Object["spec"].(map[string]any)["volumeName"] = ""
 	_, additional, err = a.Execute(pvc, backup)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, additional)
 
 	// Action should clean the spec.Selector when the StorageClassName is not set.
@@ -146,6 +146,6 @@ func TestBackupPVAction(t *testing.T) {
 	// result in no error and no additional items
 	pvc.Object["spec"].(map[string]any)["volumeName"] = ""
 	_, additional, err = a.Execute(pvc, backup)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, additional)
 }

pkg/backup/actions/service_account_action_test.go

@@ -385,7 +385,7 @@ func TestServiceAccountActionExecute(t *testing.T) {
 			res, additional, err := action.Execute(test.serviceAccount, nil)
 
 			assert.Equal(t, test.serviceAccount, res)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			// ensure slices are ordered for valid comparison
 			sort.Slice(test.expectedAdditionalItems, func(i, j int) bool {
@@ -592,7 +592,7 @@ func TestServiceAccountActionExecuteOnBeta1(t *testing.T) {
 			res, additional, err := action.Execute(test.serviceAccount, nil)
 
 			assert.Equal(t, test.serviceAccount, res)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			// ensure slices are ordered for valid comparison
 			sort.Slice(test.expectedAdditionalItems, func(i, j int) bool {

pkg/backup/backup_test.go

@@ -1476,7 +1476,7 @@ func TestBackupItemActionsForSkippedPV(t *testing.T) {
 			}
 
 			err := h.backupper.Backup(h.log, tc.backupReq, backupFile, actions, nil, nil)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			if tc.expectSkippedPVs != nil {
 				for pvName, reasons := range tc.expectSkippedPVs {
@@ -1694,7 +1694,7 @@ func TestBackupActionsRunForCorrectItems(t *testing.T) {
 			}
 
 			err := h.backupper.Backup(h.log, req, backupFile, actions, nil, nil)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			for action, want := range tc.actions {
 				assert.Equal(t, want, action.ids)
@@ -1928,7 +1928,7 @@ func TestBackupActionModifications(t *testing.T) {
 			}
 
 			err := h.backupper.Backup(h.log, req, backupFile, tc.actions, nil, nil)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			assertTarballFileContents(t, backupFile, tc.want)
 		})
@@ -2188,7 +2188,7 @@ func TestBackupActionAdditionalItems(t *testing.T) {
 			}
 
 			err := h.backupper.Backup(h.log, req, backupFile, tc.actions, nil, nil)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			assertTarballContents(t, backupFile, append(tc.want, "metadata/version")...)
 		})
@@ -2454,7 +2454,7 @@ func TestItemBlockActionsRunForCorrectItems(t *testing.T) {
 			}
 
 			err := h.backupper.Backup(h.log, req, backupFile, nil, actions, nil)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			for action, want := range tc.actions {
 				assert.Equal(t, want, action.ids)
@@ -2790,7 +2790,7 @@ func TestItemBlockActionRelatedItems(t *testing.T) {
 			}
 
 			err := h.backupper.Backup(h.log, req, backupFile, nil, tc.actions, nil)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			assertTarballContents(t, backupFile, append(tc.want, "metadata/version")...)
 		})
@@ -3267,7 +3267,7 @@ func TestBackupWithSnapshots(t *testing.T) {
 			}
 
 			err := h.backupper.Backup(h.log, tc.req, backupFile, nil, nil, tc.snapshotterGetter)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			assert.Equal(t, tc.want, tc.req.VolumeSnapshots)
 		})
@@ -3434,7 +3434,7 @@ func TestBackupWithAsyncOperations(t *testing.T) {
 			}
 
 			err := h.backupper.Backup(h.log, tc.req, backupFile, tc.actions, nil, nil)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			resultOper := *tc.req.GetItemOperationsList()
 			// set want Created times so it won't fail the assert.Equal test
@@ -4423,7 +4423,7 @@ func assertTarballFileContents(t *testing.T, backupFile io.Reader, want map[stri
 		// json-unmarshal the data from the tarball
 		var got unstructuredObject
 		err := json.Unmarshal(gotData, &got)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		if err != nil {
 			continue
 		}

pkg/client/client_test.go

@@ -19,6 +19,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestBuildUserAgent(t *testing.T) {
@@ -79,7 +80,7 @@ func TestConfig(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			client, err := Config(test.kubeconfig, test.kubecontext, "velero", test.QPS, test.burst)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, test.expectedHost, client.Host)
 			assert.Equal(t, test.QPS, client.QPS)
 			assert.Equal(t, test.burst, client.Burst)

pkg/client/config_test.go

@@ -23,6 +23,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestVeleroConfig(t *testing.T) {
@@ -62,13 +63,13 @@ func TestConfigOperations(t *testing.T) {
 
 	// Remove config file if it exists
 	err := removeConfigfileName()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Test LoadConfig: expect an empty velero config
 	expectedConfig := VeleroConfig{}
 	config, err := LoadConfig()
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, reflect.DeepEqual(expectedConfig, config))
 
 	// Test savedConfig
@@ -84,9 +85,9 @@ func TestConfigOperations(t *testing.T) {
 
 	err = SaveConfig(config)
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	savedConfig, err := LoadConfig()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Test Features
 	feature := savedConfig.Features()
@@ -107,7 +108,7 @@ func TestConfigOperations(t *testing.T) {
 
 	t.Cleanup(func() {
 		err = removeConfigfileName()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		os.Unsetenv("HOME")
 		os.Setenv("HOME", preHomeEnv)
 	})

pkg/client/factory_test.go

@@ -24,6 +24,7 @@ import (
 
 	flag "github.com/spf13/pflag"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 )
@@ -95,7 +96,7 @@ func TestFactory(t *testing.T) {
 
 	baseName := "velero-bn"
 	config, err := LoadConfig()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			f = NewFactory(baseName, config)
@@ -129,16 +130,16 @@ func TestFactory(t *testing.T) {
 					LabelSelector: "none",
 				},
 			)
-			assert.ErrorContains(t, e, fmt.Sprintf("Get \"%s/apis/%s/%s/namespaces/%s", test.expectedHost, resource.Group, resource.Version, namespace))
+			require.ErrorContains(t, e, fmt.Sprintf("Get \"%s/apis/%s/%s/namespaces/%s", test.expectedHost, resource.Group, resource.Version, namespace))
 			assert.Nil(t, list)
 			assert.NotNil(t, dynamicClient)
 
 			kubebuilderClient, e := f.KubebuilderClient()
-			assert.NoError(t, e)
+			require.NoError(t, e)
 			assert.NotNil(t, kubebuilderClient)
 
 			kbClientWithWatch, e := f.KubebuilderWatchClient()
-			assert.NoError(t, e)
+			require.NoError(t, e)
 			assert.NotNil(t, kbClientWithWatch)
 		})
 	}

pkg/cmd/cli/backup/create_test.go

@@ -59,10 +59,10 @@ func TestCreateOptions_BuildBackup(t *testing.T) {
 		},
 	}
 	o.OrSelector.OrLabelSelectors = orLabelSelectors
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	backup, err := o.BuildBackup(cmdtest.VeleroNameSpace)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, velerov1api.BackupSpec{
 		TTL:                     metav1.Duration{Duration: o.TTL},
@@ -159,7 +159,7 @@ func TestCreateOptions_BuildBackupFromSchedule(t *testing.T) {
 		o.Labels.Set("velero.io/test=yes,custom-label=true")
 		o.Annotations.Set("velero.io/test=yes,custom-annotation=true")
 		backup, err := o.BuildBackup(cmdtest.VeleroNameSpace)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.Equal(t, expectedBackupSpec, backup.Spec)
 		assert.Equal(t, map[string]string{
@@ -176,10 +176,10 @@ func TestCreateOptions_BuildBackupFromSchedule(t *testing.T) {
 
 func TestCreateOptions_OrderedResources(t *testing.T) {
 	_, err := ParseOrderedResources("pods= ns1/p1; ns1/p2; persistentvolumeclaims=ns2/pvc1, ns2/pvc2")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	orderedResources, err := ParseOrderedResources("pods= ns1/p1,ns1/p2 ; persistentvolumeclaims=ns2/pvc1,ns2/pvc2")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	expectedResources := map[string]string{
 		"pods":                   "ns1/p1,ns1/p2",
@@ -188,7 +188,7 @@ func TestCreateOptions_OrderedResources(t *testing.T) {
 	assert.Equal(t, expectedResources, orderedResources)
 
 	orderedResources, err = ParseOrderedResources("pods= ns1/p1,ns1/p2 ; persistentvolumes=pv1,pv2")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	expectedMixedResources := map[string]string{
 		"pods":              "ns1/p1,ns1/p2",
@@ -338,7 +338,7 @@ func TestCreateCommand(t *testing.T) {
 
 		// Complete
 		e := o.Complete(args, f)
-		assert.NoError(t, e)
+		require.NoError(t, e)
 
 		// Validate
 		e = o.Validate(cmd, args, f)
@@ -369,7 +369,7 @@ func TestCreateCommand(t *testing.T) {
 
 		// Complete
 		e := o.Complete(args, f)
-		assert.NoError(t, e)
+		require.NoError(t, e)
 
 		// Validate
 		e = o.Validate(cmd, args, f)
@@ -397,10 +397,10 @@ func TestCreateCommand(t *testing.T) {
 		f.On("KubebuilderWatchClient").Return(kbclient, nil)
 
 		e := o.Complete(args, f)
-		assert.NoError(t, e)
+		require.NoError(t, e)
 
 		e = o.Run(c, f)
-		assert.NoError(t, e)
+		require.NoError(t, e)
 
 		c.SetArgs([]string{"bk-1"})
 		e = c.Execute()

pkg/cmd/cli/backup/describe_test.go

@@ -24,6 +24,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"k8s.io/client-go/rest"
 	controllerclient "sigs.k8s.io/controller-runtime/pkg/client"
 
@@ -58,7 +59,7 @@ func TestNewDescribeCommand(t *testing.T) {
 
 	c.SetArgs([]string{backupName})
 	e := c.Execute()
-	assert.NoError(t, e)
+	require.NoError(t, e)
 
 	if os.Getenv(cmdtest.CaptureFlag) == "1" {
 		return

pkg/cmd/cli/backup/download_test.go

@@ -74,10 +74,10 @@ func TestNewDownloadCommand(t *testing.T) {
 	args := []string{backupName, "arg2"}
 
 	e := o.Complete(args)
-	assert.NoError(t, e)
+	require.NoError(t, e)
 
 	e = o.Validate(c, args, f)
-	assert.NoError(t, e)
+	require.NoError(t, e)
 
 	// verify all options are set as expected
 	assert.Equal(t, output, o.Output)

pkg/cmd/cli/backup/get_test.go

@@ -58,7 +58,7 @@ func TestNewGetCommand(t *testing.T) {
 
 	c.SetArgs(args)
 	e := c.Execute()
-	assert.NoError(t, e)
+	require.NoError(t, e)
 
 	if os.Getenv(cmdtest.CaptureFlag) == "1" {
 		return
@@ -83,7 +83,7 @@ func TestNewGetCommand(t *testing.T) {
 	d := NewGetCommand(f, "velero backup get")
 	c.SetArgs([]string{"-l", "abc=abc"})
 	e = d.Execute()
-	assert.NoError(t, e)
+	require.NoError(t, e)
 
 	cmd = exec.Command(os.Args[0], []string{"-test.run=TestNewGetCommand"}...)
 	cmd.Env = append(os.Environ(), fmt.Sprintf("%s=1", cmdtest.CaptureFlag))

pkg/cmd/cli/backuplocation/create_test.go

@@ -26,6 +26,7 @@ import (
 	flag "github.com/spf13/pflag"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 	corev1api "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -38,7 +39,7 @@ func TestBuildBackupStorageLocationSetsNamespace(t *testing.T) {
 	o := NewCreateOptions()
 
 	bsl, err := o.BuildBackupStorageLocation("velero-test-ns", false, false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "velero-test-ns", bsl.Namespace)
 }
 
@@ -47,11 +48,11 @@ func TestBuildBackupStorageLocationSetsSyncPeriod(t *testing.T) {
 	o.BackupSyncPeriod = 2 * time.Minute
 
 	bsl, err := o.BuildBackupStorageLocation("velero-test-ns", false, false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, bsl.Spec.BackupSyncPeriod)
 
 	bsl, err = o.BuildBackupStorageLocation("velero-test-ns", true, false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, &metav1.Duration{Duration: 2 * time.Minute}, bsl.Spec.BackupSyncPeriod)
 }
 
@@ -60,11 +61,11 @@ func TestBuildBackupStorageLocationSetsValidationFrequency(t *testing.T) {
 	o.ValidationFrequency = 2 * time.Minute
 
 	bsl, err := o.BuildBackupStorageLocation("velero-test-ns", false, false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, bsl.Spec.ValidationFrequency)
 
 	bsl, err = o.BuildBackupStorageLocation("velero-test-ns", false, true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, &metav1.Duration{Duration: 2 * time.Minute}, bsl.Spec.ValidationFrequency)
 }
 
@@ -72,14 +73,14 @@ func TestBuildBackupStorageLocationSetsCredential(t *testing.T) {
 	o := NewCreateOptions()
 
 	bsl, err := o.BuildBackupStorageLocation("velero-test-ns", false, false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, bsl.Spec.Credential)
 
 	setErr := o.Credential.Set("my-secret=key-from-secret")
-	assert.NoError(t, setErr)
+	require.NoError(t, setErr)
 
 	bsl, err = o.BuildBackupStorageLocation("velero-test-ns", false, true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, &corev1api.SecretKeySelector{
 		LocalObjectReference: corev1api.LocalObjectReference{Name: "my-secret"},
 		Key:                  "key-from-secret",
@@ -90,10 +91,10 @@ func TestBuildBackupStorageLocationSetsLabels(t *testing.T) {
 	o := NewCreateOptions()
 
 	err := o.Labels.Set("key=value")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	bsl, err := o.BuildBackupStorageLocation("velero-test-ns", false, false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, map[string]string{"key": "value"}, bsl.Labels)
 }
 
@@ -148,10 +149,10 @@ func TestCreateCommand_Run(t *testing.T) {
 
 	o.Complete(args, f)
 	e := o.Validate(c, args, f)
-	assert.NoError(t, e)
+	require.NoError(t, e)
 
 	e = o.Run(c, f)
-	assert.ErrorContains(t, e, fmt.Sprintf("%s: no such file or directory", caCertFile))
+	require.ErrorContains(t, e, fmt.Sprintf("%s: no such file or directory", caCertFile))
 
 	// verify all options are set as expected
 	assert.Equal(t, name, o.Name)
@@ -178,7 +179,7 @@ func TestCreateCommand_Run(t *testing.T) {
 	o.Complete(args, f)
 
 	e = o.Run(c, f)
-	assert.NoError(t, e)
+	require.NoError(t, e)
 	c.SetArgs([]string{"bsl-1", "--provider=aws", "--bucket=bk1", "--default"})
 	e = c.Execute()
 	assert.NoError(t, e)

pkg/cmd/cli/backuplocation/delete_test.go

@@ -25,6 +25,7 @@ import (
 	flag "github.com/spf13/pflag"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 
 	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	factorymocks "github.com/vmware-tanzu/velero/pkg/client/mocks"
@@ -52,15 +53,15 @@ func TestNewDeleteCommand(t *testing.T) {
 
 	args := []string{"bk-loc-1", "bk-loc-2"}
 	e := o.Complete(f, args)
-	assert.NoError(t, e)
+	require.NoError(t, e)
 	e = o.Validate(c, f, args)
-	assert.NoError(t, e)
+	require.NoError(t, e)
 	c.SetArgs([]string{"bk-1", "--confirm"})
 	e = c.Execute()
-	assert.NoError(t, e)
+	require.NoError(t, e)
 
 	e = Run(f, o)
-	assert.NoError(t, e)
+	require.NoError(t, e)
 	if os.Getenv(cmdtest.CaptureFlag) == "1" {
 		return
 	}

pkg/cmd/cli/backuplocation/set_test.go

@@ -26,6 +26,7 @@ import (
 	flag "github.com/spf13/pflag"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 
 	factorymocks "github.com/vmware-tanzu/velero/pkg/client/mocks"
 	cmdtest "github.com/vmware-tanzu/velero/pkg/cmd/test"
@@ -66,10 +67,10 @@ func TestNewSetCommand(t *testing.T) {
 	args := []string{backupName}
 	o.Complete(args, f)
 	e := o.Validate(c, args, f)
-	assert.NoError(t, e)
+	require.NoError(t, e)
 
 	e = o.Run(c, f)
-	assert.ErrorContains(t, e, fmt.Sprintf("%s: no such file or directory", cacert))
+	require.ErrorContains(t, e, fmt.Sprintf("%s: no such file or directory", cacert))
 
 	// verify all options are set as expected
 	assert.Equal(t, backupName, o.Name)

pkg/cmd/cli/restore/describe_test.go

@@ -24,6 +24,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"k8s.io/client-go/rest"
 	controllerclient "sigs.k8s.io/controller-runtime/pkg/client"
 
@@ -58,7 +59,7 @@ func TestNewDescribeCommand(t *testing.T) {
 
 	c.SetArgs([]string{restoreName})
 	e := c.Execute()
-	assert.NoError(t, e)
+	require.NoError(t, e)
 
 	if os.Getenv(cmdtest.CaptureFlag) == "1" {
 		return

pkg/cmd/cli/select_option_test.go

@@ -38,7 +38,7 @@ func TestValidateOfSelectOption(t *testing.T) {
 		Selector: flag.LabelSelector{},
 		All:      false,
 	}
-	assert.Error(t, option.Validate())
+	require.Error(t, option.Validate())
 
 	option.All = true
 	assert.NoError(t, option.Validate())

pkg/cmd/server/server_test.go

@@ -63,7 +63,7 @@ func TestVeleroResourcesExist(t *testing.T) {
 			},
 		},
 	}
-	assert.Error(t, server.veleroResourcesExist())
+	require.Error(t, server.veleroResourcesExist())
 
 	// Velero v1 API group doesn't contain any custom resources: should error
 	veleroAPIResourceListVelerov1 := &metav1.APIResourceList{
@@ -71,7 +71,7 @@ func TestVeleroResourcesExist(t *testing.T) {
 	}
 
 	fakeDiscoveryHelper.ResourceList = append(fakeDiscoveryHelper.ResourceList, veleroAPIResourceListVelerov1)
-	assert.Error(t, server.veleroResourcesExist())
+	require.Error(t, server.veleroResourcesExist())
 
 	// Velero v2alpha1 API group doesn't contain any custom resources: should error
 	veleroAPIResourceListVeleroV2alpha1 := &metav1.APIResourceList{
@@ -79,7 +79,7 @@ func TestVeleroResourcesExist(t *testing.T) {
 	}
 
 	fakeDiscoveryHelper.ResourceList = append(fakeDiscoveryHelper.ResourceList, veleroAPIResourceListVeleroV2alpha1)
-	assert.Error(t, server.veleroResourcesExist())
+	require.Error(t, server.veleroResourcesExist())
 
 	// Velero v1 API group contains all custom resources, but v2alpha1 doesn't contain any custom resources: should error
 	for kind := range velerov1api.CustomResources() {
@@ -87,7 +87,7 @@ func TestVeleroResourcesExist(t *testing.T) {
 			Kind: kind,
 		})
 	}
-	assert.Error(t, server.veleroResourcesExist())
+	require.Error(t, server.veleroResourcesExist())
 
 	// Velero v1 and v2alpha1 API group contain all custom resources: should not error
 	for kind := range velerov2alpha1api.CustomResources() {
@@ -95,7 +95,7 @@ func TestVeleroResourcesExist(t *testing.T) {
 			Kind: kind,
 		})
 	}
-	assert.NoError(t, server.veleroResourcesExist())
+	require.NoError(t, server.veleroResourcesExist())
 
 	// Velero API group contains some but not all custom resources: should error
 	veleroAPIResourceListVelerov1.APIResources = veleroAPIResourceListVelerov1.APIResources[:3]
@@ -169,7 +169,7 @@ func TestRemoveControllers(t *testing.T) {
 			if tt.errorExpected {
 				assert.Error(t, removeControllers(tt.disabledControllers, enabledRuntimeControllers, logger))
 			} else {
-				assert.NoError(t, removeControllers(tt.disabledControllers, enabledRuntimeControllers, logger))
+				require.NoError(t, removeControllers(tt.disabledControllers, enabledRuntimeControllers, logger))
 
 				totalNumEnabledControllers := len(enabledRuntimeControllers)
 				assert.Equal(t, totalNumEnabledControllers, totalNumOriginalControllers-len(tt.disabledControllers))
@@ -195,21 +195,21 @@ func Test_newServer(t *testing.T) {
 	_, err := newServer(factory, &config.Config{
 		UploaderType: "invalid",
 	}, logger)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// invalid clientQPS
 	_, err = newServer(factory, &config.Config{
 		UploaderType: uploader.KopiaType,
 		ClientQPS:    -1,
 	}, logger)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// invalid clientQPS Restic uploader
 	_, err = newServer(factory, &config.Config{
 		UploaderType: uploader.ResticType,
 		ClientQPS:    -1,
 	}, logger)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// invalid clientBurst
 	factory.On("SetClientQPS", mock.Anything).Return()
@@ -218,7 +218,7 @@ func Test_newServer(t *testing.T) {
 		ClientQPS:    1,
 		ClientBurst:  -1,
 	}, logger)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// invalid clientBclientPageSizeurst
 	factory.On("SetClientQPS", mock.Anything).Return().
@@ -229,7 +229,7 @@ func Test_newServer(t *testing.T) {
 		ClientBurst:    1,
 		ClientPageSize: -1,
 	}, logger)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// got error when creating client
 	factory.On("SetClientQPS", mock.Anything).Return().
@@ -258,7 +258,7 @@ func Test_namespaceExists(t *testing.T) {
 	}
 
 	// namespace doesn't exist
-	assert.Error(t, server.namespaceExists("not-exist"))
+	require.Error(t, server.namespaceExists("not-exist"))
 
 	// namespace exists
 	assert.NoError(t, server.namespaceExists("velero"))
@@ -273,7 +273,7 @@ func Test_veleroResourcesExist(t *testing.T) {
 
 	// velero resources don't exist
 	helper.On("Resources").Return(nil)
-	assert.Error(t, server.veleroResourcesExist())
+	require.Error(t, server.veleroResourcesExist())
 
 	// velero resources exist
 	helper.On("Resources").Unset()
@@ -421,7 +421,7 @@ func Test_setDefaultBackupLocation(t *testing.T) {
 	// no default location specified
 	c = fake.NewClientBuilder().WithScheme(scheme).Build()
 	err := setDefaultBackupLocation(context.Background(), c, "velero", "", logrus.New())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// no default location created
 	err = setDefaultBackupLocation(context.Background(), c, "velero", "default", logrus.New())

pkg/cmd/util/flag/enum_test.go

@@ -14,7 +14,7 @@ func TestStringOfEnum(t *testing.T) {
 
 func TestSetOfEnum(t *testing.T) {
 	enum := NewEnum("a", "a", "b", "c")
-	assert.Error(t, enum.Set("d"))
+	require.Error(t, enum.Set("d"))
 
 	require.NoError(t, enum.Set("b"))
 	assert.Equal(t, "b", enum.String())

pkg/cmd/util/flag/optional_bool_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestStringOfOptionalBool(t *testing.T) {
@@ -25,16 +26,16 @@ func TestStringOfOptionalBool(t *testing.T) {
 func TestSetOfOptionalBool(t *testing.T) {
 	// error
 	ob := NewOptionalBool(nil)
-	assert.Error(t, ob.Set("invalid"))
+	require.Error(t, ob.Set("invalid"))
 
 	// nil
 	ob = NewOptionalBool(nil)
-	assert.NoError(t, ob.Set(""))
+	require.NoError(t, ob.Set(""))
 	assert.Nil(t, ob.Value)
 
 	// true
 	ob = NewOptionalBool(nil)
-	assert.NoError(t, ob.Set("true"))
+	require.NoError(t, ob.Set("true"))
 	assert.True(t, *ob.Value)
 }
 

pkg/cmd/util/output/output_test.go

@@ -3,6 +3,7 @@ package output
 import (
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/runtime"
 
 	velerov1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
@@ -372,9 +373,9 @@ func TestPrintWithFormat(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			p, err := PrintWithFormat(tc.input.cmd, tc.input.obj)
 			if tc.hasErr {
-				assert.Error(t, err)
+				require.Error(t, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 			assert.Equal(t, tc.printed, p)
 		})

pkg/controller/backup_controller_test.go

@@ -244,7 +244,7 @@ func TestProcessBackupValidationFailures(t *testing.T) {
 
 			actualResult, err := c.Reconcile(ctx, ctrl.Request{NamespacedName: types.NamespacedName{Namespace: test.backup.Namespace, Name: test.backup.Name}})
 			assert.Equal(t, ctrl.Result{}, actualResult)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			res := &velerov1api.Backup{}
 			err = c.kbClient.Get(context.Background(), kbclient.ObjectKey{Namespace: test.backup.Namespace, Name: test.backup.Name}, res)
 			require.NoError(t, err)
@@ -1578,7 +1578,7 @@ func TestProcessBackupCompletions(t *testing.T) {
 
 			actualResult, err := c.Reconcile(ctx, ctrl.Request{NamespacedName: types.NamespacedName{Namespace: test.backup.Namespace, Name: test.backup.Name}})
 			assert.Equal(t, ctrl.Result{}, actualResult)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			// Disable CSI feature to not impact other test cases.
 			if test.enableCSI {

pkg/controller/backup_deletion_controller_test.go

@@ -195,7 +195,7 @@ func TestBackupDeletionControllerReconcile(t *testing.T) {
 		err = td.fakeClient.Create(context.TODO(), existing2)
 		require.NoError(t, err)
 		_, err = td.controller.Reconcile(context.TODO(), td.req)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		// verify "existing" is deleted
 		err = td.fakeClient.Get(context.TODO(), types.NamespacedName{
 			Namespace: existing.Namespace,
@@ -392,7 +392,7 @@ func TestBackupDeletionControllerReconcile(t *testing.T) {
 			Namespace: velerov1api.DefaultNamespace,
 			Name:      "restore-3",
 		}, &velerov1api.Restore{})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		td.backupStore.AssertCalled(t, "DeleteBackup", input.Spec.BackupName)
 
@@ -516,7 +516,7 @@ func TestBackupDeletionControllerReconcile(t *testing.T) {
 			Namespace: velerov1api.DefaultNamespace,
 			Name:      "restore-3",
 		}, &velerov1api.Restore{})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		// Make sure snapshot was deleted
 		assert.Equal(t, 0, td.volumeSnapshotter.SnapshotsTaken.Len())
@@ -900,7 +900,7 @@ func TestGetSnapshotsInBackup(t *testing.T) {
 			})
 
 			res, err := getSnapshotsInBackup(context.TODO(), veleroBackup, clientBuilder.Build())
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			assert.True(t, reflect.DeepEqual(res, test.expected))
 		})

pkg/controller/backup_repository_controller_test.go

@@ -22,6 +22,7 @@ import (
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 	corev1api "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -83,12 +84,12 @@ func TestPatchBackupRepository(t *testing.T) {
 	rr := mockBackupRepositoryCR()
 	reconciler := mockBackupRepoReconciler(t, "", nil, nil)
 	err := reconciler.Client.Create(context.TODO(), rr)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = reconciler.patchBackupRepository(context.Background(), rr, repoReady())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, velerov1api.BackupRepositoryPhaseReady, rr.Status.Phase)
 	err = reconciler.patchBackupRepository(context.Background(), rr, repoNotReady("not ready"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotEqual(t, velerov1api.BackupRepositoryPhaseReady, rr.Status.Phase)
 }
 
@@ -99,7 +100,7 @@ func TestCheckNotReadyRepo(t *testing.T) {
 	rr.Spec.VolumeNamespace = "volume-ns-1"
 	reconciler := mockBackupRepoReconciler(t, "PrepareRepo", rr, nil)
 	err := reconciler.Client.Create(context.TODO(), rr)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	location := velerov1api.BackupStorageLocation{
 		Spec: velerov1api.BackupStorageLocationSpec{
 			Config: map[string]string{"resticRepoPrefix": "s3:test.amazonaws.com/bucket/restic"},
@@ -111,7 +112,7 @@ func TestCheckNotReadyRepo(t *testing.T) {
 	}
 
 	_, err = reconciler.checkNotReadyRepo(context.TODO(), rr, &location, reconciler.logger)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, velerov1api.BackupRepositoryPhaseReady, rr.Status.Phase)
 	assert.Equal(t, "s3:test.amazonaws.com/bucket/restic/volume-ns-1", rr.Spec.ResticIdentifier)
 }
@@ -368,14 +369,14 @@ func TestRunMaintenanceIfDue(t *testing.T) {
 			reconciler := mockBackupRepoReconciler(t, "", test.repo, nil)
 			reconciler.clock = &fakeClock{now}
 			err := reconciler.Client.Create(context.TODO(), test.repo)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			funcStartMaintenanceJob = test.startJobFunc
 			funcWaitMaintenanceJobComplete = test.waitJobFunc
 
 			err = reconciler.runMaintenanceIfDue(context.TODO(), test.repo, velerotest.NewLogger())
 			if test.expectedErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, test.expectedMaintenanceTime, test.repo.Status.LastMaintenanceTime.Time)
@@ -401,7 +402,7 @@ func TestInitializeRepo(t *testing.T) {
 	rr.Spec.BackupStorageLocation = "default"
 	reconciler := mockBackupRepoReconciler(t, "PrepareRepo", rr, nil)
 	err := reconciler.Client.Create(context.TODO(), rr)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	location := velerov1api.BackupStorageLocation{
 		Spec: velerov1api.BackupStorageLocationSpec{
 			Config: map[string]string{"resticRepoPrefix": "s3:test.amazonaws.com/bucket/restic"},
@@ -413,7 +414,7 @@ func TestInitializeRepo(t *testing.T) {
 	}
 
 	err = reconciler.initializeRepo(context.TODO(), rr, &location, reconciler.logger)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, velerov1api.BackupRepositoryPhaseReady, rr.Status.Phase)
 }
 
@@ -470,7 +471,7 @@ func TestBackupRepoReconcile(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			reconciler := mockBackupRepoReconciler(t, "", test.repo, nil)
 			err := reconciler.Client.Create(context.TODO(), test.repo)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			_, err = reconciler.Reconcile(context.TODO(), ctrl.Request{NamespacedName: types.NamespacedName{Namespace: test.repo.Namespace, Name: "repo"}})
 			if test.expectNil {
 				assert.NoError(t, err)
@@ -766,7 +767,7 @@ func TestGetBackupRepositoryConfig(t *testing.T) {
 			if test.expectedErr != "" {
 				assert.EqualError(t, err, test.expectedErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, test.expectedResult, result)
 			}
 		})

pkg/controller/backup_storage_location_controller_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
@@ -238,7 +239,7 @@ func TestEnsureSingleDefaultBSL(t *testing.T) {
 
 	for _, test := range tests {
 		// Setup reconciler
-		assert.NoError(t, velerov1api.AddToScheme(scheme.Scheme))
+		require.NoError(t, velerov1api.AddToScheme(scheme.Scheme))
 		t.Run(test.name, func(t *testing.T) {
 			r := &backupStorageLocationReconciler{
 				ctx:                       context.Background(),
@@ -282,7 +283,7 @@ func TestBSLReconcile(t *testing.T) {
 	pluginManager.On("CleanupClients").Return(nil)
 	for _, test := range tests {
 		// Setup reconciler
-		assert.NoError(t, velerov1api.AddToScheme(scheme.Scheme))
+		require.NoError(t, velerov1api.AddToScheme(scheme.Scheme))
 		t.Run(test.name, func(t *testing.T) {
 			r := &backupStorageLocationReconciler{
 				ctx:              context.Background(),

pkg/controller/data_download_controller_test.go

@@ -559,9 +559,9 @@ func TestDataDownloadReconcile(t *testing.T) {
 			})
 
 			if test.expectedErr != "" {
-				assert.EqualError(t, err, test.expectedErr)
+				require.EqualError(t, err, test.expectedErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			if test.expectedResult != nil {
@@ -614,15 +614,15 @@ func TestOnDataDownloadFailed(t *testing.T) {
 		namespace := dd.Namespace
 		ddName := dd.Name
 		// Add the DataDownload object to the fake client
-		assert.NoError(t, r.client.Create(ctx, dd))
+		require.NoError(t, r.client.Create(ctx, dd))
 		r.OnDataDownloadFailed(ctx, namespace, ddName, fmt.Errorf("Failed to handle %v", ddName))
 		updatedDD := &velerov2alpha1api.DataDownload{}
 		if getErr {
-			assert.Error(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
+			require.Error(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
 			assert.NotEqual(t, velerov2alpha1api.DataDownloadPhaseFailed, updatedDD.Status.Phase)
 			assert.True(t, updatedDD.Status.StartTimestamp.IsZero())
 		} else {
-			assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
+			require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
 			assert.Equal(t, velerov2alpha1api.DataDownloadPhaseFailed, updatedDD.Status.Phase)
 			assert.True(t, updatedDD.Status.StartTimestamp.IsZero())
 		}
@@ -640,15 +640,15 @@ func TestOnDataDownloadCancelled(t *testing.T) {
 		namespace := dd.Namespace
 		ddName := dd.Name
 		// Add the DataDownload object to the fake client
-		assert.NoError(t, r.client.Create(ctx, dd))
+		require.NoError(t, r.client.Create(ctx, dd))
 		r.OnDataDownloadCancelled(ctx, namespace, ddName)
 		updatedDD := &velerov2alpha1api.DataDownload{}
 		if getErr {
-			assert.Error(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
+			require.Error(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
 			assert.NotEqual(t, velerov2alpha1api.DataDownloadPhaseFailed, updatedDD.Status.Phase)
 			assert.True(t, updatedDD.Status.StartTimestamp.IsZero())
 		} else {
-			assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
+			require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
 			assert.Equal(t, velerov2alpha1api.DataDownloadPhaseCanceled, updatedDD.Status.Phase)
 			assert.False(t, updatedDD.Status.StartTimestamp.IsZero())
 			assert.False(t, updatedDD.Status.CompletionTimestamp.IsZero())
@@ -692,15 +692,15 @@ func TestOnDataDownloadCompleted(t *testing.T) {
 			namespace := dd.Namespace
 			ddName := dd.Name
 			// Add the DataDownload object to the fake client
-			assert.NoError(t, r.client.Create(ctx, dd))
+			require.NoError(t, r.client.Create(ctx, dd))
 			r.OnDataDownloadCompleted(ctx, namespace, ddName, datapath.Result{})
 			updatedDD := &velerov2alpha1api.DataDownload{}
 			if test.isGetErr {
-				assert.Error(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
+				require.Error(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
 				assert.Equal(t, velerov2alpha1api.DataDownloadPhase(""), updatedDD.Status.Phase)
 				assert.True(t, updatedDD.Status.CompletionTimestamp.IsZero())
 			} else {
-				assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
+				require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
 				assert.Equal(t, velerov2alpha1api.DataDownloadPhaseCompleted, updatedDD.Status.Phase)
 				assert.False(t, updatedDD.Status.CompletionTimestamp.IsZero())
 			}
@@ -750,7 +750,7 @@ func TestOnDataDownloadProgress(t *testing.T) {
 			namespace := dd.Namespace
 			duName := dd.Name
 			// Add the DataDownload object to the fake client
-			assert.NoError(t, r.client.Create(context.Background(), dd))
+			require.NoError(t, r.client.Create(context.Background(), dd))
 
 			// Create a Progress object
 			progress := &uploader.Progress{
@@ -763,7 +763,7 @@ func TestOnDataDownloadProgress(t *testing.T) {
 			if len(test.needErrs) != 0 && !test.needErrs[0] {
 				// Get the updated DataDownload object from the fake client
 				updatedDu := &velerov2alpha1api.DataDownload{}
-				assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: duName, Namespace: namespace}, updatedDu))
+				require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: duName, Namespace: namespace}, updatedDu))
 				// Assert that the DataDownload object has been updated with the progress
 				assert.Equal(t, test.progress.TotalBytes, updatedDu.Status.Progress.TotalBytes)
 				assert.Equal(t, test.progress.BytesDone, updatedDu.Status.Progress.BytesDone)
@@ -1131,7 +1131,7 @@ func TestAttemptDataDownloadResume(t *testing.T) {
 				r.client.Delete(ctx, test.dd, &kbclient.DeleteOptions{})
 			}()
 
-			assert.NoError(t, r.client.Create(ctx, test.dd))
+			require.NoError(t, r.client.Create(ctx, test.dd))
 
 			dt := &duResumeTestHelper{
 				resumeErr: test.resumeErr,

pkg/controller/data_upload_controller_test.go

@@ -673,9 +673,9 @@ func TestReconcile(t *testing.T) {
 			})
 
 			if test.expectedErr != "" {
-				assert.EqualError(t, err, test.expectedErr)
+				require.EqualError(t, err, test.expectedErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			if test.expectedResult != nil {
@@ -726,11 +726,11 @@ func TestOnDataUploadCancelled(t *testing.T) {
 	namespace := du.Namespace
 	duName := du.Name
 	// Add the DataUpload object to the fake client
-	assert.NoError(t, r.client.Create(ctx, du))
+	require.NoError(t, r.client.Create(ctx, du))
 
 	r.OnDataUploadCancelled(ctx, namespace, duName)
 	updatedDu := &velerov2alpha1api.DataUpload{}
-	assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: duName, Namespace: namespace}, updatedDu))
+	require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: duName, Namespace: namespace}, updatedDu))
 	assert.Equal(t, velerov2alpha1api.DataUploadPhaseCanceled, updatedDu.Status.Phase)
 	assert.False(t, updatedDu.Status.CompletionTimestamp.IsZero())
 	assert.False(t, updatedDu.Status.StartTimestamp.IsZero())
@@ -778,7 +778,7 @@ func TestOnDataUploadProgress(t *testing.T) {
 			namespace := du.Namespace
 			duName := du.Name
 			// Add the DataUpload object to the fake client
-			assert.NoError(t, r.client.Create(context.Background(), du))
+			require.NoError(t, r.client.Create(context.Background(), du))
 
 			// Create a Progress object
 			progress := &uploader.Progress{
@@ -791,7 +791,7 @@ func TestOnDataUploadProgress(t *testing.T) {
 			if len(test.needErrs) != 0 && !test.needErrs[0] {
 				// Get the updated DataUpload object from the fake client
 				updatedDu := &velerov2alpha1api.DataUpload{}
-				assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: duName, Namespace: namespace}, updatedDu))
+				require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: duName, Namespace: namespace}, updatedDu))
 				// Assert that the DataUpload object has been updated with the progress
 				assert.Equal(t, test.progress.TotalBytes, updatedDu.Status.Progress.TotalBytes)
 				assert.Equal(t, test.progress.BytesDone, updatedDu.Status.Progress.BytesDone)
@@ -810,11 +810,11 @@ func TestOnDataUploadFailed(t *testing.T) {
 	namespace := du.Namespace
 	duName := du.Name
 	// Add the DataUpload object to the fake client
-	assert.NoError(t, r.client.Create(ctx, du))
+	require.NoError(t, r.client.Create(ctx, du))
 	r.snapshotExposerList = map[velerov2alpha1api.SnapshotType]exposer.SnapshotExposer{velerov2alpha1api.SnapshotTypeCSI: exposer.NewCSISnapshotExposer(r.kubeClient, r.csiSnapshotClient, velerotest.NewLogger())}
 	r.OnDataUploadFailed(ctx, namespace, duName, fmt.Errorf("Failed to handle %v", duName))
 	updatedDu := &velerov2alpha1api.DataUpload{}
-	assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: duName, Namespace: namespace}, updatedDu))
+	require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: duName, Namespace: namespace}, updatedDu))
 	assert.Equal(t, velerov2alpha1api.DataUploadPhaseFailed, updatedDu.Status.Phase)
 	assert.False(t, updatedDu.Status.CompletionTimestamp.IsZero())
 	assert.False(t, updatedDu.Status.StartTimestamp.IsZero())
@@ -829,11 +829,11 @@ func TestOnDataUploadCompleted(t *testing.T) {
 	namespace := du.Namespace
 	duName := du.Name
 	// Add the DataUpload object to the fake client
-	assert.NoError(t, r.client.Create(ctx, du))
+	require.NoError(t, r.client.Create(ctx, du))
 	r.snapshotExposerList = map[velerov2alpha1api.SnapshotType]exposer.SnapshotExposer{velerov2alpha1api.SnapshotTypeCSI: exposer.NewCSISnapshotExposer(r.kubeClient, r.csiSnapshotClient, velerotest.NewLogger())}
 	r.OnDataUploadCompleted(ctx, namespace, duName, datapath.Result{})
 	updatedDu := &velerov2alpha1api.DataUpload{}
-	assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: duName, Namespace: namespace}, updatedDu))
+	require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: duName, Namespace: namespace}, updatedDu))
 	assert.Equal(t, velerov2alpha1api.DataUploadPhaseCompleted, updatedDu.Status.Phase)
 	assert.False(t, updatedDu.Status.CompletionTimestamp.IsZero())
 }

pkg/controller/pod_volume_backup_controller_test.go

@@ -510,9 +510,9 @@ func TestPVBReconcile(t *testing.T) {
 			})
 
 			if test.expectedErr != "" {
-				assert.EqualError(t, err, test.expectedErr)
+				require.EqualError(t, err, test.expectedErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			if test.expectedResult != nil {
@@ -562,11 +562,11 @@ func TestOnPVBCancelled(t *testing.T) {
 	namespace := pvb.Namespace
 	pvbName := pvb.Name
 
-	assert.NoError(t, r.client.Create(ctx, pvb))
+	require.NoError(t, r.client.Create(ctx, pvb))
 
 	r.OnDataPathCancelled(ctx, namespace, pvbName)
 	updatedPvb := &velerov1api.PodVolumeBackup{}
-	assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvbName, Namespace: namespace}, updatedPvb))
+	require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvbName, Namespace: namespace}, updatedPvb))
 	assert.Equal(t, velerov1api.PodVolumeBackupPhaseCanceled, updatedPvb.Status.Phase)
 	assert.False(t, updatedPvb.Status.CompletionTimestamp.IsZero())
 	assert.False(t, updatedPvb.Status.StartTimestamp.IsZero())
@@ -614,7 +614,7 @@ func TestOnPVBProgress(t *testing.T) {
 			namespace := pvb.Namespace
 			pvbName := pvb.Name
 
-			assert.NoError(t, r.client.Create(context.Background(), pvb))
+			require.NoError(t, r.client.Create(context.Background(), pvb))
 
 			// Create a Progress object
 			progress := &uploader.Progress{
@@ -625,7 +625,7 @@ func TestOnPVBProgress(t *testing.T) {
 			r.OnDataPathProgress(ctx, namespace, pvbName, progress)
 			if len(test.needErrs) != 0 && !test.needErrs[0] {
 				updatedPvb := &velerov1api.PodVolumeBackup{}
-				assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvbName, Namespace: namespace}, updatedPvb))
+				require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvbName, Namespace: namespace}, updatedPvb))
 				assert.Equal(t, test.progress.TotalBytes, updatedPvb.Status.Progress.TotalBytes)
 				assert.Equal(t, test.progress.BytesDone, updatedPvb.Status.Progress.BytesDone)
 			}
@@ -642,11 +642,11 @@ func TestOnPvbFailed(t *testing.T) {
 	namespace := pvb.Namespace
 	pvbName := pvb.Name
 
-	assert.NoError(t, r.client.Create(ctx, pvb))
+	require.NoError(t, r.client.Create(ctx, pvb))
 
 	r.OnDataPathFailed(ctx, namespace, pvbName, fmt.Errorf("Failed to handle %v", pvbName))
 	updatedPvb := &velerov1api.PodVolumeBackup{}
-	assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvbName, Namespace: namespace}, updatedPvb))
+	require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvbName, Namespace: namespace}, updatedPvb))
 	assert.Equal(t, velerov1api.PodVolumeBackupPhaseFailed, updatedPvb.Status.Phase)
 	assert.False(t, updatedPvb.Status.CompletionTimestamp.IsZero())
 	assert.False(t, updatedPvb.Status.StartTimestamp.IsZero())
@@ -662,11 +662,11 @@ func TestOnPvbCompleted(t *testing.T) {
 	namespace := pvb.Namespace
 	pvbName := pvb.Name
 
-	assert.NoError(t, r.client.Create(ctx, pvb))
+	require.NoError(t, r.client.Create(ctx, pvb))
 
 	r.OnDataPathCompleted(ctx, namespace, pvbName, datapath.Result{})
 	updatedPvb := &velerov1api.PodVolumeBackup{}
-	assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvbName, Namespace: namespace}, updatedPvb))
+	require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvbName, Namespace: namespace}, updatedPvb))
 	assert.Equal(t, velerov1api.PodVolumeBackupPhaseCompleted, updatedPvb.Status.Phase)
 	assert.False(t, updatedPvb.Status.CompletionTimestamp.IsZero())
 }

pkg/controller/pod_volume_restore_controller_test.go

@@ -1019,9 +1019,9 @@ func TestPodVolumeRestoreReconcile(t *testing.T) {
 			})
 
 			if test.expectedErr != "" {
-				assert.EqualError(t, err, test.expectedErr)
+				require.EqualError(t, err, test.expectedErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			if test.expectedResult != nil {
@@ -1074,15 +1074,15 @@ func TestOnPodVolumeRestoreFailed(t *testing.T) {
 		namespace := pvr.Namespace
 		pvrName := pvr.Name
 
-		assert.NoError(t, r.client.Create(ctx, pvr))
+		require.NoError(t, r.client.Create(ctx, pvr))
 		r.OnDataPathFailed(ctx, namespace, pvrName, fmt.Errorf("Failed to handle %v", pvrName))
 		updatedPVR := &velerov1api.PodVolumeRestore{}
 		if getErr {
-			assert.Error(t, r.client.Get(ctx, types.NamespacedName{Name: pvrName, Namespace: namespace}, updatedPVR))
+			require.Error(t, r.client.Get(ctx, types.NamespacedName{Name: pvrName, Namespace: namespace}, updatedPVR))
 			assert.NotEqual(t, velerov1api.PodVolumeRestorePhaseFailed, updatedPVR.Status.Phase)
 			assert.True(t, updatedPVR.Status.StartTimestamp.IsZero())
 		} else {
-			assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvrName, Namespace: namespace}, updatedPVR))
+			require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvrName, Namespace: namespace}, updatedPVR))
 			assert.Equal(t, velerov1api.PodVolumeRestorePhaseFailed, updatedPVR.Status.Phase)
 			assert.True(t, updatedPVR.Status.StartTimestamp.IsZero())
 		}
@@ -1100,15 +1100,15 @@ func TestOnPodVolumeRestoreCancelled(t *testing.T) {
 		namespace := pvr.Namespace
 		pvrName := pvr.Name
 
-		assert.NoError(t, r.client.Create(ctx, pvr))
+		require.NoError(t, r.client.Create(ctx, pvr))
 		r.OnDataPathCancelled(ctx, namespace, pvrName)
 		updatedPVR := &velerov1api.PodVolumeRestore{}
 		if getErr {
-			assert.Error(t, r.client.Get(ctx, types.NamespacedName{Name: pvrName, Namespace: namespace}, updatedPVR))
+			require.Error(t, r.client.Get(ctx, types.NamespacedName{Name: pvrName, Namespace: namespace}, updatedPVR))
 			assert.NotEqual(t, velerov1api.PodVolumeRestorePhaseFailed, updatedPVR.Status.Phase)
 			assert.True(t, updatedPVR.Status.StartTimestamp.IsZero())
 		} else {
-			assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvrName, Namespace: namespace}, updatedPVR))
+			require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvrName, Namespace: namespace}, updatedPVR))
 			assert.Equal(t, velerov1api.PodVolumeRestorePhaseCanceled, updatedPVR.Status.Phase)
 			assert.False(t, updatedPVR.Status.StartTimestamp.IsZero())
 			assert.False(t, updatedPVR.Status.CompletionTimestamp.IsZero())
@@ -1147,15 +1147,15 @@ func TestOnPodVolumeRestoreCompleted(t *testing.T) {
 			namespace := pvr.Namespace
 			ddName := pvr.Name
 
-			assert.NoError(t, r.client.Create(ctx, pvr))
+			require.NoError(t, r.client.Create(ctx, pvr))
 			r.OnDataPathCompleted(ctx, namespace, ddName, datapath.Result{})
 			updatedDD := &velerov1api.PodVolumeRestore{}
 			if test.isGetErr {
-				assert.Error(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
+				require.Error(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
 				assert.Equal(t, velerov1api.PodVolumeRestorePhase(""), updatedDD.Status.Phase)
 				assert.True(t, updatedDD.Status.CompletionTimestamp.IsZero())
 			} else {
-				assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
+				require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: ddName, Namespace: namespace}, updatedDD))
 				assert.Equal(t, velerov1api.PodVolumeRestorePhaseCompleted, updatedDD.Status.Phase)
 				assert.False(t, updatedDD.Status.CompletionTimestamp.IsZero())
 			}
@@ -1205,7 +1205,7 @@ func TestOnPodVolumeRestoreProgress(t *testing.T) {
 			namespace := pvr.Namespace
 			pvrName := pvr.Name
 
-			assert.NoError(t, r.client.Create(context.Background(), pvr))
+			require.NoError(t, r.client.Create(context.Background(), pvr))
 
 			// Create a Progress object
 			progress := &uploader.Progress{
@@ -1216,7 +1216,7 @@ func TestOnPodVolumeRestoreProgress(t *testing.T) {
 			r.OnDataPathProgress(ctx, namespace, pvrName, progress)
 			if len(test.needErrs) != 0 && !test.needErrs[0] {
 				updatedPVR := &velerov1api.PodVolumeRestore{}
-				assert.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvrName, Namespace: namespace}, updatedPVR))
+				require.NoError(t, r.client.Get(ctx, types.NamespacedName{Name: pvrName, Namespace: namespace}, updatedPVR))
 				assert.Equal(t, test.progress.TotalBytes, updatedPVR.Status.Progress.TotalBytes)
 				assert.Equal(t, test.progress.BytesDone, updatedPVR.Status.Progress.BytesDone)
 			}

pkg/controller/restore_controller_test.go

@@ -125,7 +125,7 @@ func TestFetchBackupInfo(t *testing.T) {
 				}
 
 				for _, itm := range test.informerBackups {
-					assert.NoError(t, r.kbClient.Create(context.Background(), itm))
+					require.NoError(t, r.kbClient.Create(context.Background(), itm))
 				}
 			}
 
@@ -180,7 +180,7 @@ func TestProcessQueueItemSkips(t *testing.T) {
 			)
 
 			if test.restore != nil {
-				assert.NoError(t, fakeClient.Create(context.Background(), test.restore))
+				require.NoError(t, fakeClient.Create(context.Background(), test.restore))
 			}
 
 			r := NewRestoreReconciler(
@@ -524,7 +524,7 @@ func TestRestoreReconcile(t *testing.T) {
 				require.NoError(t, r.kbClient.Create(context.Background(), test.location))
 			}
 			if test.backup != nil {
-				assert.NoError(t, r.kbClient.Create(context.Background(), test.backup))
+				require.NoError(t, r.kbClient.Create(context.Background(), test.backup))
 			}
 
 			if test.restore != nil {

pkg/controller/restore_finalizer_controller_test.go

@@ -151,7 +151,7 @@ func TestRestoreFinalizerReconcile(t *testing.T) {
 				backupStore.On("GetRestoreItemOperations", test.restore.Name).Return([]*itemoperation.RestoreOperation{}, nil)
 			}
 			if test.backup != nil {
-				assert.NoError(t, r.Client.Create(context.Background(), test.backup))
+				require.NoError(t, r.Client.Create(context.Background(), test.backup))
 				backupStore.On("GetBackupVolumeInfos", test.backup.Name).Return(nil, nil)
 				pluginManager.On("GetRestoreItemActionsV2").Return(nil, nil)
 				pluginManager.On("CleanupClients")
@@ -457,7 +457,7 @@ func TestPatchDynamicPVWithVolumeInfo(t *testing.T) {
 		for pvName, expectedPVInfo := range tc.expectedPatch {
 			pv := &corev1api.PersistentVolume{}
 			err := ctx.crClient.Get(context.Background(), crclient.ObjectKey{Name: pvName}, pv)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			assert.Equal(t, expectedPVInfo.ReclaimPolicy, string(pv.Spec.PersistentVolumeReclaimPolicy))
 			assert.Equal(t, expectedPVInfo.Labels, pv.Labels)
@@ -555,7 +555,7 @@ func TestWaitRestoreExecHook(t *testing.T) {
 
 		updated := &velerov1api.Restore{}
 		err := ctx.crClient.Get(context.Background(), crclient.ObjectKey{Namespace: velerov1api.DefaultNamespace, Name: tc.restore.Name}, updated)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, tc.expectedHooksAttempted, updated.Status.HookStatus.HooksAttempted)
 		assert.Equal(t, tc.expectedHooksFailed, updated.Status.HookStatus.HooksFailed)
 	}

pkg/datamover/backup_micro_service_test.go

@@ -27,6 +27,7 @@ import (
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/runtime"
 
 	"github.com/vmware-tanzu/velero/pkg/builder"
@@ -114,7 +115,7 @@ func TestOnDataUploadFailed(t *testing.T) {
 	go bs.OnDataUploadFailed(context.TODO(), velerov1api.DefaultNamespace, dataUploadName, errors.New("fake-error"))
 
 	result := <-bs.resultSignal
-	assert.EqualError(t, result.err, expectedErr)
+	require.EqualError(t, result.err, expectedErr)
 	assert.Equal(t, expectedEventReason, bt.EventReason())
 	assert.Equal(t, expectedEventMsg, bt.EventMessage())
 }
@@ -138,7 +139,7 @@ func TestOnDataUploadCancelled(t *testing.T) {
 	go bs.OnDataUploadCancelled(context.TODO(), velerov1api.DefaultNamespace, dataUploadName)
 
 	result := <-bs.resultSignal
-	assert.EqualError(t, result.err, expectedErr)
+	require.EqualError(t, result.err, expectedErr)
 	assert.Equal(t, expectedEventReason, bt.EventReason())
 	assert.Equal(t, expectedEventMsg, bt.EventMessage())
 }
@@ -189,7 +190,7 @@ func TestOnDataUploadCompleted(t *testing.T) {
 			if test.marshalErr != nil {
 				assert.EqualError(t, result.err, test.expectedErr)
 			} else {
-				assert.NoError(t, result.err)
+				require.NoError(t, result.err)
 				assert.Equal(t, test.expectedEventReason, bt.EventReason())
 				assert.Equal(t, test.expectedEventMsg, bt.EventMessage())
 			}
@@ -282,7 +283,7 @@ func TestCancelDataUpload(t *testing.T) {
 
 			result := <-bs.resultSignal
 
-			assert.EqualError(t, result.err, test.expectedErr)
+			require.EqualError(t, result.err, test.expectedErr)
 			assert.True(t, bt.withEvent)
 			assert.Equal(t, test.expectedEventReason, bt.EventReason())
 			assert.Equal(t, test.expectedEventMsg, bt.EventMessage())
@@ -431,9 +432,9 @@ func TestRunCancelableDataPath(t *testing.T) {
 			result, err := bs.RunCancelableDataPath(test.ctx)
 
 			if test.expectedErr != "" {
-				assert.EqualError(t, err, test.expectedErr)
+				require.EqualError(t, err, test.expectedErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, test.result.result, result)
 			}
 

pkg/datamover/restore_micro_service_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/runtime"
 	kbclient "sigs.k8s.io/controller-runtime/pkg/client"
 	clientFake "sigs.k8s.io/controller-runtime/pkg/client/fake"
@@ -60,7 +61,7 @@ func TestOnDataDownloadFailed(t *testing.T) {
 	go bs.OnDataDownloadFailed(context.TODO(), velerov1api.DefaultNamespace, dataDownloadName, errors.New("fake-error"))
 
 	result := <-bs.resultSignal
-	assert.EqualError(t, result.err, expectedErr)
+	require.EqualError(t, result.err, expectedErr)
 	assert.Equal(t, expectedEventReason, bt.EventReason())
 	assert.Equal(t, expectedEventMsg, bt.EventMessage())
 }
@@ -84,7 +85,7 @@ func TestOnDataDownloadCancelled(t *testing.T) {
 	go bs.OnDataDownloadCancelled(context.TODO(), velerov1api.DefaultNamespace, dataDownloadName)
 
 	result := <-bs.resultSignal
-	assert.EqualError(t, result.err, expectedErr)
+	require.EqualError(t, result.err, expectedErr)
 	assert.Equal(t, expectedEventReason, bt.EventReason())
 	assert.Equal(t, expectedEventMsg, bt.EventMessage())
 }
@@ -135,7 +136,7 @@ func TestOnDataDownloadCompleted(t *testing.T) {
 			if test.marshalErr != nil {
 				assert.EqualError(t, result.err, test.expectedErr)
 			} else {
-				assert.NoError(t, result.err)
+				require.NoError(t, result.err)
 				assert.Equal(t, test.expectedEventReason, bt.EventReason())
 				assert.Equal(t, test.expectedEventMsg, bt.EventMessage())
 			}
@@ -226,7 +227,7 @@ func TestCancelDataDownload(t *testing.T) {
 
 			result := <-bs.resultSignal
 
-			assert.EqualError(t, result.err, test.expectedErr)
+			require.EqualError(t, result.err, test.expectedErr)
 			assert.True(t, bt.withEvent)
 			assert.Equal(t, test.expectedEventReason, bt.EventReason())
 			assert.Equal(t, test.expectedEventMsg, bt.EventMessage())
@@ -375,9 +376,9 @@ func TestRunCancelableRestore(t *testing.T) {
 			result, err := rs.RunCancelableDataPath(test.ctx)
 
 			if test.expectedErr != "" {
-				assert.EqualError(t, err, test.expectedErr)
+				require.EqualError(t, err, test.expectedErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, test.result.result, result)
 			}
 

pkg/datapath/manager_test.go

@@ -21,16 +21,17 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateFileSystemBR(t *testing.T) {
 	m := NewManager(2)
 
 	async_job_1, err := m.CreateFileSystemBR("job-1", "test", context.TODO(), nil, "velero", Callbacks{}, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = m.CreateFileSystemBR("job-2", "test", context.TODO(), nil, "velero", Callbacks{}, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = m.CreateFileSystemBR("job-3", "test", context.TODO(), nil, "velero", Callbacks{}, nil)
 	assert.Equal(t, ConcurrentLimitExceed, err)
@@ -55,16 +56,16 @@ func TestCreateMicroServiceBRWatcher(t *testing.T) {
 	m := NewManager(2)
 
 	async_job_1, err := m.CreateMicroServiceBRWatcher(context.TODO(), nil, nil, nil, "test", "job-1", "velero", "pod-1", "container", "du-1", Callbacks{}, false, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = m.CreateMicroServiceBRWatcher(context.TODO(), nil, nil, nil, "test", "job-2", "velero", "pod-2", "container", "du-2", Callbacks{}, false, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = m.CreateMicroServiceBRWatcher(context.TODO(), nil, nil, nil, "test", "job-3", "velero", "pod-3", "container", "du-3", Callbacks{}, false, nil)
 	assert.Equal(t, ConcurrentLimitExceed, err)
 
 	async_job_4, err := m.CreateMicroServiceBRWatcher(context.TODO(), nil, nil, nil, "test", "job-4", "velero", "pod-4", "container", "du-4", Callbacks{}, true, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	ret := m.GetAsyncBR("job-0")
 	assert.Nil(t, ret)

pkg/datapath/micro_service_watcher_test.go

@@ -619,7 +619,7 @@ func TestRedirectDataMoverLogs(t *testing.T) {
 			if test.expectErr != "" {
 				assert.EqualError(t, err, test.expectErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				assert.Contains(t, buffer, test.logMessage)
 			}

pkg/discovery/helper_test.go

@@ -195,9 +195,9 @@ func TestRefreshServerPreferredResources(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			resources, err := refreshServerPreferredResources(fakeServer, logging.DefaultLogger(logrus.DebugLevel, formatFlag))
 			if test.returnError != nil {
-				assert.Error(t, err)
+				require.Error(t, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, test.returnError, err)
 			}
 
@@ -311,7 +311,7 @@ func TestHelper_ResourceFor(t *testing.T) {
 			}
 			gvr, apiResource, err := h.ResourceFor(*tc.input)
 			if tc.err == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			} else {
 				require.ErrorContains(t, err, tc.err)
 			}
@@ -418,7 +418,7 @@ func TestHelper_KindFor(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			gvr, apiResource, err := h.KindFor(*tc.input)
 			if tc.err == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			} else {
 				require.ErrorContains(t, err, tc.err)
 			}
@@ -575,7 +575,7 @@ func TestHelper_refreshServerPreferredResources(t *testing.T) {
 			if tc.expectedErr != nil {
 				assert.Error(t, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.NotNil(t, resources)
 			}
 		})
@@ -630,7 +630,7 @@ func TestHelper_refreshServerGroupsAndResources(t *testing.T) {
 			if tc.expectedErr != nil {
 				assert.Error(t, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.NotNil(t, serverGroups)
 				assert.NotNil(t, serverResources)
 			}
@@ -645,7 +645,7 @@ func TestHelper(t *testing.T) {
 	h, err := NewHelper(&velerotest.DiscoveryClient{
 		FakeDiscovery: fakeDiscoveryClient,
 	}, logrus.New())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// All below calls put together for the implementation are empty or just very simple, and just want to cover testing
 	// If wanting to write unit tests for some functions could remove it and with writing new function alone
 	h.Resources()

pkg/exposer/csi_snapshot_test.go

@@ -26,6 +26,7 @@ import (
 	snapshotFake "github.com/kubernetes-csi/external-snapshotter/client/v7/clientset/versioned/fake"
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	appsv1api "k8s.io/api/apps/v1"
 	corev1api "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
@@ -500,19 +501,19 @@ func TestExpose(t *testing.T) {
 
 			err := exposer.Expose(context.Background(), ownerObject, &test.exposeParam)
 			if err == nil {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				_, err = exposer.kubeClient.CoreV1().Pods(ownerObject.Namespace).Get(context.Background(), ownerObject.Name, metav1.GetOptions{})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				backupPVC, err := exposer.kubeClient.CoreV1().PersistentVolumeClaims(ownerObject.Namespace).Get(context.Background(), ownerObject.Name, metav1.GetOptions{})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				expectedVS, err := exposer.csiSnapshotClient.VolumeSnapshots(ownerObject.Namespace).Get(context.Background(), ownerObject.Name, metav1.GetOptions{})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				expectedVSC, err := exposer.csiSnapshotClient.VolumeSnapshotContents().Get(context.Background(), ownerObject.Name, metav1.GetOptions{})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				assert.Equal(t, expectedVS.Annotations, vsObject.Annotations)
 				assert.Equal(t, *expectedVS.Spec.VolumeSnapshotClassName, *vsObject.Spec.VolumeSnapshotClassName)
@@ -710,12 +711,12 @@ func TestGetExpose(t *testing.T) {
 
 			result, err := exposer.GetExposed(context.Background(), ownerObject, test.Timeout, &test.exposeWaitParam)
 			if test.err == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				if test.expectedResult == nil {
 					assert.Nil(t, result)
 				} else {
-					assert.NoError(t, err)
+					require.NoError(t, err)
 					assert.Equal(t, test.expectedResult.ByPod.VolumeName, result.ByPod.VolumeName)
 					assert.Equal(t, test.expectedResult.ByPod.HostingPod.Name, result.ByPod.HostingPod.Name)
 				}

pkg/exposer/host_path_test.go

@@ -24,6 +24,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	corev1api "k8s.io/api/core/v1"
 	"k8s.io/client-go/kubernetes"
 
@@ -154,7 +155,7 @@ func TestExtractPodVolumeHostPath(t *testing.T) {
 			if test.expectedErr != "" {
 				assert.EqualError(t, err, test.expectedErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, test.expected, path)
 			}
 		})

pkg/exposer/image_test.go

@@ -22,6 +22,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/kubernetes"
@@ -327,7 +328,7 @@ func TestGetInheritedPodInfo(t *testing.T) {
 			info, err := getInheritedPodInfo(context.Background(), fakeKubeClient, test.namespace, kube.NodeOSLinux)
 
 			if test.expectErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.True(t, reflect.DeepEqual(info, test.result))
 			} else {
 				assert.EqualError(t, err, test.expectErr)

pkg/exposer/pod_volume_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	appsv1api "k8s.io/api/apps/v1"
 	corev1api "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -221,7 +222,7 @@ func TestPodVolumeExpose(t *testing.T) {
 
 			err := exposer.Expose(context.Background(), ownerObject, test.exposeParam)
 			if err == nil {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				_, err = exposer.kubeClient.CoreV1().Pods(ownerObject.Namespace).Get(context.Background(), ownerObject.Name, metav1.GetOptions{})
 				assert.NoError(t, err)
@@ -319,12 +320,12 @@ func TestGetPodVolumeExpose(t *testing.T) {
 
 			result, err := exposer.GetExposed(context.Background(), ownerObject, fakeClient, test.nodeName, test.Timeout)
 			if test.err == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				if test.expectedResult == nil {
 					assert.Nil(t, result)
 				} else {
-					assert.NoError(t, err)
+					require.NoError(t, err)
 					assert.Equal(t, test.expectedResult.ByPod.VolumeName, result.ByPod.VolumeName)
 					assert.Equal(t, test.expectedResult.ByPod.HostingPod.Name, result.ByPod.HostingPod.Name)
 				}

pkg/itemblock/actions/service_account_action_test.go

@@ -384,7 +384,7 @@ func TestServiceAccountActionExecute(t *testing.T) {
 
 			additional, err := action.GetRelatedItems(test.serviceAccount, nil)
 
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			// ensure slices are ordered for valid comparison
 			sort.Slice(test.expectedAdditionalItems, func(i, j int) bool {
@@ -590,7 +590,7 @@ func TestServiceAccountActionExecuteOnBeta1(t *testing.T) {
 
 			additional, err := action.GetRelatedItems(test.serviceAccount, nil)
 
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			// ensure slices are ordered for valid comparison
 			sort.Slice(test.expectedAdditionalItems, func(i, j int) bool {

pkg/kopia/kopia_log_test.go

@@ -335,7 +335,7 @@ func TestWrite(t *testing.T) {
 
 			err := log.Write(tc.ent, nil)
 
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			if len(tc.logMessage) > 0 {
 				assert.Contains(t, logMessage, tc.logMessage)

pkg/nodeagent/node_agent_test.go

@@ -22,6 +22,7 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	appsv1api "k8s.io/api/apps/v1"
 	corev1api "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -232,7 +233,7 @@ func TestGetPodSpec(t *testing.T) {
 
 			spec, err := GetPodSpec(context.TODO(), fakeKubeClient, test.namespace, kube.NodeOSLinux)
 			if test.expectErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, *spec, test.expectSpec)
 			} else {
 				assert.EqualError(t, err, test.expectErr)
@@ -317,7 +318,7 @@ func TestGetConfigs(t *testing.T) {
 
 			result, err := GetConfigs(context.TODO(), test.namespace, fakeKubeClient, "node-agent-config")
 			if test.expectErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				if test.expectResult == nil {
 					assert.Nil(t, result)
@@ -453,7 +454,7 @@ func TestGetLabelValue(t *testing.T) {
 
 			value, err := GetLabelValue(context.TODO(), fakeKubeClient, test.namespace, "fake-label", kube.NodeOSLinux)
 			if test.expectErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, test.expectedValue, value)
 			} else {
 				assert.EqualError(t, err, test.expectErr)
@@ -582,7 +583,7 @@ func TestGetAnnotationValue(t *testing.T) {
 
 			value, err := GetAnnotationValue(context.TODO(), fakeKubeClient, test.namespace, "fake-annotation", kube.NodeOSLinux)
 			if test.expectErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, test.expectedValue, value)
 			} else {
 				assert.EqualError(t, err, test.expectErr)
@@ -743,7 +744,7 @@ func TestGetHostPodPath(t *testing.T) {
 			path, err := GetHostPodPath(context.TODO(), fakeKubeClient, test.namespace, test.osType)
 
 			if test.expectErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, test.expectedValue, path)
 			} else {
 				assert.EqualError(t, err, test.expectErr)

pkg/persistence/object_store_test.go

@@ -421,13 +421,13 @@ func TestGetBackupVolumeSnapshots(t *testing.T) {
 	// volumesnapshots file not found should not error
 	harness.objectStore.PutObject(harness.bucket, "backups/test-backup/velero-backup.json", newStringReadSeeker("foo"))
 	res, err := harness.GetBackupVolumeSnapshots("test-backup")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, res)
 
 	// volumesnapshots file containing invalid data should error
 	harness.objectStore.PutObject(harness.bucket, "backups/test-backup/test-backup-volumesnapshots.json.gz", newStringReadSeeker("foo"))
 	_, err = harness.GetBackupVolumeSnapshots("test-backup")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// volumesnapshots file containing gzipped json data should return correctly
 	snapshots := []*volume.Snapshot{
@@ -453,7 +453,7 @@ func TestGetBackupVolumeSnapshots(t *testing.T) {
 	require.NoError(t, harness.objectStore.PutObject(harness.bucket, "backups/test-backup/test-backup-volumesnapshots.json.gz", obj))
 
 	res, err = harness.GetBackupVolumeSnapshots("test-backup")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, snapshots, res)
 }
 
@@ -463,13 +463,13 @@ func TestGetBackupItemOperations(t *testing.T) {
 	// itemoperations file not found should not error
 	harness.objectStore.PutObject(harness.bucket, "backups/test-backup/velero-backup.json", newStringReadSeeker("foo"))
 	res, err := harness.GetBackupItemOperations("test-backup")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, res)
 
 	// itemoperations file containing invalid data should error
 	harness.objectStore.PutObject(harness.bucket, "backups/test-backup/test-backup-itemoperations.json.gz", newStringReadSeeker("foo"))
 	_, err = harness.GetBackupItemOperations("test-backup")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// itemoperations file containing gzipped json data should return correctly
 	operations := []*itemoperation.BackupOperation{
@@ -503,7 +503,7 @@ func TestGetBackupItemOperations(t *testing.T) {
 	require.NoError(t, harness.objectStore.PutObject(harness.bucket, "backups/test-backup/test-backup-itemoperations.json.gz", obj))
 
 	res, err = harness.GetBackupItemOperations("test-backup")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, operations, res)
 }
 
@@ -512,13 +512,13 @@ func TestGetRestoreItemOperations(t *testing.T) {
 
 	// itemoperations file not found should not error
 	res, err := harness.GetRestoreItemOperations("test-restore")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, res)
 
 	// itemoperations file containing invalid data should error
 	harness.objectStore.PutObject(harness.bucket, "restores/test-restore/restore-test-restore-itemoperations.json.gz", newStringReadSeeker("foo"))
 	_, err = harness.GetRestoreItemOperations("test-restore")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// itemoperations file containing gzipped json data should return correctly
 	operations := []*itemoperation.RestoreOperation{
@@ -552,7 +552,7 @@ func TestGetRestoreItemOperations(t *testing.T) {
 	require.NoError(t, harness.objectStore.PutObject(harness.bucket, "restores/test-restore/restore-test-restore-itemoperations.json.gz", obj))
 
 	res, err = harness.GetRestoreItemOperations("test-restore")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, operations, res)
 }
 
@@ -800,13 +800,13 @@ func TestGetCSIVolumeSnapshotClasses(t *testing.T) {
 
 	// file not found should not error
 	res, err := harness.GetCSIVolumeSnapshotClasses("test-backup")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, res)
 
 	// file containing invalid data should error
 	harness.objectStore.PutObject(harness.bucket, "backups/test-backup/test-backup-csi-volumesnapshotclasses.json.gz", newStringReadSeeker("foo"))
 	_, err = harness.GetCSIVolumeSnapshotClasses("test-backup")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// file containing gzipped json data should return correctly
 	classes := []*snapshotv1api.VolumeSnapshotClass{
@@ -823,7 +823,7 @@ func TestGetCSIVolumeSnapshotClasses(t *testing.T) {
 	require.NoError(t, harness.objectStore.PutObject(harness.bucket, "backups/test-backup/test-backup-csi-volumesnapshotclasses.json.gz", obj))
 
 	res, err = harness.GetCSIVolumeSnapshotClasses("test-backup")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, classes, res)
 }
 
@@ -832,13 +832,13 @@ func TestGetCSIVolumeSnapshots(t *testing.T) {
 
 	// file not found should not error
 	res, err := harness.GetCSIVolumeSnapshots("test-backup")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, res)
 
 	// file containing invalid data should error
 	harness.objectStore.PutObject(harness.bucket, "backups/test-backup/test-backup-csi-volumesnapshots.json.gz", newStringReadSeeker("foo"))
 	_, err = harness.GetCSIVolumeSnapshots("test-backup")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// file containing gzipped json data should return correctly
 	snapshots := []*snapshotv1api.VolumeSnapshot{
@@ -859,7 +859,7 @@ func TestGetCSIVolumeSnapshots(t *testing.T) {
 	require.NoError(t, harness.objectStore.PutObject(harness.bucket, "backups/test-backup/test-backup-csi-volumesnapshots.json.gz", obj))
 
 	res, err = harness.GetCSIVolumeSnapshots("test-backup")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, snapshots, res)
 }
 
@@ -1116,12 +1116,12 @@ func TestGetRestoreResults(t *testing.T) {
 
 	// file not found should not error
 	_, err := harness.GetRestoreResults("test-restore")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// file containing invalid data should error
 	harness.objectStore.PutObject(harness.bucket, "restores/test-restore/restore-test-restore-results.gz", newStringReadSeeker("foo"))
 	_, err = harness.GetRestoreResults("test-restore")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// file containing gzipped json data should return correctly
 	contents := map[string]results.Result{
@@ -1136,7 +1136,7 @@ func TestGetRestoreResults(t *testing.T) {
 	require.NoError(t, harness.objectStore.PutObject(harness.bucket, "restores/test-restore/restore-test-restore-results.gz", obj))
 	res, err := harness.GetRestoreResults("test-restore")
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, contents["warnings"], res["warnings"])
 	assert.Equal(t, contents["errors"], res["errors"])
 }
@@ -1146,12 +1146,12 @@ func TestGetRestoredResourceList(t *testing.T) {
 
 	// file not found should not error
 	_, err := harness.GetRestoredResourceList("test-restore")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// file containing invalid data should error
 	harness.objectStore.PutObject(harness.bucket, "restores/test-restore/restore-test-restore-resource-list.json.gz", newStringReadSeeker("foo"))
 	_, err = harness.GetRestoredResourceList("test-restore")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// file containing gzipped json data should return correctly
 	list := map[string][]string{
@@ -1165,7 +1165,7 @@ func TestGetRestoredResourceList(t *testing.T) {
 	require.NoError(t, harness.objectStore.PutObject(harness.bucket, "restores/test-restore/restore-test-restore-resource-list.json.gz", obj))
 	res, err := harness.GetRestoredResourceList("test-restore")
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, list["pod"], res["pod"])
 }
 

pkg/plugin/clientmgmt/backupitemaction/v1/restartable_backup_item_action_test.go

@@ -88,7 +88,7 @@ func TestRestartableBackupItemActionGetDelegate(t *testing.T) {
 	r := NewRestartableBackupItemAction(name, p)
 	a, err := r.getDelegate()
 	assert.Nil(t, a)
-	assert.EqualError(t, err, "reset error")
+	require.EqualError(t, err, "reset error")
 
 	// Happy path
 	p.On("ResetIfNeeded").Return(nil)
@@ -97,7 +97,7 @@ func TestRestartableBackupItemActionGetDelegate(t *testing.T) {
 	p.On("GetByKindAndName", key).Return(expected, nil)
 
 	a, err = r.getDelegate()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, a)
 }
 

pkg/plugin/clientmgmt/backupitemaction/v2/restartable_backup_item_action_test.go

@@ -88,7 +88,7 @@ func TestRestartableBackupItemActionGetDelegate(t *testing.T) {
 	r := NewRestartableBackupItemAction(name, p)
 	a, err := r.getDelegate()
 	assert.Nil(t, a)
-	assert.EqualError(t, err, "reset error")
+	require.EqualError(t, err, "reset error")
 
 	// Happy path
 	p.On("ResetIfNeeded").Return(nil)
@@ -97,7 +97,7 @@ func TestRestartableBackupItemActionGetDelegate(t *testing.T) {
 	p.On("GetByKindAndName", key).Return(expected, nil)
 
 	a, err = r.getDelegate()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, a)
 }
 

pkg/plugin/clientmgmt/itemblockaction/v1/restartable_item_block_action_test.go

@@ -88,7 +88,7 @@ func TestRestartableItemBlockActionGetDelegate(t *testing.T) {
 	r := NewRestartableItemBlockAction(name, p)
 	a, err := r.getDelegate()
 	assert.Nil(t, a)
-	assert.EqualError(t, err, "reset error")
+	require.EqualError(t, err, "reset error")
 
 	// Happy path
 	p.On("ResetIfNeeded").Return(nil)
@@ -97,7 +97,7 @@ func TestRestartableItemBlockActionGetDelegate(t *testing.T) {
 	p.On("GetByKindAndName", key).Return(expected, nil)
 
 	a, err = r.getDelegate()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, a)
 }
 

pkg/plugin/clientmgmt/manager_test.go

@@ -108,7 +108,7 @@ func TestGetRestartableProcess(t *testing.T) {
 	registry.On("Get", pluginKind, pluginName).Return(nil, errors.Errorf("registry")).Once()
 	rp, err := m.getRestartableProcess(pluginKind, pluginName)
 	assert.Nil(t, rp)
-	assert.EqualError(t, err, "registry")
+	require.EqualError(t, err, "registry")
 
 	// Test 2: registry ok, factory error
 	podID := framework.PluginIdentifier{
@@ -120,7 +120,7 @@ func TestGetRestartableProcess(t *testing.T) {
 	factory.On("NewRestartableProcess", podID.Command, logger, logLevel).Return(nil, errors.Errorf("factory")).Once()
 	rp, err = m.getRestartableProcess(pluginKind, pluginName)
 	assert.Nil(t, rp)
-	assert.EqualError(t, err, "factory")
+	require.EqualError(t, err, "factory")
 
 	// Test 3: registry ok, factory ok
 	restartableProcess := &restartabletest.MockRestartableProcess{}
@@ -310,7 +310,7 @@ func getPluginTest(
 	factory.On("NewRestartableProcess", pluginID.Command, logger, logLevel).Return(nil, errors.Errorf("NewRestartableProcess")).Once()
 	actual, err := getPluginFunc(m, pluginName)
 	assert.Nil(t, actual)
-	assert.EqualError(t, err, "NewRestartableProcess")
+	require.EqualError(t, err, "NewRestartableProcess")
 
 	// Test 2: happy path
 	factory.On("NewRestartableProcess", pluginID.Command, logger, logLevel).Return(restartableProcess, nil).Once()

pkg/plugin/clientmgmt/restartable_delete_item_action_test.go

@@ -87,7 +87,7 @@ func TestRestartableDeleteItemActionGetDelegate(t *testing.T) {
 	r := NewRestartableDeleteItemAction(name, p)
 	a, err := r.getDelegate()
 	assert.Nil(t, a)
-	assert.EqualError(t, err, "reset error")
+	require.EqualError(t, err, "reset error")
 
 	// Happy path
 	// Currently broken since this mocks out the restore item action interface
@@ -97,7 +97,7 @@ func TestRestartableDeleteItemActionGetDelegate(t *testing.T) {
 	p.On("GetByKindAndName", key).Return(expected, nil)
 
 	a, err = r.getDelegate()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, a)
 }
 

pkg/plugin/clientmgmt/restartable_object_store_test.go

@@ -97,7 +97,7 @@ func TestRestartableObjectStoreReinitialize(t *testing.T) {
 	}
 
 	err := r.Reinitialize(3)
-	assert.EqualError(t, err, "plugin int is not a ObjectStore")
+	require.EqualError(t, err, "plugin int is not a ObjectStore")
 
 	objectStore := new(providermocks.ObjectStore)
 	objectStore.Test(t)
@@ -105,7 +105,7 @@ func TestRestartableObjectStoreReinitialize(t *testing.T) {
 
 	objectStore.On("Init", r.config).Return(errors.Errorf("init error")).Once()
 	err = r.Reinitialize(objectStore)
-	assert.EqualError(t, err, "init error")
+	require.EqualError(t, err, "init error")
 
 	objectStore.On("Init", r.config).Return(nil)
 	err = r.Reinitialize(objectStore)
@@ -127,7 +127,7 @@ func TestRestartableObjectStoreGetDelegate(t *testing.T) {
 	}
 	a, err := r.getDelegate()
 	assert.Nil(t, a)
-	assert.EqualError(t, err, "reset error")
+	require.EqualError(t, err, "reset error")
 
 	// Happy path
 	p.On("ResetIfNeeded").Return(nil)
@@ -137,7 +137,7 @@ func TestRestartableObjectStoreGetDelegate(t *testing.T) {
 	p.On("GetByKindAndName", key).Return(objectStore, nil)
 
 	a, err = r.getDelegate()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, objectStore, a)
 }
 
@@ -159,7 +159,7 @@ func TestRestartableObjectStoreInit(t *testing.T) {
 		"color": "blue",
 	}
 	err := r.Init(config)
-	assert.EqualError(t, err, "GetByKindAndName error")
+	require.EqualError(t, err, "GetByKindAndName error")
 
 	// Delegate returns error
 	objectStore := new(providermocks.ObjectStore)
@@ -169,7 +169,7 @@ func TestRestartableObjectStoreInit(t *testing.T) {
 	objectStore.On("Init", config).Return(errors.Errorf("Init error")).Once()
 
 	err = r.Init(config)
-	assert.EqualError(t, err, "Init error")
+	require.EqualError(t, err, "Init error")
 
 	// wipe this out because the previous failed Init call set it
 	r.config = nil
@@ -177,7 +177,7 @@ func TestRestartableObjectStoreInit(t *testing.T) {
 	// Happy path
 	objectStore.On("Init", config).Return(nil)
 	err = r.Init(config)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, config, r.config)
 
 	// Calling Init twice is forbidden

pkg/plugin/clientmgmt/restoreitemaction/v1/restartable_restore_item_action_test.go

@@ -87,7 +87,7 @@ func TestRestartableRestoreItemActionGetDelegate(t *testing.T) {
 	r := NewRestartableRestoreItemAction(name, p)
 	a, err := r.getDelegate()
 	assert.Nil(t, a)
-	assert.EqualError(t, err, "reset error")
+	require.EqualError(t, err, "reset error")
 
 	// Happy path
 	p.On("ResetIfNeeded").Return(nil)
@@ -96,7 +96,7 @@ func TestRestartableRestoreItemActionGetDelegate(t *testing.T) {
 	p.On("GetByKindAndName", key).Return(expected, nil)
 
 	a, err = r.getDelegate()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, a)
 }
 

pkg/plugin/clientmgmt/restoreitemaction/v2/restartable_restore_item_action_test.go

@@ -87,7 +87,7 @@ func TestRestartableRestoreItemActionGetDelegate(t *testing.T) {
 	r := NewRestartableRestoreItemAction(name, p)
 	a, err := r.getDelegate()
 	assert.Nil(t, a)
-	assert.EqualError(t, err, "reset error")
+	require.EqualError(t, err, "reset error")
 
 	// Happy path
 	p.On("ResetIfNeeded").Return(nil)
@@ -96,7 +96,7 @@ func TestRestartableRestoreItemActionGetDelegate(t *testing.T) {
 	p.On("GetByKindAndName", key).Return(expected, nil)
 
 	a, err = r.getDelegate()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, a)
 }
 

pkg/plugin/clientmgmt/volumesnapshotter/v1/restartable_volume_snapshotter_test.go

@@ -96,7 +96,7 @@ func TestRestartableVolumeSnapshotterReinitialize(t *testing.T) {
 	}
 
 	err := r.Reinitialize(3)
-	assert.EqualError(t, err, "plugin int is not a VolumeSnapshotter")
+	require.EqualError(t, err, "plugin int is not a VolumeSnapshotter")
 
 	volumeSnapshotter := new(providermocks.VolumeSnapshotter)
 	volumeSnapshotter.Test(t)
@@ -104,7 +104,7 @@ func TestRestartableVolumeSnapshotterReinitialize(t *testing.T) {
 
 	volumeSnapshotter.On("Init", r.config).Return(errors.Errorf("init error")).Once()
 	err = r.Reinitialize(volumeSnapshotter)
-	assert.EqualError(t, err, "init error")
+	require.EqualError(t, err, "init error")
 
 	volumeSnapshotter.On("Init", r.config).Return(nil)
 	err = r.Reinitialize(volumeSnapshotter)
@@ -126,7 +126,7 @@ func TestRestartableVolumeSnapshotterGetDelegate(t *testing.T) {
 	}
 	a, err := r.getDelegate()
 	assert.Nil(t, a)
-	assert.EqualError(t, err, "reset error")
+	require.EqualError(t, err, "reset error")
 
 	// Happy path
 	p.On("ResetIfNeeded").Return(nil)
@@ -136,7 +136,7 @@ func TestRestartableVolumeSnapshotterGetDelegate(t *testing.T) {
 	p.On("GetByKindAndName", key).Return(volumeSnapshotter, nil)
 
 	a, err = r.getDelegate()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, volumeSnapshotter, a)
 }
 
@@ -158,7 +158,7 @@ func TestRestartableVolumeSnapshotterInit(t *testing.T) {
 		"color": "blue",
 	}
 	err := r.Init(config)
-	assert.EqualError(t, err, "GetByKindAndName error")
+	require.EqualError(t, err, "GetByKindAndName error")
 
 	// Delegate returns error
 	volumeSnapshotter := new(providermocks.VolumeSnapshotter)
@@ -168,7 +168,7 @@ func TestRestartableVolumeSnapshotterInit(t *testing.T) {
 	volumeSnapshotter.On("Init", config).Return(errors.Errorf("Init error")).Once()
 
 	err = r.Init(config)
-	assert.EqualError(t, err, "Init error")
+	require.EqualError(t, err, "Init error")
 
 	// wipe this out because the previous failed Init call set it
 	r.config = nil
@@ -176,7 +176,7 @@ func TestRestartableVolumeSnapshotterInit(t *testing.T) {
 	// Happy path
 	volumeSnapshotter.On("Init", config).Return(nil)
 	err = r.Init(config)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, config, r.config)
 
 	// Calling Init twice is forbidden

pkg/plugin/framework/validation_test.go

@@ -20,18 +20,19 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestValidateConfigKeys(t *testing.T) {
-	assert.NoError(t, validateConfigKeys(nil))
-	assert.NoError(t, validateConfigKeys(map[string]string{}))
-	assert.NoError(t, validateConfigKeys(map[string]string{"foo": "bar"}, "foo"))
-	assert.NoError(t, validateConfigKeys(map[string]string{"foo": "bar", "bar": "baz"}, "foo", "bar"))
+	require.NoError(t, validateConfigKeys(nil))
+	require.NoError(t, validateConfigKeys(map[string]string{}))
+	require.NoError(t, validateConfigKeys(map[string]string{"foo": "bar"}, "foo"))
+	require.NoError(t, validateConfigKeys(map[string]string{"foo": "bar", "bar": "baz"}, "foo", "bar"))
 
-	assert.Error(t, validateConfigKeys(map[string]string{"foo": "bar"}))
-	assert.Error(t, validateConfigKeys(map[string]string{"foo": "bar"}, "Foo"))
-	assert.Error(t, validateConfigKeys(map[string]string{"foo": "bar", "boo": ""}, "foo"))
+	require.Error(t, validateConfigKeys(map[string]string{"foo": "bar"}))
+	require.Error(t, validateConfigKeys(map[string]string{"foo": "bar"}, "Foo"))
+	require.Error(t, validateConfigKeys(map[string]string{"foo": "bar", "boo": ""}, "foo"))
 
-	assert.NoError(t, ValidateObjectStoreConfigKeys(map[string]string{"bucket": "foo"}))
+	require.NoError(t, ValidateObjectStoreConfigKeys(map[string]string{"bucket": "foo"}))
 	assert.Error(t, ValidateVolumeSnapshotterConfigKeys(map[string]string{"bucket": "foo"}))
 }

pkg/podexec/pod_command_executor_test.go

@@ -130,7 +130,7 @@ func TestExecutePodCommandMissingInputs(t *testing.T) {
 			err := e.ExecutePodCommand(velerotest.NewLogger(), test.item, test.podNamespace, test.podName, test.hookName, test.hook)
 
 			if hookPodContainerNotSame && test.hook.Container == pod.Spec.Containers[0].Name {
-				assert.Error(t, fmt.Errorf("hook exec container is overwritten"))
+				require.Error(t, fmt.Errorf("hook exec container is overwritten"))
 			}
 			assert.Error(t, err)
 		})
@@ -257,7 +257,7 @@ func TestEnsureContainerExists(t *testing.T) {
 	}
 
 	err := ensureContainerExists(pod, "bar")
-	assert.EqualError(t, err, `no such container: "bar"`)
+	require.EqualError(t, err, `no such container: "bar"`)
 
 	err = ensureContainerExists(pod, "foo")
 	assert.NoError(t, err)

pkg/podvolume/backup_micro_service_test.go

@@ -27,6 +27,7 @@ import (
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/runtime"
 
 	"github.com/vmware-tanzu/velero/pkg/builder"
@@ -113,7 +114,7 @@ func TestOnDataPathFailed(t *testing.T) {
 	go bs.OnDataPathFailed(context.TODO(), velerov1api.DefaultNamespace, pvbName, errors.New("fake-error"))
 
 	result := <-bs.resultSignal
-	assert.EqualError(t, result.err, expectedErr)
+	require.EqualError(t, result.err, expectedErr)
 	assert.Equal(t, expectedEventReason, bt.EventReason())
 	assert.Equal(t, expectedEventMsg, bt.EventMessage())
 }
@@ -137,7 +138,7 @@ func TestOnDataPathCancelled(t *testing.T) {
 	go bs.OnDataPathCancelled(context.TODO(), velerov1api.DefaultNamespace, pvbName)
 
 	result := <-bs.resultSignal
-	assert.EqualError(t, result.err, expectedErr)
+	require.EqualError(t, result.err, expectedErr)
 	assert.Equal(t, expectedEventReason, bt.EventReason())
 	assert.Equal(t, expectedEventMsg, bt.EventMessage())
 }
@@ -188,7 +189,7 @@ func TestOnDataPathCompleted(t *testing.T) {
 			if test.marshalErr != nil {
 				assert.EqualError(t, result.err, test.expectedErr)
 			} else {
-				assert.NoError(t, result.err)
+				require.NoError(t, result.err)
 				assert.Equal(t, test.expectedEventReason, bt.EventReason())
 				assert.Equal(t, test.expectedEventMsg, bt.EventMessage())
 			}
@@ -281,7 +282,7 @@ func TestCancelPodVolumeBackup(t *testing.T) {
 
 			result := <-bs.resultSignal
 
-			assert.EqualError(t, result.err, test.expectedErr)
+			require.EqualError(t, result.err, test.expectedErr)
 			assert.True(t, bt.withEvent)
 			assert.Equal(t, test.expectedEventReason, bt.EventReason())
 			assert.Equal(t, test.expectedEventMsg, bt.EventMessage())
@@ -430,9 +431,9 @@ func TestRunCancelableDataPath(t *testing.T) {
 			result, err := bs.RunCancelableDataPath(test.ctx)
 
 			if test.expectedErr != "" {
-				assert.EqualError(t, err, test.expectedErr)
+				require.EqualError(t, err, test.expectedErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, test.result.result, result)
 			}
 

pkg/podvolume/backupper_test.go

@@ -51,7 +51,7 @@ func TestIsHostPathVolume(t *testing.T) {
 		},
 	}
 	isHostPath, err := isHostPathVolume(vol, nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, isHostPath)
 
 	// non-hostPath pod volume
@@ -61,7 +61,7 @@ func TestIsHostPathVolume(t *testing.T) {
 		},
 	}
 	isHostPath, err = isHostPathVolume(vol, nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, isHostPath)
 
 	// PVC that doesn't have a PV
@@ -79,7 +79,7 @@ func TestIsHostPathVolume(t *testing.T) {
 		},
 	}
 	isHostPath, err = isHostPathVolume(vol, pvc, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, isHostPath)
 
 	// PVC that claims a non-hostPath PV
@@ -107,7 +107,7 @@ func TestIsHostPathVolume(t *testing.T) {
 	}
 	crClient1 := velerotest.NewFakeControllerRuntimeClient(t, pv)
 	isHostPath, err = isHostPathVolume(vol, pvc, crClient1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, isHostPath)
 
 	// PVC that claims a hostPath PV
@@ -140,7 +140,7 @@ func TestIsHostPathVolume(t *testing.T) {
 	crClient2 := velerotest.NewFakeControllerRuntimeClient(t, pv)
 
 	isHostPath, err = isHostPathVolume(vol, pvc, crClient2)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, isHostPath)
 }
 
@@ -588,10 +588,10 @@ func TestBackupPodVolumes(t *testing.T) {
 			pvbs, _, errs := bp.BackupPodVolumes(backupObj, test.sourcePod, test.volumes, nil, velerotest.NewLogger())
 
 			if test.errs == nil {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			} else {
 				for i := 0; i < len(errs); i++ {
-					assert.EqualError(t, errs[i], test.errs[i])
+					require.EqualError(t, errs[i], test.errs[i])
 				}
 			}
 

pkg/podvolume/restore_micro_service_test.go

@@ -28,6 +28,7 @@ import (
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/runtime"
 
 	"github.com/vmware-tanzu/velero/pkg/builder"
@@ -121,7 +122,7 @@ func TestOnPvrFailed(t *testing.T) {
 	go rs.OnPvrFailed(context.TODO(), velerov1api.DefaultNamespace, pvrName, errors.New("fake-error"))
 
 	result := <-rs.resultSignal
-	assert.EqualError(t, result.err, expectedErr)
+	require.EqualError(t, result.err, expectedErr)
 	assert.Equal(t, expectedEventReason, rt.EventReason())
 	assert.Equal(t, expectedEventMsg, rt.EventMessage())
 }
@@ -145,7 +146,7 @@ func TestPvrCancelled(t *testing.T) {
 	go rs.OnPvrCancelled(context.TODO(), velerov1api.DefaultNamespace, pvrName)
 
 	result := <-rs.resultSignal
-	assert.EqualError(t, result.err, expectedErr)
+	require.EqualError(t, result.err, expectedErr)
 	assert.Equal(t, expectedEventReason, rt.EventReason())
 	assert.Equal(t, expectedEventMsg, rt.EventMessage())
 }
@@ -210,7 +211,7 @@ func TestOnPvrCompleted(t *testing.T) {
 			if test.marshalErr != nil {
 				assert.EqualError(t, result.err, test.expectedErr)
 			} else {
-				assert.NoError(t, result.err)
+				require.NoError(t, result.err)
 				assert.Equal(t, test.expectedEventReason, rt.EventReason())
 				assert.Equal(t, test.expectedEventMsg, rt.EventMessage())
 
@@ -307,7 +308,7 @@ func TestCancelPodVolumeRestore(t *testing.T) {
 
 			result := <-rs.resultSignal
 
-			assert.EqualError(t, result.err, test.expectedErr)
+			require.EqualError(t, result.err, test.expectedErr)
 			assert.True(t, rt.withEvent)
 			assert.Equal(t, test.expectedEventReason, rt.EventReason())
 			assert.Equal(t, test.expectedEventMsg, rt.EventMessage())
@@ -456,9 +457,9 @@ func TestRunCancelableDataPathRestore(t *testing.T) {
 			result, err := rs.RunCancelableDataPath(test.ctx)
 
 			if test.expectedErr != "" {
-				assert.EqualError(t, err, test.expectedErr)
+				require.EqualError(t, err, test.expectedErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, test.result.result, result)
 			}
 
@@ -609,9 +610,9 @@ func TestWriteCompletionMark(t *testing.T) {
 			err := writeCompletionMark(test.pvr, test.result, velerotest.NewSingleLogger(&logBuffer))
 
 			if test.expectedErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			} else {
-				assert.EqualError(t, err, test.expectedErr)
+				require.EqualError(t, err, test.expectedErr)
 			}
 
 			if test.expectedLog != "" {

pkg/repository/config/config_test.go

@@ -21,6 +21,7 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 )
@@ -252,7 +253,7 @@ func TestGetRepoIdentifier(t *testing.T) {
 			if tc.expectedErr == "" {
 				assert.NoError(t, err)
 			} else {
-				assert.EqualError(t, err, tc.expectedErr)
+				require.EqualError(t, err, tc.expectedErr)
 				assert.Empty(t, id)
 			}
 		})

pkg/repository/ensurer_test.go

@@ -22,6 +22,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
@@ -128,9 +129,9 @@ func TestEnsureRepo(t *testing.T) {
 
 			repo, err := ensurer.EnsureRepo(context.Background(), velerov1.DefaultNamespace, test.namespace, test.bsl, test.repositoryType)
 			if err != nil {
-				assert.EqualError(t, err, test.err)
+				require.EqualError(t, err, test.err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, test.expectedRepo, repo)
@@ -252,9 +253,9 @@ func TestCreateBackupRepositoryAndWait(t *testing.T) {
 				RepositoryType:  test.repositoryType,
 			})
 			if err != nil {
-				assert.EqualError(t, err, test.err)
+				require.EqualError(t, err, test.err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, test.expectedRepo, repo)

pkg/repository/maintenance/maintenance_test.go

@@ -117,12 +117,12 @@ func TestDeleteOldJobs(t *testing.T) {
 
 	// Call the function
 	err := DeleteOldJobs(cli, repo, keep)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Get the remaining jobs
 	jobList := &batchv1.JobList{}
 	err = cli.List(context.TODO(), jobList, client.MatchingLabels(map[string]string{RepositoryNameLabel: repo}))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// We expect the number of jobs to be equal to 'keep'
 	assert.Len(t, jobList.Items, keep)
@@ -255,9 +255,9 @@ func TestWaitForJobComplete(t *testing.T) {
 
 			// Check if the error matches the expectation
 			if tc.expectError {
-				assert.Error(t, err)
+				require.Error(t, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.LessOrEqual(t, len(buffer), tc.expectedLogs)
@@ -288,14 +288,14 @@ func TestGetResultFromJob(t *testing.T) {
 
 	// test an error should be returned
 	result, err := getResultFromJob(cli, job)
-	assert.EqualError(t, err, "no pod found for job test-job")
+	require.EqualError(t, err, "no pod found for job test-job")
 	assert.Empty(t, result)
 
 	cli = fake.NewClientBuilder().WithObjects(job, pod).Build()
 
 	// test an error should be returned
 	result, err = getResultFromJob(cli, job)
-	assert.EqualError(t, err, "no container statuses found for job test-job")
+	require.EqualError(t, err, "no container statuses found for job test-job")
 	assert.Empty(t, result)
 
 	// Set a non-terminated container status to the pod
@@ -310,7 +310,7 @@ func TestGetResultFromJob(t *testing.T) {
 	// Test an error should be returned
 	cli = fake.NewClientBuilder().WithObjects(job, pod).Build()
 	result, err = getResultFromJob(cli, job)
-	assert.EqualError(t, err, "container for job test-job is not terminated")
+	require.EqualError(t, err, "container for job test-job is not terminated")
 	assert.Empty(t, result)
 
 	// Set a terminated container status to the pod
@@ -327,7 +327,7 @@ func TestGetResultFromJob(t *testing.T) {
 	// This call should return the termination message with no error
 	cli = fake.NewClientBuilder().WithObjects(job, pod).Build()
 	result, err = getResultFromJob(cli, job)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, result)
 
 	// Set a terminated container status with invalidate message to the pod
@@ -345,7 +345,7 @@ func TestGetResultFromJob(t *testing.T) {
 
 	cli = fake.NewClientBuilder().WithObjects(job, pod).Build()
 	result, err = getResultFromJob(cli, job)
-	assert.EqualError(t, err, "error to locate repo maintenance error indicator from termination message")
+	require.EqualError(t, err, "error to locate repo maintenance error indicator from termination message")
 	assert.Empty(t, result)
 
 	// Set a terminated container status with empty maintenance error to the pod
@@ -363,7 +363,7 @@ func TestGetResultFromJob(t *testing.T) {
 
 	cli = fake.NewClientBuilder().WithObjects(job, pod).Build()
 	result, err = getResultFromJob(cli, job)
-	assert.EqualError(t, err, "nothing after repo maintenance error indicator in termination message")
+	require.EqualError(t, err, "nothing after repo maintenance error indicator in termination message")
 	assert.Empty(t, result)
 
 	// Set a terminated container status with maintenance error to the pod
@@ -381,7 +381,7 @@ func TestGetResultFromJob(t *testing.T) {
 
 	cli = fake.NewClientBuilder().WithObjects(job, pod).Build()
 	result, err = getResultFromJob(cli, job)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "fake-error", result)
 }
 
@@ -843,7 +843,7 @@ func TestWaitAllJobsComplete(t *testing.T) {
 			history, err := WaitAllJobsComplete(test.ctx, fakeClient, repo, 3, velerotest.NewLogger())
 
 			if test.expectedError != "" {
-				assert.EqualError(t, err, test.expectedError)
+				require.EqualError(t, err, test.expectedError)
 			} else {
 				require.NoError(t, err)
 			}
@@ -1061,10 +1061,10 @@ func TestBuildJob(t *testing.T) {
 
 			// Check the error
 			if tc.expectedError {
-				assert.Error(t, err)
+				require.Error(t, err)
 				assert.Nil(t, job)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.NotNil(t, job)
 				assert.Contains(t, job.Name, tc.expectedJobName)
 				assert.Equal(t, param.BackupRepo.Namespace, job.Namespace)

pkg/repository/udmrepo/kopialib/backend/file_system_test.go

@@ -24,6 +24,7 @@ import (
 
 	"github.com/kopia/kopia/repo/blob/filesystem"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"github.com/vmware-tanzu/velero/pkg/repository/udmrepo"
 )
@@ -73,7 +74,7 @@ func TestFSSetup(t *testing.T) {
 			err := fsFlags.Setup(context.Background(), tc.flags, logger)
 
 			if tc.expectedErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tc.expectedOptions, fsFlags.options)
 			} else {
 				assert.EqualError(t, err, tc.expectedErr)

pkg/repository/udmrepo/kopialib/backend/gcs_test.go

@@ -24,6 +24,7 @@ import (
 
 	"github.com/kopia/kopia/repo/blob/gcs"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"github.com/vmware-tanzu/velero/pkg/repository/udmrepo"
 )
@@ -95,7 +96,7 @@ func TestGcsSetup(t *testing.T) {
 			err := gcsFlags.Setup(context.Background(), tc.flags, logger)
 
 			if tc.expectedErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tc.expectedOptions, gcsFlags.options)
 			} else {
 				assert.EqualError(t, err, tc.expectedErr)

pkg/repository/udmrepo/kopialib/lib_repo_test.go

@@ -422,9 +422,9 @@ func TestWriteInitParameters(t *testing.T) {
 			err := writeInitParameters(ctx, tc.repoOptions, logger)
 
 			if tc.expectedErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			} else {
-				assert.EqualError(t, err, tc.expectedErr)
+				require.EqualError(t, err, tc.expectedErr)
 			}
 			if tc.expectedReplaceManifestsParams != nil {
 				actualReplaceManifestsParams, converted := tc.returnRepoWriter.Calls[0].Arguments.Get(2).(*maintenance.Params)
@@ -1026,7 +1026,7 @@ func TestReaderSeek(t *testing.T) {
 			ret, err := kr.Seek(0, 0)
 
 			if tc.expectedErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tc.expectedRet, ret)
 			} else {
 				assert.EqualError(t, err, tc.expectedErr)
@@ -1157,7 +1157,7 @@ func TestWriterWrite(t *testing.T) {
 			ret, err := kr.Write(nil)
 
 			if tc.expectedErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tc.expectedRet, ret)
 			} else {
 				assert.EqualError(t, err, tc.expectedErr)
@@ -1205,7 +1205,7 @@ func TestWriterCheckpoint(t *testing.T) {
 			ret, err := kr.Checkpoint()
 
 			if tc.expectedErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tc.expectedRet, ret)
 			} else {
 				assert.EqualError(t, err, tc.expectedErr)
@@ -1253,7 +1253,7 @@ func TestWriterResult(t *testing.T) {
 			ret, err := kr.Result()
 
 			if tc.expectedErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tc.expectedRet, ret)
 			} else {
 				assert.EqualError(t, err, tc.expectedErr)

pkg/restic/exec_commands_test.go

@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"github.com/vmware-tanzu/velero/pkg/test"
 	"github.com/vmware-tanzu/velero/pkg/util/filesystem"
@@ -56,7 +57,7 @@ func Test_getSummaryLine(t *testing.T) {
 			if tt.wantErr {
 				assert.Error(t, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, summaryLine, string(summary))
 			}
 		})
@@ -105,6 +106,6 @@ func Test_getVolumeSize(t *testing.T) {
 
 	actualSize, err := getVolumeSize("/")
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expectedSize, actualSize)
 }

pkg/restore/actions/admissionwebhook_config_action_test.go

@@ -21,6 +21,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 
@@ -186,26 +187,26 @@ func TestNewAdmissionWebhookConfigurationActionExecute(t *testing.T) {
 			}
 			output, err := action.Execute(input)
 			if tt.wantErr {
-				assert.Error(t, err)
+				require.Error(t, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 			if tt.NoneSideEffectsIndex != nil {
 				wb, _, err := unstructured.NestedSlice(output.UpdatedItem.UnstructuredContent(), "webhooks")
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				for _, i := range tt.NoneSideEffectsIndex {
 					it, err := runtime.DefaultUnstructuredConverter.ToUnstructured(&wb[i])
-					assert.NoError(t, err)
+					require.NoError(t, err)
 					s := it["sideEffects"].(string)
 					assert.Equal(t, "None", s)
 				}
 			}
 			if tt.NotNoneSideEffectsIndex != nil {
 				wb, _, err := unstructured.NestedSlice(output.UpdatedItem.UnstructuredContent(), "webhooks")
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				for _, i := range tt.NotNoneSideEffectsIndex {
 					it, err := runtime.DefaultUnstructuredConverter.ToUnstructured(&wb[i])
-					assert.NoError(t, err)
+					require.NoError(t, err)
 					s := it["sideEffects"].(string)
 					assert.NotEqual(t, "None", s)
 				}

pkg/restore/actions/change_image_name_action_test.go

@@ -167,9 +167,9 @@ func TestChangeImageRepositoryActionExecute(t *testing.T) {
 			// validate for both error and non-error cases
 			switch {
 			case tc.wantErr != nil:
-				assert.EqualError(t, err, tc.wantErr.Error())
+				require.EqualError(t, err, tc.wantErr.Error())
 			default:
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				pod := new(corev1api.Pod)
 				err = runtime.DefaultUnstructuredConverter.FromUnstructured(res.UpdatedItem.UnstructuredContent(), pod)
 				require.NoError(t, err)

pkg/restore/actions/change_storageclass_action_test.go

@@ -257,9 +257,9 @@ func TestChangeStorageClassActionExecute(t *testing.T) {
 			// validate for both error and non-error cases
 			switch {
 			case tc.wantErr != nil:
-				assert.EqualError(t, err, tc.wantErr.Error())
+				require.EqualError(t, err, tc.wantErr.Error())
 			default:
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				wantUnstructured, err := runtime.DefaultUnstructuredConverter.ToUnstructured(tc.want)
 				require.NoError(t, err)

pkg/restore/actions/csi/pvc_action_test.go

@@ -175,11 +175,11 @@ func TestResetPVCResourceRequest(t *testing.T) {
 	var storageReq50Mi, storageReq1Gi, cpuQty resource.Quantity
 
 	storageReq50Mi, err := resource.ParseQuantity("50Mi")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	storageReq1Gi, err = resource.ParseQuantity("1Gi")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	cpuQty, err = resource.ParseQuantity("100m")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	testCases := []struct {
 		name                      string
@@ -260,7 +260,7 @@ func TestResetPVCResourceRequest(t *testing.T) {
 			log := logrus.New().WithField("unit-test", tc.name)
 			setPVCStorageResourceRequest(&tc.pvc, tc.restoreSize, log)
 			expected, err := resource.ParseQuantity(tc.expectedStorageRequestQty)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, expected, tc.pvc.Spec.Resources.Requests[corev1api.ResourceStorage])
 		})
 	}

pkg/restore/actions/init_restorehook_pod_action_test.go

@@ -134,7 +134,7 @@ func TestInitContainerRestoreHookPodActionExecute(t *testing.T) {
 				assert.Error(t, err, "expected an error")
 				return
 			}
-			assert.NoError(t, err, "expected no error, got %v", err)
+			require.NoError(t, err, "expected no error, got %v", err)
 
 			var pod corev1api.Pod
 			require.NoError(t, runtime.DefaultUnstructuredConverter.FromUnstructured(res.UpdatedItem.UnstructuredContent(), &pod))

pkg/restore/actions/pod_action_test.go

@@ -239,7 +239,7 @@ func TestPodActionExecute(t *testing.T) {
 				assert.Error(t, err, "expected an error")
 				return
 			}
-			assert.NoError(t, err, "expected no error, got %v", err)
+			require.NoError(t, err, "expected no error, got %v", err)
 
 			var pod corev1api.Pod
 			require.NoError(t, runtime.DefaultUnstructuredConverter.FromUnstructured(res.UpdatedItem.UnstructuredContent(), &pod))

pkg/restore/actions/pod_volume_restore_action_test.go

@@ -364,7 +364,7 @@ func TestPodVolumeRestoreActionExecute(t *testing.T) {
 
 			// method under test
 			res, err := a.Execute(input)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			updatedPod := new(corev1api.Pod)
 			require.NoError(t, runtime.DefaultUnstructuredConverter.FromUnstructured(res.UpdatedItem.UnstructuredContent(), updatedPod))

pkg/restore/actions/pvc_action_test.go

@@ -177,10 +177,10 @@ func TestPVCActionExecute(t *testing.T) {
 			// validate for both error and non-error cases
 			switch {
 			case tc.wantErr != nil:
-				assert.EqualError(t, err, tc.wantErr.Error())
+				require.EqualError(t, err, tc.wantErr.Error())
 			default:
 				fmt.Printf("got +%v\n", res.UpdatedItem)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				wantUnstructured, err := runtime.DefaultUnstructuredConverter.ToUnstructured(tc.want)
 				fmt.Printf("expected +%v\n", wantUnstructured)

pkg/restore/pv_restorer_test.go

@@ -135,7 +135,7 @@ func TestExecutePVAction_NoSnapshotRestores(t *testing.T) {
 			switch tc.expectedErr {
 			case true:
 				assert.Nil(t, res)
-				assert.Error(t, err)
+				require.Error(t, err)
 			case false:
 				assert.Equal(t, tc.expectedRes, res)
 				assert.NoError(t, err)
@@ -209,7 +209,7 @@ func TestExecutePVAction_SnapshotRestores(t *testing.T) {
 			volumeSnapshotter.On("SetVolumeID", tc.obj, "volume-1").Return(tc.obj, nil)
 
 			_, err := r.executePVAction(tc.obj)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			volumeSnapshotter.AssertExpectations(t)
 		})

pkg/restore/restore_test.go

@@ -2346,19 +2346,19 @@ func assertRestoredItems(t *testing.T, h *harness, want []*test.APIResource) {
 			}
 
 			res, err := client.Get(context.TODO(), item.GetName(), metav1.GetOptions{})
-			if !assert.NoError(t, err) {
+			if !assert.NoError(t, err) { //nolint:testifylint // require is inappropriate
 				continue
 			}
 
 			itemJSON, err := json.Marshal(item)
-			if !assert.NoError(t, err) {
+			if !assert.NoError(t, err) { //nolint:testifylint // require is inappropriate
 				continue
 			}
 
 			t.Logf("%v", string(itemJSON))
 
 			u := make(map[string]any)
-			if !assert.NoError(t, json.Unmarshal(itemJSON, &u)) {
+			if !assert.NoError(t, json.Unmarshal(itemJSON, &u)) { //nolint:testifylint // require is inappropriate
 				continue
 			}
 			want := &unstructured.Unstructured{Object: u}
@@ -3630,7 +3630,7 @@ func (cr *createRecorder) reactor() func(kubetesting.Action) (bool, runtime.Obje
 		}
 
 		accessor, err := meta.Accessor(createAction.GetObject())
-		assert.NoError(cr.t, err)
+		require.NoError(cr.t, err)
 
 		cr.resources = append(cr.resources, resourceID{
 			groupResource: action.GetResource().GroupResource().String(),
@@ -3653,7 +3653,7 @@ func assertAPIContents(t *testing.T, h *harness, want map[*test.APIResource][]st
 
 	for r, want := range want {
 		res, err := h.DynamicClient.Resource(r.GVR()).List(context.TODO(), metav1.ListOptions{})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		if err != nil {
 			continue
 		}

pkg/uploader/kopia/shim_test.go

@@ -278,9 +278,9 @@ func TestReplaceManifests(t *testing.T) {
 			id, err := NewShimRepo(tc.backupRepo).ReplaceManifests(ctx, map[string]string{}, nil)
 
 			if tc.expectedError != "" {
-				assert.EqualError(t, err, tc.expectedError)
+				require.EqualError(t, err, tc.expectedError)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, tc.expectedID, id)

pkg/uploader/kopia/snapshot_test.go

@@ -87,7 +87,7 @@ func TestSnapshotSource(t *testing.T) {
 		Path:     "/var",
 	}
 	rootDir, err := getLocalFSEntry(sourceInfo.Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	log := logrus.New()
 	manifest := &snapshot.Manifest{
 		ID:        "test",
@@ -563,7 +563,7 @@ func TestFindPreviousSnapshotManifest(t *testing.T) {
 			if tc.expectedError != nil {
 				require.ErrorContains(t, err, tc.expectedError.Error())
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			// Check the number of returned snapshots
@@ -656,7 +656,7 @@ func TestBackup(t *testing.T) {
 			if tc.expectedError != nil {
 				require.ErrorContains(t, err, tc.expectedError.Error())
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, tc.expectedEmpty, isSnapshotEmpty)
@@ -795,7 +795,7 @@ func TestRestore(t *testing.T) {
 			if tc.expectedError != nil {
 				require.ErrorContains(t, err, tc.expectedError.Error())
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			// Check the number of bytes restored

pkg/uploader/provider/kopia_test.go

@@ -284,9 +284,9 @@ func TestGetPassword(t *testing.T) {
 
 			password, err := kp.GetPassword(nil)
 			if tc.expectError {
-				assert.Error(t, err, "Expected an error")
+				require.Error(t, err, "Expected an error")
 			} else {
-				assert.NoError(t, err, "Expected no error")
+				require.NoError(t, err, "Expected no error")
 			}
 
 			assert.Equal(t, tc.expectedPass, password, "Expected password to match")
@@ -383,7 +383,7 @@ func TestNewKopiaUploaderProvider(t *testing.T) {
 			if tc.expectedError != "" {
 				require.ErrorContains(t, err, tc.expectedError)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			// Verify that the expected methods were called on the mocks.

pkg/uploader/provider/restic_test.go

@@ -304,15 +304,16 @@ func TestNewResticUploaderProvider(t *testing.T) {
 		mockCredFunc             func(*MockCredentialGetter, *corev1api.SecretKeySelector)
 		resticCmdEnvFunc         func(backupLocation *velerov1api.BackupStorageLocation, credentialFileStore credentials.FileStore) ([]string, error)
 		resticTempCACertFileFunc func(caCert []byte, bsl string, fs filesystem.Interface) (string, error)
-		checkFunc                func(provider Provider, err error)
+		checkFunc                func(t *testing.T, provider Provider, err error)
 	}{
 		{
 			name: "No error in creating temp credentials file",
 			mockCredFunc: func(credGetter *MockCredentialGetter, repoKeySelector *corev1api.SecretKeySelector) {
 				credGetter.On("Path", repoKeySelector).Return("temp-credentials", nil)
 			},
-			checkFunc: func(provider Provider, err error) {
-				assert.NoError(t, err)
+			checkFunc: func(t *testing.T, provider Provider, err error) {
+				t.Helper()
+				require.NoError(t, err)
 				assert.NotNil(t, provider)
 			},
 		}, {
@@ -320,8 +321,9 @@ func TestNewResticUploaderProvider(t *testing.T) {
 			mockCredFunc: func(credGetter *MockCredentialGetter, repoKeySelector *corev1api.SecretKeySelector) {
 				credGetter.On("Path", repoKeySelector).Return("", errors.New("error creating temp credentials file"))
 			},
-			checkFunc: func(provider Provider, err error) {
-				assert.Error(t, err)
+			checkFunc: func(t *testing.T, provider Provider, err error) {
+				t.Helper()
+				require.Error(t, err)
 				assert.Nil(t, provider)
 			},
 		}, {
@@ -332,8 +334,9 @@ func TestNewResticUploaderProvider(t *testing.T) {
 			resticTempCACertFileFunc: func(caCert []byte, bsl string, fs filesystem.Interface) (string, error) {
 				return "", errors.New("error writing CACert file")
 			},
-			checkFunc: func(provider Provider, err error) {
-				assert.Error(t, err)
+			checkFunc: func(t *testing.T, provider Provider, err error) {
+				t.Helper()
+				require.Error(t, err)
 				assert.Nil(t, provider)
 			},
 		}, {
@@ -347,8 +350,9 @@ func TestNewResticUploaderProvider(t *testing.T) {
 			resticCmdEnvFunc: func(backupLocation *velerov1api.BackupStorageLocation, credentialFileStore credentials.FileStore) ([]string, error) {
 				return nil, errors.New("error generating repository cmnd env")
 			},
-			checkFunc: func(provider Provider, err error) {
-				assert.Error(t, err)
+			checkFunc: func(t *testing.T, provider Provider, err error) {
+				t.Helper()
+				require.Error(t, err)
 				assert.Nil(t, provider)
 			},
 		}, {
@@ -362,8 +366,9 @@ func TestNewResticUploaderProvider(t *testing.T) {
 			resticCmdEnvFunc: func(backupLocation *velerov1api.BackupStorageLocation, credentialFileStore credentials.FileStore) ([]string, error) {
 				return nil, nil
 			},
-			checkFunc: func(provider Provider, err error) {
-				assert.NoError(t, err)
+			checkFunc: func(t *testing.T, provider Provider, err error) {
+				t.Helper()
+				require.NoError(t, err)
 				assert.NotNil(t, provider)
 			},
 		},
@@ -379,8 +384,9 @@ func TestNewResticUploaderProvider(t *testing.T) {
 			resticCmdEnvFunc: func(backupLocation *velerov1api.BackupStorageLocation, credentialFileStore credentials.FileStore) ([]string, error) {
 				return nil, nil
 			},
-			checkFunc: func(provider Provider, err error) {
-				assert.NoError(t, err)
+			checkFunc: func(t *testing.T, provider Provider, err error) {
+				t.Helper()
+				require.NoError(t, err)
 				assert.NotNil(t, provider)
 			},
 		},
@@ -406,7 +412,8 @@ func TestNewResticUploaderProvider(t *testing.T) {
 			if tc.resticTempCACertFileFunc != nil {
 				resticTempCACertFileFunc = tc.resticTempCACertFileFunc
 			}
-			tc.checkFunc(NewResticUploaderProvider(repoIdentifier, bsl, credGetter, repoKeySelector, log))
+			provider, err := NewResticUploaderProvider(repoIdentifier, bsl, credGetter, repoKeySelector, log)
+			tc.checkFunc(t, provider, err)
 		})
 	}
 }

pkg/uploader/types_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestValidateUploaderType(t *testing.T) {
@@ -36,9 +37,9 @@ func TestValidateUploaderType(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			msg, err := ValidateUploaderType(tt.input)
 			if tt.wantErr != "" {
-				assert.EqualError(t, err, tt.wantErr)
+				require.EqualError(t, err, tt.wantErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, tt.wantMsg, msg)

pkg/util/csi/volume_snapshot_test.go

@@ -200,9 +200,9 @@ func TestWaitVolumeSnapshotReady(t *testing.T) {
 
 			vs, err := WaitVolumeSnapshotReady(context.Background(), fakeClient.SnapshotV1(), test.vsName, test.namespace, time.Millisecond, velerotest.NewLogger())
 			if err != nil {
-				assert.EqualError(t, err, test.err)
+				require.EqualError(t, err, test.err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, test.expect, vs)
@@ -286,9 +286,9 @@ func TestGetVolumeSnapshotContentForVolumeSnapshot(t *testing.T) {
 
 			vs, err := GetVolumeSnapshotContentForVolumeSnapshot(test.snapshotObj, fakeClient.SnapshotV1())
 			if err != nil {
-				assert.EqualError(t, err, test.err)
+				require.EqualError(t, err, test.err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, test.expect, vs)
@@ -723,9 +723,9 @@ func TestRetainVSC(t *testing.T) {
 			returned, err := RetainVSC(context.Background(), fakeSnapshotClient.SnapshotV1(), test.vsc)
 
 			if len(test.err) == 0 {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			} else {
-				assert.EqualError(t, err, test.err)
+				require.EqualError(t, err, test.err)
 			}
 
 			if test.updated != nil {
@@ -817,14 +817,14 @@ func TestRemoveVSCProtect(t *testing.T) {
 			err := RemoveVSCProtect(context.Background(), fakeSnapshotClient.SnapshotV1(), test.vsc, test.timeout)
 
 			if len(test.err) == 0 {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			} else {
-				assert.EqualError(t, err, test.err)
+				require.EqualError(t, err, test.err)
 			}
 
 			if test.updated != nil {
 				updated, err := fakeSnapshotClient.SnapshotV1().VolumeSnapshotContents().Get(context.Background(), test.vsc, metav1.GetOptions{})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				assert.Equal(t, test.updated.Finalizers, updated.Finalizers)
 			}
@@ -1032,7 +1032,7 @@ func TestGetVolumeSnapshotClass(t *testing.T) {
 			actualSnapshotClass, actualError := GetVolumeSnapshotClass(
 				tc.driverName, tc.backup, tc.pvc, logrus.New(), fakeClient)
 			if tc.expectError {
-				assert.Error(t, actualError)
+				require.Error(t, actualError)
 				assert.Nil(t, actualSnapshotClass)
 				return
 			}
@@ -1147,7 +1147,7 @@ func TestGetVolumeSnapshotClassForStorageClass(t *testing.T) {
 			actualVSC, actualError := GetVolumeSnapshotClassForStorageClass(tc.driverName, snapshotClasses)
 
 			if tc.expectError {
-				assert.Error(t, actualError)
+				require.Error(t, actualError)
 				assert.Nil(t, actualVSC)
 				return
 			}
@@ -1444,14 +1444,14 @@ func TestSetVolumeSnapshotContentDeletionPolicy(t *testing.T) {
 			if tc.expectError {
 				assert.Error(t, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				actual := new(snapshotv1api.VolumeSnapshotContent)
 				err := fakeClient.Get(
 					context.TODO(),
 					crclient.ObjectKey{Name: tc.inputVSCName},
 					actual,
 				)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(
 					t,
 					tc.policy,
@@ -1680,7 +1680,7 @@ func TestWaitUntilVSCHandleIsReady(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			actualVSC, actualError := WaitUntilVSCHandleIsReady(tc.volSnap, fakeClient, logrus.New().WithField("fake", "test"), 0)
 			if tc.expectError && actualError == nil {
-				assert.Error(t, actualError)
+				require.Error(t, actualError)
 				assert.Nil(t, actualVSC)
 				return
 			}

pkg/util/kube/pod_test.go

@@ -737,7 +737,7 @@ func TestCollectPodLogs(t *testing.T) {
 			if test.expectErr != "" {
 				assert.EqualError(t, err, test.expectErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, fp.outputMessage, test.message)
 			}
 		})

pkg/util/kube/pvc_pv_test.go

@@ -23,6 +23,7 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/kubernetes"
@@ -125,9 +126,9 @@ func TestWaitPVCBound(t *testing.T) {
 			pv, err := WaitPVCBound(context.Background(), kubeClient.CoreV1(), kubeClient.CoreV1(), test.pvcName, test.pvcNamespace, time.Millisecond)
 
 			if err != nil {
-				assert.EqualError(t, err, test.err)
+				require.EqualError(t, err, test.err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, test.expected, pv)
@@ -289,9 +290,9 @@ func TestWaitPVCConsumed(t *testing.T) {
 			selectedNode, pvc, err := WaitPVCConsumed(context.Background(), kubeClient.CoreV1(), test.pvcName, test.pvcNamespace, kubeClient.StorageV1(), time.Millisecond, test.ignoreWaitForFirstConsumer)
 
 			if err != nil {
-				assert.EqualError(t, err, test.err)
+				require.EqualError(t, err, test.err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, test.expectedPVC, pvc)
@@ -861,9 +862,9 @@ func TestRebindPVC(t *testing.T) {
 
 			result, err := RebindPVC(context.Background(), kubeClient.CoreV1(), test.pvc, test.pv)
 			if err != nil {
-				assert.EqualError(t, err, test.err)
+				require.EqualError(t, err, test.err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, test.result, result)
@@ -968,9 +969,9 @@ func TestResetPVBinding(t *testing.T) {
 
 			result, err := ResetPVBinding(context.Background(), kubeClient.CoreV1(), test.pv, test.labels, test.pvc)
 			if err != nil {
-				assert.EqualError(t, err, test.err)
+				require.EqualError(t, err, test.err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, test.result, result)
@@ -1046,9 +1047,9 @@ func TestSetPVReclaimPolicy(t *testing.T) {
 
 			result, err := SetPVReclaimPolicy(context.Background(), kubeClient.CoreV1(), test.pv, test.policy)
 			if err != nil {
-				assert.EqualError(t, err, test.err)
+				require.EqualError(t, err, test.err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, test.result, result)
@@ -1197,9 +1198,9 @@ func TestWaitPVBound(t *testing.T) {
 			pv, err := WaitPVBound(context.Background(), kubeClient.CoreV1(), test.pvName, test.pvcName, test.pvcNamespace, time.Millisecond)
 
 			if err != nil {
-				assert.EqualError(t, err, test.err)
+				require.EqualError(t, err, test.err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, test.expectedPV, pv)
@@ -1372,12 +1373,12 @@ func TestGetPVForPVC(t *testing.T) {
 			actualPV, actualError := GetPVForPVC(tc.inPVC, fakeClient)
 
 			if tc.expectError {
-				assert.Error(t, actualError, "Want error; Got nil error")
+				require.Error(t, actualError, "Want error; Got nil error")
 				assert.Nilf(t, actualPV, "Want PV: nil; Got PV: %q", actualPV)
 				return
 			}
 
-			assert.NoErrorf(t, actualError, "Want: nil error; Got: %v", actualError)
+			require.NoErrorf(t, actualError, "Want: nil error; Got: %v", actualError)
 			assert.Equalf(t, actualPV.Name, tc.expectedPV.Name, "Want PV with name %q; Got PV with name %q", tc.expectedPV.Name, actualPV.Name)
 		})
 	}
@@ -1495,11 +1496,11 @@ func TestGetPVCForPodVolume(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			actualPVC, actualError := GetPVCForPodVolume(tc.vol, samplePod, fakeClient)
 			if tc.expectedError {
-				assert.Error(t, actualError, "Want error; Got nil error")
+				require.Error(t, actualError, "Want error; Got nil error")
 				assert.Nilf(t, actualPVC, "Want PV: nil; Got PV: %q", actualPVC)
 				return
 			}
-			assert.NoErrorf(t, actualError, "Want: nil error; Got: %v", actualError)
+			require.NoErrorf(t, actualError, "Want: nil error; Got: %v", actualError)
 			assert.Equalf(t, actualPVC.Name, tc.expectedPVC.Name, "Want PVC with name %q; Got PVC with name %q", tc.expectedPVC.Name, actualPVC)
 		})
 	}

pkg/util/kube/resource_requirements_test.go

@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	corev1api "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 )
@@ -78,7 +79,7 @@ func TestParseResourceRequirements(t *testing.T) {
 				assert.Error(t, err)
 				return
 			}
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			var expected corev1api.ResourceRequirements
 			if tt.expected == nil {

pkg/util/kube/security_context_test.go

@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	corev1api "k8s.io/api/core/v1"
 
 	"github.com/vmware-tanzu/velero/pkg/util/boolptr"
@@ -260,7 +261,7 @@ allowPrivilegeEscalation: false`},
 				assert.Error(t, err)
 				return
 			}
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			if tt.expected == nil {
 				tt.expected = &corev1api.SecurityContext{}

pkg/util/kube/utils_test.go

@@ -496,7 +496,6 @@ func TestSinglePathMatch(t *testing.T) {
 	fakeFS.MkdirAll("testDir2/subpath", 0755)
 
 	_, err := SinglePathMatch("./*/subpath", fakeFS, logrus.StandardLogger())
-	assert.Error(t, err)
 	require.ErrorContains(t, err, "expected one matching path")
 }
 

pkg/util/logging/error_location_hook_test.go

@@ -166,7 +166,7 @@ func TestGetInnermostTrace(t *testing.T) {
 			res := getInnermostTrace(test.err)
 
 			if test.expectedRes == nil {
-				assert.NoError(t, res)
+				require.NoError(t, res)
 				return
 			}
 

pkg/util/logging/log_counter_hook_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"github.com/vmware-tanzu/velero/pkg/util/results"
 )
@@ -26,7 +27,7 @@ func TestLogHook_Fire(t *testing.T) {
 	}
 
 	err := hook.Fire(entry)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Verify the counts
 	assert.Equal(t, 1, hook.counts[logrus.ErrorLevel])
@@ -47,7 +48,7 @@ func TestLogHook_Fire(t *testing.T) {
 	}
 
 	err = hook.Fire(entry1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Verify the counts
 	assert.Equal(t, 2, hook.counts[logrus.ErrorLevel])

pkg/util/logging/log_merge_hook_test.go

@@ -68,7 +68,7 @@ func TestMergeHook_Fire(t *testing.T) {
 			// method under test
 			err := hook.Fire(&test.entry)
 
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			if test.expectHook {
 				assert.NotNil(t, test.entry.Logger.Out.(*hookWriter))
@@ -161,7 +161,7 @@ func TestMergeHook_Write(t *testing.T) {
 			n, err := writer.Write(test.content)
 
 			if test.expectError == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				expectStr := string(test.content)
 				if expectStr == ListeningMessage {
@@ -174,7 +174,7 @@ func TestMergeHook_Write(t *testing.T) {
 				writtenStr := string(fakeWriter.p)
 				assert.Equal(t, writtenStr, expectStr)
 			} else {
-				assert.EqualError(t, err, test.expectError)
+				require.EqualError(t, err, test.expectError)
 			}
 
 			if test.needRollBackHook {

pkg/util/podvolume/pod_volume_test.go

@@ -21,6 +21,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	corev1api "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -786,7 +787,7 @@ func TestGetPodsUsingPVC(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			actualPods, err := GetPodsUsingPVC(tc.pvcNamespace, tc.pvcName, fakeClient)
-			assert.NoErrorf(t, err, "Want error=nil; Got error=%v", err)
+			require.NoErrorf(t, err, "Want error=nil; Got error=%v", err)
 			assert.Lenf(t, actualPods, tc.expectedPodCount, "unexpected number of pods in result; Want: %d; Got: %d", tc.expectedPodCount, len(actualPods))
 		})
 	}