fix testifylint issues

agent/agent_test.go

@@ -94,13 +94,12 @@ func TestAgentStartStop(t *testing.T) {
 	defer cancel()
 
 	assert.Equal(t, errAgentNotStarted, agent.Stop(ctx))
-	assert.NoError(t, agent.Start(ctx))
+	require.NoError(t, agent.Start(ctx))
 
-	if err := agent.Start(ctx); err != errAgentStarted {
-		t.Fatalf("expected agent started error: %v", err)
-	}
+	err = agent.Start(ctx)
+	require.Equalf(t, err, errAgentStarted, "expected agent started error: %v", err)
 
-	assert.NoError(t, agent.Stop(ctx))
+	require.NoError(t, agent.Stop(ctx))
 }
 
 func TestHandleSessionMessageNetworkManagerChanges(t *testing.T) {
@@ -429,9 +428,9 @@ func TestAgentExitsBasedOnSessionTracker(t *testing.T) {
 	}
 
 	establishedSessions, errCounter, closeClounter := tracker.Stats()
-	require.Equal(t, establishedSessions, 0)
-	require.Equal(t, errCounter, 3)
-	require.Equal(t, closeClounter, 3)
+	require.Equal(t, 0, establishedSessions)
+	require.Equal(t, 3, errCounter)
+	require.Equal(t, 3, closeClounter)
 	currSession, closedSessions := tester.dispatcher.GetSessions()
 	require.Nil(t, currSession)
 	require.Len(t, closedSessions, 3)
@@ -461,11 +460,11 @@ func TestAgentRegistersSessionsWithSessionTracker(t *testing.T) {
 		}
 		return nil
 	}, 3*time.Millisecond))
-	require.Equal(t, errCounter, 0)
-	require.Equal(t, closeCounter, 0)
+	require.Equal(t, 0, errCounter)
+	require.Equal(t, 0, closeCounter)
 	currSession, closedSessions := tester.dispatcher.GetSessions()
 	require.NotNil(t, currSession)
-	require.Len(t, closedSessions, 0)
+	require.Empty(t, closedSessions)
 }
 
 type agentTester struct {

agent/csi/volume_manager_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/moby/swarmkit/v2/api"
 	"github.com/moby/swarmkit/v2/volumequeue"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -84,10 +85,10 @@ func TestTaskRestrictedVolumesProvider(t *testing.T) {
 
 			volume, err := volumesGetter.Get(testCase.volumeID)
 			if testCase.expectedErr != "" {
-				assert.Error(t, err, testCase.desc)
+				require.Error(t, err, testCase.desc)
 				assert.Equal(t, testCase.expectedErr, err.Error())
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.NotEmpty(t, volume)
 			}
 		})

agent/exec/controller_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/moby/swarmkit/v2/api"
 	"github.com/moby/swarmkit/v2/log"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestResolve(t *testing.T) {
@@ -21,14 +22,14 @@ func TestResolve(t *testing.T) {
 	)
 
 	_, status, err := Resolve(ctx, task, executor)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, api.TaskStateAccepted, status.State)
 	assert.Equal(t, "accepted", status.Message)
 
 	task.Status = *status
 	// now, we get no status update.
 	_, status, err = Resolve(ctx, task, executor)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, task.Status, *status)
 
 	// now test an error causing rejection
@@ -56,7 +57,7 @@ func TestResolve(t *testing.T) {
 	task.Status = *status
 	executor.err = nil
 	_, status, err = Resolve(ctx, task, executor)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, task.Status, *status)
 }
 
