fluxcd
/
source-controller
mirror of https://github.com/fluxcd/source-controller.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Migrate tests from gotest to gomega 

Signed-off-by: Stefan Prodan <stefan.prodan@gmail.com>
This commit is contained in:
Stefan Prodan 2025-08-30 23:54:45 +03:00
parent 1a244f7c30
commit 3749be4d26
No known key found for this signature in database
GPG Key ID: 3299AEB0E4085BAF
11 changed files with 151 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
go.mod
View File

@ -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

2
go.sum
View File

@ -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=

4
internal/bucket/azure/blob_test.go
View File

@ -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",
},
}

65
internal/bucket/gcp/gcp_test.go
View File

@ -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")
assert.Assert(t, gcpClient == nil)
g := NewWithT(t)
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)
assert.Assert(t, !metadata.OnGCE())
g := NewWithT(t)
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)
assert.Assert(t, gcpClient != nil)
g := NewWithT(t)
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)
assert.Assert(t, exists)
g.Expect(err).NotTo(HaveOccurred())
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)
assert.Assert(t, exists)
g := NewWithT(t)
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)
assert.Assert(t, !exists)
g := NewWithT(t)
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)
assert.DeepEqual(t, keys, []string{objectName})
assert.DeepEqual(t, etags, []string{objectEtag})
g := NewWithT(t)
g.Expect(err).NotTo(HaveOccurred())
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())
}
})
}

112
internal/bucket/minio/minio_test.go
View File

@ -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)
assert.Assert(t, minioClient != nil)
g := NewWithT(t)
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)
assert.Assert(t, minioClient != nil)
g := NewWithT(t)
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)
assert.Assert(t, minioClient != nil)
g := NewWithT(t)
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")
assert.Assert(t, minioClient == nil)
g := NewWithT(t)
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)
assert.Assert(t, exists)
g := NewWithT(t)
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)
assert.Assert(t, !exists)
g := NewWithT(t)
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)
assert.Equal(t, password, ldapPassword)
g.Expect(username).To(Equal(ldapUsername))
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)
assert.Assert(t, minioClient != nil)
g := NewWithT(t)
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)
assert.Assert(t, credsRetrieved)
g.Expect(err).NotTo(HaveOccurred())
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)
assert.Assert(t, minioClient != nil)
g := NewWithT(t)
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.")
assert.Check(t, testMinioClient.ObjectIsNotFound(err))
g := NewWithT(t)
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)
assert.DeepEqual(t, keys, []string{objectName})
assert.DeepEqual(t, etags, []string{objectEtag})
g := NewWithT(t)
g.Expect(err).NotTo(HaveOccurred())
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())
}
})
}

23
internal/controller/bucket_controller_fetch_test.go
View File

@ -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")
assert.Check(t, !index.Has("bar.yaml"))
g := NewWithT(t)
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) {

15
internal/controller/helmchart_controller_test.go
View File

@ -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())
})
}

2
internal/helm/chart/builder_local_test.go
View File

@ -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",

4
internal/helm/chart/builder_remote_test.go
View File

@ -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",

7
tests/listener/listener.go
View File

@ -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
}

7
tests/registry/registry.go
View File

@ -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()