operator/pkg: unit test cert tasks

Signed-off-by: Mohamed Awnallah <[email protected]>

operator/pkg/tasks/init/cert_test.go

@@ -0,0 +1,323 @@
+package tasks
+
+import (
+ "context"
+ "fmt"
+ "strings"
+ "testing"
+
+ corev1 "k8s.io/api/core/v1"
+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ "k8s.io/client-go/kubernetes"
+ fakeclientset "k8s.io/client-go/kubernetes/fake"
+ "k8s.io/client-go/rest"
+
+ operatorv1alpha1 "github.com/karmada-io/karmada/operator/pkg/apis/operator/v1alpha1"
+ "github.com/karmada-io/karmada/operator/pkg/certs"
+ "github.com/karmada-io/karmada/operator/pkg/util"
+ "github.com/karmada-io/karmada/operator/pkg/workflow"
+)
+
+type TestInterface interface {
+ Get() string
+}
+
+type MyTestData struct {
+ Data string
+}
+
+func (m *MyTestData) Get() string {
+ return m.Data
+}
+
+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 kubernetes.Interface
+ karmadaClient kubernetes.Interface
+ controlplaneAddr string
+ certs []*certs.KarmadaCert
+}
+
+// Ensure TestInitData implements InitData interface at compile time.
+var _ InitData = &TestInitData{}
+
+func TestNewCertTask(t *testing.T) {
+ tests := []struct {
+ name string
+ wantTask workflow.Task
+ }{
+ {
+ name: "TestNewCertTask_IsCalled_ExpectedWorkflowTask",
+ wantTask: workflow.Task{
+ Name: "Certs",
+ Run: runCerts,
+ Skip: skipCerts,
+ RunSubTasks: true,
+ Tasks: newCertSubTasks(),
+ },
+ },
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ certTask := NewCertTask()
+ err := util.DeepEqualTasks(certTask, test.wantTask)
+ if err != nil {
+ t.Errorf("unexpected error, got %v", err)
+ }
+ })
+ }
+}
+
+func TestRunCerts(t *testing.T) {
+ tests := []struct {
+ name string
+ runData workflow.RunData
+ wantErr bool
+ errMsg string
+ }{
+ {
+ name: "RunCerts_InvalidTypeAssertion_TypeAssertionFailed",
+ runData: MyTestData{Data: "test"},
+ wantErr: true,
+ errMsg: "certs task invoked with an invalid data struct",
+ },
+ {
+ name: "RunCerts_ValidTypeAssertion_TypeAssertionSuceeded",
+ runData: &TestInitData{},
+ wantErr: false,
+ },
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ err := runCerts(test.runData)
+ if err == nil && test.wantErr {
+ t.Errorf("expected error, but got none")
+ }
+ if err != nil && !test.wantErr {
+ t.Errorf("unexpected error: %v", err)
+ }
+ if err != nil && test.wantErr && !strings.Contains(err.Error(), test.errMsg) {
+ t.Errorf("expected %s error msg to contain %s", err.Error(), test.errMsg)
+ }
+ })
+ }
+}
+
+func TestSkipCerts(t *testing.T) {
+ client := fakeclientset.NewSimpleClientset()
+ tests := []struct {
+ name string
+ runData workflow.RunData
+ prep func() error
+ cleanup func() error
+ wantErr bool
+ wantSkip bool
+ errMsg string
+ }{
+ {
+ name: "SkipCerts_InvalidTypeAssertion_TypeAssertionFailed",
+ runData: MyTestData{Data: "test"},
+ prep: func() error { return nil },
+ cleanup: func() error { return nil },
+ wantErr: true,
+ wantSkip: false,
+ errMsg: "certs task invoked with an invalid data struct",
+ },
+ {
+ name: "SkipCerts_ValidTypeAssertion_TypeAssertionSuceeded",
+ runData: &TestInitData{
+ name: "karmada-demo",
+ namespace: "test",
+ remoteClient: client,
+ },
+ prep: func() error { return nil },
+ cleanup: func() error { return nil },
+ wantErr: false,
+ wantSkip: false,
+ },
+ {
+ name: "SkipCerts_WithEmptySecretData_ErrorReturned",
+ runData: &TestInitData{
+ name: "karmada-demo",
+ namespace: "test",
+ remoteClient: client,
+ },
+ prep: func() error {
+ _, err := client.CoreV1().Secrets("test").Create(
+ context.TODO(), &corev1.Secret{
+ ObjectMeta: metav1.ObjectMeta{
+ Name: util.KarmadaCertSecretName("karmada-demo"),
+ Namespace: "test",
+ },
+ Data: map[string][]byte{},
+ },
+ metav1.CreateOptions{},
+ )
+ return err
+ },
+ cleanup: func() error {
+ err := client.CoreV1().Secrets("test").Delete(
+ context.TODO(), util.KarmadaCertSecretName("karmada-demo"),
+ metav1.DeleteOptions{},
+ )
+ if err != nil {
+ return fmt.Errorf("failed to delete %s secret", "test")
+ }
+ return nil
+ },
+ wantErr: true,
+ wantSkip: false,
+ },
+ {
+ name: "SkipCerts_SecertCertDataExist_CertsSkipped",
+ runData: &TestInitData{
+ name: "karmada-demo",
+ namespace: "test",
+ remoteClient: client,
+ },
+ prep: func() error {
+ var err error
+ _, err = client.CoreV1().Secrets("test").Create(
+ context.TODO(), &corev1.Secret{
+ ObjectMeta: metav1.ObjectMeta{
+ Name: util.KarmadaCertSecretName("karmada-demo"),
+ Namespace: "test",
+ },
+ Data: map[string][]byte{
+ "ca.crt": []byte("ca-crt-data"),
+ "ca.key": []byte("ca-key-data"),
+ },
+ },
+ metav1.CreateOptions{},
+ )
+ return err
+ },
+ cleanup: func() error {
+ err := client.CoreV1().Secrets("test").Delete(
+ context.TODO(), util.KarmadaCertSecretName("karmada-demo"),
+ metav1.DeleteOptions{},
+ )
+ if err != nil {
+ return fmt.Errorf("failed to delete %s secret", "test")
+ }
+ return nil
+ },
+ wantErr: false,
+ wantSkip: true,
+ },
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ err := test.prep()
+ if err != nil {
+ t.Errorf("failed to prep test: %v", err)
+ }
+
+ skip, err := skipCerts(test.runData)
+ if err == nil && test.wantErr {
+ t.Errorf("expected error, but got none")
+ }
+ if err != nil && !test.wantErr {
+ t.Errorf("unexpected error: %v", err)
+ }
+ if err != nil && test.wantErr && !strings.Contains(err.Error(), test.errMsg) {
+ t.Errorf("expected %s error msg to contain %s", err.Error(), test.errMsg)
+ }
+ if skip != test.wantSkip {
+ t.Errorf("expected %t skip, but got %t", test.wantSkip, skip)
+ }
+ err = test.cleanup()
+ if err != nil {
+ t.Errorf("failed to clean up test: %v", err)
+ }
+ })
+ }
+}
+
+// Implement InitData methods.
+func (t *TestInitData) GetName() string {
+ return t.name
+}
+
+func (t *TestInitData) GetNamespace() string {
+ return t.namespace
+}
+
+func (t *TestInitData) SetControlplaneConfig(config *rest.Config) {
+ t.controlplaneConfig = config
+}
+
+func (t *TestInitData) ControlplaneConfig() *rest.Config {
+ return t.controlplaneConfig
+}
+
+func (t *TestInitData) ControlplaneAddress() string {
+ return t.controlplaneAddr
+}
+
+func (t *TestInitData) RemoteClient() kubernetes.Interface {
+ return t.remoteClient
+}
+
+func (t *TestInitData) KarmadaClient() kubernetes.Interface {
+ return t.karmadaClient
+}
+
+func (t *TestInitData) DataDir() string {
+ return t.dataDir
+}
+
+func (t *TestInitData) CrdTarball() operatorv1alpha1.CRDTarball {
+ return t.crdTarball
+}
+
+func (t *TestInitData) KarmadaVersion() string {
+ return t.karmadaVersion
+}
+
+func (t *TestInitData) Components() *operatorv1alpha1.KarmadaComponents {
+ return t.components
+}
+
+func (t *TestInitData) FeatureGates() map[string]bool {
+ return t.featureGates
+}
+
+// Implement Cert Store Methods.
+func (t *TestInitData) AddCert(cert *certs.KarmadaCert) {
+ t.certs = append(t.certs, cert)
+}
+
+func (t *TestInitData) GetCert(name string) *certs.KarmadaCert {
+ for _, cert := range t.certs {
+ if cert.CertName() == name {
+ return cert
+ }
+ }
+ return nil
+}
+
+func (t *TestInitData) CertList() []*certs.KarmadaCert {
+ return t.certs
+}
+
+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
+}

