Adjust E2E test codes

Signed-off-by: Ming <mqiu@vmware.com>

test/e2e/basic/api-group/enable_api_group_versions.go

@@ -100,7 +100,7 @@ func APIGropuVersionsTest() {
 				DeleteBackups(context.Background(), *veleroCfg.ClientToInstallVelero)
 			})
 			if veleroCfg.InstallVelero {
-				By("Uninstall Velero", func() {
+				By("Uninstall Velero in api group version case", func() {
 					Expect(VeleroUninstall(ctx, veleroCfg.VeleroCLI, veleroCfg.VeleroNamespace)).NotTo(HaveOccurred())
 				})
 			}

test/e2e/basic/namespace-mapping.go

@@ -23,12 +23,13 @@ type NamespaceMapping struct {
 
 const NamespaceBaseName string = "ns-mp-"
 
-var OneNamespaceMappingResticTest func() = TestFunc(&NamespaceMapping{TestCase: TestCase{NSBaseName: NamespaceBaseName, NSIncluded: &[]string{NamespaceBaseName + "1"}, UseVolumeSnapshots: false}})
-var MultiNamespacesMappingResticTest func() = TestFunc(&NamespaceMapping{TestCase: TestCase{NSBaseName: NamespaceBaseName, NSIncluded: &[]string{NamespaceBaseName + "2", NamespaceBaseName + "3"}, UseVolumeSnapshots: false}})
-var OneNamespaceMappingSnapshotTest func() = TestFunc(&NamespaceMapping{TestCase: TestCase{NSBaseName: NamespaceBaseName, NSIncluded: &[]string{NamespaceBaseName + "4"}, UseVolumeSnapshots: true}})
-var MultiNamespacesMappingSnapshotTest func() = TestFunc(&NamespaceMapping{TestCase: TestCase{NSBaseName: NamespaceBaseName, NSIncluded: &[]string{NamespaceBaseName + "5", NamespaceBaseName + "6"}, UseVolumeSnapshots: true}})
+var OneNamespaceMappingResticTest func() = TestFunc(&NamespaceMapping{TestCase: TestCase{NamespacesTotal: 1, UseVolumeSnapshots: false}})
+var MultiNamespacesMappingResticTest func() = TestFunc(&NamespaceMapping{TestCase: TestCase{NamespacesTotal: 2, UseVolumeSnapshots: false}})
+var OneNamespaceMappingSnapshotTest func() = TestFunc(&NamespaceMapping{TestCase: TestCase{NamespacesTotal: 1, UseVolumeSnapshots: true}})
+var MultiNamespacesMappingSnapshotTest func() = TestFunc(&NamespaceMapping{TestCase: TestCase{NamespacesTotal: 2, UseVolumeSnapshots: true}})
 
 func (n *NamespaceMapping) Init() error {
+	n.TestCase.Init()
 	n.VeleroCfg = VeleroCfg
 	n.Client = *n.VeleroCfg.ClientToInstallVelero
 	n.VeleroCfg.UseVolumeSnapshots = n.UseVolumeSnapshots
@@ -38,29 +39,28 @@ func (n *NamespaceMapping) Init() error {
 	if n.UseVolumeSnapshots {
 		backupType = "snapshot"
 	}
+	n.CaseBaseName = "ns-mp-" + n.UUIDgen
+	var mappedNS string
+	var mappedNSList []string
+	n.NSIncluded = &[]string{}
+	for nsNum := 0; nsNum < n.NamespacesTotal; nsNum++ {
+		createNSName := fmt.Sprintf("%s-%00000d", n.CaseBaseName, nsNum)
+		*n.NSIncluded = append(*n.NSIncluded, createNSName)
+		mappedNS = mappedNS + createNSName + ":" + createNSName + "-mapped"
+		mappedNSList = append(mappedNSList, createNSName+"-mapped")
+		mappedNS = mappedNS + ","
+	}
+	mappedNS = strings.TrimRightFunc(mappedNS, func(r rune) bool {
+		return r == ','
+	})
+
 	n.TestMsg = &TestMSG{
 		Desc:      fmt.Sprintf("Restore namespace %s with namespace mapping by %s test", *n.NSIncluded, backupType),
 		FailedMSG: "Failed to restore with namespace mapping",
 		Text:      fmt.Sprintf("should restore namespace %s with namespace mapping by %s", *n.NSIncluded, backupType),
 	}
-	return nil
-}
-
-func (n *NamespaceMapping) StartRun() error {
-	var mappedNS string
-	var mappedNSList []string
-
-	for index, ns := range *n.NSIncluded {
-		mappedNS = mappedNS + ns + ":" + ns + UUIDgen.String()
-		mappedNSList = append(mappedNSList, ns+UUIDgen.String())
-		if index+1 != len(*n.NSIncluded) {
-			mappedNS = mappedNS + ","
-		}
-		n.BackupName = n.BackupName + ns
-		n.RestoreName = n.RestoreName + ns
-	}
-	n.BackupName = n.BackupName + UUIDgen.String()
-	n.RestoreName = n.RestoreName + UUIDgen.String()
+	n.BackupName = "backup-" + n.CaseBaseName
+	n.RestoreName = "restore-" + n.CaseBaseName
 
 	n.MappedNamespaceList = mappedNSList
 	fmt.Println(mappedNSList)
@@ -81,6 +81,7 @@ func (n *NamespaceMapping) StartRun() error {
 	}
 	return nil
 }
+
 func (n *NamespaceMapping) CreateResources() error {
 	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
 	defer ctxCancel()
@@ -115,3 +116,19 @@ func (n *NamespaceMapping) Verify() error {
 	}
 	return nil
 }
+
+func (n *NamespaceMapping) Clean() error {
+	if !n.VeleroCfg.Debug {
+		if err := DeleteStorageClass(context.Background(), n.Client, "kibishii-storage-class"); err != nil {
+			return err
+		}
+		for _, ns := range n.MappedNamespaceList {
+			if err := DeleteNamespace(context.Background(), n.Client, ns, false); err != nil {
+				return err
+			}
+		}
+
+		return n.GetTestCase().Clean()
+	}
+	return nil
+}

test/e2e/basic/nodeport.go

@@ -3,6 +3,7 @@ package basic
 import (
 	"context"
 	"fmt"
+	"strings"
 	"time"
 
 	. "github.com/onsi/ginkgo"
@@ -20,40 +21,42 @@ import (
 
 type NodePort struct {
 	TestCase
-	replica              int32
 	labels               map[string]string
-	containers           *[]v1.Container
 	serviceName          string
-	serviceSpec          *v1.ServiceSpec
+	namespaceToCollision []string
 	nodePort             int32
-	namespaceToCollision string
-	namespace            string
 }
 
 const NodeportBaseName string = "nodeport-"
 
-var NodePortTest func() = TestFunc(&NodePort{namespace: NodeportBaseName + "1", TestCase: TestCase{NSBaseName: NodeportBaseName}})
+var NodePortTest func() = TestFunc(&NodePort{})
 
 func (n *NodePort) Init() error {
+	n.TestCase.Init()
+	n.CaseBaseName = NodeportBaseName + n.UUIDgen
+	n.BackupName = "backup-" + n.CaseBaseName
+	n.RestoreName = "restore-" + n.CaseBaseName
+	n.serviceName = "nginx-service-" + n.CaseBaseName
 	n.VeleroCfg = VeleroCfg
 	n.Client = *n.VeleroCfg.ClientToInstallVelero
-	n.NSBaseName = NodeportBaseName
+	n.NamespacesTotal = 1
 	n.TestMsg = &TestMSG{
-		Desc:      fmt.Sprintf("Nodeport preservation"),
+		Desc:      "Nodeport preservation",
 		FailedMSG: "Failed to restore with nodeport preservation",
-		Text:      fmt.Sprintf("Nodeport can be preserved or omit during restore"),
+		Text:      "Nodeport can be preserved or omit during restore",
+	}
+
+	n.labels = map[string]string{"app": "nginx"}
+	n.NSIncluded = &[]string{}
+	for nsNum := 0; nsNum < n.NamespacesTotal; nsNum++ {
+		createNSName := fmt.Sprintf("%s-%00000d", n.CaseBaseName, nsNum)
+		n.namespaceToCollision = append(n.namespaceToCollision, createNSName+"tmp")
+		*n.NSIncluded = append(*n.NSIncluded, createNSName)
 	}
-	n.BackupName = "backup-nodeport-" + UUIDgen.String()
-	n.RestoreName = "restore-" + UUIDgen.String()
-	n.serviceName = "nginx-service-" + UUIDgen.String()
-	n.labels = map[string]string{"app": "nginx"}
-	return nil
-}
 
-func (n *NodePort) StartRun() error {
 	n.BackupArgs = []string{
 		"create", "--namespace", VeleroCfg.VeleroNamespace, "backup", n.BackupName,
-		"--include-namespaces", n.namespace, "--wait",
+		"--include-namespaces", strings.Join(*n.NSIncluded, ","), "--wait",
 	}
 	n.RestoreArgs = []string{
 		"create", "--namespace", VeleroCfg.VeleroNamespace, "restore",
@@ -66,37 +69,40 @@ func (n *NodePort) CreateResources() error {
 	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
 	defer ctxCancel()
 
-	By(fmt.Sprintf("Creating service %s in namespaces %s ......\n", n.serviceName, n.namespace), func() {
-		Expect(CreateNamespace(ctx, n.Client, n.namespace)).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", n.namespace))
-		Expect(createServiceWithNodeport(ctx, n.Client, n.namespace, n.serviceName, n.labels, 0)).To(Succeed(), fmt.Sprintf("Failed to create service %s", n.serviceName))
-		service, err := GetService(ctx, n.Client, n.namespace, n.serviceName)
-		Expect(err).To(Succeed())
-		Expect(len(service.Spec.Ports)).To(Equal(1))
-		n.nodePort = service.Spec.Ports[0].NodePort
-		_, err = GetAllService(ctx)
-		Expect(err).To(Succeed(), "fail to get service")
-	})
+	for _, ns := range *n.NSIncluded {
+		By(fmt.Sprintf("Creating service %s in namespaces %s ......\n", n.serviceName, ns), func() {
+			Expect(CreateNamespace(ctx, n.Client, ns)).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", ns))
+			Expect(createServiceWithNodeport(ctx, n.Client, ns, n.serviceName, n.labels, 0)).To(Succeed(), fmt.Sprintf("Failed to create service %s", n.serviceName))
+			service, err := GetService(ctx, n.Client, ns, n.serviceName)
+			Expect(err).To(Succeed())
+			Expect(len(service.Spec.Ports)).To(Equal(1))
+			n.nodePort = service.Spec.Ports[0].NodePort
+			_, err = GetAllService(ctx)
+			Expect(err).To(Succeed(), "fail to get service")
+		})
+	}
 	return nil
 }
 
 func (n *NodePort) Destroy() error {
 	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
 	defer ctxCancel()
-	By(fmt.Sprintf("Start to destroy namespace %s......", n.NSBaseName), func() {
-		Expect(CleanupNamespacesWithPoll(ctx, n.Client, NodeportBaseName)).To(Succeed(),
-			fmt.Sprintf("Failed to delete namespace %s", n.NSBaseName))
-		Expect(WaitForServiceDelete(n.Client, n.namespace, n.serviceName, false)).To(Succeed(), "fail to delete service")
-		_, err := GetAllService(ctx)
-		Expect(err).To(Succeed(), "fail to get service")
-	})
+	for i, ns := range *n.NSIncluded {
+		By(fmt.Sprintf("Start to destroy namespace %s......", n.CaseBaseName), func() {
+			Expect(CleanupNamespacesWithPoll(ctx, n.Client, NodeportBaseName)).To(Succeed(),
+				fmt.Sprintf("Failed to delete namespace %s", n.CaseBaseName))
+			Expect(WaitForServiceDelete(n.Client, ns, n.serviceName, false)).To(Succeed(), "fail to delete service")
+			_, err := GetAllService(ctx)
+			Expect(err).To(Succeed(), "fail to get service")
+		})
 
-	n.namespaceToCollision = NodeportBaseName + "tmp"
-	By(fmt.Sprintf("Creating a new service which has the same nodeport as backed up service has in a new namespaces for nodeport collision ...%s\n", n.namespaceToCollision), func() {
-		Expect(CreateNamespace(ctx, n.Client, n.namespaceToCollision)).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", n.namespaceToCollision))
-		Expect(createServiceWithNodeport(ctx, n.Client, n.namespaceToCollision, n.serviceName, n.labels, n.nodePort)).To(Succeed(), fmt.Sprintf("Failed to create service %s", n.serviceName))
-		_, err := GetAllService(ctx)
-		Expect(err).To(Succeed(), "fail to get service")
-	})
+		By(fmt.Sprintf("Creating a new service which has the same nodeport as backed up service has in a new namespaces for nodeport collision ...%s\n", n.namespaceToCollision[i]), func() {
+			Expect(CreateNamespace(ctx, n.Client, n.namespaceToCollision[i])).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", n.namespaceToCollision[i]))
+			Expect(createServiceWithNodeport(ctx, n.Client, n.namespaceToCollision[i], n.serviceName, n.labels, n.nodePort)).To(Succeed(), fmt.Sprintf("Failed to create service %s", n.serviceName))
+			_, err := GetAllService(ctx)
+			Expect(err).To(Succeed(), "fail to get service")
+		})
+	}
 
 	return nil
 }
@@ -134,37 +140,38 @@ func (n *NodePort) Restore() error {
 		})
 	})
 
-	By(fmt.Sprintf("Delete service %s by deleting namespace %s", n.serviceName, n.namespace), func() {
-		service, err := GetService(ctx, n.Client, n.namespace, n.serviceName)
-		Expect(err).To(Succeed())
-		Expect(len(service.Spec.Ports)).To(Equal(1))
-		fmt.Println(service.Spec.Ports)
-		Expect(DeleteNamespace(ctx, n.Client, n.namespace, true)).To(Succeed())
-	})
-
-	By(fmt.Sprintf("Start to delete service %s in namespace %s ......", n.serviceName, n.namespaceToCollision), func() {
-		Expect(WaitForServiceDelete(n.Client, n.namespaceToCollision, n.serviceName, true)).To(Succeed(), "fail to delete service")
-		_, err := GetAllService(ctx)
-		Expect(err).To(Succeed(), "fail to get service")
-	})
-
-	args = n.RestoreArgs
-	args = append(args[:index], append([]string{restoreName2}, args[index:]...)...)
-	args = append(args, "--preserve-nodeports=true")
-	By(fmt.Sprintf("Start to restore %s with nodeports preservation ......", restoreName2), func() {
-		Expect(VeleroRestoreExec(ctx, n.VeleroCfg.VeleroCLI, n.VeleroCfg.VeleroNamespace,
-			restoreName2, args, velerov1api.RestorePhaseCompleted)).To(Succeed(), func() string {
-			RunDebug(context.Background(), n.VeleroCfg.VeleroCLI, n.VeleroCfg.VeleroNamespace, "", restoreName2)
-			return "Fail to restore workload"
+	for i, ns := range *n.NSIncluded {
+		By(fmt.Sprintf("Delete service %s by deleting namespace %s", n.serviceName, ns), func() {
+			service, err := GetService(ctx, n.Client, ns, n.serviceName)
+			Expect(err).To(Succeed())
+			Expect(len(service.Spec.Ports)).To(Equal(1))
+			fmt.Println(service.Spec.Ports)
+			Expect(DeleteNamespace(ctx, n.Client, ns, true)).To(Succeed())
 		})
-	})
 
-	By(fmt.Sprintf("Verify service %s was restore successfully with the origin nodeport.", n.namespace), func() {
-		service, err := GetService(ctx, n.Client, n.namespace, n.serviceName)
-		Expect(err).To(Succeed())
-		Expect(len(service.Spec.Ports)).To(Equal(1))
-		Expect(service.Spec.Ports[0].NodePort).To(Equal(n.nodePort))
-	})
+		By(fmt.Sprintf("Start to delete service %s in namespace %s ......", n.serviceName, n.namespaceToCollision[i]), func() {
+			Expect(WaitForServiceDelete(n.Client, n.namespaceToCollision[i], n.serviceName, true)).To(Succeed(), "fail to delete service")
+			_, err := GetAllService(ctx)
+			Expect(err).To(Succeed(), "fail to get service")
+		})
+		args = n.RestoreArgs
+		args = append(args[:index], append([]string{restoreName2}, args[index:]...)...)
+		args = append(args, "--preserve-nodeports=true")
+		By(fmt.Sprintf("Start to restore %s with nodeports preservation ......", restoreName2), func() {
+			Expect(VeleroRestoreExec(ctx, n.VeleroCfg.VeleroCLI, n.VeleroCfg.VeleroNamespace,
+				restoreName2, args, velerov1api.RestorePhaseCompleted)).To(Succeed(), func() string {
+				RunDebug(context.Background(), n.VeleroCfg.VeleroCLI, n.VeleroCfg.VeleroNamespace, "", restoreName2)
+				return "Fail to restore workload"
+			})
+		})
+
+		By(fmt.Sprintf("Verify service %s was restore successfully with the origin nodeport.", ns), func() {
+			service, err := GetService(ctx, n.Client, ns, n.serviceName)
+			Expect(err).To(Succeed())
+			Expect(len(service.Spec.Ports)).To(Equal(1))
+			Expect(service.Spec.Ports[0].NodePort).To(Equal(n.nodePort))
+		})
+	}
 
 	return nil
 }

test/e2e/basic/pvc-selected-node-changing.go

@@ -31,24 +31,22 @@ type PVCSelectedNodeChanging struct {
 	ann            string
 }
 
-const PSNCBaseName string = "psnc-"
-
-var PVCSelectedNodeChangingTest func() = TestFunc(&PVCSelectedNodeChanging{
-	namespace: PSNCBaseName + "1", TestCase: TestCase{NSBaseName: PSNCBaseName}})
+var PVCSelectedNodeChangingTest func() = TestFunc(&PVCSelectedNodeChanging{})
 
 func (p *PVCSelectedNodeChanging) Init() error {
+	p.TestCase.Init()
+	p.CaseBaseName = "psnc-" + p.UUIDgen
+	p.namespace = p.CaseBaseName
+	p.mappedNS = p.namespace + "-mapped"
 	p.VeleroCfg = VeleroCfg
 	p.Client = *p.VeleroCfg.ClientToInstallVelero
-	p.NSBaseName = PSNCBaseName
-	p.namespace = p.NSBaseName + UUIDgen.String()
-	p.mappedNS = p.namespace + "-mapped"
 	p.TestMsg = &TestMSG{
 		Desc:      "Changing PVC node selector",
 		FailedMSG: "Failed to changing PVC node selector",
 		Text:      "Change node selectors of persistent volume claims during restores",
 	}
-	p.BackupName = "backup-sc-" + UUIDgen.String()
-	p.RestoreName = "restore-" + UUIDgen.String()
+	p.BackupName = "backup-" + p.CaseBaseName
+	p.RestoreName = "restore-" + p.CaseBaseName
 	p.labels = map[string]string{"velero.io/plugin-config": "",
 		"velero.io/change-pvc-node-selector": "RestoreItemAction"}
 	p.configmaptName = "change-pvc-node-selector-config"
@@ -56,12 +54,6 @@ func (p *PVCSelectedNodeChanging) Init() error {
 	p.podName = "pod-1"
 	p.pvcName = "pvc-1"
 	p.ann = "volume.kubernetes.io/selected-node"
-	return nil
-}
-
-func (p *PVCSelectedNodeChanging) StartRun() error {
-	p.BackupName = p.BackupName + "backup-" + UUIDgen.String()
-	p.RestoreName = p.RestoreName + "restore-" + UUIDgen.String()
 	p.BackupArgs = []string{
 		"create", "--namespace", VeleroCfg.VeleroNamespace, "backup", p.BackupName,
 		"--include-namespaces", p.namespace,
@@ -73,6 +65,7 @@ func (p *PVCSelectedNodeChanging) StartRun() error {
 	}
 	return nil
 }
+
 func (p *PVCSelectedNodeChanging) CreateResources() error {
 	By(fmt.Sprintf("Create namespace %s", p.namespace), func() {
 		Expect(CreateNamespace(context.Background(), p.Client, p.namespace)).To(Succeed(),
@@ -116,9 +109,9 @@ func (p *PVCSelectedNodeChanging) CreateResources() error {
 }
 
 func (p *PVCSelectedNodeChanging) Destroy() error {
-	By(fmt.Sprintf("Start to destroy namespace %s......", p.NSBaseName), func() {
-		Expect(CleanupNamespacesWithPoll(context.Background(), p.Client, p.NSBaseName)).To(Succeed(),
-			fmt.Sprintf("Failed to delete namespace %s", p.NSBaseName))
+	By(fmt.Sprintf("Start to destroy namespace %s......", p.CaseBaseName), func() {
+		Expect(CleanupNamespacesWithPoll(context.Background(), p.Client, p.CaseBaseName)).To(Succeed(),
+			fmt.Sprintf("Failed to delete namespace %s", p.CaseBaseName))
 	})
 	return nil
 }
@@ -152,3 +145,13 @@ func (p *PVCSelectedNodeChanging) Verify() error {
 	})
 	return nil
 }
+
+func (p *PVCSelectedNodeChanging) Clean() error {
+	if !p.VeleroCfg.Debug {
+		p.TestCase.Clean()
+		By(fmt.Sprintf("Clean namespace with prefix %s after test", p.mappedNS), func() {
+			CleanupNamespaces(context.Background(), p.Client, p.mappedNS)
+		})
+	}
+	return nil
+}

test/e2e/basic/resources-check/namespaces.go

@@ -19,11 +19,9 @@ package basic
 import (
 	"context"
 	"fmt"
-	"math/rand"
 	"strings"
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/pkg/errors"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -40,11 +38,11 @@ type MultiNSBackup struct {
 }
 
 func (m *MultiNSBackup) Init() error {
-	rand.Seed(time.Now().UnixNano())
-	UUIDgen, _ = uuid.NewRandom()
-	m.BackupName = "backup-" + UUIDgen.String()
-	m.RestoreName = "restore-" + UUIDgen.String()
-	m.NSBaseName = "nstest-" + UUIDgen.String()
+	m.TestCase.Init()
+	m.CaseBaseName = "nstest-" + m.UUIDgen
+	m.BackupName = "backup-" + m.CaseBaseName
+	m.RestoreName = "restore-" + m.CaseBaseName
+
 	m.VeleroCfg = VeleroCfg
 	m.Client = *m.VeleroCfg.ClientToInstallVelero
 	m.NSExcluded = &[]string{}
@@ -64,10 +62,7 @@ func (m *MultiNSBackup) Init() error {
 			FailedMSG: "Failed to successfully backup and restore multiple namespaces",
 		}
 	}
-	return nil
-}
 
-func (m *MultiNSBackup) StartRun() error {
 	// Currently it's hard to build a large list of namespaces to include and wildcards do not work so instead
 	// we will exclude all of the namespaces that existed prior to the test from the backup
 	namespaces, err := m.Client.ClientGo.CoreV1().Namespaces().List(context.Background(), v1.ListOptions{})
@@ -100,7 +95,7 @@ func (m *MultiNSBackup) CreateResources() error {
 		"ns-test": "true",
 	}
 	for nsNum := 0; nsNum < m.NamespacesTotal; nsNum++ {
-		createNSName := fmt.Sprintf("%s-%00000d", m.NSBaseName, nsNum)
+		createNSName := fmt.Sprintf("%s-%00000d", m.CaseBaseName, nsNum)
 		if err := CreateNamespaceWithLabel(ctx, m.Client, createNSName, labels); err != nil {
 			return errors.Wrapf(err, "Failed to create namespace %s", createNSName)
 		}
@@ -113,7 +108,7 @@ func (m *MultiNSBackup) Verify() error {
 	defer ctxCancel()
 	// Verify that we got back all of the namespaces we created
 	for nsNum := 0; nsNum < m.NamespacesTotal; nsNum++ {
-		checkNSName := fmt.Sprintf("%s-%00000d", m.NSBaseName, nsNum)
+		checkNSName := fmt.Sprintf("%s-%00000d", m.CaseBaseName, nsNum)
 		checkNS, err := GetNamespace(ctx, m.Client, checkNSName)
 		if err != nil {
 			return errors.Wrapf(err, "Could not retrieve test namespace %s", checkNSName)
@@ -127,7 +122,7 @@ func (m *MultiNSBackup) Verify() error {
 func (m *MultiNSBackup) Destroy() error {
 	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
 	defer ctxCancel()
-	err := CleanupNamespaces(ctx, m.Client, m.NSBaseName)
+	err := CleanupNamespaces(ctx, m.Client, m.CaseBaseName)
 	if err != nil {
 		return errors.Wrap(err, "Could cleanup retrieve namespaces")
 	}

test/e2e/basic/resources-check/namespaces_annotation.go

@@ -19,11 +19,9 @@ package basic
 import (
 	"context"
 	"fmt"
-	"math/rand"
 	"strings"
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/pkg/errors"
 
 	. "github.com/vmware-tanzu/velero/test/e2e"
@@ -36,17 +34,17 @@ type NSAnnotationCase struct {
 }
 
 func (n *NSAnnotationCase) Init() error {
-	rand.Seed(time.Now().UnixNano())
-	UUIDgen, _ = uuid.NewRandom()
-	n.BackupName = "backup-namespace-annotations" + UUIDgen.String()
-	n.RestoreName = "restore-namespace-annotations" + UUIDgen.String()
-	n.NSBaseName = "namespace-annotations-" + UUIDgen.String()
+	n.TestCase.Init()
+	n.CaseBaseName = "namespace-annotations-" + n.UUIDgen
+	n.BackupName = "backup-" + n.CaseBaseName
+	n.RestoreName = "restore-" + n.CaseBaseName
+
 	n.NamespacesTotal = 1
 	n.NSIncluded = &[]string{}
 	n.VeleroCfg = VeleroCfg
 	n.Client = *n.VeleroCfg.ClientToInstallVelero
 	for nsNum := 0; nsNum < n.NamespacesTotal; nsNum++ {
-		createNSName := fmt.Sprintf("%s-%00000d", n.NSBaseName, nsNum)
+		createNSName := fmt.Sprintf("%s-%00000d", n.CaseBaseName, nsNum)
 		*n.NSIncluded = append(*n.NSIncluded, createNSName)
 	}
 	n.TestMsg = &TestMSG{
@@ -71,8 +69,8 @@ func (n *NSAnnotationCase) CreateResources() error {
 	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
 	defer ctxCancel()
 	for nsNum := 0; nsNum < n.NamespacesTotal; nsNum++ {
-		createNSName := fmt.Sprintf("%s-%00000d", n.NSBaseName, nsNum)
-		createAnnotationName := fmt.Sprintf("annotation-%s-%00000d", n.NSBaseName, nsNum)
+		createNSName := fmt.Sprintf("%s-%00000d", n.CaseBaseName, nsNum)
+		createAnnotationName := fmt.Sprintf("annotation-%s-%00000d", n.CaseBaseName, nsNum)
 		if err := CreateNamespaceWithAnnotation(ctx, n.Client, createNSName, map[string]string{"testAnnotation": createAnnotationName}); err != nil {
 			return errors.Wrapf(err, "Failed to create namespace %s", createNSName)
 		}
@@ -84,8 +82,8 @@ func (n *NSAnnotationCase) Verify() error {
 	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
 	defer ctxCancel()
 	for nsNum := 0; nsNum < n.NamespacesTotal; nsNum++ {
-		checkNSName := fmt.Sprintf("%s-%00000d", n.NSBaseName, nsNum)
-		checkAnnoName := fmt.Sprintf("annotation-%s-%00000d", n.NSBaseName, nsNum)
+		checkNSName := fmt.Sprintf("%s-%00000d", n.CaseBaseName, nsNum)
+		checkAnnoName := fmt.Sprintf("annotation-%s-%00000d", n.CaseBaseName, nsNum)
 		checkNS, err := GetNamespace(ctx, n.Client, checkNSName)
 
 		if err != nil {

test/e2e/basic/resources-check/rbac.go

@@ -35,11 +35,9 @@ package basic
 import (
 	"context"
 	"fmt"
-	"math/rand"
 	"strings"
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/pkg/errors"
 
 	. "github.com/vmware-tanzu/velero/test/e2e"
@@ -52,15 +50,14 @@ type RBACCase struct {
 }
 
 func (r *RBACCase) Init() error {
-	rand.Seed(time.Now().UnixNano())
-	UUIDgen, _ = uuid.NewRandom()
-	r.BackupName = "backup-rbac" + UUIDgen.String()
-	r.RestoreName = "restore-rbac" + UUIDgen.String()
-	r.NSBaseName = "rabc-" + UUIDgen.String()
+	r.TestCase.Init()
+	r.CaseBaseName = "rabc-" + r.UUIDgen
+	r.BackupName = "backup-" + r.CaseBaseName
+	r.RestoreName = "restore-" + r.CaseBaseName
 	r.NamespacesTotal = 1
 	r.NSIncluded = &[]string{}
 	for nsNum := 0; nsNum < r.NamespacesTotal; nsNum++ {
-		createNSName := fmt.Sprintf("%s-%00000d", r.NSBaseName, nsNum)
+		createNSName := fmt.Sprintf("%s-%00000d", r.CaseBaseName, nsNum)
 		*r.NSIncluded = append(*r.NSIncluded, createNSName)
 	}
 	r.TestMsg = &TestMSG{
@@ -87,18 +84,18 @@ func (r *RBACCase) CreateResources() error {
 	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
 	defer ctxCancel()
 	for nsNum := 0; nsNum < r.NamespacesTotal; nsNum++ {
-		createNSName := fmt.Sprintf("%s-%00000d", r.NSBaseName, nsNum)
+		createNSName := fmt.Sprintf("%s-%00000d", r.CaseBaseName, nsNum)
 		fmt.Printf("Creating namespaces ...%s\n", createNSName)
 		if err := CreateNamespace(ctx, r.Client, createNSName); err != nil {
 			return errors.Wrapf(err, "Failed to create namespace %s", createNSName)
 		}
-		serviceAccountName := fmt.Sprintf("service-account-%s-%00000d", r.NSBaseName, nsNum)
+		serviceAccountName := fmt.Sprintf("service-account-%s-%00000d", r.CaseBaseName, nsNum)
 		fmt.Printf("Creating service account ...%s\n", createNSName)
 		if err := CreateServiceAccount(ctx, r.Client, createNSName, serviceAccountName); err != nil {
 			return errors.Wrapf(err, "Failed to create service account %s", serviceAccountName)
 		}
-		clusterRoleName := fmt.Sprintf("clusterrole-%s-%00000d", r.NSBaseName, nsNum)
-		clusterRoleBindingName := fmt.Sprintf("clusterrolebinding-%s-%00000d", r.NSBaseName, nsNum)
+		clusterRoleName := fmt.Sprintf("clusterrole-%s-%00000d", r.CaseBaseName, nsNum)
+		clusterRoleBindingName := fmt.Sprintf("clusterrolebinding-%s-%00000d", r.CaseBaseName, nsNum)
 		if err := CreateRBACWithBindingSA(ctx, r.Client, createNSName, serviceAccountName, clusterRoleName, clusterRoleBindingName); err != nil {
 			return errors.Wrapf(err, "Failed to create cluster role %s with role binding %s", clusterRoleName, clusterRoleBindingName)
 		}
@@ -110,10 +107,10 @@ func (r *RBACCase) Verify() error {
 	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
 	defer ctxCancel()
 	for nsNum := 0; nsNum < r.NamespacesTotal; nsNum++ {
-		checkNSName := fmt.Sprintf("%s-%00000d", r.NSBaseName, nsNum)
-		checkServiceAccountName := fmt.Sprintf("service-account-%s-%00000d", r.NSBaseName, nsNum)
-		checkClusterRoleName := fmt.Sprintf("clusterrole-%s-%00000d", r.NSBaseName, nsNum)
-		checkClusterRoleBindingName := fmt.Sprintf("clusterrolebinding-%s-%00000d", r.NSBaseName, nsNum)
+		checkNSName := fmt.Sprintf("%s-%00000d", r.CaseBaseName, nsNum)
+		checkServiceAccountName := fmt.Sprintf("service-account-%s-%00000d", r.CaseBaseName, nsNum)
+		checkClusterRoleName := fmt.Sprintf("clusterrole-%s-%00000d", r.CaseBaseName, nsNum)
+		checkClusterRoleBindingName := fmt.Sprintf("clusterrolebinding-%s-%00000d", r.CaseBaseName, nsNum)
 		checkNS, err := GetNamespace(ctx, r.Client, checkNSName)
 		if err != nil {
 			return errors.Wrapf(err, "Could not retrieve test namespace %s", checkNSName)
@@ -169,18 +166,18 @@ func (r *RBACCase) Destroy() error {
 	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
 	defer ctxCancel()
 	//cleanup clusterrole
-	err := CleanupClusterRole(ctx, r.Client, r.NSBaseName)
+	err := CleanupClusterRole(ctx, r.Client, r.CaseBaseName)
 	if err != nil {
 		return errors.Wrap(err, "Could not cleanup clusterroles")
 	}
 
 	//cleanup cluster rolebinding
-	err = CleanupClusterRoleBinding(ctx, r.Client, r.NSBaseName)
+	err = CleanupClusterRoleBinding(ctx, r.Client, r.CaseBaseName)
 	if err != nil {
 		return errors.Wrap(err, "Could not cleanup clusterrolebindings")
 	}
 
-	err = CleanupNamespacesWithPoll(ctx, r.Client, r.NSBaseName)
+	err = CleanupNamespacesWithPoll(ctx, r.Client, r.CaseBaseName)
 	if err != nil {
 		return errors.Wrap(err, "Could cleanup retrieve namespaces")
 	}
@@ -189,5 +186,8 @@ func (r *RBACCase) Destroy() error {
 }
 
 func (r *RBACCase) Clean() error {
-	return r.Destroy()
+	if !r.VeleroCfg.Debug {
+		return r.Destroy()
+	}
+	return nil
 }

test/e2e/basic/resources-check/resources_check.go

@@ -33,15 +33,14 @@ limitations under the License.
 package basic
 
 import (
-	. "github.com/vmware-tanzu/velero/test/e2e"
 	. "github.com/vmware-tanzu/velero/test/e2e/test"
 )
 
 func GetResourcesCheckTestCases() []VeleroBackupRestoreTest {
 	return []VeleroBackupRestoreTest{
-		&NSAnnotationCase{TestCase{VeleroCfg: VeleroCfg}},
-		&MultiNSBackup{IsScalTest: false, TestCase: TestCase{VeleroCfg: VeleroCfg}},
-		&RBACCase{TestCase{VeleroCfg: VeleroCfg}},
+		&NSAnnotationCase{},
+		&MultiNSBackup{IsScalTest: false},
+		&RBACCase{},
 	}
 }
 

test/e2e/basic/storage-class-changing.go

@@ -31,15 +31,17 @@ type StorageClasssChanging struct {
 
 const SCCBaseName string = "scc-"
 
-var StorageClasssChangingTest func() = TestFunc(&StorageClasssChanging{
-	namespace: SCCBaseName + "1", TestCase: TestCase{NSBaseName: SCCBaseName}})
+var StorageClasssChangingTest func() = TestFunc(&StorageClasssChanging{})
 
 func (s *StorageClasssChanging) Init() error {
+	s.TestCase.Init()
+	s.CaseBaseName = SCCBaseName + s.UUIDgen
+	s.namespace = s.CaseBaseName
+	s.BackupName = "backup-" + s.CaseBaseName
+	s.RestoreName = "restore-" + s.CaseBaseName
+	s.mappedNS = s.namespace + "-mapped"
 	s.VeleroCfg = VeleroCfg
 	s.Client = *s.VeleroCfg.ClientToInstallVelero
-	s.NSBaseName = SCCBaseName
-	s.namespace = s.NSBaseName + UUIDgen.String()
-	s.mappedNS = s.namespace + "-mapped"
 	s.TestMsg = &TestMSG{
 		Desc:      "Changing PV/PVC Storage Classes",
 		FailedMSG: "Failed to changing PV/PVC Storage Classes",
@@ -56,10 +58,7 @@ func (s *StorageClasssChanging) Init() error {
 	s.configmaptName = "change-storage-class-config"
 	s.volume = "volume-1"
 	s.podName = "pod-1"
-	return nil
-}
 
-func (s *StorageClasssChanging) StartRun() error {
 	s.BackupName = s.BackupName + "backup-" + UUIDgen.String()
 	s.RestoreName = s.RestoreName + "restore-" + UUIDgen.String()
 	s.BackupArgs = []string{
@@ -109,9 +108,9 @@ func (s *StorageClasssChanging) Destroy() error {
 			fmt.Sprintf("PV storage %s is not as expected %s", pv.Spec.StorageClassName, s.srcStorageClass))
 	})
 
-	By(fmt.Sprintf("Start to destroy namespace %s......", s.NSBaseName), func() {
-		Expect(CleanupNamespacesWithPoll(ctx, s.Client, s.NSBaseName)).To(Succeed(),
-			fmt.Sprintf("Failed to delete namespace %s", s.NSBaseName))
+	By(fmt.Sprintf("Start to destroy namespace %s......", s.CaseBaseName), func() {
+		Expect(CleanupNamespacesWithPoll(ctx, s.Client, s.CaseBaseName)).To(Succeed(),
+			fmt.Sprintf("Failed to delete namespace %s", s.CaseBaseName))
 	})
 	return nil
 }
@@ -147,3 +146,14 @@ func (s *StorageClasssChanging) Verify() error {
 	})
 	return nil
 }
+
+func (s *StorageClasssChanging) Clean() error {
+	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
+	defer ctxCancel()
+	if !s.VeleroCfg.Debug {
+		DeleteConfigmap(s.Client.ClientGo, s.VeleroCfg.VeleroNamespace, s.configmaptName)
+		DeleteStorageClass(ctx, s.Client, s.desStorageClass)
+		s.TestCase.Clean()
+	}
+	return nil
+}