machine-api-operator.go

package operators

import (
	"context"
	"fmt"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	configv1 "github.com/openshift/api/config/v1"
	"github.com/openshift/cluster-api-actuator-pkg/pkg/framework"
	mapiv1beta1 "github.com/openshift/machine-api-operator/pkg/apis/machine/v1beta1"
	"k8s.io/utils/pointer"
)

var (
	maoDeployment        = "machine-api-operator"
	maoManagedDeployment = "machine-api-controllers"
)

var _ = Describe("[Feature:Operators] Machine API operator deployment should", func() {
	defer GinkgoRecover()

	It("be available", func() {
		client, err := framework.LoadClient()
		Expect(err).NotTo(HaveOccurred())
		Expect(framework.IsDeploymentAvailable(client, maoDeployment, framework.MachineAPINamespace)).To(BeTrue())
	})

	It("reconcile controllers deployment", func() {
		client, err := framework.LoadClient()
		Expect(err).NotTo(HaveOccurred())

		initialDeployment, err := framework.GetDeployment(client, maoManagedDeployment, framework.MachineAPINamespace)
		Expect(err).NotTo(HaveOccurred())

		By(fmt.Sprintf("checking deployment %q is available", maoManagedDeployment))
		Expect(framework.IsDeploymentAvailable(client, maoManagedDeployment, framework.MachineAPINamespace)).To(BeTrue())

		By(fmt.Sprintf("deleting deployment %q", maoManagedDeployment))
		Expect(framework.DeleteDeployment(client, initialDeployment)).NotTo(HaveOccurred())

		By(fmt.Sprintf("checking deployment %q is available again", maoManagedDeployment))
		Expect(framework.IsDeploymentAvailable(client, maoManagedDeployment, framework.MachineAPINamespace)).To(BeTrue())

		By(fmt.Sprintf("checking deployment %q spec matches", maoManagedDeployment))
		Expect(framework.IsDeploymentSynced(client, initialDeployment, maoManagedDeployment, framework.MachineAPINamespace)).To(BeTrue())
	})

	It("maintains deployment spec", func() {
		client, err := framework.LoadClient()
		Expect(err).NotTo(HaveOccurred())

		initialDeployment, err := framework.GetDeployment(client, maoManagedDeployment, framework.MachineAPINamespace)
		Expect(err).NotTo(HaveOccurred())

		By(fmt.Sprintf("checking deployment %q is available", maoManagedDeployment))
		Expect(framework.IsDeploymentAvailable(client, maoManagedDeployment, framework.MachineAPINamespace)).To(BeTrue())

		changedDeployment := initialDeployment.DeepCopy()
		changedDeployment.Spec.Replicas = pointer.Int32Ptr(0)

		By(fmt.Sprintf("updating deployment %q", maoManagedDeployment))
		Expect(framework.UpdateDeployment(client, maoManagedDeployment, framework.MachineAPINamespace, changedDeployment)).NotTo(HaveOccurred())

		By(fmt.Sprintf("checking deployment %q spec matches", maoManagedDeployment))
		Expect(framework.IsDeploymentSynced(client, initialDeployment, maoManagedDeployment, framework.MachineAPINamespace)).To(BeTrue())

		By(fmt.Sprintf("checking deployment %q is available again", maoManagedDeployment))
		Expect(framework.IsDeploymentAvailable(client, maoManagedDeployment, framework.MachineAPINamespace)).To(BeTrue())

	})

	It("reconcile mutating webhook configuration", func() {
		client, err := framework.LoadClient()
		Expect(err).NotTo(HaveOccurred())

		Expect(framework.IsMutatingWebhookConfigurationSynced(client)).To(BeTrue())
	})

	It("reconcile validating webhook configuration", func() {
		client, err := framework.LoadClient()
		Expect(err).NotTo(HaveOccurred())

		Expect(framework.IsValidatingWebhookConfigurationSynced(client)).To(BeTrue())
	})

	It("recover after validating webhook configuration deletion", func() {
		client, err := framework.LoadClient()
		Expect(err).NotTo(HaveOccurred())

		Expect(framework.DeleteValidatingWebhookConfiguration(client, framework.DefaultValidatingWebhookConfiguration)).To(Succeed())

		Expect(framework.IsValidatingWebhookConfigurationSynced(client)).To(BeTrue())
	})

	It("recover after mutating webhook configuration deletion", func() {
		client, err := framework.LoadClient()
		Expect(err).NotTo(HaveOccurred())

		Expect(framework.DeleteMutatingWebhookConfiguration(client, framework.DefaultMutatingWebhookConfiguration)).To(Succeed())

		Expect(framework.IsMutatingWebhookConfigurationSynced(client)).To(BeTrue())
	})

	It("maintains spec after mutating webhook configuration change and preserve caBundle", func() {
		client, err := framework.LoadClient()
		Expect(err).NotTo(HaveOccurred())

		initial, err := framework.GetMutatingWebhookConfiguration(client, framework.DefaultMutatingWebhookConfiguration.Name)
		Expect(initial).ToNot(BeNil())
		Expect(err).To(Succeed())

		toUpdate := initial.DeepCopy()
		for _, webhook := range toUpdate.Webhooks {
			webhook.ClientConfig.CABundle = []byte("test")
			webhook.AdmissionReviewVersions = []string{"test"}
		}

		Expect(framework.UpdateMutatingWebhookConfiguration(client, toUpdate)).To(Succeed())

		Expect(framework.IsMutatingWebhookConfigurationSynced(client)).To(BeTrue())

		updated, err := framework.GetMutatingWebhookConfiguration(client, framework.DefaultMutatingWebhookConfiguration.Name)
		Expect(updated).ToNot(BeNil())
		Expect(err).To(Succeed())

		for i, webhook := range updated.Webhooks {
			Expect(webhook.ClientConfig.CABundle).To(Equal(initial.Webhooks[i].ClientConfig.CABundle))
		}
	})

	It("maintains spec after validating webhook configuration change and preserve caBundle", func() {
		client, err := framework.LoadClient()
		Expect(err).NotTo(HaveOccurred())

		initial, err := framework.GetValidatingWebhookConfiguration(client, framework.DefaultValidatingWebhookConfiguration.Name)
		Expect(initial).ToNot(BeNil())
		Expect(err).To(Succeed())

		toUpdate := initial.DeepCopy()
		for _, webhook := range toUpdate.Webhooks {
			webhook.ClientConfig.CABundle = []byte("test")
			webhook.AdmissionReviewVersions = []string{"test"}
		}

		Expect(framework.UpdateValidatingWebhookConfiguration(client, toUpdate)).To(Succeed())

		Expect(framework.IsValidatingWebhookConfigurationSynced(client)).To(BeTrue())

		updated, err := framework.GetValidatingWebhookConfiguration(client, framework.DefaultValidatingWebhookConfiguration.Name)
		Expect(updated).ToNot(BeNil())
		Expect(err).To(Succeed())

		for i, webhook := range updated.Webhooks {
			Expect(webhook.ClientConfig.CABundle).To(Equal(initial.Webhooks[i].ClientConfig.CABundle))
		}
	})

})

