github.com/ironcore-dev/gardener-extension-provider-ironcore@v0.3.2-0.20240314231816-8336447fb9a0/pkg/webhook/cloudprovider/ensurer_test.go (about)

     1  // SPDX-FileCopyrightText: 2023 SAP SE or an SAP affiliate company and IronCore contributors
     2  // SPDX-License-Identifier: Apache-2.0
     3  
     4  package cloudprovider
     5  
     6  import (
     7  	"context"
     8  	"testing"
     9  
    10  	extensionscontroller "github.com/gardener/gardener/extensions/pkg/controller"
    11  	"github.com/gardener/gardener/extensions/pkg/webhook/cloudprovider"
    12  	gcontext "github.com/gardener/gardener/extensions/pkg/webhook/context"
    13  	gardencorev1beta1 "github.com/gardener/gardener/pkg/apis/core/v1beta1"
    14  	mockclient "github.com/gardener/gardener/pkg/mock/controller-runtime/client"
    15  	mockmanager "github.com/gardener/gardener/pkg/mock/controller-runtime/manager"
    16  	. "github.com/onsi/ginkgo/v2"
    17  	. "github.com/onsi/gomega"
    18  	"go.uber.org/mock/gomock"
    19  	corev1 "k8s.io/api/core/v1"
    20  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    21  	"k8s.io/apimachinery/pkg/runtime"
    22  	"k8s.io/client-go/tools/clientcmd"
    23  
    24  	api "github.com/ironcore-dev/gardener-extension-provider-ironcore/pkg/apis/ironcore"
    25  )
    26  
    27  const namespace = "test"
    28  
    29  func TestController(t *testing.T) {
    30  	RegisterFailHandler(Fail)
    31  	RunSpecs(t, "CloudProvider Webhook Suite")
    32  }
    33  
    34  var _ = Describe("Ensurer", func() {
    35  	var (
    36  		ctrl   *gomock.Controller
    37  		ctx    = context.TODO()
    38  		mgr    *mockmanager.MockManager
    39  		c      *mockclient.MockClient
    40  		scheme *runtime.Scheme
    41  
    42  		cloudProfileConfig = &api.CloudProfileConfig{
    43  			TypeMeta:      metav1.TypeMeta{},
    44  			MachineImages: []api.MachineImages{},
    45  			RegionConfigs: []api.RegionConfig{
    46  				{
    47  					Name:                     "foo",
    48  					Server:                   "https://localhost",
    49  					CertificateAuthorityData: []byte("abcd1234"),
    50  				},
    51  			},
    52  		}
    53  
    54  		eContextK8s = gcontext.NewInternalGardenContext(
    55  			&extensionscontroller.Cluster{
    56  				CloudProfile: &gardencorev1beta1.CloudProfile{
    57  					Spec: gardencorev1beta1.CloudProfileSpec{
    58  						ProviderConfig: &runtime.RawExtension{
    59  							Object: cloudProfileConfig,
    60  						},
    61  					},
    62  				},
    63  				Shoot: &gardencorev1beta1.Shoot{
    64  					Spec: gardencorev1beta1.ShootSpec{
    65  						Region: "foo",
    66  						Kubernetes: gardencorev1beta1.Kubernetes{
    67  							Version: "1.26.0",
    68  						},
    69  					},
    70  				},
    71  			},
    72  		)
    73  	)
    74  
    75  	BeforeEach(func() {
    76  		ctrl = gomock.NewController(GinkgoT())
    77  		c = mockclient.NewMockClient(ctrl)
    78  		scheme = &runtime.Scheme{}
    79  
    80  		mgr = mockmanager.NewMockManager(ctrl)
    81  		mgr.EXPECT().GetClient().Return(c)
    82  		mgr.EXPECT().GetScheme().Return(scheme)
    83  	})
    84  
    85  	AfterEach(func() {
    86  		ctrl.Finish()
    87  	})
    88  
    89  	Describe("#EnsureCloudProviderSecret", func() {
    90  		var (
    91  			secret                 *corev1.Secret
    92  			secretWithoutToken     *corev1.Secret
    93  			secretWithoutNamespace *corev1.Secret
    94  			secretWithoutUsername  *corev1.Secret
    95  			ensurer                cloudprovider.Ensurer
    96  		)
    97  
    98  		BeforeEach(func() {
    99  			secret = &corev1.Secret{
   100  				ObjectMeta: metav1.ObjectMeta{
   101  					Namespace: namespace,
   102  					Name:      "cloudprovider",
   103  				},
   104  				Data: map[string][]byte{
   105  					"namespace": []byte("foo"),
   106  					"token":     []byte("bar"),
   107  					"username":  []byte("admin"),
   108  				},
   109  			}
   110  
   111  			secretWithoutToken = &corev1.Secret{
   112  				ObjectMeta: metav1.ObjectMeta{
   113  					Namespace: namespace,
   114  					Name:      "cloudprovider",
   115  				},
   116  				Data: map[string][]byte{
   117  					"token":    []byte("bar"),
   118  					"username": []byte("admin"),
   119  				},
   120  			}
   121  
   122  			secretWithoutNamespace = &corev1.Secret{
   123  				ObjectMeta: metav1.ObjectMeta{
   124  					Namespace: namespace,
   125  					Name:      "cloudprovider",
   126  				},
   127  				Data: map[string][]byte{
   128  					"namespace": []byte("foo"),
   129  					"username":  []byte("admin"),
   130  				},
   131  			}
   132  
   133  			secretWithoutUsername = &corev1.Secret{
   134  				ObjectMeta: metav1.ObjectMeta{
   135  					Namespace: namespace,
   136  					Name:      "cloudprovider",
   137  				},
   138  				Data: map[string][]byte{
   139  					"namespace": []byte("foo"),
   140  					"token":     []byte("bar"),
   141  				},
   142  			}
   143  
   144  			ensurer = NewEnsurer(logger, mgr)
   145  		})
   146  
   147  		It("should add a kubeconfig to the cloudprovider secret", func() {
   148  			err := ensurer.EnsureCloudProviderSecret(ctx, eContextK8s, secret, nil)
   149  			Expect(err).To(Not(HaveOccurred()))
   150  
   151  			Expect(secret.Data).To(HaveKey("kubeconfig"))
   152  			config, err := clientcmd.Load(secret.Data["kubeconfig"])
   153  			Expect(err).NotTo(HaveOccurred())
   154  			Expect(config.Clusters[config.CurrentContext].Server).To(Equal("https://localhost"))
   155  			Expect(config.Clusters[config.CurrentContext].CertificateAuthorityData).To(Equal([]byte("abcd1234")))
   156  			Expect(config.AuthInfos["admin"].Token).To(Equal("bar"))
   157  		})
   158  
   159  		It("should fail if the cloudprovider secret has no token", func() {
   160  			err := ensurer.EnsureCloudProviderSecret(ctx, eContextK8s, secretWithoutToken, nil)
   161  			Expect(err).To(HaveOccurred())
   162  		})
   163  
   164  		It("should fail if the cloudprovider secret has no namespace", func() {
   165  			err := ensurer.EnsureCloudProviderSecret(ctx, eContextK8s, secretWithoutNamespace, nil)
   166  			Expect(err).To(HaveOccurred())
   167  		})
   168  
   169  		It("should fail if the cloudprovider secret has no username", func() {
   170  			err := ensurer.EnsureCloudProviderSecret(ctx, eContextK8s, secretWithoutUsername, nil)
   171  			Expect(err).To(HaveOccurred())
   172  		})
   173  	})
   174  })