defaults_test.go

// Copyright (c) 2020 SAP SE or an SAP affiliate company. All rights reserved. This file is licensed under the Apache Software License, v. 2 except as noted otherwise in the LICENSE file
//
// 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 v1alpha1_test

import (
	"time"

	. "github.com/gardener/gardener/pkg/apis/core/v1alpha1"
	v1beta1constants "github.com/gardener/gardener/pkg/apis/core/v1beta1/constants"

	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"
	. "github.com/onsi/gomega/gstruct"
	rbacv1 "k8s.io/api/rbac/v1"
	"k8s.io/apimachinery/pkg/api/resource"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/utils/pointer"
)

var _ = Describe("Defaults", func() {
	Describe("#SetDefaults_Project", func() {
		var obj *Project

		BeforeEach(func() {
			obj = &Project{}
		})

		Context("api group defaulting", func() {
			DescribeTable(
				"should default the owner api groups",
				func(owner *rbacv1.Subject, kind string, expectedAPIGroup string) {
					if owner != nil {
						owner.Kind = kind
					}

					obj.Spec.Owner = owner

					SetDefaults_Project(obj)

					if owner != nil {
						Expect(obj.Spec.Owner.APIGroup).To(Equal(expectedAPIGroup))
					} else {
						Expect(obj.Spec.Owner).To(BeNil())
					}
				},
				Entry("do nothing because owner is nil", nil, "", ""),
				Entry("kind serviceaccount", &rbacv1.Subject{}, rbacv1.ServiceAccountKind, ""),
				Entry("kind user", &rbacv1.Subject{}, rbacv1.UserKind, rbacv1.GroupName),
				Entry("kind group", &rbacv1.Subject{}, rbacv1.GroupKind, rbacv1.GroupName),
			)

			It("should default the api groups of members", func() {
				member1 := ProjectMember{
					Subject: rbacv1.Subject{
						APIGroup: "group",
						Kind:     "kind",
						Name:     "member1",
					},
					Roles: []string{"role"},
				}
				member2 := ProjectMember{
					Subject: rbacv1.Subject{
						Kind: rbacv1.ServiceAccountKind,
						Name: "member2",
					},
					Roles: []string{"role"},
				}
				member3 := ProjectMember{
					Subject: rbacv1.Subject{
						Kind: rbacv1.UserKind,
						Name: "member3",
					},
					Roles: []string{"role"},
				}
				member4 := ProjectMember{
					Subject: rbacv1.Subject{
						Kind: rbacv1.GroupKind,
						Name: "member4",
					},
					Roles: []string{"role"},
				}

				obj.Spec.Members = []ProjectMember{member1, member2, member3, member4}

				SetDefaults_Project(obj)

				Expect(obj.Spec.Members[0].APIGroup).To(Equal(member1.Subject.APIGroup))
				Expect(obj.Spec.Members[1].APIGroup).To(BeEmpty())
				Expect(obj.Spec.Members[2].APIGroup).To(Equal(rbacv1.GroupName))
				Expect(obj.Spec.Members[3].APIGroup).To(Equal(rbacv1.GroupName))
			})
		})

		It("should default the roles of members", func() {
			member1 := ProjectMember{
				Subject: rbacv1.Subject{
					APIGroup: "group",
					Kind:     "kind",
					Name:     "member1",
				},
			}
			member2 := ProjectMember{
				Subject: rbacv1.Subject{
					APIGroup: "group",
					Kind:     "kind",
					Name:     "member2",
				},
			}

			obj.Spec.Members = []ProjectMember{member1, member2}

			SetDefaults_Project(obj)

			for _, m := range obj.Spec.Members {
				Expect(m.Role).NotTo(HaveLen(0))
				Expect(m.Role).To(Equal(ProjectMemberViewer))
			}
		})

		It("should not add the 'protected' toleration if the namespace is not 'garden' (w/o existing project tolerations)", func() {
			obj.Spec.Namespace = pointer.String("foo")

			SetDefaults_Project(obj)

			Expect(obj.Spec.Tolerations).To(BeNil())
		})

		It("should not add the 'protected' toleration if the namespace is not 'garden' (w/ existing project tolerations)", func() {
			obj.Spec.Namespace = pointer.String("foo")
			obj.Spec.Tolerations = &ProjectTolerations{
				Defaults:  []Toleration{{Key: "foo"}},
				Whitelist: []Toleration{{Key: "bar"}},
			}

			SetDefaults_Project(obj)

			Expect(obj.Spec.Tolerations.Defaults).To(Equal([]Toleration{{Key: "foo"}}))
			Expect(obj.Spec.Tolerations.Whitelist).To(Equal([]Toleration{{Key: "bar"}}))
		})

		It("should add the 'protected' toleration if the namespace is 'garden' (w/o existing project tolerations)", func() {
			obj.Spec.Namespace = pointer.String(v1beta1constants.GardenNamespace)
			obj.Spec.Tolerations = nil

			SetDefaults_Project(obj)

			Expect(obj.Spec.Tolerations.Defaults).To(Equal([]Toleration{{Key: SeedTaintProtected}}))
			Expect(obj.Spec.Tolerations.Whitelist).To(Equal([]Toleration{{Key: SeedTaintProtected}}))
		})

		It("should add the 'protected' toleration if the namespace is 'garden' (w/ existing project tolerations)", func() {
			obj.Spec.Namespace = pointer.String(v1beta1constants.GardenNamespace)
			obj.Spec.Tolerations = &ProjectTolerations{
				Defaults:  []Toleration{{Key: "foo"}},
				Whitelist: []Toleration{{Key: "bar"}},
			}

			SetDefaults_Project(obj)

			Expect(obj.Spec.Tolerations.Defaults).To(Equal([]Toleration{{Key: "foo"}, {Key: SeedTaintProtected}}))
			Expect(obj.Spec.Tolerations.Whitelist).To(Equal([]Toleration{{Key: "bar"}, {Key: SeedTaintProtected}}))
		})
	})

	Describe("#SetDefaults_ControllerResource", func() {
		It("should default the primary field", func() {
			resource := ControllerResource{}

			SetDefaults_ControllerResource(&resource)

			Expect(resource.Primary).To(PointTo(BeTrue()))
		})

		It("should not default the primary field", func() {
			resource := ControllerResource{Primary: pointer.Bool(false)}
			resourceCopy := resource.DeepCopy()

			SetDefaults_ControllerResource(&resource)

			Expect(resource.Primary).To(Equal(resourceCopy.Primary))
		})

		const kindExtension = "Extension"
		It("should default the globallyEnabled field when kind is Extension", func() {
			resource := ControllerResource{Kind: kindExtension}
			SetDefaults_ControllerResource(&resource)

			Expect(resource.GloballyEnabled).To(Equal(pointer.Bool(false)))
		})

		It("should not default the globallyEnabled field when kind is Extension and globallyEnabled is already set", func() {
			resource := ControllerResource{Kind: kindExtension, GloballyEnabled: pointer.Bool(true)}
			SetDefaults_ControllerResource(&resource)

			Expect(resource.GloballyEnabled).To(Equal(pointer.Bool(true)))
		})

		It("should not default the globallyEnabled field when kind is not Extension", func() {
			resource := ControllerResource{Kind: "not extension"}
			SetDefaults_ControllerResource(&resource)

			Expect(resource.GloballyEnabled).To(BeNil())
		})

		It("should default the reconcile timeout when kind is Extension", func() {
			resource := ControllerResource{Kind: kindExtension}
			SetDefaults_ControllerResource(&resource)

			Expect(resource.ReconcileTimeout).To(Equal(&metav1.Duration{Duration: time.Minute * 3}))
		})

		It("should not default the reconcile timeout when kind is Extension and timeout is already set", func() {
			resource := ControllerResource{Kind: kindExtension, ReconcileTimeout: &metav1.Duration{Duration: time.Second * 62}}
			SetDefaults_ControllerResource(&resource)

			Expect(resource.ReconcileTimeout).To(Equal(&metav1.Duration{Duration: time.Second * 62}))
		})

		It("should not default the reconcile timeout when kind is not Extension", func() {
			resource := ControllerResource{Kind: "not extension"}
			SetDefaults_ControllerResource(&resource)

			Expect(resource.ReconcileTimeout).To(BeNil())
		})

		It("should default the lifecycle strategy field when kind is Extension", func() {
			resource := ControllerResource{Kind: kindExtension}
			SetDefaults_ControllerResource(&resource)

			Expect(resource.Lifecycle).ToNot(BeNil())
			Expect(*resource.Lifecycle.Reconcile).To(Equal(AfterKubeAPIServer))
			Expect(*resource.Lifecycle.Delete).To(Equal(BeforeKubeAPIServer))
			Expect(*resource.Lifecycle.Migrate).To(Equal(BeforeKubeAPIServer))
		})

		It("should default the lifecycle strategy field when kind is not Extension", func() {
			resource := ControllerResource{Kind: "not an extension"}
			SetDefaults_ControllerResource(&resource)

			Expect(resource.Lifecycle).To(BeNil())
		})

		It("should default only the missing lifecycle strategy fields when kind is Extension", func() {
			before := BeforeKubeAPIServer
			resource := ControllerResource{
				Kind: kindExtension,
				Lifecycle: &ControllerResourceLifecycle{
					Reconcile: &before,
				},
			}
			SetDefaults_ControllerResource(&resource)

			Expect(resource.Lifecycle).ToNot(BeNil())
			Expect(*resource.Lifecycle.Reconcile).To(Equal(BeforeKubeAPIServer))
			Expect(*resource.Lifecycle.Delete).To(Equal(BeforeKubeAPIServer))
			Expect(*resource.Lifecycle.Migrate).To(Equal(BeforeKubeAPIServer))
		})
	})

	Describe("#SetDefaults_ControllerDeployment", func() {
		var (
			ondemand = ControllerDeploymentPolicyOnDemand
			always   = ControllerDeploymentPolicyAlways
		)

		It("should default the policy field", func() {
			deployment := ControllerRegistrationDeployment{}

			SetDefaults_ControllerRegistrationDeployment(&deployment)

			Expect(deployment.Policy).To(PointTo(Equal(ondemand)))
		})

		It("should not default the policy field", func() {
			deployment := ControllerRegistrationDeployment{Policy: &always}
			deploymentCopy := deployment.DeepCopy()

			SetDefaults_ControllerRegistrationDeployment(&deployment)

			Expect(deployment.Policy).To(Equal(deploymentCopy.Policy))
		})
	})

	Describe("#SetDefaults_Seed", func() {
		var obj *Seed

		BeforeEach(func() {
			obj = &Seed{}
		})

		It("should default the seed settings (w/o taints)", func() {
			SetDefaults_Seed(obj)

			Expect(obj.Spec.Settings.DependencyWatchdog).NotTo(BeNil())
			Expect(obj.Spec.Settings.ExcessCapacityReservation.Enabled).To(BeTrue())
			Expect(obj.Spec.Settings.Scheduling.Visible).To(BeTrue())
			Expect(obj.Spec.Settings.VerticalPodAutoscaler.Enabled).To(BeTrue())
			Expect(obj.Spec.Settings.OwnerChecks.Enabled).To(BeTrue())
		})

		It("should allow taints that were not allowed in version v1.12", func() {
			taints := []SeedTaint{
				{Key: "seed.gardener.cloud/disable-capacity-reservation"},
				{Key: "seed.gardener.cloud/disable-dns"},
				{Key: "seed.gardener.cloud/invisible"},
			}
			obj.Spec.Taints = taints

			SetDefaults_Seed(obj)

			Expect(obj.Spec.Settings.DependencyWatchdog).NotTo(BeNil())
			Expect(obj.Spec.Settings.ExcessCapacityReservation.Enabled).To(BeTrue())
			Expect(obj.Spec.Settings.Scheduling.Visible).To(BeTrue())
			Expect(obj.Spec.Settings.VerticalPodAutoscaler.Enabled).To(BeTrue())
			Expect(obj.Spec.Settings.OwnerChecks.Enabled).To(BeTrue())
			Expect(obj.Spec.Taints).To(HaveLen(3))
			Expect(obj.Spec.Taints).To(Equal(taints))
		})

		It("should not default the seed settings because they were provided", func() {
			var (
				dwdEndpointEnabled        = false
				dwdProbeEnabled           = false
				excessCapacityReservation = false
				scheduling                = true
				vpaEnabled                = false
				ownerChecks               = false
			)

			obj.Spec.Settings = &SeedSettings{
				DependencyWatchdog: &SeedSettingDependencyWatchdog{
					Endpoint: &SeedSettingDependencyWatchdogEndpoint{Enabled: dwdEndpointEnabled},
					Probe:    &SeedSettingDependencyWatchdogProbe{Enabled: dwdProbeEnabled},
				},
				ExcessCapacityReservation: &SeedSettingExcessCapacityReservation{Enabled: excessCapacityReservation},
				Scheduling:                &SeedSettingScheduling{Visible: scheduling},
				VerticalPodAutoscaler:     &SeedSettingVerticalPodAutoscaler{Enabled: vpaEnabled},
				OwnerChecks:               &SeedSettingOwnerChecks{Enabled: ownerChecks},
			}

			SetDefaults_Seed(obj)

			Expect(obj.Spec.Settings.DependencyWatchdog.Endpoint.Enabled).To(Equal(dwdEndpointEnabled))
			Expect(obj.Spec.Settings.DependencyWatchdog.Probe.Enabled).To(Equal(dwdProbeEnabled))
			Expect(obj.Spec.Settings.ExcessCapacityReservation.Enabled).To(Equal(excessCapacityReservation))
			Expect(obj.Spec.Settings.Scheduling.Visible).To(Equal(scheduling))
			Expect(obj.Spec.Settings.VerticalPodAutoscaler.Enabled).To(Equal(vpaEnabled))
			Expect(obj.Spec.Settings.OwnerChecks.Enabled).To(Equal(ownerChecks))
		})
	})

	Describe("#SetDefaults_SeedSettingDependencyWatchdog", func() {
		var obj *SeedSettingDependencyWatchdog

		BeforeEach(func() {
			obj = &SeedSettingDependencyWatchdog{}
		})

		It("should default the settings", func() {
			SetDefaults_SeedSettingDependencyWatchdog(obj)

			Expect(obj.Endpoint.Enabled).To(BeTrue())
			Expect(obj.Probe.Enabled).To(BeTrue())
		})

		It("should not default the seed settings because they were provided", func() {
			var (
				dwdEndpointEnabled = false
				dwdProbeEnabled    = false
			)

			obj = &SeedSettingDependencyWatchdog{
				Endpoint: &SeedSettingDependencyWatchdogEndpoint{Enabled: dwdEndpointEnabled},
				Probe:    &SeedSettingDependencyWatchdogProbe{Enabled: dwdProbeEnabled},
			}

			SetDefaults_SeedSettingDependencyWatchdog(obj)

			Expect(obj.Endpoint.Enabled).To(Equal(dwdEndpointEnabled))
			Expect(obj.Probe.Enabled).To(Equal(dwdProbeEnabled))
		})
	})

	Describe("#SetDefaults_Shoot", func() {
		var obj *Shoot

		BeforeEach(func() {
			obj = &Shoot{
				Spec: ShootSpec{
					Kubernetes: Kubernetes{
						Version: "1.22.1",
					},
				},
			}
		})

		It("should not add the 'protected' toleration if the namespace is not 'garden'", func() {
			obj.Namespace = "foo"
			obj.Spec.Tolerations = nil

			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Tolerations).To(BeNil())
		})

		It("should add the 'protected' toleration if the namespace is 'garden'", func() {
			obj.Namespace = "garden"
			obj.Spec.Tolerations = []Toleration{{Key: "foo"}}

			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Tolerations).To(ConsistOf(
				Equal(Toleration{Key: "foo"}),
				Equal(Toleration{Key: SeedTaintProtected}),
			))
		})

		It("should default the failSwapOn field", func() {
			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Kubernetes.Kubelet.FailSwapOn).To(PointTo(BeTrue()))
		})

		It("should not default the failSwapOn field", func() {
			falseVar := false
			obj.Spec.Kubernetes.Kubelet = &KubeletConfig{}
			obj.Spec.Kubernetes.Kubelet.FailSwapOn = &falseVar

			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Kubernetes.Kubelet.FailSwapOn).To(PointTo(BeFalse()))
		})

		It("should default the imageGCThreshold fields", func() {
			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Kubernetes.Kubelet.ImageGCHighThresholdPercent).To(PointTo(Equal(int32(50))))
			Expect(obj.Spec.Kubernetes.Kubelet.ImageGCLowThresholdPercent).To(PointTo(Equal(int32(40))))
		})

		It("should not default the imageGCThreshold fields", func() {
			var (
				high int32 = 12
				low  int32 = 34
			)

			obj.Spec.Kubernetes.Kubelet = &KubeletConfig{}
			obj.Spec.Kubernetes.Kubelet.ImageGCHighThresholdPercent = &high
			obj.Spec.Kubernetes.Kubelet.ImageGCLowThresholdPercent = &low

			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Kubernetes.Kubelet.ImageGCHighThresholdPercent).To(PointTo(Equal(high)))
			Expect(obj.Spec.Kubernetes.Kubelet.ImageGCLowThresholdPercent).To(PointTo(Equal(low)))
		})

		It("should default the serializeImagePulls field", func() {
			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Kubernetes.Kubelet.SerializeImagePulls).To(PointTo(BeTrue()))
		})

		It("should not default the serializeImagePulls field if it is already set", func() {
			falseVar := false
			obj.Spec.Kubernetes.Kubelet = &KubeletConfig{}
			obj.Spec.Kubernetes.Kubelet.SerializeImagePulls = &falseVar

			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Kubernetes.Kubelet.SerializeImagePulls).To(PointTo(BeFalse()))
		})

		It("should not default the kube-controller-manager's node monitor grace period", func() {
			nodeMonitorGracePeriod := &metav1.Duration{Duration: time.Minute}
			obj.Spec.Kubernetes.KubeControllerManager = &KubeControllerManagerConfig{NodeMonitorGracePeriod: nodeMonitorGracePeriod}

			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Kubernetes.KubeControllerManager.NodeMonitorGracePeriod).To(Equal(nodeMonitorGracePeriod))
		})

		It("should default the kube-controller-manager's node monitor grace period", func() {
			obj.Spec.Kubernetes.KubeControllerManager = &KubeControllerManagerConfig{}

			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Kubernetes.KubeControllerManager.NodeMonitorGracePeriod).To(Equal(&metav1.Duration{Duration: 2 * time.Minute}))
		})

		It("should default the kubeScheduler.profile field", func() {
			obj.Spec.Kubernetes.KubeScheduler = &KubeSchedulerConfig{}

			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Kubernetes.KubeScheduler.Profile).To(PointTo(Equal(SchedulingProfileBalanced)))
		})

		It("should not default the kubeScheduler.profile field if it is already set", func() {
			profile := SchedulingProfileBinPacking
			obj.Spec.Kubernetes.KubeScheduler = &KubeSchedulerConfig{
				Profile: &profile,
			}

			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Kubernetes.KubeScheduler.Profile).To(PointTo(Equal(SchedulingProfileBinPacking)))
		})

		Context("default kubeReserved", func() {
			var (
				defaultKubeReservedMemory = resource.MustParse("1Gi")
				defaultKubeReservedCPU    = resource.MustParse("80m")
				defaultKubeReservedPID    = resource.MustParse("20k")
				kubeReservedMemory        = resource.MustParse("2Gi")
				kubeReservedCPU           = resource.MustParse("20m")
				kubeReservedPID           = resource.MustParse("10k")
			)

			It("should default all fields", func() {
				SetDefaults_Shoot(obj)

				Expect(obj.Spec.Kubernetes.Kubelet.KubeReserved).To(PointTo(Equal(KubeletConfigReserved{
					CPU:    &defaultKubeReservedCPU,
					Memory: &defaultKubeReservedMemory,
					PID:    &defaultKubeReservedPID,
				})))
			})

			It("should not overwrite manually set kubeReserved", func() {
				obj.Spec.Kubernetes.Kubelet = &KubeletConfig{
					KubeReserved: &KubeletConfigReserved{
						CPU:    &kubeReservedCPU,
						Memory: &kubeReservedMemory,
						PID:    &kubeReservedPID,
					},
				}
				SetDefaults_Shoot(obj)

				Expect(obj.Spec.Kubernetes.Kubelet.KubeReserved).To(PointTo(Equal(KubeletConfigReserved{
					CPU:    &kubeReservedCPU,
					Memory: &kubeReservedMemory,
					PID:    &kubeReservedPID,
				})))
			})
		})

		It("should set the maintenance field", func() {
			obj.Spec.Maintenance = nil

			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Maintenance).To(Equal(&Maintenance{}))
		})

		It("should disable basic auth", func() {
			obj.Spec.Kubernetes.Version = "1.20.1"
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.EnableBasicAuthentication).To(PointTo(BeFalse()))
		})

		It("should default the max inflight requests fields", func() {
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.Requests.MaxNonMutatingInflight).To(Equal(pointer.Int32(400)))
			Expect(obj.Spec.Kubernetes.KubeAPIServer.Requests.MaxMutatingInflight).To(Equal(pointer.Int32(200)))
		})

		It("should not default the max inflight requests fields", func() {
			var (
				maxNonMutatingRequestsInflight int32 = 123
				maxMutatingRequestsInflight    int32 = 456
			)

			obj.Spec.Kubernetes.KubeAPIServer = &KubeAPIServerConfig{Requests: &KubeAPIServerRequests{}}
			obj.Spec.Kubernetes.KubeAPIServer.Requests.MaxNonMutatingInflight = &maxNonMutatingRequestsInflight
			obj.Spec.Kubernetes.KubeAPIServer.Requests.MaxMutatingInflight = &maxMutatingRequestsInflight

			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.Requests.MaxNonMutatingInflight).To(Equal(&maxNonMutatingRequestsInflight))
			Expect(obj.Spec.Kubernetes.KubeAPIServer.Requests.MaxMutatingInflight).To(Equal(&maxMutatingRequestsInflight))
		})

		It("should disable anonymous authentication by default", func() {
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.EnableAnonymousAuthentication).To(PointTo(BeFalse()))
		})

		It("should not default the anonymous authentication field if it is explicitly set", func() {
			trueVar := true
			obj.Spec.Kubernetes.KubeAPIServer = &KubeAPIServerConfig{EnableAnonymousAuthentication: &trueVar}
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.EnableAnonymousAuthentication).To(PointTo(BeTrue()))
		})

		It("should default the event ttl field", func() {
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.EventTTL).To(Equal(&metav1.Duration{Duration: time.Hour}))
		})

		It("should not default the event ttl field", func() {
			eventTTL := &metav1.Duration{Duration: 4 * time.Hour}
			obj.Spec.Kubernetes.KubeAPIServer = &KubeAPIServerConfig{EventTTL: eventTTL}

			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.EventTTL).To(Equal(eventTTL))
		})

		It("should default the log verbosity level", func() {
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.Logging.Verbosity).To(PointTo(Equal(int32(2))))
		})

		It("should not overwrite the log verbosity level", func() {
			obj.Spec.Kubernetes.KubeAPIServer = &KubeAPIServerConfig{Logging: &KubeAPIServerLogging{Verbosity: pointer.Int32(3)}}
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.Logging.Verbosity).To(PointTo(Equal(int32(3))))
		})

		It("should not default the access log level", func() {
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.Logging.HTTPAccessVerbosity).To(BeNil())
		})

		It("should default the defaultNotReadyTolerationSeconds field", func() {
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.DefaultNotReadyTolerationSeconds).To(PointTo(Equal(int64(300))))
		})

		It("should not default the defaultNotReadyTolerationSeconds field", func() {
			var tolerationSeconds int64 = 120
			obj.Spec.Kubernetes.KubeAPIServer = &KubeAPIServerConfig{DefaultNotReadyTolerationSeconds: pointer.Int64(tolerationSeconds)}

			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.DefaultNotReadyTolerationSeconds).To(PointTo(Equal(tolerationSeconds)))
		})

		It("should default the defaultUnreachableTolerationSeconds field", func() {
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.DefaultUnreachableTolerationSeconds).To(PointTo(Equal(int64(300))))
		})

		It("should not default the defaultUnreachableTolerationSeconds field", func() {
			var tolerationSeconds int64 = 120
			obj.Spec.Kubernetes.KubeAPIServer = &KubeAPIServerConfig{DefaultUnreachableTolerationSeconds: pointer.Int64(tolerationSeconds)}

			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Kubernetes.KubeAPIServer.DefaultUnreachableTolerationSeconds).To(PointTo(Equal(tolerationSeconds)))
		})

		It("should default architecture of worker's machine to amd64", func() {
			obj.Spec.Provider.Workers = []Worker{
				{Name: "Default Worker"},
				{Name: "Worker with machine architecture type",
					Machine: Machine{Architecture: pointer.String("test")}},
			}
			SetDefaults_Shoot(obj)
			Expect(*obj.Spec.Provider.Workers[0].Machine.Architecture).To(Equal(v1beta1constants.ArchitectureAMD64))
			Expect(*obj.Spec.Provider.Workers[1].Machine.Architecture).To(Equal("test"))
		})

		It("should default cri.name to containerd when control plane Kubernetes version >= 1.22", func() {
			obj.Spec.Kubernetes.Version = "1.22"
			obj.Spec.Provider.Workers = []Worker{
				{Name: "DefaultWorker"},
				{Name: "Worker with CRI configuration",
					CRI: &CRI{Name: "some configured value"}},
			}
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Provider.Workers[0].CRI).ToNot(BeNil())
			Expect(obj.Spec.Provider.Workers[0].CRI.Name).To(Equal(CRINameContainerD))
			Expect(obj.Spec.Provider.Workers[1].CRI.Name).To(BeEquivalentTo("some configured value"))
		})

		It("should default cri.name to containerd when worker Kubernetes version >= 1.22", func() {
			obj.Spec.Kubernetes.Version = "1.20"
			obj.Spec.Provider.Workers = []Worker{
				{Name: "DefaultWorker",
					Kubernetes: &WorkerKubernetes{Version: pointer.String("1.22")}},
				{Name: "Worker with CRI configuration",
					CRI: &CRI{Name: "some configured value"}},
			}
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Provider.Workers[0].CRI).ToNot(BeNil())
			Expect(obj.Spec.Provider.Workers[0].CRI.Name).To(Equal(CRINameContainerD))
			Expect(obj.Spec.Provider.Workers[1].CRI.Name).To(BeEquivalentTo("some configured value"))
		})

		It("should not default cri.name to containerd when control plane Kubernetes version < 1.22", func() {
			obj.Spec.Kubernetes.Version = "1.21"
			obj.Spec.Provider.Workers = []Worker{
				{Name: "DefaultWorker"},
				{Name: "Worker with CRI configuration",
					CRI: &CRI{Name: "some configured value"}},
			}
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Provider.Workers[0].CRI).To(BeNil())
			Expect(obj.Spec.Provider.Workers[1].CRI.Name).To(BeEquivalentTo("some configured value"))
		})

		It("should not default cri.name to containerd when worker Kubernetes version < 1.22", func() {
			obj.Spec.Kubernetes.Version = "1.22"
			obj.Spec.Provider.Workers = []Worker{
				{Name: "DefaultWorker",
					Kubernetes: &WorkerKubernetes{Version: pointer.String("1.21")}},
				{Name: "Worker with CRI configuration",
					CRI: &CRI{Name: "some configured value"}},
			}
			SetDefaults_Shoot(obj)
			Expect(obj.Spec.Provider.Workers[0].CRI).To(BeNil())
			Expect(obj.Spec.Provider.Workers[1].CRI.Name).To(BeEquivalentTo("some configured value"))
		})

		It("should set the workers settings field", func() {
			obj.Spec.Provider.WorkersSettings = nil

			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Provider.WorkersSettings).To(Equal(&WorkersSettings{SSHAccess: &SSHAccess{Enabled: true}}))
		})

		It("should not overwrite the ssh access field in workers settings", func() {
			obj.Spec.Provider.WorkersSettings = &WorkersSettings{
				SSHAccess: &SSHAccess{
					Enabled: false,
				},
			}

			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Provider.WorkersSettings).To(Equal(&WorkersSettings{SSHAccess: &SSHAccess{Enabled: false}}))
		})

		It("should set the system components and coredns autoscaling fields", func() {
			obj.Spec.SystemComponents = nil

			SetDefaults_Shoot(obj)

			Expect(obj.Spec.SystemComponents).To(Equal(&SystemComponents{CoreDNS: &CoreDNS{Autoscaling: &CoreDNSAutoscaling{Mode: CoreDNSAutoscalingModeHorizontal}}}))
		})

		It("should default the enableStaticTokenKubeconfig field", func() {
			SetDefaults_Shoot(obj)

			Expect(obj.Spec.Kubernetes.EnableStaticTokenKubeconfig).To(PointTo(BeTrue()))
		})
		Context("k8s version < 1.25", func() {
			BeforeEach(func() {
				obj.Spec.Kubernetes = Kubernetes{
					Version:       "1.24.0",
					KubeAPIServer: &KubeAPIServerConfig{},
				}
			})

			Context("allowPrivilegedContainers field is not set", func() {
				It("should set the field to true if PodSecurityPolicy admission plugin is not disabled", func() {
					SetDefaults_Shoot(obj)

					Expect(obj.Spec.Kubernetes.AllowPrivilegedContainers).To(PointTo(BeTrue()))
				})

				It("should not default the field if PodSecurityPolicy admission plugin is disabled in the shoot spec", func() {
					obj.Spec.Kubernetes.KubeAPIServer = &KubeAPIServerConfig{
						AdmissionPlugins: []AdmissionPlugin{
							{
								Name:     "PodSecurityPolicy",
								Disabled: pointer.Bool(true),
							},
						},
					}
					SetDefaults_Shoot(obj)

					Expect(obj.Spec.Kubernetes.AllowPrivilegedContainers).To(BeNil())
				})
			})

			Context("allowPrivilegedContainers field is set", func() {
				BeforeEach(func() {
					obj.Spec.Kubernetes.AllowPrivilegedContainers = pointer.Bool(false)
				})

				It("should not set the field", func() {
					SetDefaults_Shoot(obj)

					Expect(obj.Spec.Kubernetes.AllowPrivilegedContainers).To(PointTo(BeFalse()))
				})
			})
		})

		Context("k8s version >= 1.25", func() {
			BeforeEach(func() {
				obj.Spec.Kubernetes.Version = "1.25.0"
			})

			Context("allowPrivilegedContainers field is not set", func() {
				It("should not set the field", func() {
					SetDefaults_Shoot(obj)

					Expect(obj.Spec.Kubernetes.AllowPrivilegedContainers).To(BeNil())
				})
			})
		})
	})

	Describe("#SetDefaults_Maintenance", func() {
		var obj *Maintenance

		BeforeEach(func() {
			obj = &Maintenance{}
		})

		It("should correctly default the maintenance", func() {
			obj.AutoUpdate = nil
			obj.TimeWindow = nil

			SetDefaults_Maintenance(obj)

			Expect(obj.AutoUpdate).NotTo(BeNil())
			Expect(obj.AutoUpdate.KubernetesVersion).To(BeTrue())
			Expect(obj.AutoUpdate.MachineImageVersion).To(BeTrue())
			Expect(obj.TimeWindow).NotTo(BeNil())
			Expect(obj.TimeWindow.Begin).To(HaveSuffix("0000+0000"))
			Expect(obj.TimeWindow.End).To(HaveSuffix("0000+0000"))
		})
	})

	Describe("#SetDefaults_Worker", func() {
		var obj *Worker

		BeforeEach(func() {
			obj = &Worker{}
		})

		It("should set the allowSystemComponents field", func() {
			obj.SystemComponents = nil

			SetDefaults_Worker(obj)

			Expect(obj.SystemComponents.Allow).To(BeTrue())
		})
	})

	Describe("#SetDefaults_ClusterAutoscaler", func() {
		var (
			obj                *ClusterAutoscaler
			expanderRandom     = ClusterAutoscalerExpanderRandom
			expanderLeastWaste = ClusterAutoscalerExpanderLeastWaste
		)

		BeforeEach(func() {
			obj = &ClusterAutoscaler{}
		})

		It("should correctly default the ClusterAutoscaler", func() {
			SetDefaults_ClusterAutoscaler(obj)

			Expect(obj.ScaleDownDelayAfterAdd).To(PointTo(Equal(metav1.Duration{Duration: 1 * time.Hour})))
			Expect(obj.ScaleDownDelayAfterDelete).To(PointTo(Equal(metav1.Duration{Duration: 0})))
			Expect(obj.ScaleDownDelayAfterFailure).To(PointTo(Equal(metav1.Duration{Duration: 3 * time.Minute})))
			Expect(obj.ScaleDownUnneededTime).To(PointTo(Equal(metav1.Duration{Duration: 30 * time.Minute})))
			Expect(obj.ScanInterval).To(PointTo(Equal(metav1.Duration{Duration: 10 * time.Second})))
			Expect(obj.MaxNodeProvisionTime).To(PointTo(Equal(metav1.Duration{Duration: 20 * time.Minute})))
			Expect(obj.Expander).To(PointTo(Equal(expanderLeastWaste)))
			Expect(obj.MaxGracefulTerminationSeconds).To(PointTo(Equal(int32(600))))
		})

		It("should not default explicitly set fields", func() {
			obj = &ClusterAutoscaler{
				ScaleDownDelayAfterAdd:        &metav1.Duration{Duration: 1 * time.Hour},
				ScaleDownDelayAfterDelete:     &metav1.Duration{Duration: 2 * time.Hour},
				ScaleDownDelayAfterFailure:    &metav1.Duration{Duration: 3 * time.Hour},
				ScaleDownUnneededTime:         &metav1.Duration{Duration: 4 * time.Hour},
				ScaleDownUtilizationThreshold: pointer.Float64(0.8),
				ScanInterval:                  &metav1.Duration{Duration: 5 * time.Hour},
				Expander:                      &expanderRandom,
				MaxNodeProvisionTime:          &metav1.Duration{Duration: 6 * time.Hour},
				MaxGracefulTerminationSeconds: pointer.Int32(60 * 60 * 24),
			}

			SetDefaults_ClusterAutoscaler(obj)

			Expect(obj.ScaleDownDelayAfterAdd).To(PointTo(Equal(metav1.Duration{Duration: 1 * time.Hour})))
			Expect(obj.ScaleDownDelayAfterDelete).To(PointTo(Equal(metav1.Duration{Duration: 2 * time.Hour})))
			Expect(obj.ScaleDownDelayAfterFailure).To(PointTo(Equal(metav1.Duration{Duration: 3 * time.Hour})))
			Expect(obj.ScaleDownUnneededTime).To(PointTo(Equal(metav1.Duration{Duration: 4 * time.Hour})))
			Expect(obj.ScanInterval).To(PointTo(Equal(metav1.Duration{Duration: 5 * time.Hour})))
			Expect(obj.MaxNodeProvisionTime).To(PointTo(Equal(metav1.Duration{Duration: 6 * time.Hour})))
			Expect(obj.Expander).To(PointTo(Equal(ClusterAutoscalerExpanderRandom)))
			Expect(obj.MaxGracefulTerminationSeconds).To(PointTo(Equal(int32(60 * 60 * 24))))
		})
	})

	Describe("#SetDefaults_VerticalPodAutoscaler", func() {
		var obj *VerticalPodAutoscaler

		BeforeEach(func() {
			obj = &VerticalPodAutoscaler{}
		})

		It("should correctly default the VerticalPodAutoscaler", func() {
			SetDefaults_VerticalPodAutoscaler(obj)

			Expect(obj.Enabled).To(BeFalse())
			Expect(obj.EvictAfterOOMThreshold).To(PointTo(Equal(metav1.Duration{Duration: 10 * time.Minute})))
			Expect(obj.EvictionRateBurst).To(PointTo(Equal(int32(1))))
			Expect(obj.EvictionRateLimit).To(PointTo(Equal(float64(-1))))
			Expect(obj.EvictionTolerance).To(PointTo(Equal(0.5)))
			Expect(obj.RecommendationMarginFraction).To(PointTo(Equal(0.15)))
			Expect(obj.UpdaterInterval).To(PointTo(Equal(metav1.Duration{Duration: time.Minute})))
			Expect(obj.RecommenderInterval).To(PointTo(Equal(metav1.Duration{Duration: time.Minute})))
		})
	})

	Describe("#SetDefaults_MachineImageVersion", func() {
		var obj *MachineImageVersion

		BeforeEach(func() {
			obj = &MachineImageVersion{}
		})

		It("should correctly default the MachineImageVersion", func() {
			SetDefaults_MachineImageVersion(obj)

			Expect(len(obj.CRI)).To(Equal(1))
			Expect(obj.CRI[0].Name).To(Equal(CRINameDocker))
			Expect(obj.Architectures).To(Equal([]string{"amd64"}))
		})
	})
})