From 8cdb59f01b611c2a510ef0404ad5b08e83dc7cf1 Mon Sep 17 00:00:00 2001 From: Yang Le Date: Fri, 3 Apr 2020 20:42:02 +0800 Subject: [PATCH] Add unit test cases --- pkg/spoke/bootstrap/bootstrap.go | 3 +- pkg/spoke/bootstrap/bootstrap_test.go | 234 ++++++++++++++++++++++++++ 2 files changed, 235 insertions(+), 2 deletions(-) create mode 100644 pkg/spoke/bootstrap/bootstrap_test.go diff --git a/pkg/spoke/bootstrap/bootstrap.go b/pkg/spoke/bootstrap/bootstrap.go index dec269d92..6975a2285 100644 --- a/pkg/spoke/bootstrap/bootstrap.go +++ b/pkg/spoke/bootstrap/bootstrap.go @@ -359,9 +359,8 @@ func getAgentName(secretKey string, coreClient corev1client.CoreV1Interface) (st if err != nil { if kerrors.IsNotFound(err) { return "", nil - } else { - return "", fmt.Errorf("unable to get secret %q: %v", secretKey, err) } + return "", fmt.Errorf("unable to get secret %q: %v", secretKey, err) } if secret.Data == nil { diff --git a/pkg/spoke/bootstrap/bootstrap_test.go b/pkg/spoke/bootstrap/bootstrap_test.go new file mode 100644 index 000000000..f2594e9bd --- /dev/null +++ b/pkg/spoke/bootstrap/bootstrap_test.go @@ -0,0 +1,234 @@ +package bootstrap + +import ( + "context" + "strings" + "testing" + + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + kubefakeclient "k8s.io/client-go/kubernetes/fake" +) + +func TestRecoverAgentState(t *testing.T) { + kubeClient := kubefakeclient.NewSimpleClientset() + + options := &Options{ + HubKubeconfigSecret: "default/hub-kubeconfig-secret", + BootstrapKubeconfigSecret: "default/bootstrap-kubeconfig-secret", + CertStoreSecret: "default/cert-store-secret", + } + + agentName, bootstrapped, err := recoverAgentState(kubeClient.CoreV1(), options) + if err != nil { + t.Fatalf("failed to recover agent state: %v", err) + } + + if agentName != "" { + t.Fatal("agent name should be empty") + } + + if bootstrapped { + t.Fatal("agent should have not been bootstrapped") + } +} + +func TestRecoverAgentStateWithAgentName(t *testing.T) { + options := &Options{ + HubKubeconfigSecret: "default/hub-kubeconfig-secret", + CertStoreSecret: "default/cert-store-secret", + } + + agentName := "cluster1: agent1" + secret := &corev1.Secret{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: "default", + Name: "cert-store-secret", + }, + Data: map[string][]byte{ + agentNameSecretDataKey: []byte(agentName), + }, + } + + kubeClient := kubefakeclient.NewSimpleClientset(secret) + + an, bootstrapped, err := recoverAgentState(kubeClient.CoreV1(), options) + if err != nil { + t.Fatalf("failed to recover agent state: %v", err) + } + + if an != agentName { + t.Fatalf("expect agent name %q, but got %q", agentName, an) + } + + if bootstrapped { + t.Fatal("agent should have not been bootstrapped") + } +} + +func TestResolveAgentName(t *testing.T) { + kubeClient := kubefakeclient.NewSimpleClientset() + + agentName, err := resolveAgentName("non-existing-secret", "", kubeClient.CoreV1()) + if err != nil { + t.Fatalf("failed to resolve agent name: %v", err) + } + + if agentName != "" { + t.Fatal("agent name should be empty") + } +} + +func TestResolveAgentNameWithSecret(t *testing.T) { + namespace := "default" + name := "cert-store-secret" + + agentName := "cluster1: agent1" + secret := &corev1.Secret{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: namespace, + Name: name, + }, + Data: map[string][]byte{ + agentNameSecretDataKey: []byte(agentName), + }, + } + kubeClient := kubefakeclient.NewSimpleClientset(secret) + + an, err := resolveAgentName(namespace+"/"+name, "", kubeClient.CoreV1()) + if err != nil { + t.Fatalf("failed to resolve agent name: %v", err) + } + + if an != agentName { + t.Fatalf("expect agent name %q, but got %q", agentName, an) + } +} + +func TestResolveAgentNameWithSecretAndNameOverride(t *testing.T) { + namespace := "default" + name := "cert-store-secret" + + agentName := "cluster1: agent1" + clusterName := "cluster0" + secret := &corev1.Secret{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: namespace, + Name: name, + }, + Data: map[string][]byte{ + agentNameSecretDataKey: []byte(agentName), + }, + } + kubeClient := kubefakeclient.NewSimpleClientset(secret) + + an, err := resolveAgentName(namespace+"/"+name, clusterName, kubeClient.CoreV1()) + if err != nil { + t.Fatalf("failed to resolve agent name: %v", err) + } + + if an == agentName { + t.Fatal("agent should not loaded from secret") + } + + if !strings.HasPrefix(an, clusterName) { + t.Fatalf("expect agent name starts with cluster name %q", clusterName) + } +} + +func TestGetClusterName(t *testing.T) { + cn, err := getClusterName("") + if err != nil { + t.Fatalf("failed to get cluster name from agent name: %v", err) + } + + if cn != "" { + t.Fatal("cluster name should be empty") + } +} + +func TestGetClusterNameWithInvalidInput(t *testing.T) { + _, err := getClusterName("abc") + if err == nil { + t.Fatal("should return error when agent name is invalid") + } +} + +func TestGetClusterNameWithValidInput(t *testing.T) { + clusterName := "cluster0" + cn, err := getClusterName(clusterName + ":cde") + if err != nil { + t.Fatalf("failed to get cluster name from agent name: %v", err) + } + + if cn != clusterName { + t.Fatalf("expect cluster name %q, got %q", clusterName, cn) + } +} + +func TestGetAgentName(t *testing.T) { + kubeClient := kubefakeclient.NewSimpleClientset() + agentName, err := getAgentName("non-existing-secret", kubeClient.CoreV1()) + if err != nil { + t.Fatalf("failed to get agent name: %v", err) + } + + if agentName != "" { + t.Fatal("agent name should be empty") + } +} + +func TestGetAgentNameWithSecret(t *testing.T) { + namespace := "default" + name := "cert-store-secret" + + agentName := "cluster1: agent1" + secret := &corev1.Secret{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: namespace, + Name: name, + }, + Data: map[string][]byte{ + agentNameSecretDataKey: []byte(agentName), + }, + } + + kubeClient := kubefakeclient.NewSimpleClientset(secret) + an, err := getAgentName(namespace+"/"+name, kubeClient.CoreV1()) + if err != nil { + t.Fatalf("failed to get agent name: %v", err) + } + + if an != agentName { + t.Fatalf("expect agent name %q, but got %q", agentName, an) + } +} + +func TestWriteAgentName(t *testing.T) { + kubeClient := kubefakeclient.NewSimpleClientset() + agentName := "cluster1:agent1" + namespace, name := "default", "cert-store-secret" + err := writeAgentName(agentName, namespace+"/"+name, kubeClient.CoreV1()) + if err != nil { + t.Fatalf("failed to write agent name: %v", err) + } + + secret, err := kubeClient.CoreV1().Secrets(namespace).Get(context.Background(), name, metav1.GetOptions{}) + if err != nil { + t.Fatalf("failed to get secret: %v", err) + } + + if secret.Data == nil { + t.Fatalf("secret is empty") + } + + value, ok := secret.Data[agentNameSecretDataKey] + if !ok { + t.Fatal("agent name is not writtten") + } + + if string(value) != agentName { + t.Fatalf("expected %q but got %q", agentName, string(value)) + } + +}