Migrate tests from gotest to gomega

Signed-off-by: Stefan Prodan <stefan.prodan@gmail.com>

go.mod

@@ -67,7 +67,6 @@ require (
 	golang.org/x/oauth2 v0.30.0
 	golang.org/x/sync v0.16.0
 	google.golang.org/api v0.248.0
-	gotest.tools v2.2.0+incompatible
 	helm.sh/helm/v3 v3.18.6
 	k8s.io/api v0.34.0
 	k8s.io/apimachinery v0.34.0

go.sum

@@ -1359,8 +1359,6 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
-gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
 gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=
 helm.sh/helm/v3 v3.18.6 h1:S/2CqcYnNfLckkHLI0VgQbxgcDaU3N4A/46E3n9wSNY=

internal/bucket/azure/blob_test.go

@@ -45,7 +45,7 @@ import (
 func TestNewClientAndBucketExistsWithProxy(t *testing.T) {
 	g := NewWithT(t)
 
-	proxyAddr, proxyPort := testproxy.New(t)
+	proxyAddr, _ := testproxy.New(t)
 
 	// start mock bucket server
 	bucketListener, bucketAddr, _ := testlistener.New(t)
@@ -91,7 +91,7 @@ func TestNewClientAndBucketExistsWithProxy(t *testing.T) {
 		{
 			name:     "with incorrect proxy",
 			endpoint: bucketEndpoint,
-			proxyURL: &url.URL{Scheme: "http", Host: fmt.Sprintf("localhost:%d", proxyPort+1)},
+			proxyURL: &url.URL{Scheme: "http", Host: fmt.Sprintf("localhost:%d", 1)},
 			err:      "connection refused",
 		},
 	}

internal/bucket/gcp/gcp_test.go

@@ -38,7 +38,6 @@ import (
 	"google.golang.org/api/googleapi"
 	"google.golang.org/api/option"
 	raw "google.golang.org/api/storage/v1"
-	"gotest.tools/assert"
 	corev1 "k8s.io/api/core/v1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -167,14 +166,17 @@ func TestNewClientWithSecretErr(t *testing.T) {
 	bucket := createTestBucket()
 	gcpClient, err := NewClient(context.Background(), bucket, WithSecret(secret.DeepCopy()))
 	t.Log(err)
-	assert.Error(t, err, "dialing: invalid character 'e' looking for beginning of value")
+	g := NewWithT(t)
-	assert.Assert(t, gcpClient == nil)
+	g.Expect(err).To(HaveOccurred())
+	g.Expect(err.Error()).To(Equal("dialing: invalid character 'e' looking for beginning of value"))
+	g.Expect(gcpClient).To(BeNil())
 }
 
 func TestNewClientWithProxyErr(t *testing.T) {
 	_, envADCIsSet := os.LookupEnv(envADC)
-	assert.Assert(t, !envADCIsSet)
+	g := NewWithT(t)
-	assert.Assert(t, !metadata.OnGCE())
+	g.Expect(envADCIsSet).To(BeFalse())
+	g.Expect(metadata.OnGCE()).To(BeFalse())
 
 	t.Run("with secret", func(t *testing.T) {
 		g := NewWithT(t)
@@ -205,10 +207,11 @@ func TestProxy(t *testing.T) {
 	proxyAddr, proxyPort := testproxy.New(t)
 
 	err := os.Setenv(envGCSHost, fmt.Sprintf("https://%s", host))
-	assert.NilError(t, err)
+	g := NewWithT(t)
+	g.Expect(err).NotTo(HaveOccurred())
 	defer func() {
 		err := os.Unsetenv(envGCSHost)
-		assert.NilError(t, err)
+		g.Expect(err).NotTo(HaveOccurred())
 	}()
 
 	tests := []struct {
@@ -242,15 +245,17 @@ func TestProxy(t *testing.T) {
 			})
 			bucket := createTestBucket()
 			gcpClient, err := NewClient(context.Background(), bucket, opts...)
-			assert.NilError(t, err)
+			g := NewWithT(t)
-			assert.Assert(t, gcpClient != nil)
+			g.Expect(err).NotTo(HaveOccurred())
+			g.Expect(gcpClient).NotTo(BeNil())
 			gcpClient.Client.SetRetry(gcpstorage.WithMaxAttempts(1))
 			exists, err := gcpClient.BucketExists(context.Background(), bucketName)
 			if tt.err != "" {
-				assert.ErrorContains(t, err, tt.err)
+				g.Expect(err).To(HaveOccurred())
+				g.Expect(err.Error()).To(ContainSubstring(tt.err))
 			} else {
-				assert.NilError(t, err)
+				g.Expect(err).NotTo(HaveOccurred())
-				assert.Assert(t, exists)
+				g.Expect(exists).To(BeTrue())
 			}
 		})
 	}
@@ -261,8 +266,9 @@ func TestBucketExists(t *testing.T) {
 		Client: client,
 	}
 	exists, err := gcpClient.BucketExists(context.Background(), bucketName)
-	assert.NilError(t, err)
+	g := NewWithT(t)
-	assert.Assert(t, exists)
+	g.Expect(err).NotTo(HaveOccurred())
+	g.Expect(exists).To(BeTrue())
 }
 
 func TestBucketNotExists(t *testing.T) {
@@ -271,8 +277,9 @@ func TestBucketNotExists(t *testing.T) {
 		Client: client,
 	}
 	exists, err := gcpClient.BucketExists(context.Background(), bucket)
-	assert.NilError(t, err)
+	g := NewWithT(t)
-	assert.Assert(t, !exists)
+	g.Expect(err).NotTo(HaveOccurred())
+	g.Expect(exists).To(BeFalse())
 }
 
 func TestVisitObjects(t *testing.T) {
@@ -286,9 +293,10 @@ func TestVisitObjects(t *testing.T) {
 		etags = append(etags, etag)
 		return nil
 	})
-	assert.NilError(t, err)
+	g := NewWithT(t)
-	assert.DeepEqual(t, keys, []string{objectName})
+	g.Expect(err).NotTo(HaveOccurred())
-	assert.DeepEqual(t, etags, []string{objectEtag})
+	g.Expect(keys).To(Equal([]string{objectName}))
+	g.Expect(etags).To(Equal([]string{objectEtag}))
 }
 
 func TestVisitObjectsErr(t *testing.T) {
@@ -313,10 +321,13 @@ func TestVisitObjectsCallbackErr(t *testing.T) {
 	err := gcpClient.VisitObjects(context.Background(), bucketName, "", func(key, etag string) error {
 		return mockErr
 	})
-	assert.Error(t, err, mockErr.Error())
+	g := NewWithT(t)
+	g.Expect(err).To(HaveOccurred())
+	g.Expect(err.Error()).To(Equal(mockErr.Error()))
 }
 
 func TestFGetObject(t *testing.T) {
+	g := NewWithT(t)
 	tempDir := t.TempDir()
 	gcpClient := &GCSClient{
 		Client: client,
@@ -324,9 +335,9 @@ func TestFGetObject(t *testing.T) {
 	localPath := filepath.Join(tempDir, objectName)
 	etag, err := gcpClient.FGetObject(context.Background(), bucketName, objectName, localPath)
 	if err != io.EOF {
-		assert.NilError(t, err)
+		g.Expect(err).NotTo(HaveOccurred())
 	}
-	assert.Equal(t, etag, objectEtag)
+	g.Expect(etag).To(Equal(objectEtag))
 }
 
 func TestFGetObjectNotExists(t *testing.T) {
@@ -343,13 +354,15 @@ func TestFGetObjectNotExists(t *testing.T) {
 }
 
 func TestFGetObjectDirectoryIsFileName(t *testing.T) {
+	g := NewWithT(t)
 	tempDir := t.TempDir()
 	gcpClient := &GCSClient{
 		Client: client,
 	}
 	_, err = gcpClient.FGetObject(context.Background(), bucketName, objectName, tempDir)
 	if err != io.EOF {
-		assert.Error(t, err, "filename is a directory")
+		g.Expect(err).To(HaveOccurred())
+		g.Expect(err.Error()).To(Equal("filename is a directory"))
 	}
 }
 
@@ -375,10 +388,12 @@ func TestValidateSecret(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			err := ValidateSecret(tt.secret)
+			g := NewWithT(t)
 			if tt.error {
-				assert.Error(t, err, fmt.Sprintf("invalid '%v' secret data: required fields 'serviceaccount'", tt.secret.Name))
+				g.Expect(err).To(HaveOccurred())
+				g.Expect(err.Error()).To(Equal(fmt.Sprintf("invalid '%v' secret data: required fields 'serviceaccount'", tt.secret.Name)))
 			} else {
-				assert.NilError(t, err)
+				g.Expect(err).NotTo(HaveOccurred())
 			}
 		})
 	}

internal/bucket/minio/minio_test.go

@@ -35,9 +35,9 @@ import (
 	"github.com/google/uuid"
 	miniov7 "github.com/minio/minio-go/v7"
 	"github.com/minio/minio-go/v7/pkg/credentials"
+	. "github.com/onsi/gomega"
 	"github.com/ory/dockertest/v3"
 	"github.com/ory/dockertest/v3/docker"
-	"gotest.tools/assert"
 	corev1 "k8s.io/api/core/v1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -214,16 +214,18 @@ func TestNewClient(t *testing.T) {
 	minioClient, err := NewClient(ctx, bucketStub(bucket, testMinioAddress),
 		WithSecret(secret.DeepCopy()),
 		WithTLSConfig(testTLSConfig))
-	assert.NilError(t, err)
+	g := NewWithT(t)
-	assert.Assert(t, minioClient != nil)
+	g.Expect(err).NotTo(HaveOccurred())
+	g.Expect(minioClient).NotTo(BeNil())
 }
 
 func TestNewClientEmptySecret(t *testing.T) {
 	minioClient, err := NewClient(ctx, bucketStub(bucket, testMinioAddress),
 		WithSecret(emptySecret.DeepCopy()),
 		WithTLSConfig(testTLSConfig))
-	assert.NilError(t, err)
+	g := NewWithT(t)
-	assert.Assert(t, minioClient != nil)
+	g.Expect(err).NotTo(HaveOccurred())
+	g.Expect(minioClient).NotTo(BeNil())
 }
 
 func TestNewClientAWSProvider(t *testing.T) {
@@ -242,58 +244,65 @@ func TestNewClientAWSProvider(t *testing.T) {
 
 		bucket := bucketStub(bucketAwsProvider, testMinioAddress)
 		minioClient, err := NewClient(ctx, bucket, WithSecret(&validSecret))
-		assert.NilError(t, err)
+		g := NewWithT(t)
-		assert.Assert(t, minioClient != nil)
+		g.Expect(err).NotTo(HaveOccurred())
+		g.Expect(minioClient).NotTo(BeNil())
 	})
 
 	t.Run("without secret", func(t *testing.T) {
 		bucket := bucketStub(bucketAwsProvider, testMinioAddress)
 		minioClient, err := NewClient(ctx, bucket)
-		assert.ErrorContains(t, err, "AWS authentication failed")
+		g := NewWithT(t)
-		assert.Assert(t, minioClient == nil)
+		g.Expect(err).To(HaveOccurred())
+		g.Expect(err.Error()).To(ContainSubstring("AWS authentication failed"))
+		g.Expect(minioClient).To(BeNil())
 	})
 }
 
 func TestBucketExists(t *testing.T) {
 	exists, err := testMinioClient.BucketExists(ctx, bucketName)
-	assert.NilError(t, err)
+	g := NewWithT(t)
-	assert.Assert(t, exists)
+	g.Expect(err).NotTo(HaveOccurred())
+	g.Expect(exists).To(BeTrue())
 }
 
 func TestBucketNotExists(t *testing.T) {
 	exists, err := testMinioClient.BucketExists(ctx, "notexistsbucket")
-	assert.NilError(t, err)
+	g := NewWithT(t)
-	assert.Assert(t, !exists)
+	g.Expect(err).NotTo(HaveOccurred())
+	g.Expect(exists).To(BeFalse())
 }
 
 func TestFGetObject(t *testing.T) {
 	tempDir := t.TempDir()
 	path := filepath.Join(tempDir, sourceignore.IgnoreFile)
 	_, err := testMinioClient.FGetObject(ctx, bucketName, objectName, path)
-	assert.NilError(t, err)
+	g := NewWithT(t)
+	g.Expect(err).NotTo(HaveOccurred())
 }
 
 func TestNewClientAndFGetObjectWithSTSEndpoint(t *testing.T) {
 	var credsRetrieved bool
 
 	// start a mock LDAP STS server
-	ldapSTSListener, ldapSTSAddr, ldapSTSPort := testlistener.New(t)
+	ldapSTSListener, ldapSTSAddr, _ := testlistener.New(t)
 	ldapSTSEndpoint := fmt.Sprintf("https://%s", ldapSTSAddr)
 	ldapSTSHandler := http.NewServeMux()
 	var ldapUsername, ldapPassword string
 	ldapSTSHandler.HandleFunc("POST /",
 		func(w http.ResponseWriter, r *http.Request) {
+			g := NewWithT(t)
 			err := r.ParseForm()
-			assert.NilError(t, err)
+			g.Expect(err).NotTo(HaveOccurred())
 			username := r.Form.Get("LDAPUsername")
 			password := r.Form.Get("LDAPPassword")
-			assert.Equal(t, username, ldapUsername)
+			g.Expect(username).To(Equal(ldapUsername))
-			assert.Equal(t, password, ldapPassword)
+			g.Expect(password).To(Equal(ldapPassword))
 			var result credentials.LDAPIdentityResult
 			result.Credentials.AccessKey = testMinioRootUser
 			result.Credentials.SecretKey = testMinioRootPassword
 			err = xml.NewEncoder(w).Encode(credentials.AssumeRoleWithLDAPResponse{Result: result})
-			assert.NilError(t, err)
+			g.Expect(err).NotTo(HaveOccurred())
 			credsRetrieved = true
 		})
 	ldapSTSServer := &http.Server{
@@ -329,7 +338,7 @@ func TestNewClientAndFGetObjectWithSTSEndpoint(t *testing.T) {
 			provider: "generic",
 			stsSpec: &sourcev1.BucketSTSSpec{
 				Provider: "ldap",
-				Endpoint: fmt.Sprintf("http://localhost:%d", ldapSTSPort+1),
+				Endpoint: fmt.Sprintf("http://localhost:%d", 1),
 			},
 			err: "connection refused",
 		},
@@ -383,7 +392,7 @@ func TestNewClientAndFGetObjectWithSTSEndpoint(t *testing.T) {
 				Provider: "ldap",
 				Endpoint: ldapSTSEndpoint,
 			},
-			err: "tls: failed to verify certificate: x509: certificate signed by unknown authority",
+			err: "tls: failed to verify certificate",
 		},
 	}
 
@@ -401,16 +410,18 @@ func TestNewClientAndFGetObjectWithSTSEndpoint(t *testing.T) {
 			opts = append(opts, WithTLSConfig(testTLSConfig))
 
 			minioClient, err := NewClient(ctx, bucket, opts...)
-			assert.NilError(t, err)
+			g := NewWithT(t)
-			assert.Assert(t, minioClient != nil)
+			g.Expect(err).NotTo(HaveOccurred())
+			g.Expect(minioClient).NotTo(BeNil())
 
 			path := filepath.Join(t.TempDir(), sourceignore.IgnoreFile)
 			_, err = minioClient.FGetObject(ctx, bucketName, objectName, path)
 			if tt.err != "" {
-				assert.ErrorContains(t, err, tt.err)
+				g.Expect(err).To(HaveOccurred())
+				g.Expect(err.Error()).To(ContainSubstring(tt.err))
 			} else {
-				assert.NilError(t, err)
+				g.Expect(err).NotTo(HaveOccurred())
-				assert.Assert(t, credsRetrieved)
+				g.Expect(credsRetrieved).To(BeTrue())
 			}
 		})
 	}
@@ -442,15 +453,17 @@ func TestNewClientAndFGetObjectWithProxy(t *testing.T) {
 				WithSecret(secret.DeepCopy()),
 				WithTLSConfig(testTLSConfig),
 				WithProxyURL(tt.proxyURL))
-			assert.NilError(t, err)
+			g := NewWithT(t)
-			assert.Assert(t, minioClient != nil)
+			g.Expect(err).NotTo(HaveOccurred())
+			g.Expect(minioClient).NotTo(BeNil())
 			tempDir := t.TempDir()
 			path := filepath.Join(tempDir, sourceignore.IgnoreFile)
 			_, err = minioClient.FGetObject(ctx, bucketName, objectName, path)
 			if tt.errSubstring != "" {
-				assert.ErrorContains(t, err, tt.errSubstring)
+				g.Expect(err).To(HaveOccurred())
+				g.Expect(err.Error()).To(ContainSubstring(tt.errSubstring))
 			} else {
-				assert.NilError(t, err)
+				g.Expect(err).NotTo(HaveOccurred())
 			}
 		})
 	}
