fix linter issues

Author: tjamet

internal/controller/genericprovider_controller.go

@@ -240,16 +240,20 @@ func addConfigSecretToHash(ctx context.Context, k8sClient client.Client, hash ha
 		if secret.Namespace == "" {
 			secret.Namespace = provider.GetNamespace()
 		}
+
 		err := k8sClient.Get(ctx, client.ObjectKeyFromObject(secret), secret)
 		if err != nil {
 			return err
 		}
+
 		err = addObjectToHash(hash, secret.Data)
 		if err != nil {
 			return err
 		}
+
 		return nil
 	}
+
 	return nil
 }
 
@@ -262,6 +266,7 @@ func addObjectToHash(hash hash.Hash, object interface{}) error {
 	if _, err = hash.Write(jsonData); err != nil {
 		return fmt.Errorf("cannot calculate object hash: %w", err)
 	}
+
 	return nil
 }
 

internal/controller/genericprovider_controller_test.go

@@ -24,7 +24,6 @@ import (
 	. "github.com/onsi/gomega"
 	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
-	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
@@ -93,10 +92,10 @@ func insertDummyConfig(provider genericprovider.GenericProvider) {
 	provider.SetSpec(spec)
 }
 
-func dummyConfigMap(ns, name string) *corev1.ConfigMap {
+func dummyConfigMap(ns string) *corev1.ConfigMap {
 	return &corev1.ConfigMap{
 		ObjectMeta: metav1.ObjectMeta{
-			Name:      name,
+			Name:      testCurrentVersion,
 			Namespace: ns,
 			Labels: map[string]string{
 				"test": "dummy-config",
@@ -109,13 +108,15 @@ func dummyConfigMap(ns, name string) *corev1.ConfigMap {
 	}
 }
 
-func createDummyProviderWithConfigSecret(objs []client.Object, provider genericprovider.GenericProvider, configSecret *v1.Secret) ([]client.Object, error) {
-	cm := dummyConfigMap(provider.GetNamespace(), testCurrentVersion)
+func createDummyProviderWithConfigSecret(objs []client.Object, provider genericprovider.GenericProvider, configSecret *corev1.Secret) ([]client.Object, error) {
+	cm := dummyConfigMap(provider.GetNamespace())
 
 	if err := env.CreateAndWait(ctx, cm); err != nil {
 		return objs, err
 	}
+
 	objs = append(objs, cm)
+
 	provider.SetSpec(operatorv1.ProviderSpec{
 		Version: testCurrentVersion,
 		ConfigSecret: &operatorv1.SecretReference{
@@ -124,12 +125,16 @@ func createDummyProviderWithConfigSecret(objs []client.Object, provider genericp
 		},
 		ManifestPatches: []string{},
 	})
+
 	insertDummyConfig(provider)
+
 	err := env.CreateAndWait(ctx, provider)
 	if err != nil {
 		return objs, err
 	}
+
 	objs = append(objs, provider)
+
 	return objs, nil
 }
 
@@ -153,6 +158,7 @@ func testDeploymentLabelValueGetter(deploymentNS, deploymentName string) func()
 func TestConfigSecretChangesAreAppliedTotheDeployment(t *testing.T) {
 	g := NewWithT(t)
 	objs := []client.Object{}
+
 	defer func() {
 		g.Expect(env.CleanupAndWait(ctx, objs...)).To(Succeed())
 	}()
@@ -277,7 +283,7 @@ func TestReconcilerPreflightConditions(t *testing.T) {
 			t.Log("Ensure namespace exists", tc.namespace)
 			g.Expect(env.EnsureNamespaceExists(ctx, tc.namespace)).To(Succeed())
 
-			g.Expect(env.CreateAndWait(ctx, dummyConfigMap(tc.namespace, testCurrentVersion))).To(Succeed())
+			g.Expect(env.CreateAndWait(ctx, dummyConfigMap(tc.namespace))).To(Succeed())
 
 			for _, p := range tc.providers {
 				insertDummyConfig(p)
@@ -566,6 +572,7 @@ func TestProviderConfigSecretChanges(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			g := NewWithT(t)
 			objs := []client.Object{}
+
 			defer func() {
 				g.Expect(env.CleanupAndWait(ctx, objs...)).To(Succeed())
 			}()
@@ -601,7 +608,7 @@ func TestProviderConfigSecretChanges(t *testing.T) {
 			t.Log("Ensure namespace exists", configNamespace.Name)
 			g.Expect(err).ToNot(HaveOccurred())
 
-			cm := dummyConfigMap(providerNamespace.Name, testCurrentVersion)
+			cm := dummyConfigMap(providerNamespace.Name)
 			g.Expect(env.CreateAndWait(ctx, cm)).To(Succeed())
 			objs = append(objs, cm)
 
@@ -640,16 +647,19 @@ func TestProviderConfigSecretChanges(t *testing.T) {
 			}).Should(Succeed())
 
 			var updatedDataHash string
+
 			if tc.expectSameHash {
 				g.Eventually(func() string {
 					updatedDataHash, err = calculateHash(ctx, env.Client, provider)
 					g.Expect(err).ToNot(HaveOccurred())
+
 					return updatedDataHash
 				}, 15*time.Second).Should(Equal(initialHash))
 			} else {
 				g.Eventually(func() string {
 					updatedDataHash, err = calculateHash(ctx, env.Client, provider)
 					g.Expect(err).ToNot(HaveOccurred())
+
 					return updatedDataHash
 				}, 15*time.Second).ShouldNot(Equal(initialHash))
 			}
@@ -789,7 +799,7 @@ func TestProviderSpecChanges(t *testing.T) {
 			t.Log("Ensure namespace exists", ns.Name)
 			g.Expect(err).ToNot(HaveOccurred())
 
-			g.Expect(env.CreateAndWait(ctx, dummyConfigMap(ns.Name, testCurrentVersion))).To(Succeed())
+			g.Expect(env.CreateAndWait(ctx, dummyConfigMap(ns.Name))).To(Succeed())
 
 			provider.SetNamespace(ns.Name)
 			t.Log("creating test provider", provider.GetName())

internal/controller/manifests_downloader_test.go

@@ -41,7 +41,7 @@ func TestManifestsDownloader(t *testing.T) {
 		provider: &operatorv1.CoreProvider{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "cluster-api",
-				Namespace: "test-namespace",
+				Namespace: testNamespaceName,
 			},
 			Spec: operatorv1.CoreProviderSpec{
 				ProviderSpec: operatorv1.ProviderSpec{
@@ -75,8 +75,6 @@ func TestProviderDownloadWithOverrides(t *testing.T) {
 
 	fakeclient := fake.NewClientBuilder().WithObjects().Build()
 
-	namespace := "test-namespace"
-
 	reader := configclient.NewMemoryReader()
 	_, err := reader.AddProvider("cluster-api", clusterctlv1.CoreProviderType, "https://github.com/kubernetes-sigs/cluster-api/releases/v1.4.3/core-components.yaml")
 	g.Expect(err).ToNot(HaveOccurred())
@@ -94,7 +92,7 @@ all:
 		provider: &operatorv1.CoreProvider{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "cluster-api",
-				Namespace: namespace,
+				Namespace: testNamespaceName,
 			},
 			Spec: operatorv1.CoreProviderSpec{},
 		},

internal/controller/phases_test.go

@@ -41,14 +41,13 @@ func TestSecretReader(t *testing.T) {
 
 	secretName := "test-secret"
 	secretNamespace := "test-secret-namespace"
-	namespace := "test-namespace"
 
 	p := &phaseReconciler{
 		ctrlClient: fakeclient,
 		provider: &operatorv1.CoreProvider{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "cluster-api",
-				Namespace: namespace,
+				Namespace: testNamespaceName,
 			},
 			TypeMeta: metav1.TypeMeta{
 				Kind:       "CoreProvider",

internal/controller/secrets_to_providers.go

@@ -1,3 +1,19 @@
+/*
+Copyright 2024 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
 package controller
 
 import (
@@ -16,8 +32,10 @@ import (
 // If the providers references a secret without a namespace, it will assume the secret is in the same namespace as the provider.
 func newSecretToProviderFuncMapForProviderList(k8sClient client.Client, providerList genericprovider.GenericProviderList) handler.MapFunc {
 	providerListType := fmt.Sprintf("%t", providerList)
+
 	return func(ctx context.Context, secret client.Object) []reconcile.Request {
 		log := ctrl.LoggerFrom(ctx).WithValues("secret", map[string]string{"name": secret.GetName(), "namespace": secret.GetNamespace()}, "providerListType", providerListType)
+
 		var requests []reconcile.Request
 
 		if err := k8sClient.List(ctx, providerList); err != nil {
@@ -29,6 +47,7 @@ func newSecretToProviderFuncMapForProviderList(k8sClient client.Client, provider
 			log = log.WithValues("provider", map[string]string{"name": provider.GetName(), "namespace": provider.GetNamespace()})
 
 			spec := provider.GetSpec()
+
 			if spec.ConfigSecret == nil {
 				log.V(5).Info("Provider does not reference a config secret")
 				continue
@@ -37,11 +56,13 @@ func newSecretToProviderFuncMapForProviderList(k8sClient client.Client, provider
 			configNamespace := spec.ConfigSecret.Namespace
 			if configNamespace == "" {
 				log.V(5).Info("Provider configSecret namespace is empty, using provider namespace")
+
 				configNamespace = provider.GetNamespace()
 			}
 
 			if configNamespace == secret.GetNamespace() && spec.ConfigSecret.Name == secret.GetName() {
 				log.V(2).Info("Found provider using config secret")
+
 				requests = append(requests, reconcile.Request{NamespacedName: client.ObjectKeyFromObject(provider)})
 			}
 		}

internal/controller/secrets_to_providers_test.go

@@ -1,3 +1,19 @@
+/*
+Copyright 2024 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
 package controller
 
 import (
@@ -15,7 +31,6 @@ import (
 func TestProviderSecretMapper(t *testing.T) {
 	g := NewWithT(t)
 
-	configSecretNamespace := "test-namespace"
 	otherInfraProviderNamespace := "other-namespace"
 	configSecretName := "infra-provider-config"
 
@@ -25,7 +40,7 @@ func TestProviderSecretMapper(t *testing.T) {
 			&operatorv1.InfrastructureProvider{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "infra-provider-using-secret",
-					Namespace: configSecretNamespace,
+					Namespace: testNamespaceName,
 				},
 				Spec: operatorv1.InfrastructureProviderSpec{
 					ProviderSpec: operatorv1.ProviderSpec{
@@ -44,7 +59,7 @@ func TestProviderSecretMapper(t *testing.T) {
 					ProviderSpec: operatorv1.ProviderSpec{
 						ConfigSecret: &operatorv1.SecretReference{
 							Name:      configSecretName,
-							Namespace: configSecretNamespace,
+							Namespace: testNamespaceName,
 						},
 					},
 				},
@@ -58,7 +73,7 @@ func TestProviderSecretMapper(t *testing.T) {
 					ProviderSpec: operatorv1.ProviderSpec{
 						ConfigSecret: &operatorv1.SecretReference{
 							Name:      configSecretName,
-							Namespace: configSecretNamespace,
+							Namespace: testNamespaceName,
 						},
 					},
 				},
@@ -93,15 +108,14 @@ func TestProviderSecretMapper(t *testing.T) {
 	requests := newSecretToProviderFuncMapForProviderList(k8sClient, &operatorv1.InfrastructureProviderList{})(ctx, &corev1.Secret{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      configSecretName,
-			Namespace: configSecretNamespace,
+			Namespace: testNamespaceName,
 		},
 	})
 
 	g.Expect(requests).To(HaveLen(3))
 	g.Expect(requests).To(ContainElements(
-		ctrl.Request{NamespacedName: types.NamespacedName{Namespace: configSecretNamespace, Name: "infra-provider-using-secret"}},
+		ctrl.Request{NamespacedName: types.NamespacedName{Namespace: testNamespaceName, Name: "infra-provider-using-secret"}},
 		ctrl.Request{NamespacedName: types.NamespacedName{Namespace: otherInfraProviderNamespace, Name: "infra-provider-using-secret-from-other-namespace"}},
 		ctrl.Request{NamespacedName: types.NamespacedName{Namespace: otherInfraProviderNamespace, Name: "other-infra-provider-using-secret-from-other-namespace"}},
 	))
-
 }

internal/controller/suite_test.go

@@ -30,7 +30,8 @@ import (
 )
 
 const (
-	timeout = time.Second * 30
+	timeout           = time.Second * 30
+	testNamespaceName = "test-namespace"
 )
 
 var (