@@ -138,7 +139,7 @@ func TestPrepareFailure(t *testing.T) {
 	)
 	defer func() {
 		finish()
-		assert.Equal(t, ctlr.calls["Prepare"], 1)
+		assert.Equal(t, 1, ctlr.calls["Prepare"])
 	}()
 	ctlr.PrepareFn = func(_ context.Context) error {
 		return errors.New("test error")
@@ -461,22 +462,20 @@ func checkDo(ctx context.Context, t *testing.T, task *api.Task, ctlr Controller,
 	if len(expectedErr) > 0 {
 		assert.Equal(t, expectedErr[0], err)
 	} else {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	// if the status and task.Status are different, make sure new timestamp is greater
 	if task.Status.Timestamp != nil {
 		// crazy timestamp validation follows
 		previous, err := gogotypes.TimestampFromProto(task.Status.Timestamp)
-		assert.Nil(t, err)
+		require.NoError(t, err)
 
 		current, err := gogotypes.TimestampFromProto(status.Timestamp)
-		assert.Nil(t, err)
+		require.NoError(t, err)
 
-		if current.Before(previous) {
-			// ensure that the timestamp always proceeds forward
-			t.Fatalf("timestamp must proceed forward: %v < %v", current, previous)
-		}
+		// ensure that the timestamp always proceeds forward
+		require.Falsef(t, current.Before(previous), "timestamp must proceed forward: %v < %v", current, previous)
 	}
 
 	copy := status.Copy()

agent/exec/errors_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestIsTemporary(t *testing.T) {
@@ -15,13 +16,7 @@ func TestIsTemporary(t *testing.T) {
 	err4 := fmt.Errorf("err4: %w", err3)
 	err5 := errors.Wrap(err4, "err5")
 
-	if IsTemporary(nil) {
-		t.Error("expected error to not be a temporary error")
-	}
-	if IsTemporary(err) {
-		t.Error("expected error to not be a temporary error")
-	}
-	if !IsTemporary(err5) {
-		t.Error("expected error to be a temporary error")
-	}
+	assert.False(t, IsTemporary(nil), "expected error to not be a temporary error")
+	assert.False(t, IsTemporary(err), "expected error to not be a temporary error")
+	assert.True(t, IsTemporary(err5), "expected error to be a temporary error")
 }

agent/reporter_test.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/moby/swarmkit/v2/api"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type uniqueStatus struct {
@@ -41,9 +42,8 @@ func TestReporter(t *testing.T) {
 
 				key := uniqueStatus{taskID, status}
 				// make sure we get the status only once.
-				if _, ok := unique[key]; ok {
-					t.Fatal("encountered status twice")
-				}
+				_, ok := unique[key]
+				require.False(t, ok, "encountered status twice")
 
 				if status.State == api.TaskStateCompleted {
 					wg.Done()
@@ -81,15 +81,15 @@ func TestReporter(t *testing.T) {
 			// simulate pounding this with a bunch of goroutines
 			go func() {
 				if err := reporter.UpdateTaskStatus(ctx, taskID, status); err != nil {
-					assert.NoError(t, err, "sending should not fail")
+					require.NoError(t, err, "sending should not fail")
 				}
 			}()
 
 		}
 	}
 
 	wg.Wait() // wait for the propagation
-	assert.NoError(t, reporter.Close())
+	require.NoError(t, reporter.Close())
 	mu.Lock()
 	defer mu.Unlock()
 

agent/secrets/secrets_test.go

@@ -98,11 +98,11 @@ func TestTaskRestrictedSecretsProvider(t *testing.T) {
 		(secretsGetter.(*taskRestrictedSecretsProvider)).secretIDs = testCase.secretIDs
 		secret, err := secretsGetter.Get(testCase.secretIDToGet)
 		if testCase.expectedErr != "" {
-			assert.Error(t, err, testCase.desc)
+			require.Error(t, err, testCase.desc)
 			assert.Equal(t, testCase.expectedErr, err.Error(), testCase.desc)
 		} else {
 			t.Logf("secretIDs=%v", testCase.secretIDs)
-			assert.NoError(t, err, testCase.desc)
+			require.NoError(t, err, testCase.desc)
 			require.NotNil(t, secret, testCase.desc)
 			require.NotNil(t, secret.Spec, testCase.desc)
 			require.NotNil(t, secret.Spec.Data, testCase.desc)

agent/storage_test.go

@@ -10,15 +10,16 @@ import (
 	"github.com/moby/swarmkit/v2/api"
 	"github.com/moby/swarmkit/v2/identity"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	bolt "go.etcd.io/bbolt"
 )
 
 func TestStorageInit(t *testing.T) {
 	db, cleanup := storageTestEnv(t)
 	defer cleanup()
 
-	assert.NoError(t, InitDB(db)) // ensure idempotence.
-	assert.NoError(t, db.View(func(tx *bolt.Tx) error {
+	require.NoError(t, InitDB(db)) // ensure idempotence.
+	require.NoError(t, db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(bucketKeyStorageVersion)
 		assert.NotNil(t, bkt)
 
@@ -35,20 +36,20 @@ func TestStoragePutGet(t *testing.T) {
 
 	tasks := genTasks(20)
 
-	assert.NoError(t, db.Update(func(tx *bolt.Tx) error {
+	require.NoError(t, db.Update(func(tx *bolt.Tx) error {
 		for i, task := range tasks {
-			assert.NoError(t, PutTask(tx, task))
+			require.NoError(t, PutTask(tx, task))
 			// remove status to make comparison work
 			tasks[i].Status = api.TaskStatus{}
 		}
 
 		return nil
 	}))
 
-	assert.NoError(t, db.View(func(tx *bolt.Tx) error {
+	require.NoError(t, db.View(func(tx *bolt.Tx) error {
 		for _, task := range tasks {
 			retrieved, err := GetTask(tx, task.ID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, task, retrieved)
 		}
 
@@ -63,24 +64,24 @@ func TestStoragePutGetStatusAssigned(t *testing.T) {
 	tasks := genTasks(20)
 
 	// set task, status and assignment for all tasks.
-	assert.NoError(t, db.Update(func(tx *bolt.Tx) error {
+	require.NoError(t, db.Update(func(tx *bolt.Tx) error {
 		for _, task := range tasks {
-			assert.NoError(t, PutTask(tx, task))
-			assert.NoError(t, PutTaskStatus(tx, task.ID, &task.Status))
-			assert.NoError(t, SetTaskAssignment(tx, task.ID, true))
+			require.NoError(t, PutTask(tx, task))
+			require.NoError(t, PutTaskStatus(tx, task.ID, &task.Status))
+			require.NoError(t, SetTaskAssignment(tx, task.ID, true))
 		}
 
 		return nil
 	}))
 
-	assert.NoError(t, db.View(func(tx *bolt.Tx) error {
+	require.NoError(t, db.View(func(tx *bolt.Tx) error {
 		for _, task := range tasks {
 			status, err := GetTaskStatus(tx, task.ID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, &task.Status, status)
 
 			retrieved, err := GetTask(tx, task.ID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			task.Status = api.TaskStatus{}
 			assert.Equal(t, task, retrieved)
@@ -92,27 +93,27 @@ func TestStoragePutGetStatusAssigned(t *testing.T) {
 	}))
 
 	// set evens to unassigned and updates all states plus one
-	assert.NoError(t, db.Update(func(tx *bolt.Tx) error {
+	require.NoError(t, db.Update(func(tx *bolt.Tx) error {
 		for i, task := range tasks {
 			task.Status.State++
-			assert.NoError(t, PutTaskStatus(tx, task.ID, &task.Status))
+			require.NoError(t, PutTaskStatus(tx, task.ID, &task.Status))
 
 			if i%2 == 0 {
-				assert.NoError(t, SetTaskAssignment(tx, task.ID, false))
+				require.NoError(t, SetTaskAssignment(tx, task.ID, false))
 			}
 		}
 
 		return nil
 	}))
 
-	assert.NoError(t, db.View(func(tx *bolt.Tx) error {
+	require.NoError(t, db.View(func(tx *bolt.Tx) error {
 		for i, task := range tasks {
 			status, err := GetTaskStatus(tx, task.ID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, &task.Status, status)
 
 			retrieved, err := GetTask(tx, task.ID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			task.Status = api.TaskStatus{}
 			assert.Equal(t, task, retrieved)
@@ -178,13 +179,13 @@ func storageTestEnv(t *testing.T) (*bolt.DB, func()) {
 	var cleanup []func()
 	dir := t.TempDir()
 	dbpath := filepath.Join(dir, "tasks.db")
-	assert.NoError(t, os.MkdirAll(dir, 0o777))
+	require.NoError(t, os.MkdirAll(dir, 0o777))
 
 	db, err := bolt.Open(dbpath, 0666, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	cleanup = append(cleanup, func() { db.Close() })
 
-	assert.NoError(t, InitDB(db))
+	require.NoError(t, InitDB(db))
 	return db, func() {
 		// iterate in reverse so it works like defer
 		for i := len(cleanup) - 1; i >= 0; i-- {

agent/task_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/moby/swarmkit/v2/api"
 	"github.com/moby/swarmkit/v2/log"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const debugLevel = 5
@@ -70,22 +71,22 @@ func TestTaskManager(t *testing.T) {
 		select {
 		case <-acceptedWait:
 			task.DesiredState = api.TaskStateReady // proceed to ready
-			assert.NoError(t, tm.Update(ctx, task))
+			require.NoError(t, tm.Update(ctx, task))
 			acceptedWait = nil
 		case <-readyWait:
 			time.Sleep(time.Second)
 			task.DesiredState = api.TaskStateRunning // proceed to running.
-			assert.NoError(t, tm.Update(ctx, task))
+			require.NoError(t, tm.Update(ctx, task))
 			readyWait = nil
 		case <-shutdownWait:
-			assert.NoError(t, tm.Close())
+			require.NoError(t, tm.Close())
 			select {
 			case <-tm.closed:
 			default:
 				t.Fatal("not actually closed")
 			}
 
-			assert.NoError(t, tm.Close()) // hit a second time to make sure it behaves
+			require.NoError(t, tm.Close()) // hit a second time to make sure it behaves
 			assert.Equal(t, tm.Update(ctx, task), ErrClosed)
 
 			assert.Equal(t, map[string]int{