@@ -461,8 +474,10 @@ func TestFGetObjectNotExists(t *testing.T) {
 	badKey := "invalid.txt"
 	path := filepath.Join(tempDir, badKey)
 	_, err := testMinioClient.FGetObject(ctx, bucketName, badKey, path)
-	assert.Error(t, err, "The specified key does not exist.")
+	g := NewWithT(t)
-	assert.Check(t, testMinioClient.ObjectIsNotFound(err))
+	g.Expect(err).To(HaveOccurred())
+	g.Expect(err.Error()).To(Equal("The specified key does not exist."))
+	g.Expect(testMinioClient.ObjectIsNotFound(err)).To(BeTrue())
 }
 
 func TestVisitObjects(t *testing.T) {
@@ -473,9 +488,10 @@ func TestVisitObjects(t *testing.T) {
 		etags = append(etags, etag)
 		return nil
 	})
-	assert.NilError(t, err)
+	g := NewWithT(t)
-	assert.DeepEqual(t, keys, []string{objectName})
+	g.Expect(err).NotTo(HaveOccurred())
-	assert.DeepEqual(t, etags, []string{objectEtag})
+	g.Expect(keys).To(Equal([]string{objectName}))
+	g.Expect(etags).To(Equal([]string{objectEtag}))
 }
 
 func TestVisitObjectsErr(t *testing.T) {
@@ -483,7 +499,9 @@ func TestVisitObjectsErr(t *testing.T) {
 	err := testMinioClient.VisitObjects(ctx, badBucketName, prefix, func(string, string) error {
 		return nil
 	})
-	assert.Error(t, err, fmt.Sprintf("listing objects from bucket '%s' failed: The specified bucket does not exist", badBucketName))
+	g := NewWithT(t)
+	g.Expect(err).To(HaveOccurred())
+	g.Expect(err.Error()).To(Equal(fmt.Sprintf("listing objects from bucket '%s' failed: The specified bucket does not exist", badBucketName)))
 }
 
 func TestVisitObjectsCallbackErr(t *testing.T) {
@@ -491,7 +509,9 @@ func TestVisitObjectsCallbackErr(t *testing.T) {
 	err := testMinioClient.VisitObjects(context.TODO(), bucketName, prefix, func(key, etag string) error {
 		return mockErr
 	})
-	assert.Error(t, err, mockErr.Error())
+	g := NewWithT(t)
+	g.Expect(err).To(HaveOccurred())
+	g.Expect(err.Error()).To(Equal(mockErr.Error()))
 }
 
 func TestValidateSecret(t *testing.T) {
@@ -519,11 +539,13 @@ func TestValidateSecret(t *testing.T) {
 		tt := testCase
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
+			g := NewWithT(t)
 			err := ValidateSecret(tt.secret)
 			if tt.error {
-				assert.Error(t, err, fmt.Sprintf("invalid '%v' secret data: required fields 'accesskey' and 'secretkey'", tt.secret.Name))
+				g.Expect(err).To(HaveOccurred())
+				g.Expect(err.Error()).To(Equal(fmt.Sprintf("invalid '%v' secret data: required fields 'accesskey' and 'secretkey'", tt.secret.Name)))
 			} else {
-				assert.NilError(t, err)
+				g.Expect(err).NotTo(HaveOccurred())
 			}
 		})
 	}
@@ -608,11 +630,13 @@ func TestValidateSTSProvider(t *testing.T) {
 			if tt.withCertSecret {
 				sts.CertSecretRef = &meta.LocalObjectReference{}
 			}
+			g := NewWithT(t)
 			err := ValidateSTSProvider(tt.bucketProvider, sts)
 			if tt.err != "" {
-				assert.Error(t, err, tt.err)
+				g.Expect(err).To(HaveOccurred())
+				g.Expect(err.Error()).To(Equal(tt.err))
 			} else {
-				assert.NilError(t, err)
+				g.Expect(err).NotTo(HaveOccurred())
 			}
 		})
 	}