var _ = Describe("[Feature:Operators] Machine API cluster operator status should", func() {
	defer GinkgoRecover()

	It("be available", func() {
		client, err := framework.LoadClient()
		Expect(err).NotTo(HaveOccurred())
		Expect(framework.IsStatusAvailable(client, "machine-api")).To(BeTrue())
	})
})

var _ = Describe("[Feature:Operators] When cluster-wide proxy is configured, Machine API cluster operator should ", func() {
	var machineSet *mapiv1beta1.MachineSet
	var proxyMachineSet *mapiv1beta1.MachineSet
	var machineSetParams framework.MachineSetParams
	It("reflect the configured proxy in machine-api-controller", func() {
		By("creating host for proxy")
		client, err := framework.LoadClient()
		Expect(err).NotTo(HaveOccurred())
		proxyMachineSet, err = framework.CreateProxyMachineSet(client)
		Expect(err).NotTo(HaveOccurred())

		By("deploying an HTTP proxy")
		deployment, err := framework.DeployClusterProxy(client)
		Expect(err).NotTo(HaveOccurred())
		Expect(framework.IsDeploymentAvailable(client, deployment.Name, deployment.Namespace)).To(BeTrue())

		By("configuring cluster-wide proxy")
		pods, err := framework.GetPods(client, map[string]string{"app": "squid"})
		Expect(err).NotTo(HaveOccurred())
		Expect(len(pods.Items) > 0).To(BeTrue())
		proxy := configv1.Proxy{}
		proxy.Spec.HTTPProxy = "http://" + pods.Items[0].Status.HostIP + ":80"
		proxy.Spec.HTTPSProxy = "http://" + pods.Items[0].Status.HostIP + ":80"
		framework.SetClusterProxy(client, proxy)
		Expect(err).NotTo(HaveOccurred())

		By("waiting for machine-api-controller deployment to reflect configured cluster-wide proxy")
		Expect(framework.WaitForProxyInjectionSync(client, maoManagedDeployment, framework.MachineAPINamespace, true)).To(BeTrue())
	})

	It("allow a machineset to be created and destroyed", func() {
		client, err := framework.LoadClient()
		Expect(err).NotTo(HaveOccurred())

		By("creating a machineset")

		machineSetParams = framework.BuildMachineSetParams(client, 3)
		machineSet, err = framework.CreateMachineSet(client, machineSetParams)
		Expect(err).ToNot(HaveOccurred())
		framework.WaitForMachineSet(client, machineSet.GetName())

		By("destroying a machineset")
		err = client.Delete(context.Background(), machineSet)
		Expect(err).ToNot(HaveOccurred())
		framework.WaitForMachineSetDelete(client, machineSet)
	})

	It("reflect an unconfigured proxy in machine-api-controller", func() {
		client, err := framework.LoadClient()
		Expect(err).NotTo(HaveOccurred())

		By("unconfiguring cluster-wide proxy")
		proxy := configv1.Proxy{}
		proxy.Spec.HTTPProxy = ""
		proxy.Spec.HTTPSProxy = ""
		framework.SetClusterProxy(client, proxy)
		Expect(err).NotTo(HaveOccurred())

		By("waiting for machine-api-controller deployment to reflect unconfigured cluster-wide proxy")
		Expect(framework.WaitForProxyInjectionSync(client, maoManagedDeployment, framework.MachineAPINamespace, false)).To(BeTrue())
		framework.DestroyClusterProxy(client)

		Expect(proxyMachineSet != nil).To(BeTrue())
		framework.DeleteMachineSets(client, proxyMachineSet)
	})

})