testifylint: enable error-nil rule (#7670)

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

.golangci.yaml

@@ -239,7 +239,6 @@ linters-settings:
       # TODO: enable them all
       disable:
         - error-is-as
-        - error-nil
         - expected-actual
         - go-require
         - float-compare

internal/hook/hook_tracker_test.go

@@ -65,13 +65,13 @@ func TestHookTracker_Record(t *testing.T) {
 	info := tracker.tracker[key]
 	assert.True(t, info.hookFailed)
 	assert.True(t, info.hookExecuted)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	err = tracker.Record("ns2", "pod2", "container1", HookSourceAnnotation, "h1", "", true, fmt.Errorf("err"))
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	err = tracker.Record("ns1", "pod1", "container1", HookSourceAnnotation, "h1", "", false, nil)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.True(t, info.hookFailed)
 }
 
@@ -141,13 +141,13 @@ func TestMultiHookTracker_Record(t *testing.T) {
 	info := mht.trackers["restore1"].tracker[key]
 	assert.True(t, info.hookFailed)
 	assert.True(t, info.hookExecuted)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	err = mht.Record("restore1", "ns2", "pod2", "container1", HookSourceAnnotation, "h1", "", true, fmt.Errorf("err"))
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	err = mht.Record("restore2", "ns2", "pod2", "container1", HookSourceAnnotation, "h1", "", true, fmt.Errorf("err"))
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func TestMultiHookTracker_Stat(t *testing.T) {

internal/hook/item_hook_handler_test.go

@@ -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.Nil(t, err)
+			assert.NoError(t, err)
 			assert.Equal(t, tc.expected, actual)
 		})
 	}
@@ -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.Nil(t, ValidateContainer([]byte(valid)))
+	assert.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.Nil(t, err)
+				assert.NoError(t, err)
 				podCommandExecutor.On("ExecutePodCommand", mock.Anything, obj, e.pod.Namespace, e.pod.Name, e.name, e.hook).Return(e.error)
 			}
 
