[v14] Remove use of require assertions inside Eventually calls

e2e/aws/rds_test.go

@@ -190,7 +190,7 @@ func postgresConnTestFn(cluster *helpers.TeleInstance) dbConnectionTestFunc {
 		var pgConn *pgconn.PgConn
 		// retry for a while, the database service might need time to give
 		// itself IAM rds:connect permissions.
-		require.EventuallyWithT(t, func(c *assert.CollectT) {
+		require.EventuallyWithT(t, func(t *assert.CollectT) {
 			var err error
 			pgConn, err = postgres.MakeTestClient(ctx, common.TestClientConfig{
 				AuthClient:      cluster.GetSiteAPI(cluster.Secrets.SiteName),
@@ -200,8 +200,8 @@ func postgresConnTestFn(cluster *helpers.TeleInstance) dbConnectionTestFunc {
 				Username:        username,
 				RouteToDatabase: route,
 			})
-			assert.NoError(c, err)
-			assert.NotNil(c, pgConn)
+			assert.NoError(t, err)
+			assert.NotNil(t, pgConn)
 		}, time.Second*10, time.Second, "connecting to postgres")
 
 		// Execute a query.
@@ -229,11 +229,11 @@ func postgresLocalProxyConnTestFn(cluster *helpers.TeleInstance) dbConnectionTes
 		var pgConn *pgconn.PgConn
 		// retry for a while, the database service might need time to give
 		// itself IAM rds:connect permissions.
-		require.EventuallyWithT(t, func(c *assert.CollectT) {
+		require.EventuallyWithT(t, func(t *assert.CollectT) {
 			var err error
 			pgConn, err = pgconn.Connect(ctx, connString)
-			assert.NoError(c, err)
-			assert.NotNil(c, pgConn)
+			assert.NoError(t, err)
+			assert.NotNil(t, pgConn)
 		}, time.Second*10, time.Second, "connecting to postgres")
 
 		// Execute a query.
@@ -259,11 +259,11 @@ func mySQLLocalProxyConnTestFn(cluster *helpers.TeleInstance) dbConnectionTestFu
 		var conn *mysqlclient.Conn
 		// retry for a while, the database service might need time to give
 		// itself IAM rds:connect permissions.
-		require.EventuallyWithT(t, func(c *assert.CollectT) {
+		require.EventuallyWithT(t, func(t *assert.CollectT) {
 			var err error
 			conn, err = mysqlclient.Connect(lp.GetAddr(), route.Username, "" /*no password*/, route.Database)
-			assert.NoError(c, err)
-			assert.NotNil(c, conn)
+			assert.NoError(t, err)
+			assert.NotNil(t, conn)
 		}, time.Second*10, time.Second, "connecting to mysql")
 
 		// Execute a query.
@@ -329,11 +329,12 @@ func generateClientDBCert(t *testing.T, authSrv *auth.Server, user string, route
 }
 
 func waitForDatabases(t *testing.T, auth *service.TeleportProcess, wantNames ...string) {
-	require.EventuallyWithT(t, func(c *assert.CollectT) {
+	require.EventuallyWithT(t, func(t *assert.CollectT) {
 		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
+
 		databases, err := auth.GetAuthServer().GetDatabases(ctx)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 
 		// map the registered "db" resource names.
 		seen := map[string]struct{}{}
@@ -347,11 +348,12 @@ func waitForDatabases(t *testing.T, auth *service.TeleportProcess, wantNames ...
 }
 
 func waitForDatabaseServers(t *testing.T, auth *service.TeleportProcess, wantNames ...string) {
-	require.EventuallyWithT(t, func(c *assert.CollectT) {
+	require.EventuallyWithT(t, func(t *assert.CollectT) {
 		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
+
 		servers, err := auth.GetAuthServer().GetDatabaseServers(ctx, apidefaults.Namespace)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 
 		// map the registered "db_server" resource names.
 		seen := map[string]struct{}{}

integration/appaccess/pack.go

@@ -31,6 +31,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/gorilla/websocket"
 	"github.com/gravitational/trace"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/gravitational/teleport"
@@ -892,20 +893,22 @@ func (p *Pack) startLeafAppServers(t *testing.T, count int, opts AppTestOptions)
 }
 
 func waitForAppRegInRemoteSiteCache(t *testing.T, tunnel reversetunnelclient.Server, clusterName string, cfgApps []servicecfg.App, hostUUID string) {
-	require.Eventually(t, func() bool {
+	require.EventuallyWithT(t, func(t *assert.CollectT) {
 		site, err := tunnel.GetSite(clusterName)
-		require.NoError(t, err)
+		assert.NoError(t, err)
+
 		ap, err := site.CachingAccessPoint()
-		require.NoError(t, err)
+		assert.NoError(t, err)
+
 		apps, err := ap.GetApplicationServers(context.Background(), apidefaults.Namespace)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 
 		counter := 0
 		for _, v := range apps {
 			if v.GetHostID() == hostUUID {
 				counter++
 			}
 		}
-		return len(cfgApps) == counter
+		assert.Len(t, cfgApps, counter)
 	}, time.Minute*2, time.Millisecond*200)
 }

integration/ec2_test.go

@@ -31,9 +31,12 @@ import (
 	"github.com/gravitational/trace"
 	"github.com/jonboulle/clockwork"
 	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/gravitational/teleport/api/breaker"
+	apiclient "github.com/gravitational/teleport/api/client"
+	"github.com/gravitational/teleport/api/client/proto"
 	apidefaults "github.com/gravitational/teleport/api/defaults"
 	"github.com/gravitational/teleport/api/types"
 	"github.com/gravitational/teleport/integration/helpers"
@@ -208,8 +211,7 @@ func TestEC2NodeJoin(t *testing.T) {
 
 	// the node should eventually join the cluster and heartbeat
 	require.Eventually(t, func() bool {
-		nodes, err := authServer.GetNodes(ctx, apidefaults.Namespace)
-		require.NoError(t, err)
+		nodes, _ := authServer.GetNodes(ctx, apidefaults.Namespace)
 		return len(nodes) > 0
 	}, time.Minute, time.Second, "waiting for node to join cluster")
 }
@@ -267,12 +269,11 @@ func TestIAMNodeJoin(t *testing.T) {
 	t.Cleanup(func() { require.NoError(t, proxySvc.Close()) })
 
 	// the proxy should eventually join the cluster and heartbeat
-	require.Eventually(t, func() bool {
+	require.EventuallyWithT(t, func(t *assert.CollectT) {
 		proxies, err := authServer.GetProxies()
-		require.NoError(t, err)
-		return len(proxies) > 0
+		assert.NoError(t, err)
+		assert.NotEmpty(t, proxies)
 	}, time.Minute, time.Second, "waiting for proxy to join cluster")
-
 	// InsecureDevMode needed for node to trust proxy
 	wasInsecureDevMode := lib.IsInsecureDevMode()
 	t.Cleanup(func() { lib.SetInsecureDevMode(wasInsecureDevMode) })
@@ -292,10 +293,10 @@ func TestIAMNodeJoin(t *testing.T) {
 	t.Cleanup(func() { require.NoError(t, nodeSvc.Close()) })
 
 	// the node should eventually join the cluster and heartbeat
-	require.Eventually(t, func() bool {
+	require.EventuallyWithT(t, func(t *assert.CollectT) {
 		nodes, err := authServer.GetNodes(context.Background(), apidefaults.Namespace)
-		require.NoError(t, err)
-		return len(nodes) > 0
+		assert.NoError(t, err)
+		assert.NotEmpty(t, nodes)
 	}, time.Minute, time.Second, "waiting for node to join cluster")
 }
 
@@ -389,22 +390,23 @@ func TestEC2Labels(t *testing.T) {
 	var apps []types.AppServer
 	var databases []types.DatabaseServer
 	var kubes []types.KubeServer
+
 	// Wait for everything to come online.
-	require.Eventually(t, func() bool {
+	require.EventuallyWithT(t, func(t *assert.CollectT) {
 		var err error
 		nodes, err = authServer.GetNodes(ctx, tconf.SSH.Namespace)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		apps, err = authServer.GetApplicationServers(ctx, tconf.SSH.Namespace)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		databases, err = authServer.GetDatabaseServers(ctx, tconf.SSH.Namespace)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		kubes, err = authServer.GetKubernetesServers(ctx)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 
 		// dedupClusters is required because GetKubernetesServers returns duplicated servers
 		// because it lists the KindKubeServer and KindKubeService.
 		// We must remove this once legacy heartbeat is removed.
-		// DELETE IN 13.0.0
+		// DELETE IN 13.0.0 (tigrato)
 		var dedupClusters []types.KubeServer
 		dedup := map[string]struct{}{}
 		for _, kube := range kubes {
@@ -415,33 +417,51 @@ func TestEC2Labels(t *testing.T) {
 			dedupClusters = append(dedupClusters, kube)
 		}
 
-		return len(nodes) == 1 && len(apps) == 1 && len(databases) == 1 && len(dedupClusters) == 1
+		assert.Len(t, nodes, 1)
+		assert.Len(t, apps, 1)
+		assert.Len(t, databases, 1)
+		assert.Len(t, dedupClusters, 1)
 	}, 10*time.Second, time.Second)
 
 	tagName := fmt.Sprintf("%s/Name", labels.AWSLabelNamespace)
 
 	// Check that EC2 labels were applied.
-	require.Eventually(t, func() bool {
+	require.EventuallyWithT(t, func(t *assert.CollectT) {
 		node, err := authServer.GetNode(ctx, tconf.SSH.Namespace, nodes[0].GetName())
-		require.NoError(t, err)
+		assert.NoError(t, err)
+
 		_, nodeHasLabel := node.GetAllLabels()[tagName]
+		assert.True(t, nodeHasLabel)
+
 		apps, err := authServer.GetApplicationServers(ctx, tconf.SSH.Namespace)
-		require.NoError(t, err)
-		require.Len(t, apps, 1)
+		assert.NoError(t, err)
+		assert.Len(t, apps, 1)
+
 		app := apps[0].GetApp()
 		_, appHasLabel := app.GetAllLabels()[tagName]
+		assert.True(t, appHasLabel)
 
 		databases, err := authServer.GetDatabaseServers(ctx, tconf.SSH.Namespace)
-		require.NoError(t, err)
-		require.Len(t, databases, 1)
+		assert.NoError(t, err)
+		assert.Len(t, databases, 1)
+
 		database := databases[0].GetDatabase()
 		_, dbHasLabel := database.GetAllLabels()[tagName]
+		assert.True(t, dbHasLabel)
+
+		kubeResources, err := apiclient.GetResourcesWithFilters(
+			context.Background(), authServer,
+			proto.ListResourcesRequest{ResourceType: types.KindKubeServer},
+		)
+		assert.NoError(t, err)
+		assert.Len(t, kubeResources, 1)
+
+		kubeServers, err := types.ResourcesWithLabels(kubeResources).AsKubeServers()
+		assert.NoError(t, err)
 
-		kubeClusters := helpers.GetKubeClusters(t, authServer)
-		require.Len(t, kubeClusters, 1)
-		kube := kubeClusters[0]
+		kube := kubeServers[0].GetCluster()
 		_, kubeHasLabel := kube.GetStaticLabels()[tagName]
-		return nodeHasLabel && appHasLabel && dbHasLabel && kubeHasLabel
+		assert.True(t, kubeHasLabel)
 	}, 10*time.Second, time.Second)
 }
 

integrations/lib/testing/integration/setup.go

@@ -21,6 +21,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/gravitational/teleport/integrations/lib/logger"
@@ -120,10 +121,9 @@ func (s *SSHSetup) SetupService() {
 	require.True(t, ready, "ssh is not ready")
 
 	// Wait for node to show up on the server.
-	require.Eventually(t, func() bool {
+	require.EventuallyWithT(t, func(t *assert.CollectT) {
 		resources, err := s.Integration.tctl(s.Auth).GetAll(s.Context(), "nodes")
-		require.NoError(t, err)
-
-		return len(resources) != 0
+		assert.NoError(t, err)
+		assert.NotEmpty(t, resources)
 	}, 5*time.Second, time.Second)
 }

lib/cache/cache_test.go

@@ -30,6 +30,7 @@ import (
 	"github.com/gravitational/trace"
 	"github.com/jonboulle/clockwork"
 	log "github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/exp/slices"
 
@@ -968,18 +969,19 @@ func TestListResources_NodesTTLVariant(t *testing.T) {
 		Field:  types.ResourceMetadataName,
 		IsDesc: true,
 	}
-	require.Eventually(t, func() bool {
+	require.EventuallyWithT(t, func(t *assert.CollectT) {
 		resp, err := p.cache.ListResources(ctx, proto.ListResourcesRequest{
 			Namespace:    apidefaults.Namespace,
 			ResourceType: types.KindNode,
 			StartKey:     listResourcesStartKey,
 			Limit:        int32(pageSize),
 			SortBy:       sortBy,
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
+
 		resources = append(resources, resp.Resources...)
 		listResourcesStartKey = resp.NextKey
-		return len(resources) == nodeCount
+		assert.Len(t, resources, nodeCount)
 	}, 5*time.Second, 100*time.Millisecond)
 
 	servers, err := types.ResourcesWithLabels(resources).AsServers()
@@ -2213,7 +2215,7 @@ func testResources[T types.Resource](t *testing.T, p *testPack, funcs testFuncs[
 	require.Eventually(t, func() bool {
 		// Make sure the cache has a single resource in it.
 		out, err = funcs.cacheList(ctx)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		return len(cmp.Diff([]T{r}, out, cmpOpts...)) == 0
 	}, time.Second*2, time.Millisecond*250)
 
@@ -2240,7 +2242,7 @@ func testResources[T types.Resource](t *testing.T, p *testPack, funcs testFuncs[
 	require.Eventually(t, func() bool {
 		// Make sure the cache has a single resource in it.
 		out, err = funcs.cacheList(ctx)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		return len(cmp.Diff([]T{r}, out, cmpOpts...)) == 0
 	}, time.Second*2, time.Millisecond*250)
 
@@ -2252,7 +2254,7 @@ func testResources[T types.Resource](t *testing.T, p *testPack, funcs testFuncs[
 	require.Eventually(t, func() bool {
 		// Check that the cache is now empty.
 		out, err = funcs.cacheList(ctx)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		return len(out) == 0
 	}, time.Second*2, time.Millisecond*250)
 }
@@ -2805,12 +2807,10 @@ func TestInvalidDatabases(t *testing.T) {
 				require.NoError(t, err)
 
 				// Wait until the database appear on cache.
-				require.Eventually(t, func() bool {
-					if dbs, err := c.GetDatabases(ctx); err == nil {
-						return len(dbs) == 1
-					}
-
-					return false
+				require.EventuallyWithT(t, func(t *assert.CollectT) {
+					dbs, err := c.GetDatabases(ctx)
+					assert.NoError(t, err)
+					assert.Len(t, dbs, 1)
 				}, time.Second, 100*time.Millisecond, "expected database to be on cache, but nothing found")
 
 				cacheDB, err := c.GetDatabase(ctx, dbName)

lib/srv/db/server_test.go

@@ -409,10 +409,10 @@ func TestCloseWithActiveConnections(t *testing.T) {
 	server, connErrCh, _ := databaseServerWithActiveConnection(t, ctx)
 
 	require.NoError(t, server.Close())
-	require.EventuallyWithT(t, func(c *assert.CollectT) {
+	require.EventuallyWithT(t, func(t *assert.CollectT) {
 		select {
 		case err := <-connErrCh:
-			assert.ErrorIs(c, err, io.ErrUnexpectedEOF)
+			assert.ErrorIs(t, err, io.ErrUnexpectedEOF)
 		default:
 		}
 	}, time.Second, 100*time.Millisecond)