Resolve files with duplicate content, add tests

Signed-off-by: Danil-Grigorev <[email protected]>

Author: Danil-Grigorev

cmd/plugin/cmd/init_test.go

@@ -265,7 +265,6 @@ func TestInitProviders(t *testing.T) {
 			opts: &initOptions{
 				coreProvider: "cluster-api:capi-system:v1.8.0",
 				infrastructureProviders: []string{
-					"cluster-api:capi-system:v1.8.0",
 					"aws:capa-operator-system",
 					"docker:capd-operator-system",
 				},

cmd/plugin/cmd/preload.go

@@ -21,12 +21,12 @@ import (
 	"fmt"
 	"os"
 	"strings"
+	"time"
 
 	"github.com/spf13/cobra"
 	corev1 "k8s.io/api/core/v1"
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/api/meta"
 	kerrors "k8s.io/apimachinery/pkg/util/errors"
+	"k8s.io/apimachinery/pkg/util/wait"
 	"oras.land/oras-go/v2/registry/remote/auth"
 	operatorv1 "sigs.k8s.io/cluster-api-operator/api/v1alpha2"
 	providercontroller "sigs.k8s.io/cluster-api-operator/internal/controller"
@@ -207,50 +207,99 @@ func runPreLoad() error {
 		configMaps = append(configMaps, configMap)
 	}
 
-	errors := []error{}
-
-	if !loadOpts.existing {
-		for _, cm := range configMaps {
-			out, err := yaml.Marshal(cm)
-			if err != nil {
-				return fmt.Errorf("cannot serialize provider config map: %w", err)
-			}
+	if loadOpts.existing {
+		client, err := CreateKubeClient(loadOpts.kubeconfig, "")
+		if err != nil {
+			return fmt.Errorf("cannot create a client: %w", err)
+		}
 
-			fmt.Printf("---\n%s", string(out))
+		existing, err := preloadExisting(ctx, client)
+		if err != nil {
+			return err
 		}
 
-		return nil
+		configMaps = append(configMaps, existing...)
 	}
 
-	client, err := CreateKubeClient(loadOpts.kubeconfig, "")
-	if err != nil {
-		return fmt.Errorf("cannot create a client: %w", err)
+	for _, cm := range configMaps {
+		out, err := yaml.Marshal(cm)
+		if err != nil {
+			return fmt.Errorf("cannot serialize provider config map: %w", err)
+		}
+
+		fmt.Printf("---\n%s", string(out))
 	}
 
+	return nil
+}
+
+// preloadExisting uses existing cluster kubeconfig to list providers and create configmaps with components for each provider.
+func preloadExisting(ctx context.Context, cl client.Client) ([]*corev1.ConfigMap, error) {
+	errors := []error{}
+	configMaps := []*corev1.ConfigMap{}
+
 	for _, list := range operatorv1.ProviderLists {
-		maps, err := fetchProviders(ctx, client, list.(genericProviderList))
+		list, ok := list.(genericProviderList)
+		if !ok {
+			log.V(5).Info("Expected to get GenericProviderList")
+			continue
+		}
+
+		list, ok = list.DeepCopyObject().(genericProviderList)
+		if !ok {
+			log.V(5).Info("Expected to get GenericProviderList")
+			continue
+		}
+
+		maps, err := fetchProviders(ctx, cl, list)
 		configMaps = append(configMaps, maps...)
 		errors = append(errors, err)
 	}
 
-	for _, cm := range configMaps {
-		out, err := yaml.Marshal(cm)
-		if err != nil {
-			return fmt.Errorf("cannot serialize provider config map: %w", err)
+	return configMaps, kerrors.NewAggregate(errors)
+}
+
+// retryWithExponentialBackoff repeats an operation until it passes or the exponential backoff times out.
+func retryWithExponentialBackoff(ctx context.Context, opts wait.Backoff, operation func(ctx context.Context) error) error {
+	i := 0
+	if err := wait.ExponentialBackoffWithContext(ctx, opts, func(ctx context.Context) (bool, error) {
+		i++
+		if err := operation(ctx); err != nil {
+			if i < opts.Steps {
+				log.V(5).Info("Retrying with backoff", "cause", err.Error())
+				return false, nil
+			}
+
+			return false, err
 		}
 
-		fmt.Printf("---\n%s", string(out))
+		return true, nil
+	}); err != nil {
+		return fmt.Errorf("action failed after %d attempts: %w", i, err)
 	}
 
-	return kerrors.NewAggregate(errors)
+	return nil
+}
+
+// newReadBackoff creates a new API Machinery backoff parameter set suitable for use with CLI cluster operations.
+func newReadBackoff() wait.Backoff {
+	// Return a exponential backoff configuration which returns durations for a total time of ~15s.
+	// Example: 0, .25s, .6s, 1.2, 2.1s, 3.4s, 5.5s, 8s, 12s
+	// Jitter is added as a random fraction of the duration multiplied by the jitter factor.
+	return wait.Backoff{
+		Duration: 250 * time.Millisecond,
+		Factor:   1.5,
+		Steps:    9,
+		Jitter:   0.1,
+	}
 }
 
 func fetchProviders(ctx context.Context, cl client.Client, providerList genericProviderList) ([]*corev1.ConfigMap, error) {
 	configMaps := []*corev1.ConfigMap{}
 
-	if err := cl.List(ctx, providerList, client.InNamespace("")); meta.IsNoMatchError(err) || apierrors.IsNotFound(err) {
-		return configMaps, nil
-	} else if err != nil {
+	if err := retryWithExponentialBackoff(ctx, newReadBackoff(), func(ctx context.Context) error {
+		return cl.List(ctx, providerList, client.InNamespace(""))
+	}); err != nil {
 		log.Error(err, fmt.Sprintf("Unable to list providers, %#v", err))
 
 		return configMaps, err

cmd/plugin/cmd/preload_test.go

@@ -0,0 +1,232 @@
+/*
+Copyright 2025 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 cmd
+
+import (
+	"cmp"
+	"os"
+	"path"
+	"testing"
+
+	. "github.com/onsi/gomega"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+	clusterctlv1 "sigs.k8s.io/cluster-api/cmd/clusterctl/api/v1alpha3"
+	ctrlclient "sigs.k8s.io/controller-runtime/pkg/client"
+
+	operatorv1 "sigs.k8s.io/cluster-api-operator/api/v1alpha2"
+	"sigs.k8s.io/cluster-api-operator/internal/controller/genericprovider"
+)
+
+type publishProvider struct {
+	configMapName  string
+	provider       genericprovider.GenericProvider
+	metadataKey    string
+	componentsKey  string
+	metadataData   []byte
+	componentsData []byte
+}
+
+type publishOptions struct {
+	ociUrl    string
+	providers []publishProvider
+}
+
+func TestPreloadCommand(t *testing.T) {
+	tests := []struct {
+		name               string
+		customURL          string
+		publishOpts        *publishOptions
+		existingProviders  []genericprovider.GenericProvider
+		expectedConfigMaps int
+		wantErr            bool
+	}{
+		{
+			name:    "no providers",
+			wantErr: false,
+		},
+		{
+			name: "builtin core provider with OCI override",
+			publishOpts: &publishOptions{
+				ociUrl: "ttl.sh/cluster-api-operator-manifests:1m",
+				providers: []publishProvider{{
+					configMapName:  "core-cluster-api-v1.9.3",
+					provider:       generateGenericProvider(clusterctlv1.CoreProviderType, "cluster-api", "default", "v1.9.3", "", ""),
+					metadataKey:    "metadata.yaml",
+					metadataData:   []byte("metadata"),
+					componentsKey:  "components.yaml",
+					componentsData: []byte("components"),
+				}},
+			},
+			expectedConfigMaps: 1,
+		},
+		{
+			name: "multiple providers with OCI override",
+			publishOpts: &publishOptions{
+				ociUrl: "ttl.sh/cluster-api-operator-manifests:1m",
+				providers: []publishProvider{{
+					configMapName:  "core-cluster-api-v1.9.3",
+					provider:       generateGenericProvider(clusterctlv1.CoreProviderType, "cluster-api", "default", "v1.9.3", "", ""),
+					metadataKey:    "core-cluster-api-v1.9.3-metadata.yaml",
+					metadataData:   []byte("metadata"),
+					componentsKey:  "core-cluster-api-v1.9.3-components.yaml",
+					componentsData: []byte("components"),
+				}, {
+					configMapName:  "infrastructure-docker-v1.9.3",
+					provider:       generateGenericProvider(clusterctlv1.InfrastructureProviderType, "docker", "default", "v1.9.3", "", ""),
+					metadataKey:    "infrastructure-docker-v1.9.3-metadata.yaml",
+					metadataData:   []byte("metadata"),
+					componentsKey:  "infrastructure-docker-v1.9.3-components.yaml",
+					componentsData: []byte("components"),
+				}},
+			},
+			expectedConfigMaps: 2,
+		},
+		{
+			name: "custom url infra provider",
+			existingProviders: []genericprovider.GenericProvider{
+				func() genericprovider.GenericProvider {
+					p := generateGenericProvider(clusterctlv1.InfrastructureProviderType, "docker", "default", "v1.9.3", "", "")
+					spec := p.GetSpec()
+					spec.FetchConfig = &operatorv1.FetchConfiguration{
+						URL: "https://github.com/kubernetes-sigs/cluster-api/releases/latest/core-components.yaml",
+					}
+					p.SetSpec(spec)
+
+					return p
+				}(),
+			},
+			expectedConfigMaps: 1,
+		},
+		{
+			name: "regular core and infra provider",
+			existingProviders: []genericprovider.GenericProvider{
+				generateGenericProvider(clusterctlv1.CoreProviderType, "cluster-api", "default", "v1.9.3", "", ""),
+				generateGenericProvider(clusterctlv1.InfrastructureProviderType, "docker", "default", "v1.9.3", "", ""),
+			},
+			expectedConfigMaps: 2,
+		},
+		{
+			name: "OCI override with incorrect metadata key",
+			publishOpts: &publishOptions{
+				ociUrl: "ttl.sh/cluster-api-operator-manifests:1m",
+				providers: []publishProvider{{
+					configMapName:  "core-cluster-api-v1.9.3",
+					provider:       generateGenericProvider(clusterctlv1.InfrastructureProviderType, "metadata-missing", "default", "v1.9.3", "", ""),
+					metadataKey:    "incorrect-metadata.yaml",
+					metadataData:   []byte("test"),
+					componentsKey:  "components.yaml",
+					componentsData: []byte("test"),
+				}},
+			},
+			wantErr: true,
+		},
+		{
+			name: "OCI override with incorrect components key",
+			publishOpts: &publishOptions{
+				ociUrl: "ttl.sh/cluster-api-operator-manifests:1m",
+				providers: []publishProvider{{
+					configMapName:  "core-cluster-api-v1.9.3",
+					provider:       generateGenericProvider(clusterctlv1.InfrastructureProviderType, "components-missing", "default", "v1.9.3", "", ""),
+					metadataKey:    "metadata.yaml",
+					metadataData:   []byte("test"),
+					componentsKey:  "incorrect-components.yaml",
+					componentsData: []byte("test"),
+				}},
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			g := NewWithT(t)
+
+			dir, err := os.MkdirTemp("", "manifests")
+			defer func() {
+				g.Expect(os.RemoveAll(dir)).To(Succeed())
+			}()
+			g.Expect(err).To(Succeed())
+
+			opts := cmp.Or(tt.publishOpts, &publishOptions{})
+			if tt.publishOpts != nil && opts.ociUrl != "" {
+				for _, provider := range opts.providers {
+					err = os.WriteFile(path.Join(dir, provider.metadataKey), provider.metadataData, 0o777)
+					g.Expect(err).To(Succeed())
+					err = os.WriteFile(path.Join(dir, provider.componentsKey), provider.componentsData, 0o777)
+					g.Expect(err).To(Succeed())
+				}
+
+				g.Expect(publish(ctx, dir, opts.ociUrl)).To(Succeed())
+
+				for _, data := range opts.providers {
+					spec := data.provider.GetSpec()
+					spec.FetchConfig = &operatorv1.FetchConfiguration{
+						OCI: opts.ociUrl,
+					}
+					data.provider.SetSpec(spec)
+					g.Expect(env.Client.Create(ctx, data.provider)).To(Succeed())
+				}
+			}
+
+			resources := []ctrlclient.Object{}
+			for _, provider := range tt.existingProviders {
+				resources = append(resources, provider)
+			}
+
+			for _, data := range opts.providers {
+				resources = append(resources, data.provider)
+			}
+
+			defer func() {
+				g.Expect(env.CleanupAndWait(ctx, resources...)).To(Succeed())
+			}()
+
+			for _, genericProvider := range tt.existingProviders {
+				g.Expect(env.Client.Create(ctx, genericProvider)).To(Succeed())
+			}
+
+			configMaps := []*corev1.ConfigMap{}
+
+			g.Eventually(func(g Gomega) {
+				configMaps, err = preloadExisting(ctx, env)
+				g.Expect(tt.expectedConfigMaps).To(Equal(len(configMaps)))
+				if tt.wantErr {
+					g.Expect(err).To(HaveOccurred())
+				} else {
+					g.Expect(err).NotTo(HaveOccurred())
+
+					maps := map[types.NamespacedName]*corev1.ConfigMap{}
+					for _, cm := range configMaps {
+						maps[ctrlclient.ObjectKeyFromObject(cm)] = cm
+					}
+
+					for _, data := range opts.providers {
+						cm, ok := maps[types.NamespacedName{
+							Namespace: data.provider.GetNamespace(),
+							Name:      data.configMapName,
+						}]
+
+						g.Expect(ok).To(BeTrue())
+
+						g.Expect(cm.Data["metadata"]).To(Equal(string(data.metadataData)))
+						g.Expect(cm.Data["components"]).To(Equal(string(data.componentsData)))
+					}
+				}
+			}, "15s", "1s").Should(Succeed())
+		})
+	}
+}