operator/pkg/util/util.go

@@ -25,13 +25,15 @@ import (
  "net/http"
  "os"
  "path/filepath"
+ "reflect"
  "regexp"
  "strings"
  "time"
 
  "k8s.io/klog/v2"
  "sigs.k8s.io/yaml"
 
+ "github.com/karmada-io/karmada/operator/pkg/workflow"
  "github.com/karmada-io/karmada/pkg/util"
 )
 
@@ -222,3 +224,35 @@ func ReplaceYamlForReg(path, destResource string, reg *regexp.Regexp) ([]byte, e
  repl := reg.ReplaceAllString(string(data), destResource)
  return yaml.YAMLToJSON([]byte(repl))
 }
+
+// DeepEqualTasks compares two workflow.Task instances for deep equality.
+// Returns an error if they are not equal; nil if they are equal.
+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, got %v", err)
+ }
+ }
+
+ if reflect.ValueOf(t1.Skip).Pointer() != reflect.ValueOf(t2.Skip).Pointer() {
+ return fmt.Errorf("expected t1 Skip func %v, but got %v", reflect.ValueOf(t2.Skip).Pointer(), reflect.ValueOf(t1.Skip).Pointer())
+ }
+ if reflect.ValueOf(t1.Run).Pointer() != reflect.ValueOf(t2.Run).Pointer() {
+ return fmt.Errorf("expected t1 Run func %v, but got %v", reflect.ValueOf(t2.Run).Pointer(), reflect.ValueOf(t1.Run).Pointer())
+ }
+
+ return nil
+}