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

@@ -207,42 +207,49 @@ 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)
-			}
-
-			fmt.Printf("---\n%s", string(out))
+	for _, cm := range configMaps {
+		out, err := yaml.Marshal(cm)
+		if err != nil {
+			return fmt.Errorf("cannot serialize provider config map: %w", err)
 		}
 
-		return nil
+		fmt.Printf("---\n%s", string(out))
 	}
 
-	client, err := CreateKubeClient(loadOpts.kubeconfig, "")
-	if err != nil {
-		return fmt.Errorf("cannot create a client: %w", err)
+	if loadOpts.existing {
+		client, err := CreateKubeClient(loadOpts.kubeconfig, "")
+		if err != nil {
+			return fmt.Errorf("cannot create a client: %w", err)
+		}
+		if _, err := preloadExisting(ctx, client); err != nil {
+			return err
+		}
 	}
 
+	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))
+		maps, err := fetchProviders(ctx, cl, list.(genericProviderList))
 		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 nil, fmt.Errorf("cannot serialize provider config map: %w", err)
 		}
 
 		fmt.Printf("---\n%s", string(out))
 	}
 
-	return kerrors.NewAggregate(errors)
+	return configMaps, kerrors.NewAggregate(errors)
 }
 
 func fetchProviders(ctx context.Context, cl client.Client, providerList genericProviderList) ([]*corev1.ConfigMap, error) {

cmd/plugin/cmd/preload_test.go

@@ -0,0 +1,225 @@
+/*
+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-1: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-2: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-3:1m",
+				providers: []publishProvider{{
+					configMapName:  "core-cluster-api-v1.9.3",
+					provider:       generateGenericProvider(clusterctlv1.CoreProviderType, "cluster-api", "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-4: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("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, testErr := preloadExisting(ctx, env)
+
+			maps := map[types.NamespacedName]*corev1.ConfigMap{}
+			for _, cm := range configMaps {
+				maps[ctrlclient.ObjectKeyFromObject(cm)] = cm
+			}
+
+			if tt.wantErr {
+				g.Expect(testErr).To(HaveOccurred())
+			} else {
+				g.Expect(testErr).NotTo(HaveOccurred())
+				for _, data := range opts.providers {
+					cm := maps[types.NamespacedName{
+						Namespace: data.provider.GetNamespace(),
+						Name:      data.configMapName,
+					}]
+
+					g.Expect(cm.Data["metadata"]).To(Equal(string(data.metadataData)))
+					g.Expect(cm.Data["components"]).To(Equal(string(data.componentsData)))
+				}
+				g.Expect(tt.expectedConfigMaps).To(Equal(len(configMaps)))
+			}
+		})
+	}
+}