test(vm): refactor vm configuration test

images/virtualization-artifact/pkg/builder/vm/option.go

@@ -118,3 +118,12 @@ func WithProvisioningUserData(cloudInit string) Option {
 		UserData: cloudInit,
 	})
 }
+
+func WithRestartApprovalMode(restartApprovalMode v1alpha2.RestartApprovalMode) Option {
+	return func(vm *v1alpha2.VirtualMachine) {
+		if vm.Spec.Disruptions == nil {
+			vm.Spec.Disruptions = &v1alpha2.Disruptions{}
+		}
+		vm.Spec.Disruptions.RestartApprovalMode = restartApprovalMode
+	}
+}

test/e2e/internal/config/config.go

@@ -85,7 +85,6 @@ type TestData struct {
 	DiskResizing       string `yaml:"diskResizing"`
 	SizingPolicy       string `yaml:"sizingPolicy"`
 	ImageHotplug       string `yaml:"imageHotplug"`
-	VMConfiguration    string `yaml:"vmConfiguration"`
 	VMLabelAnnotation  string `yaml:"vmLabelAnnotation"`
 	VMMigration        string `yaml:"vmMigration"`
 	VMMigrationCancel  string `yaml:"vmMigrationCancel"`

test/e2e/internal/util/vm.go

@@ -101,3 +101,68 @@ func StopVirtualMachineFromOS(f *framework.Framework, vm *v1alpha2.VirtualMachin
 	}
 	return err
 }
+
+func RebootVirtualMachineBySSH(f *framework.Framework, vm *v1alpha2.VirtualMachine) {
+	GinkgoHelper()
+
+	_, err := f.SSHCommand(vm.Name, vm.Namespace, "sudo reboot")
+	Expect(err).NotTo(HaveOccurred())
+}
+
+func RebootVirtualMachineByVMOP(f *framework.Framework, vm *v1alpha2.VirtualMachine) {
+	GinkgoHelper()
+
+	vmop := vmopbuilder.New(
+		vmopbuilder.WithGenerateName("vmop-e2e-reboot-"),
+		vmopbuilder.WithNamespace(vm.Namespace),
+		vmopbuilder.WithType(v1alpha2.VMOPTypeRestart),
+		vmopbuilder.WithVirtualMachine(vm.Name),
+	)
+	err := f.CreateWithDeferredDeletion(context.Background(), vmop)
+	Expect(err).NotTo(HaveOccurred())
+}
+
+func UntilVirtualMachineRebooted(key client.ObjectKey, previousRunningTime time.Time, timeout time.Duration) {
+	Eventually(func() error {
+		vm := &v1alpha2.VirtualMachine{}
+		err := framework.GetClients().GenericClient().Get(context.Background(), key, vm)
+		if err != nil {
+			return fmt.Errorf("failed to get virtual machine: %w", err)
+		}
+
+		runningCondition, _ := conditions.GetCondition(vmcondition.TypeRunning, vm.Status.Conditions)
+
+		if runningCondition.LastTransitionTime.Time.After(previousRunningTime) && vm.Status.Phase == v1alpha2.MachineRunning {
+			return nil
+		}
+
+		return fmt.Errorf("virtual machine %s is not rebooted", key.Name)
+	}, timeout, time.Second).Should(Succeed())
+}
+
+func IsVDAttached(vm *v1alpha2.VirtualMachine, vd *v1alpha2.VirtualDisk) bool {
+	for _, bd := range vm.Status.BlockDeviceRefs {
+		if bd.Kind == v1alpha2.DiskDevice && bd.Name == vd.Name && bd.Attached {
+			return true
+		}
+	}
+	return false
+}
+
+func IsRestartRequired(vm *v1alpha2.VirtualMachine, timeout time.Duration) bool {
+	GinkgoHelper()
+
+	if vm.Spec.Disruptions.RestartApprovalMode != v1alpha2.Manual {
+		return false
+	}
+
+	Eventually(func(g Gomega) {
+		err := framework.GetClients().GenericClient().Get(context.Background(), client.ObjectKeyFromObject(vm), vm)
+		g.Expect(err).NotTo(HaveOccurred())
+		needRestart, _ := conditions.GetCondition(vmcondition.TypeAwaitingRestartToApplyConfiguration, vm.Status.Conditions)
+		g.Expect(needRestart.Status).To(Equal(metav1.ConditionTrue))
+		g.Expect(vm.Status.RestartAwaitingChanges).NotTo(BeNil())
+	}).WithTimeout(timeout).WithPolling(time.Second).Should(Succeed())
+
+	return true
+}

test/e2e/legacy/util.go

@@ -831,3 +831,19 @@ func CheckExternalConnection(host, httpCode, vmNamespace string, vmNames ...stri
 		CheckResultSSHCommand(vmNamespace, vmName, cmd, httpCode)
 	}
 }
+
+func ExecSSHCommand(vmNamespace, vmName, cmd string) {
+	GinkgoHelper()
+
+	Eventually(func() error {
+		res := framework.GetClients().D8Virtualization().SSHCommand(vmName, cmd, d8.SSHOptions{
+			Namespace:    vmNamespace,
+			Username:     conf.TestData.SSHUser,
+			IdentityFile: conf.TestData.Sshkey,
+		})
+		if res.Error() != nil {
+			return fmt.Errorf("cmd: %s\nstderr: %s", res.GetCmd(), res.StdErr())
+		}
+		return nil
+	}).WithTimeout(Timeout).WithPolling(Interval).ShouldNot(HaveOccurred())
+}