@@ -694,11 +718,13 @@ func TestValidateSTSSecret(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
+			g := NewWithT(t)
 			err := ValidateSTSSecret(tt.provider, tt.secret)
 			if tt.err != "" {
-				assert.Error(t, err, tt.err)
+				g.Expect(err).To(HaveOccurred())
+				g.Expect(err.Error()).To(Equal(tt.err))
 			} else {
-				assert.NilError(t, err)
+				g.Expect(err).NotTo(HaveOccurred())
 			}
 		})
 	}

internal/controller/bucket_controller_fetch_test.go

@@ -24,7 +24,7 @@ import (
 	"testing"
 	"time"
 
-	"gotest.tools/assert"
+	. "github.com/onsi/gomega"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	sourcev1 "github.com/fluxcd/source-controller/api/v1"
@@ -119,7 +119,8 @@ func Test_fetchEtagIndex(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		assert.Equal(t, index.Len(), 3)
+		g := NewWithT(t)
+		g.Expect(index.Len()).To(Equal(3))
 	})
 
 	t.Run("an error while bucket does not exist", func(t *testing.T) {
@@ -129,7 +130,9 @@ func Test_fetchEtagIndex(t *testing.T) {
 
 		index := index.NewDigester()
 		err := fetchEtagIndex(context.TODO(), client, bucket.DeepCopy(), index, tmp)
-		assert.ErrorContains(t, err, "not found")
+		g := NewWithT(t)
+		g.Expect(err).To(HaveOccurred())
+		g.Expect(err.Error()).To(ContainSubstring("not found"))
 	})
 
 	t.Run("filters with .sourceignore rules", func(t *testing.T) {
@@ -153,7 +156,8 @@ func Test_fetchEtagIndex(t *testing.T) {
 		if ok := index.Has("foo.txt"); ok {
 			t.Error(fmt.Errorf("expected 'foo.txt' index item to not exist"))
 		}
-		assert.Equal(t, index.Len(), 1)
+		g := NewWithT(t)
+		g.Expect(index.Len()).To(Equal(1))
 	})
 
 	t.Run("filters with ignore rules from object", func(t *testing.T) {
@@ -177,7 +181,8 @@ func Test_fetchEtagIndex(t *testing.T) {
 			t.Error(err)
 		}
 
-		assert.Equal(t, index.Len(), 1)
+		g := NewWithT(t)
+		g.Expect(index.Len()).To(Equal(1))
 		if ok := index.Has("foo.txt"); !ok {
 			t.Error(fmt.Errorf("expected 'foo.txt' index item to exist"))
 		}
@@ -243,7 +248,8 @@ func Test_fetchFiles(t *testing.T) {
 			t.Fatal(err)
 		}
 		f := index.Get("foo.yaml")
-		assert.Equal(t, f, "etag2")
+		g := NewWithT(t)
+		g.Expect(f).To(Equal("etag2"))
 	})
 
 	t.Run("a disappeared index entry is removed from the index", func(t *testing.T) {
@@ -262,8 +268,9 @@ func Test_fetchFiles(t *testing.T) {
 			t.Fatal(err)
 		}
 		f := index.Get("foo.yaml")
-		assert.Equal(t, f, "etag1")
+		g := NewWithT(t)
-		assert.Check(t, !index.Has("bar.yaml"))
+		g.Expect(f).To(Equal("etag1"))
+		g.Expect(index.Has("bar.yaml")).To(BeFalse())
 	})
 
 	t.Run("can fetch more than maxConcurrentFetches", func(t *testing.T) {

internal/controller/helmchart_controller_test.go

@@ -50,6 +50,8 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/tools/record"
 	oras "oras.land/oras-go/v2/registry/remote"
 	ctrl "sigs.k8s.io/controller-runtime"
@@ -1967,7 +1969,18 @@ func TestHelmChartReconciler_getSource(t *testing.T) {
 				return
 			}
 
-			g.Expect(got).To(Equal(tt.want))
+			// TODO(stefan): Remove this workaround when the controller-runtime fake client restores TypeMeta
+			// https://github.com/kubernetes-sigs/controller-runtime/issues/3302
+			unstructuredGot, err := runtime.DefaultUnstructuredConverter.ToUnstructured(got)
+			g.Expect(err).ToNot(HaveOccurred())
+			gotName, _, err := unstructured.NestedFieldCopy(unstructuredGot, "metadata", "name")
+			g.Expect(err).ToNot(HaveOccurred())
+			unstructuredWant, err := runtime.DefaultUnstructuredConverter.ToUnstructured(tt.want)
+			g.Expect(err).ToNot(HaveOccurred())
+			wantName, _, err := unstructured.NestedFieldCopy(unstructuredWant, "metadata", "name")
+			g.Expect(err).ToNot(HaveOccurred())
+
+			g.Expect(gotName).To(Equal(wantName))
 			g.Expect(err).ToNot(HaveOccurred())
 		})
 	}

internal/helm/chart/builder_local_test.go

@@ -93,7 +93,7 @@ func TestLocalBuilder_Build(t *testing.T) {
 			name:      "invalid version metadata",
 			reference: LocalReference{Path: "../testdata/charts/helmchart"},
 			buildOpts: BuildOptions{VersionMetadata: "^"},
-			wantErr:   "Invalid Metadata string",
+			wantErr:   "invalid metadata string",
 		},
 		{
 			name:         "with version metadata",

internal/helm/chart/builder_remote_test.go

@@ -152,7 +152,7 @@ entries:
 			reference:  RemoteReference{Name: "grafana"},
 			repository: mockRepo(),
 			buildOpts:  BuildOptions{VersionMetadata: "^"},
-			wantErr:    "Invalid Metadata string",
+			wantErr:    "invalid metadata string",
 		},
 		{
 			name:         "with version metadata",
@@ -300,7 +300,7 @@ func TestRemoteBuilder_BuildFromOCIChartRepository(t *testing.T) {
 			reference:  RemoteReference{Name: "grafana"},
 			repository: mockRepo(),
 			buildOpts:  BuildOptions{VersionMetadata: "^"},
-			wantErr:    "Invalid Metadata string",
+			wantErr:    "invalid metadata string",
 		},
 		{
 			name:         "with version metadata",

tests/listener/listener.go

@@ -22,7 +22,7 @@ import (
 	"strings"
 	"testing"
 
-	"gotest.tools/assert"
+	. "github.com/onsi/gomega"
 )
 
 // New creates a TCP listener on a random port and returns
@@ -33,14 +33,15 @@ func New(t *testing.T) (net.Listener, string, int) {
 	t.Helper()
 
 	lis, err := net.Listen("tcp", "localhost:0")
-	assert.NilError(t, err)
+	g := NewWithT(t)
+	g.Expect(err).NotTo(HaveOccurred())
 	t.Cleanup(func() { lis.Close() })
 
 	addr := lis.Addr().String()
 	addrParts := strings.Split(addr, ":")
 	portStr := addrParts[len(addrParts)-1]
 	port, err := strconv.Atoi(portStr)
-	assert.NilError(t, err)
+	g.Expect(err).NotTo(HaveOccurred())
 
 	return lis, addr, port
 }

tests/registry/registry.go

@@ -31,8 +31,8 @@ import (
 	"github.com/google/go-containerregistry/pkg/crane"
 	gcrv1 "github.com/google/go-containerregistry/pkg/v1"
 	"github.com/google/go-containerregistry/pkg/v1/mutate"
+	. "github.com/onsi/gomega"
 	"github.com/sirupsen/logrus"
-	"gotest.tools/assert"
 
 	"github.com/fluxcd/pkg/oci"
 
@@ -45,7 +45,8 @@ func New(t *testing.T) string {
 	// Get a free random port and release it so the registry can use it.
 	listener, addr, _ := testlistener.New(t)
 	err := listener.Close()
-	assert.NilError(t, err)
+	g := NewWithT(t)
+	g.Expect(err).NotTo(HaveOccurred())
 
 	config := &configuration.Configuration{}
 	config.HTTP.Addr = addr
@@ -56,7 +57,7 @@ func New(t *testing.T) string {
 	logrus.SetOutput(io.Discard)
 
 	r, err := registry.NewRegistry(context.Background(), config)
-	assert.NilError(t, err)
+	g.Expect(err).NotTo(HaveOccurred())
 
 	go r.ListenAndServe()