@@ -1269,7 +1269,7 @@ func TestRestoreHookTrackerUpdate(t *testing.T) {
 
 			for _, e := range test.expectedExecutions {
 				obj, err := runtime.DefaultUnstructuredConverter.ToUnstructured(e.pod)
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 				podCommandExecutor.On("ExecutePodCommand", mock.Anything, obj, e.pod.Namespace, e.pod.Name, e.name, e.hook).Return(e.error)
 			}
 

internal/resourcepolicies/resource_policies_test.go

@@ -232,7 +232,7 @@ func TestGetResourcePoliciesFromConfig(t *testing.T) {
 
 	// Call the function and check for errors
 	resPolicies, err := getResourcePoliciesFromConfig(cm)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	// Check that the returned resourcePolicies object contains the expected data
 	assert.Equal(t, "v1", resPolicies.version)
@@ -422,12 +422,12 @@ volumePolicies:
 			if err != nil {
 				t.Fatalf("got error when get match action %v", err)
 			}
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 			policies := &Policies{}
 			err = policies.BuildPolicy(resPolicies)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 			action, err := policies.GetMatchAction(tc.vol)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 
 			if tc.skip {
 				if action.Type != Skip {

internal/volumehelper/volume_policy_helper_test.go

@@ -336,7 +336,7 @@ func TestVolumeHelperImpl_ShouldPerformSnapshot(t *testing.T) {
 
 			actualShouldSnapshot, actualError := vh.ShouldPerformSnapshot(&unstructured.Unstructured{Object: obj}, tc.groupResource)
 			if tc.expectedErr {
-				require.NotNil(t, actualError, "Want error; Got nil error")
+				require.Error(t, actualError, "Want error; Got nil error")
 				return
 			}
 
@@ -698,7 +698,7 @@ func TestVolumeHelperImpl_ShouldPerformFSBackup(t *testing.T) {
 
 			actualShouldFSBackup, actualError := vh.ShouldPerformFSBackup(tc.pod.Spec.Volumes[0], *tc.pod)
 			if tc.expectedErr {
-				require.NotNil(t, actualError, "Want error; Got nil error")
+				require.Error(t, actualError, "Want error; Got nil error")
 				return
 			}
 

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.Nil(t, err)
+				assert.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.Nil(t, err)
+				assert.NoError(t, err)
 				assert.Equal(t, tc.want, res)
 			}
 		})

pkg/backup/actions/service_account_action_test.go

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

pkg/backup/item_backupper_test.go

@@ -220,7 +220,7 @@ func TestGetPVName(t *testing.T) {
 			if tc.obj != nil {
 				data, err := runtime.DefaultUnstructuredConverter.ToUnstructured(tc.obj)
 				o = &unstructured.Unstructured{Object: data}
-				require.Nil(t, err)
+				require.NoError(t, err)
 			}
 			name, err2 := getPVName(o, tc.groupResource)
 			assert.Equal(t, tc.pvName, name)

pkg/client/client_test.go

@@ -79,7 +79,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.Nil(t, err)
+			assert.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/factory_test.go

@@ -134,11 +134,11 @@ func TestFactory(t *testing.T) {
 			assert.NotNil(t, dynamicClient)
 
 			kubebuilderClient, e := f.KubebuilderClient()
-			assert.Nil(t, e)
+			assert.NoError(t, e)
 			assert.NotNil(t, kubebuilderClient)
 
 			kbClientWithWatch, e := f.KubebuilderWatchClient()
-			assert.Nil(t, e)
+			assert.NoError(t, e)
 			assert.NotNil(t, kbClientWithWatch)
 		})
 	}

pkg/cmd/cli/backup/create_test.go

@@ -129,7 +129,7 @@ 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.NotNil(t, err)
+	assert.Error(t, err)
 
 	orderedResources, err := ParseOrderedResources("pods= ns1/p1,ns1/p2 ; persistentvolumeclaims=ns2/pvc1,ns2/pvc2")
 	assert.NoError(t, err)

pkg/cmd/cli/backuplocation/create_test.go

@@ -148,7 +148,7 @@ func TestCreateCommand_Run(t *testing.T) {
 
 	o.Complete(args, f)
 	e := o.Validate(c, args, f)
-	assert.Nil(t, e)
+	assert.NoError(t, e)
 
 	e = o.Run(c, f)
 	assert.Contains(t, e.Error(), fmt.Sprintf("%s: no such file or directory", caCertFile))

pkg/cmd/cli/backuplocation/set_test.go

@@ -66,7 +66,7 @@ func TestNewSetCommand(t *testing.T) {
 	args := []string{backupName}
 	o.Complete(args, f)
 	e := o.Validate(c, args, f)
-	assert.Nil(t, e)
+	assert.NoError(t, e)
 
 	e = o.Run(c, f)
 	assert.Contains(t, e.Error(), fmt.Sprintf("%s: no such file or directory", cacert))

pkg/cmd/cli/select_option_test.go

@@ -28,7 +28,7 @@ import (
 func TestCompleteOfSelectOption(t *testing.T) {
 	option := &SelectOptions{}
 	args := []string{"arg1", "arg2"}
-	require.Nil(t, option.Complete(args))
+	require.NoError(t, option.Complete(args))
 	assert.Equal(t, args, option.Names)
 }
 
@@ -38,8 +38,8 @@ func TestValidateOfSelectOption(t *testing.T) {
 		Selector: flag.LabelSelector{},
 		All:      false,
 	}
-	assert.NotNil(t, option.Validate())
+	assert.Error(t, option.Validate())
 
 	option.All = true
-	assert.Nil(t, option.Validate())
+	assert.NoError(t, option.Validate())
 }

pkg/cmd/server/server_test.go

@@ -194,14 +194,14 @@ func Test_newServer(t *testing.T) {
 	_, err := newServer(factory, serverConfig{
 		uploaderType: "invalid",
 	}, logger)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	// invalid clientQPS
 	_, err = newServer(factory, serverConfig{
 		uploaderType: uploader.KopiaType,
 		clientQPS:    -1,
 	}, logger)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	// invalid clientBurst
 	factory.On("SetClientQPS", mock.Anything).Return()
@@ -210,7 +210,7 @@ func Test_newServer(t *testing.T) {
 		clientQPS:    1,
 		clientBurst:  -1,
 	}, logger)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	// invalid clientBclientPageSizeurst
 	factory.On("SetClientQPS", mock.Anything).Return().
@@ -221,7 +221,7 @@ func Test_newServer(t *testing.T) {
 		clientBurst:    1,
 		clientPageSize: -1,
 	}, logger)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	// got error when creating client
 	factory.On("SetClientQPS", mock.Anything).Return().
@@ -235,7 +235,7 @@ func Test_newServer(t *testing.T) {
 		clientBurst:    1,
 		clientPageSize: 100,
 	}, logger)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func Test_namespaceExists(t *testing.T) {
@@ -250,10 +250,10 @@ func Test_namespaceExists(t *testing.T) {
 	}
 
 	// namespace doesn't exist
-	assert.NotNil(t, server.namespaceExists("not-exist"))
+	assert.Error(t, server.namespaceExists("not-exist"))
 
 	// namespace exists
-	assert.Nil(t, server.namespaceExists("velero"))
+	assert.NoError(t, server.namespaceExists("velero"))
 }
 
 func Test_veleroResourcesExist(t *testing.T) {
@@ -265,7 +265,7 @@ func Test_veleroResourcesExist(t *testing.T) {
 
 	// velero resources don't exist
 	helper.On("Resources").Return(nil)
-	assert.NotNil(t, server.veleroResourcesExist())
+	assert.Error(t, server.veleroResourcesExist())
 
 	// velero resources exist
 	helper.On("Resources").Unset()
@@ -294,7 +294,7 @@ func Test_veleroResourcesExist(t *testing.T) {
 			},
 		},
 	})
-	assert.Nil(t, server.veleroResourcesExist())
+	assert.NoError(t, server.veleroResourcesExist())
 }
 
 func Test_markInProgressBackupsFailed(t *testing.T) {
@@ -329,11 +329,11 @@ func Test_markInProgressBackupsFailed(t *testing.T) {
 	markInProgressBackupsFailed(context.Background(), c, "velero", logrus.New())
 
 	backup01 := &velerov1api.Backup{}
-	require.Nil(t, c.Get(context.Background(), client.ObjectKey{Namespace: "velero", Name: "backup01"}, backup01))
+	require.NoError(t, c.Get(context.Background(), client.ObjectKey{Namespace: "velero", Name: "backup01"}, backup01))
 	assert.Equal(t, velerov1api.BackupPhaseFailed, backup01.Status.Phase)
 
 	backup02 := &velerov1api.Backup{}
-	require.Nil(t, c.Get(context.Background(), client.ObjectKey{Namespace: "velero", Name: "backup02"}, backup02))
+	require.NoError(t, c.Get(context.Background(), client.ObjectKey{Namespace: "velero", Name: "backup02"}, backup02))
 	assert.Equal(t, velerov1api.BackupPhaseCompleted, backup02.Status.Phase)
 }
 
@@ -369,11 +369,11 @@ func Test_markInProgressRestoresFailed(t *testing.T) {
 	markInProgressRestoresFailed(context.Background(), c, "velero", logrus.New())
 
 	restore01 := &velerov1api.Restore{}
-	require.Nil(t, c.Get(context.Background(), client.ObjectKey{Namespace: "velero", Name: "restore01"}, restore01))
+	require.NoError(t, c.Get(context.Background(), client.ObjectKey{Namespace: "velero", Name: "restore01"}, restore01))
 	assert.Equal(t, velerov1api.RestorePhaseFailed, restore01.Status.Phase)
 
 	restore02 := &velerov1api.Restore{}
-	require.Nil(t, c.Get(context.Background(), client.ObjectKey{Namespace: "velero", Name: "restore02"}, restore02))
+	require.NoError(t, c.Get(context.Background(), client.ObjectKey{Namespace: "velero", Name: "restore02"}, restore02))
 	assert.Equal(t, velerov1api.RestorePhaseCompleted, restore02.Status.Phase)
 }
 
@@ -403,11 +403,11 @@ func Test_setDefaultBackupLocation(t *testing.T) {
 	setDefaultBackupLocation(context.Background(), c, "velero", "default", logrus.New())
 
 	defaultLocation := &velerov1api.BackupStorageLocation{}
-	require.Nil(t, c.Get(context.Background(), client.ObjectKey{Namespace: "velero", Name: "default"}, defaultLocation))
+	require.NoError(t, c.Get(context.Background(), client.ObjectKey{Namespace: "velero", Name: "default"}, defaultLocation))
 	assert.True(t, defaultLocation.Spec.Default)
 
 	nonDefaultLocation := &velerov1api.BackupStorageLocation{}
-	require.Nil(t, c.Get(context.Background(), client.ObjectKey{Namespace: "velero", Name: "non-default"}, nonDefaultLocation))
+	require.NoError(t, c.Get(context.Background(), client.ObjectKey{Namespace: "velero", Name: "non-default"}, nonDefaultLocation))
 	assert.False(t, nonDefaultLocation.Spec.Default)
 
 	// no default location specified

pkg/cmd/util/flag/array_test.go

@@ -14,7 +14,7 @@ func TestStringOfStringArray(t *testing.T) {
 
 func TestSetOfStringArray(t *testing.T) {
 	array := NewStringArray()
-	require.Nil(t, array.Set("a,b"))
+	require.NoError(t, array.Set("a,b"))
 	assert.Equal(t, "a,b", array.String())
 }
 

pkg/cmd/util/flag/enum_test.go

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

pkg/cmd/util/flag/label_selector_test.go

@@ -10,7 +10,7 @@ import (
 
 func TestStringOfLabelSelector(t *testing.T) {
 	ls, err := metav1.ParseToLabelSelector("k1=v1,k2=v2")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	selector := &LabelSelector{
 		LabelSelector: ls,
 	}
@@ -19,7 +19,7 @@ func TestStringOfLabelSelector(t *testing.T) {
 
 func TestSetOfLabelSelector(t *testing.T) {
 	selector := &LabelSelector{}
-	require.Nil(t, selector.Set("k1=v1,k2=v2"))
+	require.NoError(t, selector.Set("k1=v1,k2=v2"))
 	str := selector.String()
 	assert.True(t, str == "k1=v1,k2=v2" || str == "k2=v2,k2=v2")
 }

pkg/cmd/util/flag/map_test.go

@@ -65,7 +65,7 @@ func TestSetOfMap(t *testing.T) {
 			m := NewMap()
 			err := m.Set(c.input)
 			if c.error {
-				require.NotNil(t, err)
+				require.Error(t, err)
 				return
 			}
 			assert.EqualValues(t, c.expected, m.Data())
@@ -75,7 +75,7 @@ func TestSetOfMap(t *testing.T) {
 
 func TestStringOfMap(t *testing.T) {
 	m := NewMap()
-	require.Nil(t, m.Set("k1=v1,k2=v2"))
+	require.NoError(t, m.Set("k1=v1,k2=v2"))
 	str := m.String()
 	assert.True(t, str == "k1=v1,k2=v2" || str == "k2=v2,k1=v1")
 }

pkg/cmd/util/flag/optional_bool_test.go

@@ -25,16 +25,16 @@ func TestStringOfOptionalBool(t *testing.T) {
 func TestSetOfOptionalBool(t *testing.T) {
 	// error
 	ob := NewOptionalBool(nil)
-	assert.NotNil(t, ob.Set("invalid"))
+	assert.Error(t, ob.Set("invalid"))
 
 	// nil
 	ob = NewOptionalBool(nil)
-	assert.Nil(t, ob.Set(""))
+	assert.NoError(t, ob.Set(""))
 	assert.Nil(t, ob.Value)
 
 	// true
 	ob = NewOptionalBool(nil)
-	assert.Nil(t, ob.Set("true"))
+	assert.NoError(t, ob.Set("true"))
 	assert.True(t, *ob.Value)
 }
 

pkg/cmd/util/flag/orlabelselector_test.go

@@ -89,7 +89,7 @@ func TestSetOfOrLabelSelector(t *testing.T) {
 	selector := &OrLabelSelector{}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			require.Nil(t, selector.Set(test.inputStr))
+			require.NoError(t, selector.Set(test.inputStr))
 			assert.Equal(t, len(test.expectedSelector.OrLabelSelectors), len(selector.OrLabelSelectors))
 			assert.Equal(t, test.expectedSelector.String(), selector.String())
 		})

pkg/cmd/util/output/backup_describer_test.go

@@ -623,14 +623,14 @@ func TestDescribePodVolumeBackups(t *testing.T) {
 
 func TestDescribeDeleteBackupRequests(t *testing.T) {
 	t1, err1 := time.Parse("2006-Jan-02", "2023-Jun-26")
-	require.Nil(t, err1)
+	require.NoError(t, err1)
 	dbr1 := builder.ForDeleteBackupRequest("velero", "dbr1").
 		ObjectMeta(builder.WithCreationTimestamp(t1)).
 		BackupName("bak-1").
 		Phase(velerov1api.DeleteBackupRequestPhaseProcessed).
 		Errors("some error").Result()
 	t2, err2 := time.Parse("2006-Jan-02", "2023-Jun-25")
-	require.Nil(t, err2)
+	require.NoError(t, err2)
 	dbr2 := builder.ForDeleteBackupRequest("velero", "dbr2").
 		ObjectMeta(builder.WithCreationTimestamp(t2)).
 		BackupName("bak-2").
@@ -676,11 +676,11 @@ func TestDescribeDeleteBackupRequests(t *testing.T) {
 
 func TestDescribeBackupItemOperation(t *testing.T) {
 	t1, err1 := time.Parse("2006-Jan-02", "2023-Jun-26")
-	require.Nil(t, err1)
+	require.NoError(t, err1)
 	t2, err2 := time.Parse("2006-Jan-02", "2023-Jun-25")
-	require.Nil(t, err2)
+	require.NoError(t, err2)
 	t3, err3 := time.Parse("2006-Jan-02", "2023-Jun-24")
-	require.Nil(t, err3)
+	require.NoError(t, err3)
 	input := builder.ForBackupOperation().
 		BackupName("backup-1").
 		OperationID("op-1").

pkg/cmd/util/output/backup_structured_describer_test.go

@@ -563,14 +563,14 @@ func TestDescribeBackupResultInSF(t *testing.T) {
 
 func TestDescribeDeleteBackupRequestsInSF(t *testing.T) {
 	t1, err1 := time.Parse("2006-Jan-02", "2023-Jun-26")
-	require.Nil(t, err1)
+	require.NoError(t, err1)
 	dbr1 := builder.ForDeleteBackupRequest("velero", "dbr1").
 		ObjectMeta(builder.WithCreationTimestamp(t1)).
 		BackupName("bak-1").
 		Phase(velerov1api.DeleteBackupRequestPhaseProcessed).
 		Errors("some error").Result()
 	t2, err2 := time.Parse("2006-Jan-02", "2023-Jun-25")
-	require.Nil(t, err2)
+	require.NoError(t, err2)
 	dbr2 := builder.ForDeleteBackupRequest("velero", "dbr2").
 		ObjectMeta(builder.WithCreationTimestamp(t2)).
 		BackupName("bak-2").

pkg/cmd/util/output/restore_describer_test.go

@@ -79,11 +79,11 @@ func TestDescribeResult(t *testing.T) {
 
 func TestDescribeRestoreItemOperation(t *testing.T) {
 	t1, err1 := time.Parse("2006-Jan-02", "2023-Jun-26")
-	require.Nil(t, err1)
+	require.NoError(t, err1)
 	t2, err2 := time.Parse("2006-Jan-02", "2023-Jun-25")
-	require.Nil(t, err2)
+	require.NoError(t, err2)
 	t3, err3 := time.Parse("2006-Jan-02", "2023-Jun-24")
-	require.Nil(t, err3)
+	require.NoError(t, err3)
 	input := builder.ForRestoreOperation().
 		RestoreName("restore-1").
 		OperationID("op-1").

pkg/controller/backup_controller_test.go

@@ -140,7 +140,7 @@ func TestProcessBackupNonProcessedItems(t *testing.T) {
 			}
 			actualResult, err := c.Reconcile(ctx, ctrl.Request{NamespacedName: types.NamespacedName{Namespace: test.backup.Namespace, Name: test.backup.Name}})
 			assert.Equal(t, actualResult, ctrl.Result{})
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 
 			// Any backup that would actually proceed to validation will cause a segfault because this
 			// test hasn't set up the necessary controller dependencies for validation/etc. So the lack
@@ -230,7 +230,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, actualResult, ctrl.Result{})
-			assert.Nil(t, err)
+			assert.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)
@@ -1378,7 +1378,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, actualResult, ctrl.Result{})
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 
 			// Disable CSI feature to not impact other test cases.
 			if test.enableCSI {

pkg/controller/backup_deletion_controller_test.go

@@ -125,7 +125,7 @@ func TestBackupDeletionControllerReconcile(t *testing.T) {
 		td := setupBackupDeletionControllerTest(t, defaultTestDbr(), location, backup)
 		td.controller.backupStoreGetter = &fakeErrorBackupStoreGetter{}
 		_, err := td.controller.Reconcile(ctx, td.req)
-		assert.NotNil(t, err)
+		assert.Error(t, err)
 		assert.True(t, strings.HasPrefix(err.Error(), "error getting the backup store"))
 	})
 
@@ -358,7 +358,7 @@ func TestBackupDeletionControllerReconcile(t *testing.T) {
 			Namespace: velerov1api.DefaultNamespace,
 			Name:      "restore-3",
 		}, &velerov1api.Restore{})
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 
 		td.backupStore.AssertCalled(t, "DeleteBackup", input.Spec.BackupName)
 
@@ -479,7 +479,7 @@ func TestBackupDeletionControllerReconcile(t *testing.T) {
 			Namespace: velerov1api.DefaultNamespace,
 			Name:      "restore-3",
 		}, &velerov1api.Restore{})
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 
 		// Make sure snapshot was deleted
 		assert.Equal(t, 0, td.volumeSnapshotter.SnapshotsTaken.Len())

pkg/controller/backup_storage_location_controller_test.go

@@ -238,7 +238,7 @@ func TestEnsureSingleDefaultBSL(t *testing.T) {
 
 	for _, test := range tests {
 		// Setup reconciler
-		assert.Nil(t, velerov1api.AddToScheme(scheme.Scheme))
+		assert.NoError(t, velerov1api.AddToScheme(scheme.Scheme))
 		t.Run(test.name, func(t *testing.T) {
 			r := &backupStorageLocationReconciler{
 				ctx:                       context.Background(),
@@ -282,7 +282,7 @@ func TestBSLReconcile(t *testing.T) {
 	pluginManager.On("CleanupClients").Return(nil)
 	for _, test := range tests {
 		// Setup reconciler
-		assert.Nil(t, velerov1api.AddToScheme(scheme.Scheme))
+		assert.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

@@ -448,7 +448,7 @@ func TestDataDownloadReconcile(t *testing.T) {
 			if test.expectedStatusMsg != "" {
 				assert.Contains(t, err.Error(), test.expectedStatusMsg)
 			} else {
-				require.Nil(t, err)
+				require.NoError(t, err)
 			}
 
 			require.NotNil(t, actualResult)
@@ -476,7 +476,7 @@ func TestDataDownloadReconcile(t *testing.T) {
 				if controllerutil.ContainsFinalizer(test.dd, DataUploadDownloadFinalizer) {
 					assert.True(t, true, apierrors.IsNotFound(err))
 				} else {
-					require.Nil(t, err)
+					require.NoError(t, err)
 				}
 			} else {
 				assert.True(t, true, apierrors.IsNotFound(err))

pkg/controller/restore_controller_test.go

@@ -179,7 +179,7 @@ func TestProcessQueueItemSkips(t *testing.T) {
 			)
 
 			if test.restore != nil {
-				assert.Nil(t, fakeClient.Create(context.Background(), test.restore))
+				assert.NoError(t, fakeClient.Create(context.Background(), test.restore))
 			}
 
 			r := NewRestoreReconciler(

pkg/controller/schedule_controller_test.go

@@ -39,7 +39,7 @@ import (
 
 // Test reconcile function of schedule controller. Pause is not covered as event filter will not allow it through
 func TestReconcileOfSchedule(t *testing.T) {
-	require.Nil(t, velerov1.AddToScheme(scheme.Scheme))
+	require.NoError(t, velerov1.AddToScheme(scheme.Scheme))
 
 	newScheduleBuilder := func(phase velerov1.SchedulePhase) *builder.ScheduleBuilder {
 		return builder.ForSchedule("ns", "name").Phase(phase)
@@ -169,39 +169,39 @@ func TestReconcileOfSchedule(t *testing.T) {
 			reconciler.clock = testclocks.NewFakeClock(testTime)
 
 			if test.schedule != nil {
-				require.Nil(t, client.Create(ctx, test.schedule))
+				require.NoError(t, client.Create(ctx, test.schedule))
 			}
 
 			if test.backup != nil {
-				require.Nil(t, client.Create(ctx, test.backup))
+				require.NoError(t, client.Create(ctx, test.backup))
 			}
 
 			scheduleb4reconcile := &velerov1.Schedule{}
 			err = client.Get(ctx, types.NamespacedName{Namespace: "ns", Name: "name"}, scheduleb4reconcile)
 			if test.schedule != nil {
-				require.Nil(t, err)
+				require.NoError(t, err)
 			}
 
 			_, err = reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: types.NamespacedName{Namespace: "ns", Name: "name"}})
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			schedule := &velerov1.Schedule{}
 			err = client.Get(ctx, types.NamespacedName{Namespace: "ns", Name: "name"}, schedule)
 			if len(test.expectedPhase) > 0 {
-				require.Nil(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, test.expectedPhase, string(schedule.Status.Phase))
 			}
 			if len(test.expectedValidationErrors) > 0 {
-				require.Nil(t, err)
+				require.NoError(t, err)
 				assert.EqualValues(t, test.expectedValidationErrors, schedule.Status.ValidationErrors)
 			}
 			if len(test.expectedLastBackup) > 0 {
-				require.Nil(t, err)
+				require.NoError(t, err)
 				require.NotNil(t, schedule.Status.LastBackup)
 				assert.Equal(t, parseTime(test.expectedLastBackup).Unix(), schedule.Status.LastBackup.Unix())
 			}
 			if len(test.expectedLastSkipped) > 0 {
-				require.Nil(t, err)
+				require.NoError(t, err)
 				require.NotNil(t, schedule.Status.LastSkipped)
 				assert.Equal(t, parseTime(test.expectedLastSkipped).Unix(), schedule.Status.LastSkipped.Unix())
 			}
@@ -213,17 +213,17 @@ func TestReconcileOfSchedule(t *testing.T) {
 			}
 
 			backups := &velerov1.BackupList{}
-			require.Nil(t, client.List(ctx, backups))
+			require.NoError(t, client.List(ctx, backups))
 
 			// If backup associated with schedule's status is in New or InProgress,
 			// new backup shouldn't be submitted.
 			if test.backup != nil &&
 				(test.backup.Status.Phase == velerov1.BackupPhaseNew || test.backup.Status.Phase == velerov1.BackupPhaseInProgress) {
 				assert.Len(t, backups.Items, 1)
-				require.Nil(t, client.Delete(ctx, test.backup))
+				require.NoError(t, client.Delete(ctx, test.backup))
 			}
 
-			require.Nil(t, client.List(ctx, backups))
+			require.NoError(t, client.List(ctx, backups))
 
 			if test.expectedBackupCreate == nil {
 				assert.Empty(t, backups.Items)
@@ -444,7 +444,7 @@ func TestGetBackup(t *testing.T) {
 }
 
 func TestCheckIfBackupInNewOrProgress(t *testing.T) {
-	require.Nil(t, velerov1.AddToScheme(scheme.Scheme))
+	require.NoError(t, velerov1.AddToScheme(scheme.Scheme))
 
 	client := fake.NewClientBuilder().WithScheme(scheme.Scheme).Build()
 	logger := velerotest.NewLogger()

pkg/discovery/helper_test.go

@@ -194,9 +194,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.NotNil(t, err)
+				assert.Error(t, err)
 			} else {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 				assert.Equal(t, test.returnError, err)
 			}
 
@@ -567,9 +567,9 @@ func TestHelper_refreshServerPreferredResources(t *testing.T) {
 			resources, err := refreshServerPreferredResources(fakeClient, logrus.New())
 
 			if tc.expectedErr != nil {
-				assert.NotNil(t, err)
+				assert.Error(t, err)
 			} else {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 				assert.NotNil(t, resources)
 			}
 		})
@@ -622,9 +622,9 @@ func TestHelper_refreshServerGroupsAndResources(t *testing.T) {
 			serverGroups, serverResources, err := refreshServerGroupsAndResources(fakeClient, logrus.New())
 
 			if tc.expectedErr != nil {
-				assert.NotNil(t, err)
+				assert.Error(t, err)
 			} else {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 				assert.NotNil(t, serverGroups)
 				assert.NotNil(t, serverResources)
 			}
@@ -637,7 +637,7 @@ func TestHelper(t *testing.T) {
 		Fake: &clientgotesting.Fake{},
 	}
 	h, err := NewHelper(fakeDiscoveryClient, logrus.New())
-	assert.Nil(t, err)
+	assert.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/install/install_test.go

@@ -50,10 +50,10 @@ func TestInstall(t *testing.T) {
 	).Build()
 
 	resources := &unstructured.UnstructuredList{}
-	require.Nil(t, appendUnstructured(resources, v1crds.CRDs[0]))
+	require.NoError(t, appendUnstructured(resources, v1crds.CRDs[0]))
-	require.Nil(t, appendUnstructured(resources, Namespace("velero")))
+	require.NoError(t, appendUnstructured(resources, Namespace("velero")))
 
-	assert.Nil(t, Install(factory, c, resources, os.Stdout))
+	assert.NoError(t, Install(factory, c, resources, os.Stdout))
 }
 
 func Test_crdsAreReady(t *testing.T) {
@@ -88,7 +88,7 @@ func Test_crdsAreReady(t *testing.T) {
 		},
 	}
 	obj, err := runtime.DefaultUnstructuredConverter.ToUnstructured(crd)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	crds := []*unstructured.Unstructured{
 		{
@@ -97,7 +97,7 @@ func Test_crdsAreReady(t *testing.T) {
 	}
 
 	ready, err := crdsAreReady(c, crds)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.True(t, ready)
 }
 
@@ -114,7 +114,7 @@ func TestDeploymentIsReady(t *testing.T) {
 		},
 	}
 	obj, err := runtime.DefaultUnstructuredConverter.ToUnstructured(deployment)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	dc := &test.FakeDynamicClient{}
 	dc.On("Get", mock.Anything, mock.Anything).Return(&unstructured.Unstructured{Object: obj}, nil)
@@ -123,7 +123,7 @@ func TestDeploymentIsReady(t *testing.T) {
 	factory.On("ClientForGroupVersionResource", mock.Anything, mock.Anything, mock.Anything).Return(dc, nil)
 
 	ready, err := DeploymentIsReady(factory, "velero")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.True(t, ready)
 }
 
@@ -135,7 +135,7 @@ func TestDaemonSetIsReady(t *testing.T) {
 		},
 	}
 	obj, err := runtime.DefaultUnstructuredConverter.ToUnstructured(daemonset)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	dc := &test.FakeDynamicClient{}
 	dc.On("Get", mock.Anything, mock.Anything).Return(&unstructured.Unstructured{Object: obj}, nil)
@@ -144,6 +144,6 @@ func TestDaemonSetIsReady(t *testing.T) {
 	factory.On("ClientForGroupVersionResource", mock.Anything, mock.Anything, mock.Anything).Return(dc, nil)
 
 	ready, err := DaemonSetIsReady(factory, "velero")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.True(t, ready)
 }

pkg/persistence/object_store_test.go

@@ -427,7 +427,7 @@ func TestGetBackupVolumeSnapshots(t *testing.T) {
 	// 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.NotNil(t, err)
+	assert.Error(t, err)
 
 	// volumesnapshots file containing gzipped json data should return correctly
 	snapshots := []*volume.Snapshot{
@@ -469,7 +469,7 @@ func TestGetBackupItemOperations(t *testing.T) {
 	// 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.NotNil(t, err)
+	assert.Error(t, err)
 
 	// itemoperations file containing gzipped json data should return correctly
 	operations := []*itemoperation.BackupOperation{
@@ -518,7 +518,7 @@ func TestGetRestoreItemOperations(t *testing.T) {
 	// 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.NotNil(t, err)
+	assert.Error(t, err)
 
 	// itemoperations file containing gzipped json data should return correctly
 	operations := []*itemoperation.RestoreOperation{
@@ -806,7 +806,7 @@ func TestGetCSIVolumeSnapshotClasses(t *testing.T) {
 	// 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.NotNil(t, err)
+	assert.Error(t, err)
 
 	// file containing gzipped json data should return correctly
 	classes := []*snapshotv1api.VolumeSnapshotClass{
@@ -838,7 +838,7 @@ func TestGetCSIVolumeSnapshots(t *testing.T) {
 	// 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.NotNil(t, err)
+	assert.Error(t, err)
 
 	// file containing gzipped json data should return correctly
 	snapshots := []*snapshotv1api.VolumeSnapshot{
@@ -874,7 +874,7 @@ func TestGetCSIVolumeSnapshotContents(t *testing.T) {
 	// file containing invalid data should error
 	harness.objectStore.PutObject(harness.bucket, "backups/test-backup/test-backup-csi-volumesnapshotcontents.json.gz", newStringReadSeeker("foo"))
 	_, err = harness.GetCSIVolumeSnapshotContents("test-backup")
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	// file containing gzipped json data should return correctly
 	contents := []*snapshotv1api.VolumeSnapshotContent{
@@ -986,7 +986,7 @@ func TestNewObjectBackupStoreGetter(t *testing.T) {
 			if tc.wantErr != "" {
 				require.EqualError(t, err, tc.wantErr)
 			} else {
-				require.Nil(t, err)
+				require.NoError(t, err)
 
 				store, ok := res.(*objectBackupStore)
 				require.True(t, ok)
@@ -1155,7 +1155,7 @@ func TestGetRestoreResults(t *testing.T) {
 	// 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.NotNil(t, err)
+	assert.Error(t, err)
 
 	// file containing gzipped json data should return correctly
 	contents := map[string]results.Result{
@@ -1185,7 +1185,7 @@ func TestGetRestoredResourceList(t *testing.T) {
 	// 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.NotNil(t, err)
+	assert.Error(t, err)
 
 	// file containing gzipped json data should return correctly
 	list := map[string][]string{

pkg/plugin/framework/stream_reader_test.go

@@ -61,6 +61,6 @@ func TestStreamReader(t *testing.T) {
 
 	res, err := io.ReadAll(sr)
 
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, s, string(res))
 }

pkg/podvolume/backupper_test.go

@@ -51,7 +51,7 @@ func TestIsHostPathVolume(t *testing.T) {
 		},
 	}
 	isHostPath, err := isHostPathVolume(vol, nil, nil)
-	assert.Nil(t, err)
+	assert.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.Nil(t, err)
+	assert.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.Nil(t, err)
+	assert.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.Nil(t, err)
+	assert.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.Nil(t, err)
+	assert.NoError(t, err)
 	assert.True(t, isHostPath)
 }
 
@@ -632,11 +632,11 @@ func TestWaitAllPodVolumesProcessed(t *testing.T) {
 		if c.statusToBeUpdated != nil {
 			pvb := &velerov1api.PodVolumeBackup{}
 			err := client.Get(context.Background(), ctrlclient.ObjectKey{Namespace: newPVB.Namespace, Name: newPVB.Name}, pvb)
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			pvb.Status = *c.statusToBeUpdated
 			err = client.Update(context.Background(), pvb)
-			require.Nil(t, err)
+			require.NoError(t, err)
 		}
 
 		pvbs := backuper.WaitAllPodVolumesProcessed(logger)

pkg/repository/config/azure_test.go

@@ -29,22 +29,22 @@ func TestGetAzureResticEnvVars(t *testing.T) {
 
 	// no storage account specified
 	_, err := GetAzureResticEnvVars(config)
-	require.NotNil(t, err)
+	require.Error(t, err)
 
 	// specify storage account access key
 	name := filepath.Join(os.TempDir(), "credential")
 	file, err := os.Create(name)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer file.Close()
 	defer os.Remove(name)
 	_, err = file.WriteString("AccessKey: accesskey")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	config[azure.BSLConfigStorageAccount] = "account01"
 	config[azure.BSLConfigStorageAccountAccessKeyName] = "AccessKey"
 	config["credentialsFile"] = name
 	envs, err := GetAzureResticEnvVars(config)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, "account01", envs["AZURE_ACCOUNT_NAME"])
 	assert.Equal(t, "accesskey", envs["AZURE_ACCOUNT_KEY"])

pkg/repository/manager_test.go

@@ -33,17 +33,17 @@ func TestGetRepositoryProvider(t *testing.T) {
 
 	// empty repository type
 	provider, err := mgr.getRepositoryProvider(repo)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, provider)
 
 	// valid repository type
 	repo.Spec.RepositoryType = velerov1.BackupRepositoryTypeRestic
 	provider, err = mgr.getRepositoryProvider(repo)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, provider)
 
 	// invalid repository type
 	repo.Spec.RepositoryType = "unknown"
 	_, err = mgr.getRepositoryProvider(repo)
-	require.NotNil(t, err)
+	require.Error(t, err)
 }

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

@@ -41,7 +41,7 @@ func TestAzureSetup(t *testing.T) {
 	}
 
 	err := backend.Setup(context.Background(), flags)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, flags, backend.option.Config)
 	assert.Equal(t, limits, backend.option.Limits)
 }

pkg/restore/actions/admissionwebhook_config_action_test.go

@@ -186,26 +186,26 @@ func TestNewAdmissionWebhookConfigurationActionExecute(t *testing.T) {
 			}
 			output, err := action.Execute(input)
 			if tt.wantErr {
-				assert.NotNil(t, err)
+				assert.Error(t, err)
 			} else {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 			}
 			if tt.NoneSideEffectsIndex != nil {
 				wb, _, err := unstructured.NestedSlice(output.UpdatedItem.UnstructuredContent(), "webhooks")
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 				for _, i := range tt.NoneSideEffectsIndex {
 					it, err := runtime.DefaultUnstructuredConverter.ToUnstructured(&wb[i])
-					assert.Nil(t, err)
+					assert.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.Nil(t, err)
+				assert.NoError(t, err)
 				for _, i := range tt.NotNoneSideEffectsIndex {
 					it, err := runtime.DefaultUnstructuredConverter.ToUnstructured(&wb[i])
-					assert.Nil(t, err)
+					assert.NoError(t, err)
 					s := it["sideEffects"].(string)
 					assert.NotEqual(t, "None", s)
 				}

pkg/restore/actions/init_restorehook_pod_action_test.go

@@ -131,10 +131,10 @@ func TestInitContainerRestoreHookPodActionExecute(t *testing.T) {
 				Restore:        tc.restore,
 			})
 			if tc.expectedErr {
-				assert.NotNil(t, err, "expected an error")
+				assert.Error(t, err, "expected an error")
 				return
 			}
-			assert.Nil(t, err, "expected no error, got %v", err)
+			assert.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

@@ -236,10 +236,10 @@ func TestPodActionExecute(t *testing.T) {
 			})
 
 			if test.expectedErr {
-				assert.NotNil(t, err, "expected an error")
+				assert.Error(t, err, "expected an error")
 				return
 			}
-			assert.Nil(t, err, "expected no error, got %v", err)
+			assert.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/priority_test.go

@@ -100,9 +100,9 @@ func TestSetOfPriority(t *testing.T) {
 			p := Priorities{}
 			err := p.Set(c.input)
 			if c.hasErr {
-				require.NotNil(t, err)
+				require.Error(t, err)
 			} else {
-				require.Nil(t, err)
+				require.NoError(t, err)
 			}
 			assert.Equal(t, c.priorities, p)
 		})

pkg/restore/pv_restorer_test.go

@@ -135,10 +135,10 @@ func TestExecutePVAction_NoSnapshotRestores(t *testing.T) {
 			switch tc.expectedErr {
 			case true:
 				assert.Nil(t, res)
-				assert.NotNil(t, err)
+				assert.Error(t, err)
 			case false:
 				assert.Equal(t, tc.expectedRes, res)
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 			}
 		})
 	}

pkg/restore/restore_test.go

@@ -2316,11 +2316,11 @@ func TestShouldRestore(t *testing.T) {
 			res, err := ctx.shouldRestore(tc.pvName, pvClient)
 			assert.Equal(t, tc.want, res)
 			if tc.wantErr != nil {
-				if assert.NotNil(t, err, "expected a non-nil error") {
+				if assert.Error(t, err, "expected a non-nil error") {
 					assert.EqualError(t, err, tc.wantErr.Error())
 				}
 			} else {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 			}
 		})
 	}

pkg/uploader/kopia/shim_test.go

@@ -114,7 +114,7 @@ func TestOpenObject(t *testing.T) {
 				assert.Nil(t, reader)
 			} else {
 				assert.NotNil(t, reader)
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 			}
 		})
 	}
@@ -153,7 +153,7 @@ func TestFindManifests(t *testing.T) {
 			if tc.isGetManifestError {
 				assert.Contains(t, err.Error(), "failed")
 			} else {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 			}
 		})
 	}

pkg/uploader/kopia/snapshot_test.go

@@ -562,7 +562,7 @@ func TestFindPreviousSnapshotManifest(t *testing.T) {
 			if tc.expectedError != nil {
 				assert.Contains(t, err.Error(), tc.expectedError.Error())
 			} else {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 			}
 
 			// Check the number of returned snapshots
@@ -655,7 +655,7 @@ func TestBackup(t *testing.T) {
 			if tc.expectedError != nil {
 				assert.Contains(t, err.Error(), tc.expectedError.Error())
 			} else {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 			}
 
 			assert.Equal(t, tc.expectedEmpty, isSnapshotEmpty)
@@ -794,7 +794,7 @@ func TestRestore(t *testing.T) {
 			if tc.expectedError != nil {
 				assert.Contains(t, err.Error(), tc.expectedError.Error())
 			} else {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 			}
 
 			// Check the number of bytes restored

pkg/uploader/provider/kopia_test.go

@@ -382,7 +382,7 @@ func TestNewKopiaUploaderProvider(t *testing.T) {
 			if tc.expectedError != "" {
 				assert.Contains(t, err.Error(), tc.expectedError)
 			} else {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 			}
 
 			// Verify that the expected methods were called on the mocks.

pkg/uploader/provider/provider_test.go

@@ -88,7 +88,7 @@ func TestNewUploaderProvider(t *testing.T) {
 			}
 			_, err := NewUploaderProvider(ctx, client, testCase.UploaderType, testCase.RequestorType, repoIdentifier, bsl, backupRepo, credGetter, repoKeySelector, log)
 			if testCase.ExpectedError == "" {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 			} else {
 				assert.Contains(t, err.Error(), testCase.ExpectedError)
 			}

pkg/util/azure/credential_test.go

@@ -35,7 +35,7 @@ func TestNewCredential(t *testing.T) {
 		CredentialKeyClientSecret: "secret",
 	}
 	_, err := NewCredential(creds, options)
-	require.NotNil(t, err)
+	require.Error(t, err)
 
 	// valid client secret credential
 	creds = map[string]string{
@@ -44,19 +44,19 @@ func TestNewCredential(t *testing.T) {
 		CredentialKeyClientSecret: "secret",
 	}
 	tokenCredential, err := NewCredential(creds, options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.IsType(t, &azidentity.ClientSecretCredential{}, tokenCredential)
 
 	// client certificate credential
 	certData, err := readCertData()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	creds = map[string]string{
 		CredentialKeyTenantID:          "tenantid",
 		CredentialKeyClientID:          "clientid",
 		CredentialKeyClientCertificate: certData,
 	}
 	tokenCredential, err = NewCredential(creds, options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.IsType(t, &azidentity.ClientCertificateCredential{}, tokenCredential)
 
 	// workload identity credential
@@ -65,14 +65,14 @@ func TestNewCredential(t *testing.T) {
 	os.Setenv("AZURE_FEDERATED_TOKEN_FILE", "/tmp/token")
 	creds = map[string]string{}
 	tokenCredential, err = NewCredential(creds, options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.IsType(t, &azidentity.WorkloadIdentityCredential{}, tokenCredential)
 	os.Clearenv()
 
 	// managed identity credential
 	creds = map[string]string{}
 	tokenCredential, err = NewCredential(creds, options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.IsType(t, &azidentity.ManagedIdentityCredential{}, tokenCredential)
 }
 
@@ -82,14 +82,14 @@ func Test_newConfigCredential(t *testing.T) {
 	// tenantID not specified
 	creds := map[string]string{}
 	_, err := newConfigCredential(creds, options)
-	require.NotNil(t, err)
+	require.Error(t, err)
 
 	// clientID not specified
 	creds = map[string]string{
 		CredentialKeyTenantID: "clientid",
 	}
 	_, err = newConfigCredential(creds, options)
-	require.NotNil(t, err)
+	require.Error(t, err)
 
 	// client secret
 	creds = map[string]string{
@@ -98,21 +98,21 @@ func Test_newConfigCredential(t *testing.T) {
 		CredentialKeyClientSecret: "secret",
 	}
 	credential, err := newConfigCredential(creds, options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.NotNil(t, credential)
 	_, ok := credential.(*azidentity.ClientSecretCredential)
 	require.True(t, ok)
 
 	// client certificate
 	certData, err := readCertData()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	creds = map[string]string{
 		CredentialKeyTenantID:          "clientid",
 		CredentialKeyClientID:          "clientid",
 		CredentialKeyClientCertificate: certData,
 	}
 	credential, err = newConfigCredential(creds, options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.NotNil(t, credential)
 	_, ok = credential.(*azidentity.ClientCertificateCredential)
 	require.True(t, ok)
@@ -125,7 +125,7 @@ func Test_newConfigCredential(t *testing.T) {
 		CredentialKeyPassword: "password",
 	}
 	credential, err = newConfigCredential(creds, options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.NotNil(t, credential)
 	_, ok = credential.(*azidentity.UsernamePasswordCredential)
 	require.True(t, ok)

pkg/util/azure/storage_test.go

@@ -32,15 +32,15 @@ func TestNewStorageClient(t *testing.T) {
 
 	name := filepath.Join(os.TempDir(), "credential")
 	file, err := os.Create(name)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer file.Close()
 	defer os.Remove(name)
 	_, err = file.WriteString("AccessKey: YWNjZXNza2V5\nAZURE_TENANT_ID: tenantid\nAZURE_CLIENT_ID: clientid\nAZURE_CLIENT_SECRET: secret")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// storage account isn't specified
 	_, _, err = NewStorageClient(log, config)
-	require.NotNil(t, err)
+	require.Error(t, err)
 
 	// auth with storage account access key
 	config = map[string]string{
@@ -49,7 +49,7 @@ func TestNewStorageClient(t *testing.T) {
 		BSLConfigStorageAccountAccessKeyName: "AccessKey",
 	}
 	client, credential, err := NewStorageClient(log, config)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, client)
 	assert.NotNil(t, credential)
 
@@ -60,7 +60,7 @@ func TestNewStorageClient(t *testing.T) {
 		"useAAD":                "true",
 	}
 	client, credential, err = NewStorageClient(log, config)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, client)
 	assert.Nil(t, credential)
 }
@@ -72,7 +72,7 @@ func TestGetStorageAccountCredentials(t *testing.T) {
 	}
 	creds := map[string]string{}
 	_, err := GetStorageAccountCredentials(cfg, creds)
-	require.NotNil(t, err)
+	require.Error(t, err)
 
 	// use access secret
 	cfg = map[string]string{
@@ -82,7 +82,7 @@ func TestGetStorageAccountCredentials(t *testing.T) {
 		"KEY": "key",
 	}
 	m, err := GetStorageAccountCredentials(cfg, creds)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "key", m[CredentialKeyStorageAccountAccessKey])
 
 	// use AAD, but useAAD invalid
@@ -91,7 +91,7 @@ func TestGetStorageAccountCredentials(t *testing.T) {
 	}
 	creds = map[string]string{}
 	_, err = GetStorageAccountCredentials(cfg, creds)
-	require.NotNil(t, err)
+	require.Error(t, err)
 
 	// use AAD
 	cfg = map[string]string{
@@ -101,7 +101,7 @@ func TestGetStorageAccountCredentials(t *testing.T) {
 		"KEY": "key",
 	}
 	m, err = GetStorageAccountCredentials(cfg, creds)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, creds, m)
 }
 
@@ -114,7 +114,7 @@ func Test_getStorageAccountURI(t *testing.T) {
 	}
 	creds := map[string]string{}
 	uri, err := getStorageAccountURI(log, bslCfg, creds)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "uri", uri)
 
 	// no URI specified, and auth with access key
@@ -125,7 +125,7 @@ func Test_getStorageAccountURI(t *testing.T) {
 		"KEY": "value",
 	}
 	uri, err = getStorageAccountURI(log, bslCfg, creds)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "https://.blob.core.windows.net", uri)
 
 	// no URI specified, auth with AAD, resource group isn't specified
@@ -138,7 +138,7 @@ func Test_getStorageAccountURI(t *testing.T) {
 		"AZURE_CLIENT_SECRET": "secret",
 	}
 	uri, err = getStorageAccountURI(log, bslCfg, creds)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "https://.blob.core.windows.net", uri)
 
 	// no URI specified, auth with AAD, resource group specified
@@ -153,7 +153,7 @@ func Test_getStorageAccountURI(t *testing.T) {
 		"AZURE_CLIENT_SECRET": "secret",
 	}
 	uri, err = getStorageAccountURI(log, bslCfg, creds)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "https://account.blob.core.windows.net", uri)
 }
 
@@ -168,7 +168,7 @@ func Test_exchangeStorageAccountAccessKey(t *testing.T) {
 		"AZURE_CLIENT_SECRET": "secret",
 	}
 	_, err := exchangeStorageAccountAccessKey(bslCfg, creds)
-	require.NotNil(t, err)
+	require.Error(t, err)
 
 	// storage account isn't specified
 	bslCfg = map[string]string{
@@ -181,7 +181,7 @@ func Test_exchangeStorageAccountAccessKey(t *testing.T) {
 		"AZURE_CLIENT_SECRET": "secret",
 	}
 	_, err = exchangeStorageAccountAccessKey(bslCfg, creds)
-	require.NotNil(t, err)
+	require.Error(t, err)
 
 	// storage account specified
 	bslCfg = map[string]string{
@@ -195,7 +195,7 @@ func Test_exchangeStorageAccountAccessKey(t *testing.T) {
 		"AZURE_CLIENT_SECRET": "secret",
 	}
 	_, err = exchangeStorageAccountAccessKey(bslCfg, creds)
-	require.NotNil(t, err)
+	require.Error(t, err)
 }
 
 func Test_newStorageAccountManagemenClient(t *testing.T) {
@@ -207,7 +207,7 @@ func Test_newStorageAccountManagemenClient(t *testing.T) {
 		"AZURE_CLIENT_SECRET": "secret",
 	}
 	_, err := newStorageAccountManagemenClient(bslCfg, creds)
-	require.NotNil(t, err)
+	require.Error(t, err)
 
 	// subscription ID isn't specified
 	bslCfg = map[string]string{
@@ -219,5 +219,5 @@ func Test_newStorageAccountManagemenClient(t *testing.T) {
 		"AZURE_CLIENT_SECRET": "secret",
 	}
 	_, err = newStorageAccountManagemenClient(bslCfg, creds)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }

pkg/util/azure/util_test.go

@@ -29,30 +29,30 @@ import (
 func TestLoadCredentials(t *testing.T) {
 	// no credential file
 	credentials, err := LoadCredentials(nil)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, credentials)
 
 	// specified credential file in the config
 	name := filepath.Join(os.TempDir(), "credential")
 	file, err := os.Create(name)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer file.Close()
 	defer os.Remove(name)
 	_, err = file.WriteString("key: value")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	config := map[string]string{
 		"credentialsFile": name,
 	}
 	credentials, err = LoadCredentials(config)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "value", credentials["key"])
 
 	// use the default path defined via env variable
 	config = nil
 	os.Setenv("AZURE_CREDENTIALS_FILE", name)
 	credentials, err = LoadCredentials(config)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "value", credentials["key"])
 }
 
@@ -63,7 +63,7 @@ func TestGetClientOptions(t *testing.T) {
 		CredentialKeyCloudName: "invalid",
 	}
 	_, err := GetClientOptions(bslCfg, creds)
-	require.NotNil(t, err)
+	require.Error(t, err)
 
 	// specify caCert
 	bslCfg = map[string]string{
@@ -72,7 +72,7 @@ func TestGetClientOptions(t *testing.T) {
 	}
 	creds = map[string]string{}
 	options, err := GetClientOptions(bslCfg, creds)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, options.Cloud, cloud.AzurePublic)
 	assert.NotNil(t, options.Transport)
 
@@ -82,7 +82,7 @@ func TestGetClientOptions(t *testing.T) {
 	}
 	creds = map[string]string{}
 	options, err = GetClientOptions(bslCfg, creds)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, options.Cloud, cloud.AzurePublic)
 	assert.Nil(t, options.Transport)
 }

pkg/util/csi/volume_snapshot_test.go

@@ -955,7 +955,7 @@ func TestGetVolumeSnapshotClass(t *testing.T) {
 			actualSnapshotClass, actualError := GetVolumeSnapshotClass(
 				tc.driverName, tc.backup, tc.pvc, logrus.New(), fakeClient)
 			if tc.expectError {
-				assert.NotNil(t, actualError)
+				assert.Error(t, actualError)
 				assert.Nil(t, actualSnapshotClass)
 				return
 			}
@@ -1070,7 +1070,7 @@ func TestGetVolumeSnapshotClassForStorageClass(t *testing.T) {
 			actualVSC, actualError := GetVolumeSnapshotClassForStorageClass(tc.driverName, snapshotClasses)
 
 			if tc.expectError {
-				assert.NotNil(t, actualError)
+				assert.Error(t, actualError)
 				assert.Nil(t, actualVSC)
 				return
 			}
@@ -1361,16 +1361,16 @@ func TestSetVolumeSnapshotContentDeletionPolicy(t *testing.T) {
 			fakeClient := velerotest.NewFakeControllerRuntimeClient(t, tc.objs...)
 			err := SetVolumeSnapshotContentDeletionPolicy(tc.inputVSCName, fakeClient)
 			if tc.expectError {
-				assert.NotNil(t, err)
+				assert.Error(t, err)
 			} else {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 				actual := new(snapshotv1api.VolumeSnapshotContent)
 				err := fakeClient.Get(
 					context.TODO(),
 					crclient.ObjectKey{Name: tc.inputVSCName},
 					actual,
 				)
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 				assert.Equal(
 					t,
 					snapshotv1api.VolumeSnapshotContentDelete,
@@ -1647,7 +1647,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"), tc.wait, 0)
 			if tc.expectError && actualError == nil {
-				assert.NotNil(t, actualError)
+				assert.Error(t, actualError)
 				assert.Nil(t, actualVSC)
 				return
 			}

pkg/util/kube/periodical_enqueue_source_test.go

@@ -37,21 +37,21 @@ import (
 )
 
 func TestStart(t *testing.T) {
-	require.Nil(t, velerov1.AddToScheme(scheme.Scheme))
+	require.NoError(t, velerov1.AddToScheme(scheme.Scheme))
 
 	ctx, cancelFunc := context.WithCancel(context.TODO())
 	client := (&fake.ClientBuilder{}).Build()
 	queue := workqueue.NewRateLimitingQueue(workqueue.DefaultItemBasedRateLimiter())
 	source := NewPeriodicalEnqueueSource(logrus.WithContext(ctx), client, &velerov1.ScheduleList{}, 1*time.Second, PeriodicalEnqueueSourceOption{})
 
-	require.Nil(t, source.Start(ctx, nil, queue))
+	require.NoError(t, source.Start(ctx, nil, queue))
 
 	// no resources
 	time.Sleep(1 * time.Second)
 	require.Equal(t, 0, queue.Len())
 
 	// contain one resource
-	require.Nil(t, client.Create(ctx, &velerov1.Schedule{
+	require.NoError(t, client.Create(ctx, &velerov1.Schedule{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: "schedule",
 		},
@@ -69,7 +69,7 @@ func TestStart(t *testing.T) {
 }
 
 func TestPredicate(t *testing.T) {
-	require.Nil(t, velerov1.AddToScheme(scheme.Scheme))
+	require.NoError(t, velerov1.AddToScheme(scheme.Scheme))
 
 	ctx, cancelFunc := context.WithCancel(context.TODO())
 	client := (&fake.ClientBuilder{}).Build()
@@ -82,14 +82,14 @@ func TestPredicate(t *testing.T) {
 		PeriodicalEnqueueSourceOption{},
 	)
 
-	require.Nil(t, source.Start(ctx, nil, queue, NewGenericEventPredicate(func(object crclient.Object) bool {
+	require.NoError(t, source.Start(ctx, nil, queue, NewGenericEventPredicate(func(object crclient.Object) bool {
 		location := object.(*velerov1.BackupStorageLocation)
 		return storage.IsReadyToValidate(location.Spec.ValidationFrequency, location.Status.LastValidationTime, 1*time.Minute, logrus.WithContext(ctx).WithField("BackupStorageLocation", location.Name))
 	})))
 
 	// Should not patch a backup storage location object status phase
 	// if the location's validation frequency is specifically set to zero
-	require.Nil(t, client.Create(ctx, &velerov1.BackupStorageLocation{
+	require.NoError(t, client.Create(ctx, &velerov1.BackupStorageLocation{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "location1",
 			Namespace: "default",
@@ -109,7 +109,7 @@ func TestPredicate(t *testing.T) {
 }
 
 func TestOrder(t *testing.T) {
-	require.Nil(t, velerov1.AddToScheme(scheme.Scheme))
+	require.NoError(t, velerov1.AddToScheme(scheme.Scheme))
 
 	ctx, cancelFunc := context.WithCancel(context.TODO())
 	client := (&fake.ClientBuilder{}).Build()
@@ -137,11 +137,11 @@ func TestOrder(t *testing.T) {
 		},
 	)
 
-	require.Nil(t, source.Start(ctx, nil, queue))
+	require.NoError(t, source.Start(ctx, nil, queue))
 
 	// Should not patch a backup storage location object status phase
 	// if the location's validation frequency is specifically set to zero
-	require.Nil(t, client.Create(ctx, &velerov1.BackupStorageLocation{
+	require.NoError(t, client.Create(ctx, &velerov1.BackupStorageLocation{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "location1",
 			Namespace: "default",
@@ -153,7 +153,7 @@ func TestOrder(t *testing.T) {
 			LastValidationTime: &metav1.Time{Time: time.Now()},
 		},
 	}))
-	require.Nil(t, client.Create(ctx, &velerov1.BackupStorageLocation{
+	require.NoError(t, client.Create(ctx, &velerov1.BackupStorageLocation{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "location2",
 			Namespace: "default",
@@ -171,7 +171,7 @@ func TestOrder(t *testing.T) {
 	first, _ := queue.Get()
 	bsl := &velerov1.BackupStorageLocation{}
 	require.Equal(t, "location2", first.(reconcile.Request).Name)
-	require.Nil(t, client.Get(ctx, first.(reconcile.Request).NamespacedName, bsl))
+	require.NoError(t, client.Get(ctx, first.(reconcile.Request).NamespacedName, bsl))
 	require.True(t, bsl.Spec.Default)
 
 	cancelFunc()

pkg/util/kube/pvc_pv_test.go

@@ -1248,12 +1248,12 @@ func TestGetPVForPVC(t *testing.T) {
 			actualPV, actualError := GetPVForPVC(tc.inPVC, fakeClient)
 
 			if tc.expectError {
-				assert.NotNil(t, actualError, "Want error; Got nil error")
+				assert.Error(t, actualError, "Want error; Got nil error")
 				assert.Nilf(t, actualPV, "Want PV: nil; Got PV: %q", actualPV)
 				return
 			}
 
-			assert.Nilf(t, actualError, "Want: nil error; Got: %v", actualError)
+			assert.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)
 		})
 	}
@@ -1371,11 +1371,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.NotNil(t, actualError, "Want error; Got nil error")
+				assert.Error(t, actualError, "Want error; Got nil error")
 				assert.Nilf(t, actualPVC, "Want PV: nil; Got PV: %q", actualPVC)
 				return
 			}
-			assert.Nilf(t, actualError, "Want: nil error; Got: %v", actualError)
+			assert.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/utils_test.go

@@ -469,7 +469,7 @@ func TestIsCRDReady(t *testing.T) {
 	err := json.Unmarshal(resBytes, obj)
 	require.NoError(t, err)
 	_, err = IsCRDReady(obj)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func TestSinglePathMatch(t *testing.T) {
@@ -478,7 +478,7 @@ func TestSinglePathMatch(t *testing.T) {
 	fakeFS.MkdirAll("testDir2/subpath", 0755)
 
 	_, err := SinglePathMatch("./*/subpath", fakeFS, logrus.StandardLogger())
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "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.Nil(t, res)
+				assert.NoError(t, res)
 				return
 			}
 

pkg/util/podvolume/pod_volume_test.go

@@ -669,7 +669,7 @@ func TestGetPodVolumeNameForPVC(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			actualVolumeName, err := getPodVolumeNameForPVC(tc.pod, tc.pvcName)
 			if tc.expectError && err == nil {
-				assert.NotNil(t, err, "Want error; Got nil error")
+				assert.Error(t, err, "Want error; Got nil error")
 				return
 			}
 			assert.Equalf(t, tc.expectedVolumeName, actualVolumeName, "unexpected podVolumename returned. Want %s; Got %s", tc.expectedVolumeName, actualVolumeName)
@@ -787,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.Nilf(t, err, "Want error=nil; Got error=%v", err)
+			assert.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))
 		})
 	}