add unit tests for multi-cluster support

Signed-off-by: kahirokunn <okinakahiro@gmail.com>

Author: kahirokunn

pkg/reconciler/common/multicluster_test.go

@@ -0,0 +1,353 @@
+/*
+Copyright 2026 The Knative 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 common
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	mf "github.com/manifestival/manifestival"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes/fake"
+
+	"knative.dev/operator/pkg/apis/operator/base"
+	"knative.dev/operator/pkg/apis/operator/v1beta1"
+)
+
+func TestResolveTargetCluster_NilRef(t *testing.T) {
+	// ClusterProfileRef is nil => the stage should be a no-op.
+	instance := &v1beta1.KnativeServing{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "default",
+			Name:      "test",
+		},
+	}
+
+	manifest, err := mf.ManifestFrom(mf.Slice{})
+	if err != nil {
+		t.Fatalf("Failed to create manifest: %v", err)
+	}
+
+	origClient := manifest.Client
+
+	var anchorOwner mf.Owner
+	stage := ResolveTargetCluster(nil, &anchorOwner)
+	if err := stage(context.Background(), &manifest, instance); err != nil {
+		t.Fatalf("Expected no error for nil ClusterProfileRef, got: %v", err)
+	}
+
+	if manifest.Client != origClient {
+		t.Fatal("Expected manifest.Client to remain unchanged when ClusterProfileRef is nil")
+	}
+
+	if anchorOwner != nil {
+		t.Fatal("Expected anchorOwner to remain nil when ClusterProfileRef is nil")
+	}
+}
+
+func TestResolveTargetCluster_MissingCredentialConfig(t *testing.T) {
+	// Ensure the package variable is empty for this test.
+	old := CredentialProvidersConfigPath
+	CredentialProvidersConfigPath = ""
+	defer func() { CredentialProvidersConfigPath = old }()
+
+	instance := &v1beta1.KnativeServing{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "default",
+			Name:      "test",
+		},
+		Spec: v1beta1.KnativeServingSpec{
+			CommonSpec: base.CommonSpec{
+				ClusterProfileRef: &base.ClusterProfileReference{
+					Name:      "test-cluster",
+					Namespace: "fleet-system",
+				},
+			},
+		},
+	}
+
+	manifest, err := mf.ManifestFrom(mf.Slice{})
+	if err != nil {
+		t.Fatalf("Failed to create manifest: %v", err)
+	}
+
+	var anchorOwner mf.Owner
+	stage := ResolveTargetCluster(nil, &anchorOwner)
+	err = stage(context.Background(), &manifest, instance)
+	if err == nil {
+		t.Fatal("Expected error when CredentialProvidersConfigPath is empty, got nil")
+	}
+	if !strings.Contains(err.Error(), "credential-providers-config") {
+		t.Fatalf("Expected error message to contain 'credential-providers-config', got: %v", err)
+	}
+}
+
+func TestResolveTargetClusterConfig_NilRef(t *testing.T) {
+	// ResolveTargetClusterConfig with nil ClusterProfileRef => (nil, nil).
+	instance := &v1beta1.KnativeServing{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "default",
+			Name:      "test",
+		},
+	}
+
+	cfg, err := ResolveTargetClusterConfig(context.Background(), nil, instance)
+	if err != nil {
+		t.Fatalf("Expected no error for nil ClusterProfileRef, got: %v", err)
+	}
+	if cfg != nil {
+		t.Fatal("Expected nil config for nil ClusterProfileRef")
+	}
+}
+
+func TestResolveTargetClusterConfig_MissingCredentialConfig(t *testing.T) {
+	old := CredentialProvidersConfigPath
+	CredentialProvidersConfigPath = ""
+	defer func() { CredentialProvidersConfigPath = old }()
+
+	instance := &v1beta1.KnativeServing{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "default",
+			Name:      "test",
+		},
+		Spec: v1beta1.KnativeServingSpec{
+			CommonSpec: base.CommonSpec{
+				ClusterProfileRef: &base.ClusterProfileReference{
+					Name:      "test-cluster",
+					Namespace: "fleet-system",
+				},
+			},
+		},
+	}
+
+	_, err := ResolveTargetClusterConfig(context.Background(), nil, instance)
+	if err == nil {
+		t.Fatal("Expected error when CredentialProvidersConfigPath is empty, got nil")
+	}
+	if !strings.Contains(err.Error(), "credential-providers-config") {
+		t.Fatalf("Expected error message to contain 'credential-providers-config', got: %v", err)
+	}
+}
+
+func TestAnchorName(t *testing.T) {
+	tests := []struct {
+		name     string
+		instance base.KComponent
+		want     string
+	}{
+		{
+			name: "KnativeServing",
+			instance: &v1beta1.KnativeServing{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "knative-serving",
+					Name:      "knative-serving",
+				},
+			},
+			want: "knativeserving-knative-serving-root-owner",
+		},
+		{
+			name: "KnativeEventing",
+			instance: &v1beta1.KnativeEventing{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "knative-eventing",
+					Name:      "my-eventing",
+				},
+			},
+			want: "knativeeventing-my-eventing-root-owner",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := AnchorName(tt.instance)
+			if got != tt.want {
+				t.Fatalf("AnchorName() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestEnsureAnchorConfigMap_Create(t *testing.T) {
+	// No pre-existing resources: namespace and anchor ConfigMap should be created.
+	kubeClient := fake.NewSimpleClientset()
+	instance := &v1beta1.KnativeServing{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "test-ns",
+			Name:      "test",
+		},
+	}
+
+	ctx := context.Background()
+	anchor, err := EnsureAnchorConfigMap(ctx, kubeClient, instance)
+	if err != nil {
+		t.Fatalf("EnsureAnchorConfigMap() error: %v", err)
+	}
+
+	expectedName := "knativeserving-test-root-owner"
+	if anchor.Name != expectedName {
+		t.Fatalf("anchor.Name = %q, want %q", anchor.Name, expectedName)
+	}
+	if anchor.Namespace != "test-ns" {
+		t.Fatalf("anchor.Namespace = %q, want %q", anchor.Namespace, "test-ns")
+	}
+
+	// Verify the anchor has the expected labels.
+	if anchor.Labels["app.kubernetes.io/managed-by"] != "knative-operator" {
+		t.Fatalf("Expected label app.kubernetes.io/managed-by=knative-operator, got %q",
+			anchor.Labels["app.kubernetes.io/managed-by"])
+	}
+	if anchor.Labels["operator.knative.dev/cr-name"] != "test" {
+		t.Fatalf("Expected label operator.knative.dev/cr-name=test, got %q",
+			anchor.Labels["operator.knative.dev/cr-name"])
+	}
+
+	// Verify the anchor has the expected annotations.
+	if anchor.Annotations["operator.knative.dev/anchor"] != "true" {
+		t.Fatalf("Expected annotation operator.knative.dev/anchor=true, got %q",
+			anchor.Annotations["operator.knative.dev/anchor"])
+	}
+
+	// Verify the namespace was created.
+	ns, err := kubeClient.CoreV1().Namespaces().Get(ctx, "test-ns", metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("Expected namespace test-ns to exist, got error: %v", err)
+	}
+	if ns.Name != "test-ns" {
+		t.Fatalf("namespace.Name = %q, want %q", ns.Name, "test-ns")
+	}
+}
+
+func TestEnsureAnchorConfigMap_AlreadyExists(t *testing.T) {
+	// Pre-existing anchor ConfigMap should be returned as-is.
+	existingAnchor := &corev1.ConfigMap{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "knativeserving-test-root-owner",
+			Namespace: "test-ns",
+		},
+	}
+	existingNS := &corev1.Namespace{
+		ObjectMeta: metav1.ObjectMeta{Name: "test-ns"},
+	}
+	kubeClient := fake.NewSimpleClientset(existingNS, existingAnchor)
+
+	instance := &v1beta1.KnativeServing{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "test-ns",
+			Name:      "test",
+		},
+	}
+
+	ctx := context.Background()
+	anchor, err := EnsureAnchorConfigMap(ctx, kubeClient, instance)
+	if err != nil {
+		t.Fatalf("EnsureAnchorConfigMap() error: %v", err)
+	}
+
+	if anchor.Name != "knativeserving-test-root-owner" {
+		t.Fatalf("anchor.Name = %q, want %q", anchor.Name, "knativeserving-test-root-owner")
+	}
+	if anchor.Namespace != "test-ns" {
+		t.Fatalf("anchor.Namespace = %q, want %q", anchor.Namespace, "test-ns")
+	}
+}
+
+func TestEnsureAnchorConfigMap_NamespaceAlreadyExists(t *testing.T) {
+	// Namespace exists but anchor ConfigMap does not.
+	existingNS := &corev1.Namespace{
+		ObjectMeta: metav1.ObjectMeta{Name: "test-ns"},
+	}
+	kubeClient := fake.NewSimpleClientset(existingNS)
+
+	instance := &v1beta1.KnativeServing{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "test-ns",
+			Name:      "test",
+		},
+	}
+
+	ctx := context.Background()
+	anchor, err := EnsureAnchorConfigMap(ctx, kubeClient, instance)
+	if err != nil {
+		t.Fatalf("EnsureAnchorConfigMap() error: %v", err)
+	}
+
+	if anchor.Name != "knativeserving-test-root-owner" {
+		t.Fatalf("anchor.Name = %q, want %q", anchor.Name, "knativeserving-test-root-owner")
+	}
+
+	// Verify only one namespace with that name (no duplicate creation attempt).
+	nsList, err := kubeClient.CoreV1().Namespaces().List(ctx, metav1.ListOptions{})
+	if err != nil {
+		t.Fatalf("Failed to list namespaces: %v", err)
+	}
+	count := 0
+	for _, ns := range nsList.Items {
+		if ns.Name == "test-ns" {
+			count++
+		}
+	}
+	if count != 1 {
+		t.Fatalf("Expected 1 namespace named test-ns, got %d", count)
+	}
+}
+
+func TestDeleteAnchorConfigMap_Success(t *testing.T) {
+	existingAnchor := &corev1.ConfigMap{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "knativeserving-test-root-owner",
+			Namespace: "test-ns",
+		},
+	}
+	kubeClient := fake.NewSimpleClientset(existingAnchor)
+
+	instance := &v1beta1.KnativeServing{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "test-ns",
+			Name:      "test",
+		},
+	}
+
+	ctx := context.Background()
+	if err := DeleteAnchorConfigMap(ctx, kubeClient, instance); err != nil {
+		t.Fatalf("DeleteAnchorConfigMap() error: %v", err)
+	}
+
+	// Verify the ConfigMap no longer exists.
+	_, err := kubeClient.CoreV1().ConfigMaps("test-ns").Get(ctx, "knativeserving-test-root-owner", metav1.GetOptions{})
+	if err == nil {
+		t.Fatal("Expected anchor ConfigMap to be deleted, but it still exists")
+	}
+}
+
+func TestDeleteAnchorConfigMap_NotFound(t *testing.T) {
+	// Deleting a non-existent anchor should not return an error.
+	kubeClient := fake.NewSimpleClientset()
+
+	instance := &v1beta1.KnativeServing{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "test-ns",
+			Name:      "test",
+		},
+	}
+
+	ctx := context.Background()
+	if err := DeleteAnchorConfigMap(ctx, kubeClient, instance); err != nil {
+		t.Fatalf("Expected no error for deleting non-existent anchor, got: %v", err)
+	}
+}