operator/pkg: add test helpers

Signed-off-by: Mohamed Awnallah <mohamedmohey2352@gmail.com>

operator/pkg/tasks/init/test_helpers.go

@@ -0,0 +1,208 @@
+/*
+Copyright 2024 The Karmada 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 tasks
+
+import (
+	"context"
+	"fmt"
+
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	clientset "k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/rest"
+
+	operatorv1alpha1 "github.com/karmada-io/karmada/operator/pkg/apis/operator/v1alpha1"
+	"github.com/karmada-io/karmada/operator/pkg/certs"
+)
+
+// TestInterface defines the interface for retrieving test data.
+type TestInterface interface {
+	// Get returns the data from the test instance.
+	Get() string
+}
+
+// MyTestData is a struct that implements the TestInterface.
+type MyTestData struct {
+	Data string
+}
+
+// Get returns the data stored in the MyTestData struct.
+func (m *MyTestData) Get() string {
+	return m.Data
+}
+
+// TestInitData contains the configuration and state required to initialize Karmada components.
+type TestInitData struct {
+	name               string
+	namespace          string
+	controlplaneConfig *rest.Config
+	dataDir            string
+	crdTarball         operatorv1alpha1.CRDTarball
+	karmadaVersion     string
+	components         *operatorv1alpha1.KarmadaComponents
+	featureGates       map[string]bool
+	remoteClient       clientset.Interface
+	karmadaClient      clientset.Interface
+	controlplaneAddr   string
+	certs              []*certs.KarmadaCert
+}
+
+// Ensure TestInitData implements InitData interface at compile time.
+var _ InitData = &TestInitData{}
+
+// GetName returns the name of the current Karmada installation.
+func (t *TestInitData) GetName() string {
+	return t.name
+}
+
+// GetNamespace returns the namespace of the current Karmada installation.
+func (t *TestInitData) GetNamespace() string {
+	return t.namespace
+}
+
+// SetControlplaneConfig sets the control plane configuration for Karmada.
+func (t *TestInitData) SetControlplaneConfig(config *rest.Config) {
+	t.controlplaneConfig = config
+}
+
+// ControlplaneConfig returns the control plane configuration.
+func (t *TestInitData) ControlplaneConfig() *rest.Config {
+	return t.controlplaneConfig
+}
+
+// ControlplaneAddress returns the address of the control plane.
+func (t *TestInitData) ControlplaneAddress() string {
+	return t.controlplaneAddr
+}
+
+// RemoteClient returns the Kubernetes client for remote interactions.
+func (t *TestInitData) RemoteClient() clientset.Interface {
+	return t.remoteClient
+}
+
+// KarmadaClient returns the Kubernetes client for interacting with Karmada.
+func (t *TestInitData) KarmadaClient() clientset.Interface {
+	return t.karmadaClient
+}
+
+// DataDir returns the data directory used by Karmada.
+func (t *TestInitData) DataDir() string {
+	return t.dataDir
+}
+
+// CrdTarball returns the CRD tarball used for Karmada installation.
+func (t *TestInitData) CrdTarball() operatorv1alpha1.CRDTarball {
+	return t.crdTarball
+}
+
+// KarmadaVersion returns the version of Karmada being used.
+func (t *TestInitData) KarmadaVersion() string {
+	return t.karmadaVersion
+}
+
+// Components returns the Karmada components used in the current installation.
+func (t *TestInitData) Components() *operatorv1alpha1.KarmadaComponents {
+	return t.components
+}
+
+// FeatureGates returns the feature gates enabled for the current installation.
+func (t *TestInitData) FeatureGates() map[string]bool {
+	return t.featureGates
+}
+
+// AddCert adds a Karmada certificate to the TestInitData.
+func (t *TestInitData) AddCert(cert *certs.KarmadaCert) {
+	t.certs = append(t.certs, cert)
+}
+
+// GetCert retrieves a Karmada certificate by its name.
+func (t *TestInitData) GetCert(name string) *certs.KarmadaCert {
+	for _, cert := range t.certs {
+		if cert.CertName() == name {
+			return cert
+		}
+	}
+	return nil
+}
+
+// CertList returns a list of all Karmada certificates stored in TestInitData.
+func (t *TestInitData) CertList() []*certs.KarmadaCert {
+	return t.certs
+}
+
+// LoadCertFromSecret loads a Karmada certificate from a Kubernetes secret.
+func (t *TestInitData) LoadCertFromSecret(secret *corev1.Secret) error {
+	if len(secret.Data) == 0 {
+		return fmt.Errorf("cert data is empty")
+	}
+
+	// Dummy implementation: load empty certificate.
+	cert := &certs.KarmadaCert{}
+	t.AddCert(cert)
+	return nil
+}
+
+// createPods creates a specified number of pods in the given namespace
+// with the provided component name.
+//
+// Parameters:
+// - client: Kubernetes client interface.
+// - namespace: Namespace for pod creation.
+// - componentName: Base name for pods and containers.
+// - replicaCount: Number of pods to create.
+// - labels: Labels for pods creation.
+//
+// Returns an error if pod creation fails.
+func createPods(client clientset.Interface, namespace string, componentName string, replicaCount int32, labels map[string]string) error {
+	for i := int32(0); i < replicaCount; i++ {
+		podName := fmt.Sprintf("%s-pod-%d", componentName, i)
+		pod := &corev1.Pod{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      podName,
+				Namespace: namespace,
+				Labels:    labels,
+			},
+			Spec: corev1.PodSpec{
+				Containers: []corev1.Container{{
+					Name:  fmt.Sprintf("my-%s-container-%d", componentName, i),
+					Image: fmt.Sprintf("my-%s-image:latest", componentName),
+					Ports: []corev1.ContainerPort{{ContainerPort: 80}},
+				}},
+			},
+		}
+		_, err := client.CoreV1().Pods(namespace).Create(context.TODO(), pod, metav1.CreateOptions{})
+		if err != nil {
+			return fmt.Errorf("failed to create pod %s: %w", podName, err)
+		}
+
+		// Mark the pod as in running state.
+		pod.Status = corev1.PodStatus{
+			Phase: corev1.PodRunning,
+			Conditions: []corev1.PodCondition{
+				{
+					Type:   corev1.PodReady,
+					Status: corev1.ConditionTrue,
+				},
+			},
+		}
+		_, err = client.CoreV1().Pods(namespace).UpdateStatus(context.TODO(), pod, metav1.UpdateOptions{})
+		if err != nil {
+			return fmt.Errorf("failed to create update status of the pod %s: %w", podName, err)
+		}
+	}
+	return nil
+}

operator/pkg/util/util.go

@@ -29,12 +29,28 @@ import (
 	"strings"
 	"time"
 
+	clientset "k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/rest"
 	"k8s.io/klog/v2"
 	"sigs.k8s.io/yaml"
 
+	operatorv1alpha1 "github.com/karmada-io/karmada/operator/pkg/apis/operator/v1alpha1"
+	"github.com/karmada-io/karmada/operator/pkg/workflow"
 	"github.com/karmada-io/karmada/pkg/util"
 )
 
+var (
+	// ClientFactory creates a new Kubernetes clientset from the provided kubeconfig.
+	ClientFactory = func(kubeconfig *rest.Config) (clientset.Interface, error) {
+		return clientset.NewForConfig(kubeconfig)
+	}
+
+	// BuildClientFromSecretRefFactory constructs a Kubernetes clientset using a LocalSecretReference.
+	BuildClientFromSecretRefFactory = func(client clientset.Interface, ref *operatorv1alpha1.LocalSecretReference) (clientset.Interface, error) {
+		return BuildClientFromSecretRef(client, ref)
+	}
+)
+
 // Downloader Download progress
 type Downloader struct {
 	io.Reader
@@ -222,3 +238,51 @@ func ReplaceYamlForReg(path, destResource string, reg *regexp.Regexp) ([]byte, e
 	repl := reg.ReplaceAllString(string(data), destResource)
 	return yaml.YAMLToJSON([]byte(repl))
 }
+
+// ContainAllTasks checks if all tasks in the subset are present in the tasks slice.
+// Returns an error if any subset task is not found; nil otherwise.
+func ContainAllTasks(tasks, subset []workflow.Task) error {
+	for _, subsetTask := range subset {
+		found := false
+		for _, task := range tasks {
+			found = DeepEqualTasks(task, subsetTask) == nil
+			if found {
+				break
+			}
+		}
+		if !found {
+			return fmt.Errorf("subset task %v not found in tasks", subsetTask)
+		}
+	}
+	return nil
+}
+
+// DeepEqualTasks checks if two workflow.Task instances are deeply equal.
+// It returns an error if they differ, or nil if they are equal.
+// The comparison includes the task name, RunSubTasks flag,
+// and the length and contents of the Tasks slice.
+// Function references and behavior are not compared; only the values
+// of the specified fields are considered. Any differences are detailed
+// in the returned error.
+func DeepEqualTasks(t1, t2 workflow.Task) error {
+	if t1.Name != t2.Name {
+		return fmt.Errorf("expected t1 name %s, but got %s", t2.Name, t1.Name)
+	}
+
+	if t1.RunSubTasks != t2.RunSubTasks {
+		return fmt.Errorf("expected t1 RunSubTasks flag %t, but got %t", t2.RunSubTasks, t1.RunSubTasks)
+	}
+
+	if len(t1.Tasks) != len(t2.Tasks) {
+		return fmt.Errorf("expected t1 tasks length %d, but got %d", len(t2.Tasks), len(t1.Tasks))
+	}
+
+	for index := range t1.Tasks {
+		err := DeepEqualTasks(t1.Tasks[index], t2.Tasks[index])
+		if err != nil {
+			return fmt.Errorf("unexpected error; tasks are not equal at index %d: %v", index, err)
+		}
+	}
+
+	return nil
+}