Merge pull request #6278 from qiuming-best/e2e-context

Adjust E2E context

test/e2e/basic/namespace-mapping.go

@@ -30,6 +30,9 @@ var MultiNamespacesMappingSnapshotTest func() = TestFunc(&NamespaceMapping{TestC
 
 func (n *NamespaceMapping) Init() error {
 	n.TestCase.Init()
+	n.CaseBaseName = "ns-mp-" + n.UUIDgen
+	n.BackupName = "backup-" + n.CaseBaseName
+	n.RestoreName = "restore-" + n.CaseBaseName
 	n.VeleroCfg = VeleroCfg
 	n.Client = *n.VeleroCfg.ClientToInstallVelero
 	n.VeleroCfg.UseVolumeSnapshots = n.UseVolumeSnapshots
@@ -39,7 +42,6 @@ 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{}
@@ -59,9 +61,6 @@ func (n *NamespaceMapping) Init() error {
 		FailedMSG: "Failed to restore with namespace mapping",
 		Text:      fmt.Sprintf("should restore namespace %s with namespace mapping by %s", *n.NSIncluded, backupType),
 	}
-	n.BackupName = "backup-" + n.CaseBaseName
-	n.RestoreName = "restore-" + n.CaseBaseName
-
 	n.MappedNamespaceList = mappedNSList
 	fmt.Println(mappedNSList)
 	n.BackupArgs = []string{
@@ -83,15 +82,14 @@ func (n *NamespaceMapping) Init() error {
 }
 
 func (n *NamespaceMapping) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
-	defer ctxCancel()
+	n.Ctx, n.CtxCancel = context.WithTimeout(context.Background(), 60*time.Minute)
 	for index, ns := range *n.NSIncluded {
 		n.kibishiiData.Levels = len(*n.NSIncluded) + index
 		By(fmt.Sprintf("Creating namespaces ...%s\n", ns), func() {
-			Expect(CreateNamespace(ctx, n.Client, ns)).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", ns))
+			Expect(CreateNamespace(n.Ctx, n.Client, ns)).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", ns))
 		})
 		By("Deploy sample workload of Kibishii", func() {
-			Expect(KibishiiPrepareBeforeBackup(ctx, n.Client, VeleroCfg.CloudProvider,
+			Expect(KibishiiPrepareBeforeBackup(n.Ctx, n.Client, VeleroCfg.CloudProvider,
 				ns, VeleroCfg.RegistryCredentialFile, VeleroCfg.Features,
 				VeleroCfg.KibishiiDirectory, false, n.kibishiiData)).To(Succeed())
 		})
@@ -100,18 +98,16 @@ func (n *NamespaceMapping) CreateResources() error {
 }
 
 func (n *NamespaceMapping) Verify() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
-	defer ctxCancel()
 	for index, ns := range n.MappedNamespaceList {
 		n.kibishiiData.Levels = len(*n.NSIncluded) + index
 		By(fmt.Sprintf("Verify workload %s after restore ", ns), func() {
 			Expect(KibishiiVerifyAfterRestore(n.Client, ns,
-				ctx, n.kibishiiData)).To(Succeed(), "Fail to verify workload after restore")
+				n.Ctx, n.kibishiiData)).To(Succeed(), "Fail to verify workload after restore")
 		})
 	}
 	for _, ns := range *n.NSIncluded {
 		By(fmt.Sprintf("Verify namespace %s for backup is no longer exist after restore with namespace mapping", ns), func() {
-			Expect(NamespaceShouldNotExist(ctx, n.Client, ns)).To(Succeed())
+			Expect(NamespaceShouldNotExist(n.Ctx, n.Client, ns)).To(Succeed())
 		})
 	}
 	return nil

test/e2e/basic/nodeport.go

@@ -66,18 +66,17 @@ func (n *NodePort) Init() error {
 	return nil
 }
 func (n *NodePort) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
-	defer ctxCancel()
+	n.Ctx, n.CtxCancel = context.WithTimeout(context.Background(), 60*time.Minute)
 
 	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(CreateNamespace(n.Ctx, n.Client, ns)).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", ns))
+			Expect(createServiceWithNodeport(n.Ctx, n.Client, ns, n.serviceName, n.labels, 0)).To(Succeed(), fmt.Sprintf("Failed to create service %s", n.serviceName))
+			service, err := GetService(n.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)
+			_, err = GetAllService(n.Ctx)
 			Expect(err).To(Succeed(), "fail to get service")
 		})
 	}
@@ -85,21 +84,19 @@ func (n *NodePort) CreateResources() error {
 }
 
 func (n *NodePort) Destroy() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
-	defer ctxCancel()
 	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(),
+			Expect(CleanupNamespacesWithPoll(n.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)
+			_, err := GetAllService(n.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(CreateNamespace(n.Ctx, n.Client, n.namespaceToCollision[i])).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", n.namespaceToCollision[i]))
+			Expect(createServiceWithNodeport(n.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(n.Ctx)
 			Expect(err).To(Succeed(), "fail to get service")
 		})
 	}
@@ -108,8 +105,6 @@ func (n *NodePort) Destroy() error {
 }
 
 func (n *NodePort) Restore() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
-	defer ctxCancel()
 	index := 4
 	restoreName1 := n.RestoreName + "-1"
 	restoreName2 := restoreName1 + "-1"
@@ -118,7 +113,7 @@ func (n *NodePort) Restore() error {
 	args = append(args[:index], append([]string{n.RestoreName}, args[index:]...)...)
 	args = append(args, "--preserve-nodeports=true")
 	By(fmt.Sprintf("Start to restore %s with nodeports preservation when port %d is already occupied by other service", n.RestoreName, n.nodePort), func() {
-		Expect(VeleroRestoreExec(ctx, n.VeleroCfg.VeleroCLI,
+		Expect(VeleroRestoreExec(n.Ctx, n.VeleroCfg.VeleroCLI,
 			n.VeleroCfg.VeleroNamespace, n.RestoreName,
 			args, velerov1api.RestorePhasePartiallyFailed)).To(
 			Succeed(),
@@ -133,7 +128,7 @@ func (n *NodePort) Restore() error {
 	args = append(args[:index], append([]string{restoreName1}, args[index:]...)...)
 	args = append(args, "--preserve-nodeports=false")
 	By(fmt.Sprintf("Start to restore %s without nodeports preservation ......", restoreName1), func() {
-		Expect(VeleroRestoreExec(ctx, n.VeleroCfg.VeleroCLI, n.VeleroCfg.VeleroNamespace,
+		Expect(VeleroRestoreExec(n.Ctx, n.VeleroCfg.VeleroCLI, n.VeleroCfg.VeleroNamespace,
 			restoreName1, args, velerov1api.RestorePhaseCompleted)).To(Succeed(), func() string {
 			RunDebug(context.Background(), n.VeleroCfg.VeleroCLI, n.VeleroCfg.VeleroNamespace, "", restoreName1)
 			return "Fail to restore workload"
@@ -142,23 +137,23 @@ func (n *NodePort) Restore() error {
 
 	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)
+			service, err := GetService(n.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())
+			Expect(DeleteNamespace(n.Ctx, n.Client, ns, true)).To(Succeed())
 		})
 
 		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)
+			_, err := GetAllService(n.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,
+			Expect(VeleroRestoreExec(n.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"
@@ -166,7 +161,7 @@ func (n *NodePort) Restore() error {
 		})
 
 		By(fmt.Sprintf("Verify service %s was restore successfully with the origin nodeport.", ns), func() {
-			service, err := GetService(ctx, n.Client, ns, n.serviceName)
+			service, err := GetService(n.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))

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

@@ -67,13 +67,14 @@ func (p *PVCSelectedNodeChanging) Init() error {
 }
 
 func (p *PVCSelectedNodeChanging) CreateResources() error {
+	p.Ctx, p.CtxCancel = context.WithTimeout(context.Background(), 60*time.Minute)
 	By(fmt.Sprintf("Create namespace %s", p.namespace), func() {
-		Expect(CreateNamespace(context.Background(), p.Client, p.namespace)).To(Succeed(),
+		Expect(CreateNamespace(p.Ctx, p.Client, p.namespace)).To(Succeed(),
 			fmt.Sprintf("Failed to create namespace %s", p.namespace))
 	})
 
 	By(fmt.Sprintf("Create pod %s in namespace %s", p.podName, p.namespace), func() {
-		nodeNameList, err := GetWorkerNodes(context.Background())
+		nodeNameList, err := GetWorkerNodes(p.Ctx)
 		Expect(err).To(Succeed())
 		for _, nodeName := range nodeNameList {
 			p.oldNodeName = nodeName
@@ -81,14 +82,14 @@ func (p *PVCSelectedNodeChanging) CreateResources() error {
 			pvcAnn := map[string]string{p.ann: nodeName}
 			_, err := CreatePod(p.Client, p.namespace, p.podName, "default", p.pvcName, []string{p.volume}, pvcAnn, nil)
 			Expect(err).To(Succeed())
-			err = WaitForPods(context.Background(), p.Client, p.namespace, []string{p.podName})
+			err = WaitForPods(p.Ctx, p.Client, p.namespace, []string{p.podName})
 			Expect(err).To(Succeed())
 			break
 		}
 	})
 
 	By("Prepare ConfigMap data", func() {
-		nodeNameList, err := GetWorkerNodes(context.Background())
+		nodeNameList, err := GetWorkerNodes(p.Ctx)
 		Expect(err).To(Succeed())
 		Expect(len(nodeNameList) > 2).To(Equal(true))
 		for _, nodeName := range nodeNameList {
@@ -110,17 +111,15 @@ func (p *PVCSelectedNodeChanging) CreateResources() error {
 
 func (p *PVCSelectedNodeChanging) Destroy() error {
 	By(fmt.Sprintf("Start to destroy namespace %s......", p.CaseBaseName), func() {
-		Expect(CleanupNamespacesWithPoll(context.Background(), p.Client, p.CaseBaseName)).To(Succeed(),
+		Expect(CleanupNamespacesWithPoll(p.Ctx, p.Client, p.CaseBaseName)).To(Succeed(),
 			fmt.Sprintf("Failed to delete namespace %s", p.CaseBaseName))
 	})
 	return nil
 }
 
 func (p *PVCSelectedNodeChanging) Restore() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
-	defer ctxCancel()
 	By(fmt.Sprintf("Start to restore %s .....", p.RestoreName), func() {
-		Expect(VeleroRestoreExec(ctx, p.VeleroCfg.VeleroCLI,
+		Expect(VeleroRestoreExec(p.Ctx, p.VeleroCfg.VeleroCLI,
 			p.VeleroCfg.VeleroNamespace, p.RestoreName,
 			p.RestoreArgs, velerov1api.RestorePhaseCompleted)).To(
 			Succeed(),
@@ -129,17 +128,17 @@ func (p *PVCSelectedNodeChanging) Restore() error {
 					p.VeleroCfg.VeleroNamespace, "", p.RestoreName)
 				return "Fail to restore workload"
 			})
-		err := WaitForPods(ctx, p.Client, p.mappedNS, []string{p.podName})
+		err := WaitForPods(p.Ctx, p.Client, p.mappedNS, []string{p.podName})
 		Expect(err).To(Succeed())
 	})
 	return nil
 }
 func (p *PVCSelectedNodeChanging) Verify() error {
 	By(fmt.Sprintf("PVC selected node should be %s", p.newNodeName), func() {
-		pvcNameList, err := GetPvcByPodName(context.Background(), p.mappedNS, p.pvcName)
+		pvcNameList, err := GetPvcByPodName(p.Ctx, p.mappedNS, p.pvcName)
 		Expect(err).To(Succeed())
 		Expect(len(pvcNameList)).Should(Equal(1))
-		pvc, err := GetPVC(context.Background(), p.Client, p.mappedNS, pvcNameList[0])
+		pvc, err := GetPVC(p.Ctx, p.Client, p.mappedNS, pvcNameList[0])
 		Expect(err).To(Succeed())
 		Expect(pvc.Annotations[p.ann]).To(Equal(p.newNodeName))
 	})
@@ -150,7 +149,7 @@ 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)
+			CleanupNamespaces(p.Ctx, p.Client, p.mappedNS)
 		})
 	}
 	return nil

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

@@ -88,15 +88,14 @@ func (m *MultiNSBackup) Init() error {
 }
 
 func (m *MultiNSBackup) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
-	defer ctxCancel()
+	m.Ctx, m.CtxCancel = context.WithTimeout(context.Background(), m.TimeoutDuration)
 	fmt.Printf("Creating namespaces ...\n")
 	labels := map[string]string{
 		"ns-test": "true",
 	}
 	for nsNum := 0; nsNum < m.NamespacesTotal; nsNum++ {
 		createNSName := fmt.Sprintf("%s-%00000d", m.CaseBaseName, nsNum)
-		if err := CreateNamespaceWithLabel(ctx, m.Client, createNSName, labels); err != nil {
+		if err := CreateNamespaceWithLabel(m.Ctx, m.Client, createNSName, labels); err != nil {
 			return errors.Wrapf(err, "Failed to create namespace %s", createNSName)
 		}
 	}
@@ -104,12 +103,10 @@ func (m *MultiNSBackup) CreateResources() error {
 }
 
 func (m *MultiNSBackup) Verify() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), m.TimeoutDuration)
-	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.CaseBaseName, nsNum)
-		checkNS, err := GetNamespace(ctx, m.Client, checkNSName)
+		checkNS, err := GetNamespace(m.Ctx, m.Client, checkNSName)
 		if err != nil {
 			return errors.Wrapf(err, "Could not retrieve test namespace %s", checkNSName)
 		} else if checkNS.Name != checkNSName {
@@ -120,11 +117,9 @@ 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.CaseBaseName)
+	err := CleanupNamespaces(m.Ctx, m.Client, m.CaseBaseName)
 	if err != nil {
 		return errors.Wrap(err, "Could cleanup retrieve namespaces")
 	}
-	return WaitAllSelectedNSDeleted(ctx, m.Client, "ns-test=true")
+	return WaitAllSelectedNSDeleted(m.Ctx, m.Client, "ns-test=true")
 }

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

@@ -66,12 +66,11 @@ func (n *NSAnnotationCase) Init() error {
 }
 
 func (n *NSAnnotationCase) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
-	defer ctxCancel()
+	n.Ctx, n.CtxCancel = context.WithTimeout(context.Background(), 60*time.Minute)
 	for nsNum := 0; nsNum < n.NamespacesTotal; 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 {
+		if err := CreateNamespaceWithAnnotation(n.Ctx, n.Client, createNSName, map[string]string{"testAnnotation": createAnnotationName}); err != nil {
 			return errors.Wrapf(err, "Failed to create namespace %s", createNSName)
 		}
 	}
@@ -79,12 +78,10 @@ func (n *NSAnnotationCase) CreateResources() error {
 }
 
 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.CaseBaseName, nsNum)
 		checkAnnoName := fmt.Sprintf("annotation-%s-%00000d", n.CaseBaseName, nsNum)
-		checkNS, err := GetNamespace(ctx, n.Client, checkNSName)
+		checkNS, err := GetNamespace(n.Ctx, n.Client, checkNSName)
 
 		if err != nil {
 			return errors.Wrapf(err, "Could not retrieve test namespace %s", checkNSName)

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

@@ -81,22 +81,21 @@ func (r *RBACCase) Init() error {
 }
 
 func (r *RBACCase) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
+	r.Ctx, r.CtxCancel = context.WithTimeout(context.Background(), 10*time.Minute)
 	for nsNum := 0; nsNum < r.NamespacesTotal; 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 {
+		if err := CreateNamespace(r.Ctx, r.Client, createNSName); err != nil {
 			return errors.Wrapf(err, "Failed to create namespace %s", createNSName)
 		}
 		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 {
+		if err := CreateServiceAccount(r.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.CaseBaseName, nsNum)
 		clusterRoleBindingName := fmt.Sprintf("clusterrolebinding-%s-%00000d", r.CaseBaseName, nsNum)
-		if err := CreateRBACWithBindingSA(ctx, r.Client, createNSName, serviceAccountName, clusterRoleName, clusterRoleBindingName); err != nil {
+		if err := CreateRBACWithBindingSA(r.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)
 		}
 	}
@@ -104,14 +103,12 @@ func (r *RBACCase) CreateResources() error {
 }
 
 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.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)
+		checkNS, err := GetNamespace(r.Ctx, r.Client, checkNSName)
 		if err != nil {
 			return errors.Wrapf(err, "Could not retrieve test namespace %s", checkNSName)
 		}
@@ -120,7 +117,7 @@ func (r *RBACCase) Verify() error {
 		}
 
 		//getting service account from the restore
-		checkSA, err := GetServiceAccount(ctx, r.Client, checkNSName, checkServiceAccountName)
+		checkSA, err := GetServiceAccount(r.Ctx, r.Client, checkNSName, checkServiceAccountName)
 
 		if err != nil {
 			return errors.Wrapf(err, "Could not retrieve test service account %s", checkSA)
@@ -131,7 +128,7 @@ func (r *RBACCase) Verify() error {
 		}
 
 		//getting cluster role from the restore
-		checkClusterRole, err := GetClusterRole(ctx, r.Client, checkClusterRoleName)
+		checkClusterRole, err := GetClusterRole(r.Ctx, r.Client, checkClusterRoleName)
 
 		if err != nil {
 			return errors.Wrapf(err, "Could not retrieve test cluster role %s", checkClusterRole)
@@ -142,7 +139,7 @@ func (r *RBACCase) Verify() error {
 		}
 
 		//getting cluster role binding from the restore
-		checkClusterRoleBinding, err := GetClusterRoleBinding(ctx, r.Client, checkClusterRoleBindingName)
+		checkClusterRoleBinding, err := GetClusterRoleBinding(r.Ctx, r.Client, checkClusterRoleBindingName)
 
 		if err != nil {
 			return errors.Wrapf(err, "Could not retrieve test cluster role binding %s", checkClusterRoleBinding)
@@ -163,21 +160,19 @@ func (r *RBACCase) Verify() error {
 }
 
 func (r *RBACCase) Destroy() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	//cleanup clusterrole
-	err := CleanupClusterRole(ctx, r.Client, r.CaseBaseName)
+	err := CleanupClusterRole(r.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.CaseBaseName)
+	err = CleanupClusterRoleBinding(r.Ctx, r.Client, r.CaseBaseName)
 	if err != nil {
 		return errors.Wrap(err, "Could not cleanup clusterrolebindings")
 	}
 
-	err = CleanupNamespacesWithPoll(ctx, r.Client, r.CaseBaseName)
+	err = CleanupNamespacesWithPoll(r.Ctx, r.Client, r.CaseBaseName)
 	if err != nil {
 		return errors.Wrap(err, "Could cleanup retrieve namespaces")
 	}

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

@@ -73,14 +73,13 @@ func (s *StorageClasssChanging) Init() error {
 	return nil
 }
 func (s *StorageClasssChanging) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
+	s.Ctx, s.CtxCancel = context.WithTimeout(context.Background(), 10*time.Minute)
 	By(fmt.Sprintf("Create a storage class %s", s.desStorageClass), func() {
-		Expect(InstallStorageClass(context.Background(), fmt.Sprintf("testdata/storage-class/%s.yaml",
+		Expect(InstallStorageClass(s.Ctx, fmt.Sprintf("testdata/storage-class/%s.yaml",
 			s.VeleroCfg.CloudProvider))).To(Succeed())
 	})
 	By(fmt.Sprintf("Create namespace %s", s.namespace), func() {
-		Expect(CreateNamespace(ctx, s.Client, s.namespace)).To(Succeed(),
+		Expect(CreateNamespace(s.Ctx, s.Client, s.namespace)).To(Succeed(),
 			fmt.Sprintf("Failed to create namespace %s", s.namespace))
 	})
 
@@ -96,12 +95,10 @@ func (s *StorageClasssChanging) CreateResources() error {
 }
 
 func (s *StorageClasssChanging) Destroy() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	By(fmt.Sprintf("Expect storage class of PV %s to be %s ", s.volume, s.srcStorageClass), func() {
 		pvName, err := GetPVByPodName(s.Client, s.namespace, s.volume)
 		Expect(err).To(Succeed(), fmt.Sprintf("Failed to get PV name by pod name %s", s.podName))
-		pv, err := GetPersistentVolume(ctx, s.Client, s.namespace, pvName)
+		pv, err := GetPersistentVolume(s.Ctx, s.Client, s.namespace, pvName)
 		Expect(err).To(Succeed(), fmt.Sprintf("Failed to get PV by pod name %s", s.podName))
 		fmt.Println(pv)
 		Expect(pv.Spec.StorageClassName).To(Equal(s.srcStorageClass),
@@ -109,17 +106,15 @@ func (s *StorageClasssChanging) Destroy() error {
 	})
 
 	By(fmt.Sprintf("Start to destroy namespace %s......", s.CaseBaseName), func() {
-		Expect(CleanupNamespacesWithPoll(ctx, s.Client, s.CaseBaseName)).To(Succeed(),
+		Expect(CleanupNamespacesWithPoll(s.Ctx, s.Client, s.CaseBaseName)).To(Succeed(),
 			fmt.Sprintf("Failed to delete namespace %s", s.CaseBaseName))
 	})
 	return nil
 }
 
 func (s *StorageClasssChanging) Restore() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	By(fmt.Sprintf("Start to restore %s .....", s.RestoreName), func() {
-		Expect(VeleroRestoreExec(ctx, s.VeleroCfg.VeleroCLI,
+		Expect(VeleroRestoreExec(s.Ctx, s.VeleroCfg.VeleroCLI,
 			s.VeleroCfg.VeleroNamespace, s.RestoreName,
 			s.RestoreArgs, velerov1api.RestorePhaseCompleted)).To(
 			Succeed(),
@@ -132,13 +127,11 @@ func (s *StorageClasssChanging) Restore() error {
 	return nil
 }
 func (s *StorageClasssChanging) Verify() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	By(fmt.Sprintf("Expect storage class of PV %s to be %s ", s.volume, s.desStorageClass), func() {
-		time.Sleep(1 * time.Minute)
+		Expect(WaitForPods(s.Ctx, s.Client, s.mappedNS, []string{s.podName})).To(Succeed(), fmt.Sprintf("Failed to wait pod ready %s", s.podName))
 		pvName, err := GetPVByPodName(s.Client, s.mappedNS, s.volume)
 		Expect(err).To(Succeed(), fmt.Sprintf("Failed to get PV name by pod name %s", s.podName))
-		pv, err := GetPersistentVolume(ctx, s.Client, s.mappedNS, pvName)
+		pv, err := GetPersistentVolume(s.Ctx, s.Client, s.mappedNS, pvName)
 		Expect(err).To(Succeed(), fmt.Sprintf("Failed to get PV by pod name %s", s.podName))
 		fmt.Println(pv)
 		Expect(pv.Spec.StorageClassName).To(Equal(s.desStorageClass),
@@ -148,11 +141,9 @@ func (s *StorageClasssChanging) Verify() error {
 }
 
 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)
+		DeleteStorageClass(s.Ctx, s.Client, s.desStorageClass)
 		s.TestCase.Clean()
 	}
 	return nil

test/e2e/pv-backup/pv-backup-filter.go

@@ -66,17 +66,15 @@ func (p *PVBackupFiltering) Init() error {
 }
 
 func (p *PVBackupFiltering) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
-
-	err := InstallStorageClass(ctx, fmt.Sprintf("testdata/storage-class/%s.yaml", VeleroCfg.CloudProvider))
+	p.Ctx, p.CtxCancel = context.WithTimeout(context.Background(), 10*time.Minute)
+	err := InstallStorageClass(p.Ctx, fmt.Sprintf("testdata/storage-class/%s.yaml", VeleroCfg.CloudProvider))
 	if err != nil {
 		return errors.Wrapf(err, "failed to install storage class for pv backup filtering test")
 	}
 
 	for _, ns := range *p.NSIncluded {
 		By(fmt.Sprintf("Create namespaces %s for workload\n", ns), func() {
-			Expect(CreateNamespace(ctx, p.Client, ns)).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", ns))
+			Expect(CreateNamespace(p.Ctx, p.Client, ns)).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", ns))
 		})
 		var pods []string
 		By(fmt.Sprintf("Deploy a few pods with several PVs in namespace %s", ns), func() {
@@ -104,7 +102,7 @@ func (p *PVBackupFiltering) CreateResources() error {
 						p.annotation: volumesToAnnotation,
 					}
 					By(fmt.Sprintf("Add annotation to pod %s of namespace %s", pod.Name, ns), func() {
-						_, err := AddAnnotationToPod(ctx, p.Client, ns, pod.Name, ann)
+						_, err := AddAnnotationToPod(p.Ctx, p.Client, ns, pod.Name, ann)
 						Expect(err).To(Succeed())
 					})
 				})
@@ -115,17 +113,17 @@ func (p *PVBackupFiltering) CreateResources() error {
 	By(fmt.Sprintf("Waiting for all pods to start %s\n", p.podsList), func() {
 		for index, ns := range *p.NSIncluded {
 			By(fmt.Sprintf("Waiting for all pods to start %d in namespace %s", index, ns), func() {
-				WaitForPods(ctx, p.Client, ns, p.podsList[index])
+				Expect(WaitForPods(p.Ctx, p.Client, ns, p.podsList[index])).To(Succeed())
 			})
 		}
 	})
 	By(fmt.Sprintf("Populate all pods %s with file %s", p.podsList, FILE_NAME), func() {
 		for index, ns := range *p.NSIncluded {
 			By(fmt.Sprintf("Creating file in all pods to start %d in namespace %s", index, ns), func() {
-				WaitForPods(ctx, p.Client, ns, p.podsList[index])
+				Expect(WaitForPods(p.Ctx, p.Client, ns, p.podsList[index])).To(Succeed())
 				for i, pod := range p.podsList[index] {
 					for j := range p.volumesList[i] {
-						Expect(CreateFileToPod(ctx, ns, pod, pod, p.volumesList[i][j],
+						Expect(CreateFileToPod(p.Ctx, ns, pod, pod, p.volumesList[i][j],
 							FILE_NAME, fileContent(ns, pod, p.volumesList[i][j]))).To(Succeed())
 					}
 				}
@@ -136,12 +134,10 @@ func (p *PVBackupFiltering) CreateResources() error {
 }
 
 func (p *PVBackupFiltering) Verify() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), time.Minute*60)
-	defer ctxCancel()
 	By(fmt.Sprintf("Waiting for all pods to start %s", p.podsList), func() {
 		for index, ns := range *p.NSIncluded {
 			By(fmt.Sprintf("Waiting for all pods to start %d in namespace %s", index, ns), func() {
-				WaitForPods(ctx, p.Client, ns, p.podsList[index])
+				WaitForPods(p.Ctx, p.Client, ns, p.podsList[index])
 			})
 		}
 	})
@@ -154,21 +150,21 @@ func (p *PVBackupFiltering) Verify() error {
 					if j%2 == 0 {
 						if p.annotation == OPT_IN_ANN {
 							By(fmt.Sprintf("File should exists in PV %s of pod %s under namespace %s\n", p.volumesList[i][j], p.podsList[k][i], ns), func() {
-								Expect(fileExist(ctx, ns, p.podsList[k][i], p.volumesList[i][j])).To(Succeed(), "File not exist as expect")
+								Expect(fileExist(p.Ctx, ns, p.podsList[k][i], p.volumesList[i][j])).To(Succeed(), "File not exist as expect")
 							})
 						} else {
 							By(fmt.Sprintf("File should not exist in PV %s of pod %s under namespace %s\n", p.volumesList[i][j], p.podsList[k][i], ns), func() {
-								Expect(fileNotExist(ctx, ns, p.podsList[k][i], p.volumesList[i][j])).To(Succeed(), "File exists, not as expect")
+								Expect(fileNotExist(p.Ctx, ns, p.podsList[k][i], p.volumesList[i][j])).To(Succeed(), "File exists, not as expect")
 							})
 						}
 					} else {
 						if p.annotation == OPT_OUT_ANN {
 							By(fmt.Sprintf("File should exists in PV %s of pod %s under namespace %s\n", p.volumesList[i][j], p.podsList[k][i], ns), func() {
-								Expect(fileExist(ctx, ns, p.podsList[k][i], p.volumesList[i][j])).To(Succeed(), "File not exist as expect")
+								Expect(fileExist(p.Ctx, ns, p.podsList[k][i], p.volumesList[i][j])).To(Succeed(), "File not exist as expect")
 							})
 						} else {
 							By(fmt.Sprintf("File should not exist in PV %s of pod %s under namespace %s\n", p.volumesList[i][j], p.podsList[k][i], ns), func() {
-								Expect(fileNotExist(ctx, ns, p.podsList[k][i], p.volumesList[i][j])).To(Succeed(), "File exists, not as expect")
+								Expect(fileNotExist(p.Ctx, ns, p.podsList[k][i], p.volumesList[i][j])).To(Succeed(), "File exists, not as expect")
 							})
 						}
 					}

test/e2e/resource-filtering/base.go

@@ -64,12 +64,11 @@ func (f *FilteringCase) Init() error {
 }
 
 func (f *FilteringCase) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
+	f.Ctx, f.CtxCancel = context.WithTimeout(context.Background(), 30*time.Minute)
 	for nsNum := 0; nsNum < f.NamespacesTotal; nsNum++ {
 		namespace := fmt.Sprintf("%s-%00000d", f.CaseBaseName, nsNum)
 		fmt.Printf("Creating resources in namespace ...%s\n", namespace)
-		if err := CreateNamespace(ctx, f.Client, namespace); err != nil {
+		if err := CreateNamespace(f.Ctx, f.Client, namespace); err != nil {
 			return errors.Wrapf(err, "Failed to create namespace %s", namespace)
 		}
 		//Create deployment
@@ -110,13 +109,11 @@ func (f *FilteringCase) CreateResources() error {
 }
 
 func (f *FilteringCase) Verify() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	for nsNum := 0; nsNum < f.NamespacesTotal; nsNum++ {
 		namespace := fmt.Sprintf("%s-%00000d", f.CaseBaseName, nsNum)
 		fmt.Printf("Checking resources in namespaces ...%s\n", namespace)
 		//Check namespace
-		checkNS, err := GetNamespace(ctx, f.Client, namespace)
+		checkNS, err := GetNamespace(f.Ctx, f.Client, namespace)
 		if err != nil {
 			return errors.Wrapf(err, "Could not retrieve test namespace %s", namespace)
 		}

test/e2e/resource-filtering/exclude_label.go

@@ -77,8 +77,7 @@ func (e *ExcludeFromBackup) Init() error {
 }
 
 func (e *ExcludeFromBackup) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
+	e.Ctx, e.CtxCancel = context.WithTimeout(context.Background(), 10*time.Minute)
 	namespace := e.CaseBaseName
 	// These 2 labels for resources to be included
 	label1 := map[string]string{
@@ -88,7 +87,7 @@ func (e *ExcludeFromBackup) CreateResources() error {
 		"velero.io/exclude-from-backup": "false",
 	}
 	fmt.Printf("Creating resources in namespace ...%s\n", namespace)
-	if err := CreateNamespace(ctx, e.Client, namespace); err != nil {
+	if err := CreateNamespace(e.Ctx, e.Client, namespace); err != nil {
 		return errors.Wrapf(err, "Failed to create namespace %s", namespace)
 	}
 	//Create deployment: to be included
@@ -132,12 +131,10 @@ func (e *ExcludeFromBackup) CreateResources() error {
 }
 
 func (e *ExcludeFromBackup) Verify() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	namespace := e.CaseBaseName
 	By(fmt.Sprintf("Checking resources in namespaces ...%s\n", namespace), func() {
 		//Check namespace
-		checkNS, err := GetNamespace(ctx, e.Client, namespace)
+		checkNS, err := GetNamespace(e.Ctx, e.Client, namespace)
 		Expect(err).ShouldNot(HaveOccurred(), fmt.Sprintf("Could not retrieve test namespace %s", namespace))
 		Expect(checkNS.Name == namespace).To(Equal(true), fmt.Sprintf("Retrieved namespace for %s has name %s instead", namespace, checkNS.Name))
 

test/e2e/resource-filtering/exclude_namespaces.go

@@ -110,12 +110,11 @@ func (e *ExcludeNamespaces) Init() error {
 }
 
 func (e *ExcludeNamespaces) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
+	e.Ctx, e.CtxCancel = context.WithTimeout(context.Background(), 10*time.Minute)
 	for nsNum := 0; nsNum < e.NamespacesTotal; nsNum++ {
 		createNSName := fmt.Sprintf("%s-%00000d", e.CaseBaseName, nsNum)
 		fmt.Printf("Creating namespaces ...%s\n", createNSName)
-		if err := CreateNamespace(ctx, e.Client, createNSName); err != nil {
+		if err := CreateNamespace(e.Ctx, e.Client, createNSName); err != nil {
 			return errors.Wrapf(err, "Failed to create namespace %s", createNSName)
 		}
 	}
@@ -123,12 +122,10 @@ func (e *ExcludeNamespaces) CreateResources() error {
 }
 
 func (e *ExcludeNamespaces) Verify() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	// Verify that we got back all of the namespaces we created
 	for nsNum := 0; nsNum < e.namespacesExcluded; nsNum++ {
 		excludeNSName := fmt.Sprintf("%s-%00000d", e.CaseBaseName, nsNum)
-		_, err := GetNamespace(ctx, e.Client, excludeNSName)
+		_, err := GetNamespace(e.Ctx, e.Client, excludeNSName)
 		if err == nil {
 			return errors.Wrapf(err, "Resource filtering with exclude namespace but exclude namespace %s exist", excludeNSName)
 		}
@@ -140,7 +137,7 @@ func (e *ExcludeNamespaces) Verify() error {
 
 	for nsNum := e.namespacesExcluded; nsNum < e.NamespacesTotal; nsNum++ {
 		checkNSName := fmt.Sprintf("%s-%00000d", e.CaseBaseName, nsNum)
-		checkNS, err := GetNamespace(ctx, e.Client, checkNSName)
+		checkNS, err := GetNamespace(e.Ctx, e.Client, checkNSName)
 		if err != nil {
 			return errors.Wrapf(err, "Could not retrieve test namespace %s", checkNSName)
 		}

test/e2e/resource-filtering/exclude_resources.go

@@ -17,7 +17,6 @@ limitations under the License.
 package filtering
 
 import (
-	"context"
 	"fmt"
 	"strings"
 
@@ -105,7 +104,7 @@ func (e *ExcludeResources) Verify() error {
 			return errors.Wrap(err, fmt.Sprintf("failed to list deployment in namespace: %q", namespace))
 		}
 		//Check secrets
-		secretsList, err := e.Client.ClientGo.CoreV1().Secrets(namespace).List(context.TODO(), metav1.ListOptions{LabelSelector: e.labelSelector})
+		secretsList, err := e.Client.ClientGo.CoreV1().Secrets(namespace).List(e.Ctx, metav1.ListOptions{LabelSelector: e.labelSelector})
 		if err != nil {
 			if apierrors.IsNotFound(err) { //resource should be excluded
 				return nil
@@ -116,7 +115,7 @@ func (e *ExcludeResources) Verify() error {
 		}
 
 		//Check configmap
-		configmapList, err := e.Client.ClientGo.CoreV1().ConfigMaps(namespace).List(context.TODO(), metav1.ListOptions{LabelSelector: e.labelSelector})
+		configmapList, err := e.Client.ClientGo.CoreV1().ConfigMaps(namespace).List(e.Ctx, metav1.ListOptions{LabelSelector: e.labelSelector})
 		if err != nil {
 			return errors.Wrap(err, fmt.Sprintf("failed to list configmap in namespace: %q", namespace))
 		} else if len(configmapList.Items) == 0 {

test/e2e/resource-filtering/include_namespaces.go

@@ -105,12 +105,11 @@ func (i *IncludeNamespaces) Init() error {
 }
 
 func (i *IncludeNamespaces) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
+	i.Ctx, i.CtxCancel = context.WithTimeout(context.Background(), 10*time.Minute)
 	for nsNum := 0; nsNum < i.NamespacesTotal; nsNum++ {
 		createNSName := fmt.Sprintf("%s-%00000d", i.CaseBaseName, nsNum)
 		fmt.Printf("Creating namespaces ...%s\n", createNSName)
-		if err := CreateNamespace(ctx, i.Client, createNSName); err != nil {
+		if err := CreateNamespace(i.Ctx, i.Client, createNSName); err != nil {
 			return errors.Wrapf(err, "Failed to create namespace %s", createNSName)
 		}
 	}
@@ -118,12 +117,10 @@ func (i *IncludeNamespaces) CreateResources() error {
 }
 
 func (i *IncludeNamespaces) Verify() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	// Verify that we got back all of the namespaces we created
 	for nsNum := 0; nsNum < i.namespacesIncluded; nsNum++ {
 		checkNSName := fmt.Sprintf("%s-%00000d", i.CaseBaseName, nsNum)
-		checkNS, err := GetNamespace(ctx, i.Client, checkNSName)
+		checkNS, err := GetNamespace(i.Ctx, i.Client, checkNSName)
 		if err != nil {
 			return errors.Wrapf(err, "Could not retrieve test namespace %s", checkNSName)
 		}
@@ -134,7 +131,7 @@ func (i *IncludeNamespaces) Verify() error {
 
 	for nsNum := i.namespacesIncluded; nsNum < i.NamespacesTotal; nsNum++ {
 		excludeNSName := fmt.Sprintf("%s-%00000d", i.CaseBaseName, nsNum)
-		_, err := GetNamespace(ctx, i.Client, excludeNSName)
+		_, err := GetNamespace(i.Ctx, i.Client, excludeNSName)
 		if err == nil {
 			return errors.Wrapf(err, "Resource filtering with include namespace but exclude namespace %s exist", excludeNSName)
 		}

test/e2e/resource-filtering/include_resources.go

@@ -17,7 +17,6 @@ limitations under the License.
 package filtering
 
 import (
-	"context"
 	"fmt"
 	"strings"
 
@@ -102,7 +101,7 @@ func (i *IncludeResources) Verify() error {
 			return errors.Wrap(err, fmt.Sprintf("failed to list deployment in namespace: %q", namespace))
 		}
 		//Check secrets
-		secretsList, err := i.Client.ClientGo.CoreV1().Secrets(namespace).List(context.TODO(), metav1.ListOptions{LabelSelector: i.labelSelector})
+		secretsList, err := i.Client.ClientGo.CoreV1().Secrets(namespace).List(i.Ctx, metav1.ListOptions{LabelSelector: i.labelSelector})
 		if err != nil {
 			if apierrors.IsNotFound(err) { //resource should be excluded
 				return nil
@@ -113,7 +112,7 @@ func (i *IncludeResources) Verify() error {
 		}
 
 		//Check configmap
-		configmapList, err := i.Client.ClientGo.CoreV1().ConfigMaps(namespace).List(context.TODO(), metav1.ListOptions{LabelSelector: i.labelSelector})
+		configmapList, err := i.Client.ClientGo.CoreV1().ConfigMaps(namespace).List(i.Ctx, metav1.ListOptions{LabelSelector: i.labelSelector})
 		if err != nil {
 			return errors.Wrap(err, fmt.Sprintf("failed to list configmap in namespace: %q", namespace))
 		} else if len(configmapList.Items) == 0 {

test/e2e/resource-filtering/label_selector.go

@@ -76,8 +76,7 @@ func (l *LabelSelector) Init() error {
 }
 
 func (l *LabelSelector) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
+	l.Ctx, l.CtxCancel = context.WithTimeout(context.Background(), 10*time.Minute)
 	for nsNum := 0; nsNum < l.NamespacesTotal; nsNum++ {
 		namespace := fmt.Sprintf("%s-%00000d", l.CaseBaseName, nsNum)
 		fmt.Printf("Creating resources in namespace ...%s\n", namespace)
@@ -87,7 +86,7 @@ func (l *LabelSelector) CreateResources() error {
 				"resourcefiltering": "false",
 			}
 		}
-		if err := CreateNamespaceWithLabel(ctx, l.Client, namespace, labels); err != nil {
+		if err := CreateNamespaceWithLabel(l.Ctx, l.Client, namespace, labels); err != nil {
 			return errors.Wrapf(err, "Failed to create namespace %s", namespace)
 		}
 		//Create deployment
@@ -139,7 +138,7 @@ func (l *LabelSelector) Verify() error {
 		}
 
 		//Check secrets
-		secretsList, err := l.Client.ClientGo.CoreV1().Secrets(namespace).List(context.TODO(), metav1.ListOptions{
+		secretsList, err := l.Client.ClientGo.CoreV1().Secrets(namespace).List(l.Ctx, metav1.ListOptions{
 			LabelSelector: l.labelSelector,
 		})
 

test/e2e/resourcepolicies/resource_policies.go

@@ -100,8 +100,7 @@ func (r *ResourcePoliciesCase) Init() error {
 }
 
 func (r *ResourcePoliciesCase) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
+	r.Ctx, r.CtxCancel = context.WithTimeout(context.Background(), 10*time.Minute)
 	By(("Installing storage class..."), func() {
 		Expect(r.installTestStorageClasses(fmt.Sprintf("testdata/storage-class/%s.yaml", VeleroCfg.CloudProvider))).To(Succeed(), "Failed to install storage class")
 	})
@@ -117,7 +116,7 @@ func (r *ResourcePoliciesCase) CreateResources() error {
 	for nsNum := 0; nsNum < r.NamespacesTotal; nsNum++ {
 		namespace := fmt.Sprintf("%s-%00000d", r.CaseBaseName, nsNum)
 		By(fmt.Sprintf("Create namespaces %s for workload\n", namespace), func() {
-			Expect(CreateNamespace(ctx, r.Client, namespace)).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", namespace))
+			Expect(CreateNamespace(r.Ctx, r.Client, namespace)).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", namespace))
 		})
 
 		volName := fmt.Sprintf("vol-%s-%00000d", r.CaseBaseName, nsNum)
@@ -143,14 +142,12 @@ func (r *ResourcePoliciesCase) CreateResources() error {
 }
 
 func (r *ResourcePoliciesCase) Verify() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	for i, ns := range *r.NSIncluded {
 		By(fmt.Sprintf("Verify pod data in namespace %s", ns), func() {
 			By(fmt.Sprintf("Waiting for deployment %s in namespace %s ready", r.CaseBaseName, ns), func() {
 				Expect(WaitForReadyDeployment(r.Client.ClientGo, ns, r.CaseBaseName)).To(Succeed(), fmt.Sprintf("Failed to waiting for deployment %s in namespace %s ready", r.CaseBaseName, ns))
 			})
-			podList, err := ListPods(ctx, r.Client, ns)
+			podList, err := ListPods(r.Ctx, r.Client, ns)
 			Expect(err).To(Succeed(), fmt.Sprintf("failed to list pods in namespace: %q with error %v", ns, err))
 
 			volName := fmt.Sprintf("vol-%s-%00000d", r.CaseBaseName, i)
@@ -159,7 +156,7 @@ func (r *ResourcePoliciesCase) Verify() error {
 					if vol.Name != volName {
 						continue
 					}
-					content, err := ReadFileFromPodVolume(ctx, ns, pod.Name, "container-busybox", vol.Name, FileName)
+					content, err := ReadFileFromPodVolume(r.Ctx, ns, pod.Name, "container-busybox", vol.Name, FileName)
 					if i%2 == 0 {
 						Expect(err).To(HaveOccurred(), "Expected file not found") // File should not exist
 					} else {
@@ -231,9 +228,7 @@ func (r *ResourcePoliciesCase) createDeploymentWithVolume(namespace string, volL
 }
 
 func (r *ResourcePoliciesCase) writeDataIntoPods(namespace, volName string) error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
-	podList, err := ListPods(ctx, r.Client, namespace)
+	podList, err := ListPods(r.Ctx, r.Client, namespace)
 	if err != nil {
 		return errors.Wrap(err, fmt.Sprintf("failed to list pods in namespace: %q with error %v", namespace, err))
 	}
@@ -242,7 +237,7 @@ func (r *ResourcePoliciesCase) writeDataIntoPods(namespace, volName string) erro
 			if vol.Name != volName {
 				continue
 			}
-			err := CreateFileToPod(ctx, namespace, pod.Name, "container-busybox", vol.Name, FileName, fmt.Sprintf("ns-%s pod-%s volume-%s", namespace, pod.Name, vol.Name))
+			err := CreateFileToPod(r.Ctx, namespace, pod.Name, "container-busybox", vol.Name, FileName, fmt.Sprintf("ns-%s pod-%s volume-%s", namespace, pod.Name, vol.Name))
 			if err != nil {
 				return errors.Wrap(err, fmt.Sprintf("failed to create file into pod %s in namespace: %q", pod.Name, namespace))
 			}
@@ -252,10 +247,8 @@ func (r *ResourcePoliciesCase) writeDataIntoPods(namespace, volName string) erro
 }
 
 func (r *ResourcePoliciesCase) deleteTestStorageClassList(scList []string) error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	for _, v := range scList {
-		if err := DeleteStorageClass(ctx, r.Client, v); err != nil {
+		if err := DeleteStorageClass(r.Ctx, r.Client, v); err != nil {
 			return err
 		}
 	}
@@ -263,9 +256,7 @@ func (r *ResourcePoliciesCase) deleteTestStorageClassList(scList []string) error
 }
 
 func (r *ResourcePoliciesCase) installTestStorageClasses(path string) error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
-	err := InstallStorageClass(ctx, path)
+	err := InstallStorageClass(r.Ctx, path)
 	if err != nil {
 		return err
 	}
@@ -286,5 +277,5 @@ func (r *ResourcePoliciesCase) installTestStorageClasses(path string) error {
 	if _, err := tmpFile.WriteString(newContent); err != nil {
 		return errors.Wrapf(err, "failed to write content into temp file %s when install storage class", tmpFile.Name())
 	}
-	return InstallStorageClass(ctx, tmpFile.Name())
+	return InstallStorageClass(r.Ctx, tmpFile.Name())
 }

test/e2e/schedule/ordered_resources.go

@@ -75,13 +75,12 @@ func (o *OrderedResources) Init() error {
 }
 
 func (o *OrderedResources) CreateResources() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
+	o.Ctx, o.CtxCancel = context.WithTimeout(context.Background(), 10*time.Minute)
 	label := map[string]string{
 		"orderedresources": "true",
 	}
 	fmt.Printf("Creating resources in %s namespace ...\n", o.Namespace)
-	if err := CreateNamespace(ctx, o.Client, o.Namespace); err != nil {
+	if err := CreateNamespace(o.Ctx, o.Client, o.Namespace); err != nil {
 		return errors.Wrapf(err, "failed to create namespace %s", o.Namespace)
 	}
 	//Create deployment
@@ -122,32 +121,28 @@ func (o *OrderedResources) CreateResources() error {
 }
 
 func (o *OrderedResources) Backup() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	By(fmt.Sprintf("Create schedule the workload in %s namespace", o.Namespace), func() {
-		err := VeleroScheduleCreate(ctx, o.VeleroCfg.VeleroCLI, o.VeleroCfg.VeleroNamespace, o.ScheduleName, o.ScheduleArgs)
+		err := VeleroScheduleCreate(o.Ctx, o.VeleroCfg.VeleroCLI, o.VeleroCfg.VeleroNamespace, o.ScheduleName, o.ScheduleArgs)
 		Expect(err).To(Succeed(), fmt.Sprintf("Failed to create schedule %s  with err %v", o.ScheduleName, err))
 	})
 	return nil
 }
 
 func (o *OrderedResources) Verify() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	By(fmt.Sprintf("Checking resource order in %s schedule cr", o.ScheduleName), func() {
-		err := CheckScheduleWithResourceOrder(ctx, o.VeleroCfg.VeleroCLI, o.VeleroCfg.VeleroNamespace, o.ScheduleName, o.OrderMap)
+		err := CheckScheduleWithResourceOrder(o.Ctx, o.VeleroCfg.VeleroCLI, o.VeleroCfg.VeleroNamespace, o.ScheduleName, o.OrderMap)
 		Expect(err).To(Succeed(), fmt.Sprintf("Failed to check schedule %s with err %v", o.ScheduleName, err))
 	})
 
 	By("Checking resource order in backup cr", func() {
 		backupList := new(velerov1api.BackupList)
 		err := waitutil.PollImmediate(10*time.Second, time.Minute*5, func() (bool, error) {
-			if err := o.Client.Kubebuilder.List(ctx, backupList, &kbclient.ListOptions{Namespace: o.VeleroCfg.VeleroNamespace}); err != nil {
+			if err := o.Client.Kubebuilder.List(o.Ctx, backupList, &kbclient.ListOptions{Namespace: o.VeleroCfg.VeleroNamespace}); err != nil {
 				return false, fmt.Errorf("failed to list backup object in %s namespace with err %v", o.VeleroCfg.VeleroNamespace, err)
 			}
 
 			for _, backup := range backupList.Items {
-				if err := CheckBackupWithResourceOrder(ctx, o.VeleroCfg.VeleroCLI, o.VeleroCfg.VeleroNamespace, backup.Name, o.OrderMap); err == nil {
+				if err := CheckBackupWithResourceOrder(o.Ctx, o.VeleroCfg.VeleroCLI, o.VeleroCfg.VeleroNamespace, backup.Name, o.OrderMap); err == nil {
 					return true, nil
 				}
 			}
@@ -160,24 +155,20 @@ func (o *OrderedResources) Verify() error {
 }
 
 func (o *OrderedResources) Clean() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	if !o.VeleroCfg.Debug {
-		Expect(VeleroScheduleDelete(ctx, o.VeleroCfg.VeleroCLI, o.VeleroCfg.VeleroNamespace, o.ScheduleName)).To(Succeed())
+		Expect(VeleroScheduleDelete(o.Ctx, o.VeleroCfg.VeleroCLI, o.VeleroCfg.VeleroNamespace, o.ScheduleName)).To(Succeed())
 		Expect(o.TestCase.Clean()).To(Succeed())
 	}
 	return nil
 }
 
 func (o *OrderedResources) DeleteBackups() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer ctxCancel()
 	backupList := new(velerov1api.BackupList)
-	if err := o.Client.Kubebuilder.List(ctx, backupList, &kbclient.ListOptions{Namespace: o.VeleroCfg.VeleroNamespace}); err != nil {
+	if err := o.Client.Kubebuilder.List(o.Ctx, backupList, &kbclient.ListOptions{Namespace: o.VeleroCfg.VeleroNamespace}); err != nil {
 		return fmt.Errorf("failed to list backup object in %s namespace with err %v", o.VeleroCfg.VeleroNamespace, err)
 	}
 	for _, backup := range backupList.Items {
-		if err := VeleroBackupDelete(ctx, o.VeleroCfg.VeleroCLI, o.VeleroCfg.VeleroNamespace, backup.Name); err != nil {
+		if err := VeleroBackupDelete(o.Ctx, o.VeleroCfg.VeleroCLI, o.VeleroCfg.VeleroNamespace, backup.Name); err != nil {
 			return err
 		}
 	}

test/e2e/schedule/schedule-backup-creation.go

@@ -66,23 +66,22 @@ func (n *ScheduleBackupCreation) Init() error {
 }
 
 func (p *ScheduleBackupCreation) CreateResources() error {
+	p.Ctx, p.CtxCancel = context.WithTimeout(context.Background(), 60*time.Minute)
 	By(fmt.Sprintf("Create namespace %s", p.namespace), func() {
-		Expect(CreateNamespace(context.Background(), p.Client, p.namespace)).To(Succeed(),
+		Expect(CreateNamespace(p.Ctx, p.Client, p.namespace)).To(Succeed(),
 			fmt.Sprintf("Failed to create namespace %s", p.namespace))
 	})
 
 	By(fmt.Sprintf("Create pod %s in namespace %s", p.podName, p.namespace), func() {
 		_, err := CreatePod(p.Client, p.namespace, p.podName, "default", p.pvcName, []string{p.volume}, nil, p.podAnn)
 		Expect(err).To(Succeed())
-		err = WaitForPods(context.Background(), p.Client, p.namespace, []string{p.podName})
+		err = WaitForPods(p.Ctx, p.Client, p.namespace, []string{p.podName})
 		Expect(err).To(Succeed())
 	})
 	return nil
 }
 
 func (n *ScheduleBackupCreation) Backup() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
-	defer ctxCancel()
 	// Wait until the beginning of the given period to create schedule, it will give us
 	//   a predictable period to wait for the first scheduled backup, and verify no immediate
 	//   scheduled backup was created between schedule creation and first scheduled backup.
@@ -92,7 +91,7 @@ func (n *ScheduleBackupCreation) Backup() error {
 			now := time.Now().Minute()
 			triggerNow := now % n.Period
 			if triggerNow == 0 {
-				Expect(VeleroScheduleCreate(ctx, VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, n.ScheduleName, n.ScheduleArgs)).To(Succeed(), func() string {
+				Expect(VeleroScheduleCreate(n.Ctx, VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, n.ScheduleName, n.ScheduleArgs)).To(Succeed(), func() string {
 					RunDebug(context.Background(), VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, "", "")
 					return "Fail to create schedule"
 				})
@@ -111,7 +110,7 @@ func (n *ScheduleBackupCreation) Backup() error {
 			mi, _ := time.ParseDuration("60s")
 			time.Sleep(n.podSleepDuration + mi)
 			bMap := make(map[string]string)
-			backupsInfo, err := GetScheduledBackupsCreationTime(context.Background(), VeleroCfg.VeleroCLI, "default", n.ScheduleName)
+			backupsInfo, err := GetScheduledBackupsCreationTime(n.Ctx, VeleroCfg.VeleroCLI, "default", n.ScheduleName)
 			Expect(err).To(Succeed())
 			Expect(len(backupsInfo) == i).To(Equal(true))
 			for index, bi := range backupsInfo {
@@ -132,7 +131,7 @@ func (n *ScheduleBackupCreation) Backup() error {
 
 func (n *ScheduleBackupCreation) Clean() error {
 	if !n.VeleroCfg.Debug {
-		Expect(VeleroScheduleDelete(context.Background(), n.VeleroCfg.VeleroCLI, n.VeleroCfg.VeleroNamespace, n.ScheduleName)).To(Succeed())
+		Expect(VeleroScheduleDelete(n.Ctx, n.VeleroCfg.VeleroCLI, n.VeleroCfg.VeleroNamespace, n.ScheduleName)).To(Succeed())
 		Expect(n.TestCase.Clean()).To(Succeed())
 	}
 	return nil

test/e2e/schedule/schedule.go

@@ -51,11 +51,10 @@ func (n *ScheduleBackup) Init() error {
 }
 
 func (n *ScheduleBackup) CreateResources() error {
-	ctx, ctxCanel := context.WithTimeout(context.Background(), 60*time.Minute)
-	defer ctxCanel()
+	n.Ctx, n.CtxCancel = context.WithTimeout(context.Background(), 60*time.Minute)
 	for _, ns := range *n.NSIncluded {
 		By(fmt.Sprintf("Creating namespaces %s ......\n", ns), func() {
-			Expect(CreateNamespace(ctx, n.Client, ns)).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", ns))
+			Expect(CreateNamespace(n.Ctx, n.Client, ns)).To(Succeed(), fmt.Sprintf("Failed to create namespace %s", ns))
 		})
 		configmaptName := n.CaseBaseName
 		fmt.Printf("Creating configmap %s in namespaces ...%s\n", configmaptName, ns)
@@ -68,8 +67,6 @@ func (n *ScheduleBackup) CreateResources() error {
 }
 
 func (n *ScheduleBackup) Backup() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
-	defer ctxCancel()
 	// Wait until the beginning of the given period to create schedule, it will give us
 	//   a predictable period to wait for the first scheduled backup, and verify no immediate
 	//   scheduled backup was created between schedule creation and first scheduled backup.
@@ -79,7 +76,7 @@ func (n *ScheduleBackup) Backup() error {
 			now := time.Now().Minute()
 			triggerNow := now % n.Period
 			if triggerNow == 0 {
-				Expect(VeleroScheduleCreate(ctx, VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, n.ScheduleName, n.ScheduleArgs)).To(Succeed(), func() string {
+				Expect(VeleroScheduleCreate(n.Ctx, VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, n.ScheduleName, n.ScheduleArgs)).To(Succeed(), func() string {
 					RunDebug(context.Background(), VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, "", "")
 					return "Fail to create schedule"
 				})
@@ -89,7 +86,7 @@ func (n *ScheduleBackup) Backup() error {
 	})
 
 	By(fmt.Sprintf("Schedule %s is created without any delay\n", n.ScheduleName), func() {
-		creationTimestamp, err := GetSchedule(context.Background(), VeleroCfg.VeleroNamespace, n.ScheduleName)
+		creationTimestamp, err := GetSchedule(n.Ctx, VeleroCfg.VeleroNamespace, n.ScheduleName)
 		Expect(err).To(Succeed())
 
 		creationTime, err := time.Parse(time.RFC3339, strings.Replace(creationTimestamp, "'", "", -1))
@@ -107,7 +104,7 @@ func (n *ScheduleBackup) Backup() error {
 			fmt.Printf("Get backup for #%d time at %v\n", i, now)
 			//Ignore the last minute in the period avoiding met the 1st backup by schedule
 			if i != n.Period-1 {
-				backupsInfo, err := GetScheduledBackupsCreationTime(context.Background(), VeleroCfg.VeleroCLI, "default", n.ScheduleName)
+				backupsInfo, err := GetScheduledBackupsCreationTime(n.Ctx, VeleroCfg.VeleroCLI, "default", n.ScheduleName)
 				Expect(err).To(Succeed())
 				Expect(len(backupsInfo) == 0).To(Equal(true))
 			}
@@ -123,7 +120,7 @@ func (n *ScheduleBackup) Backup() error {
 			fmt.Printf("Start to sleep %d minute #%d time...\n", n.Period, i+1)
 			time.Sleep(time.Duration(n.Period) * time.Minute)
 			bMap := make(map[string]string)
-			backupsInfo, err := GetScheduledBackupsCreationTime(context.Background(), VeleroCfg.VeleroCLI, "default", n.ScheduleName)
+			backupsInfo, err := GetScheduledBackupsCreationTime(n.Ctx, VeleroCfg.VeleroCLI, "default", n.ScheduleName)
 			Expect(err).To(Succeed())
 			Expect(len(backupsInfo) == i+2).To(Equal(true))
 			for index, bi := range backupsInfo {
@@ -143,16 +140,16 @@ func (n *ScheduleBackup) Backup() error {
 	n.BackupName = strings.Replace(n.randBackupName, " ", "", -1)
 
 	By("Delete all namespaces", func() {
-		Expect(CleanupNamespacesWithPoll(ctx, n.Client, n.CaseBaseName)).To(Succeed(), "Could cleanup retrieve namespaces")
+		Expect(CleanupNamespacesWithPoll(n.Ctx, n.Client, n.CaseBaseName)).To(Succeed(), "Could cleanup retrieve namespaces")
 	})
 
-	backupsInfo, err := GetScheduledBackupsCreationTime(context.Background(), VeleroCfg.VeleroCLI, "default", n.ScheduleName)
+	backupsInfo, err := GetScheduledBackupsCreationTime(n.Ctx, VeleroCfg.VeleroCLI, "default", n.ScheduleName)
 	Expect(err).To(Succeed(), fmt.Sprintf("Fail to get backups from schedule %s", n.ScheduleName))
 	fmt.Println(backupsInfo)
 	backupCount := len(backupsInfo)
 
 	By(fmt.Sprintf("Pause schedule %s ......\n", n.ScheduleName), func() {
-		Expect(VeleroSchedulePause(ctx, VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, n.ScheduleName)).To(Succeed(), func() string {
+		Expect(VeleroSchedulePause(n.Ctx, VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, n.ScheduleName)).To(Succeed(), func() string {
 			RunDebug(context.Background(), VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, "", "")
 			return "Fail to pause schedule"
 		})
@@ -164,7 +161,7 @@ func (n *ScheduleBackup) Backup() error {
 		time.Sleep(sleepDuration)
 	})
 
-	backupsInfo, err = GetScheduledBackupsCreationTime(context.Background(), VeleroCfg.VeleroCLI, "default", n.ScheduleName)
+	backupsInfo, err = GetScheduledBackupsCreationTime(n.Ctx, VeleroCfg.VeleroCLI, "default", n.ScheduleName)
 	Expect(err).To(Succeed(), fmt.Sprintf("Fail to get backups from schedule %s", n.ScheduleName))
 
 	backupCountPostPause := len(backupsInfo)
@@ -175,7 +172,7 @@ func (n *ScheduleBackup) Backup() error {
 	})
 
 	By(fmt.Sprintf("Unpause schedule %s ......\n", n.ScheduleName), func() {
-		Expect(VeleroScheduleUnpause(ctx, VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, n.ScheduleName)).To(Succeed(), func() string {
+		Expect(VeleroScheduleUnpause(n.Ctx, VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, n.ScheduleName)).To(Succeed(), func() string {
 			RunDebug(context.Background(), VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, "", "")
 			return "Fail to unpause schedule"
 		})
@@ -185,7 +182,7 @@ func (n *ScheduleBackup) Backup() error {
 		time.Sleep(sleepDuration)
 	})
 
-	backupsInfo, err = GetScheduledBackupsCreationTime(context.Background(), VeleroCfg.VeleroCLI, "default", n.ScheduleName)
+	backupsInfo, err = GetScheduledBackupsCreationTime(n.Ctx, VeleroCfg.VeleroCLI, "default", n.ScheduleName)
 	Expect(err).To(Succeed(), fmt.Sprintf("Fail to get backups from schedule %s", n.ScheduleName))
 	fmt.Println(backupsInfo)
 	backupCountPostUnpause := len(backupsInfo)
@@ -214,7 +211,7 @@ func (n *ScheduleBackup) Destroy() error {
 
 func (n *ScheduleBackup) Clean() error {
 	if !n.VeleroCfg.Debug {
-		Expect(VeleroScheduleDelete(context.Background(), n.VeleroCfg.VeleroCLI, n.VeleroCfg.VeleroNamespace, n.ScheduleName)).To(Succeed())
+		Expect(VeleroScheduleDelete(n.Ctx, n.VeleroCfg.VeleroCLI, n.VeleroCfg.VeleroNamespace, n.ScheduleName)).To(Succeed())
 		Expect(n.TestCase.Clean()).To(Succeed())
 	}
 	return nil

test/e2e/test/test.go

@@ -72,7 +72,8 @@ type TestCase struct {
 	UseVolumeSnapshots bool
 	VeleroCfg          VeleroConfig
 	RestorePhaseExpect velerov1api.RestorePhase
-	Timeout            time.Duration
+	Ctx                context.Context
+	CtxCancel          context.CancelFunc
 	UUIDgen            string
 }
 
@@ -80,11 +81,6 @@ func TestFunc(test VeleroBackupRestoreTest) func() {
 	return func() {
 		Expect(test.Init()).To(Succeed(), "Failed to instantiate test cases")
 		veleroCfg := test.GetTestCase().VeleroCfg
-		// If TestCase.Timeout is not set, then make 10 minutes as default value for backup
-		// or restore CLI
-		if test.GetTestCase().Timeout == 0 {
-			test.GetTestCase().Timeout = 10 * time.Minute
-		}
 		BeforeEach(func() {
 			flag.Parse()
 			veleroCfg := test.GetTestCase().VeleroCfg
@@ -117,11 +113,9 @@ func TestFuncWithMultiIt(tests []VeleroBackupRestoreTest) func() {
 		var veleroCfg VeleroConfig
 		for k := range tests {
 			Expect(tests[k].Init()).To(Succeed(), fmt.Sprintf("Failed to instantiate test %s case", tests[k].GetTestMsg().Desc))
-			if tests[k].GetTestCase().Timeout == 0 {
-				tests[k].GetTestCase().Timeout = 10 * time.Minute
-			}
 			veleroCfg = tests[k].GetTestCase().VeleroCfg
 			useVolumeSnapshots = tests[k].GetTestCase().UseVolumeSnapshots
+			defer tests[k].GetTestCase().CtxCancel()
 		}
 
 		BeforeEach(func() {
@@ -156,6 +150,7 @@ func TestFuncWithMultiIt(tests []VeleroBackupRestoreTest) func() {
 }
 
 func (t *TestCase) Init() error {
+	t.Ctx, t.CtxCancel = context.WithTimeout(context.Background(), 1*time.Hour)
 	t.UUIDgen = t.GenerateUUID()
 	return nil
 }
@@ -170,10 +165,8 @@ func (t *TestCase) CreateResources() error {
 }
 
 func (t *TestCase) Backup() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), t.Timeout)
-	defer ctxCancel()
 	veleroCfg := t.GetTestCase().VeleroCfg
-	if err := VeleroBackupExec(ctx, veleroCfg.VeleroCLI, veleroCfg.VeleroNamespace, t.BackupName, t.BackupArgs); err != nil {
+	if err := VeleroBackupExec(t.Ctx, veleroCfg.VeleroCLI, veleroCfg.VeleroNamespace, t.BackupName, t.BackupArgs); err != nil {
 		RunDebug(context.Background(), veleroCfg.VeleroCLI, veleroCfg.VeleroNamespace, t.BackupName, "")
 		return errors.Wrapf(err, "Failed to backup resources")
 	}
@@ -181,17 +174,17 @@ func (t *TestCase) Backup() error {
 }
 
 func (t *TestCase) Destroy() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
-	defer ctxCancel()
 	By(fmt.Sprintf("Start to destroy namespace %s......", t.CaseBaseName), func() {
-		Expect(CleanupNamespacesWithPoll(ctx, t.Client, t.CaseBaseName)).To(Succeed(), "Could cleanup retrieve namespaces")
+		Expect(CleanupNamespacesWithPoll(t.Ctx, t.Client, t.CaseBaseName)).To(Succeed(), "Could cleanup retrieve namespaces")
 	})
 	return nil
 }
 
 func (t *TestCase) Restore() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), t.Timeout)
-	defer ctxCancel()
+	if len(t.RestoreArgs) == 0 {
+		return nil
+	}
+
 	veleroCfg := t.GetTestCase().VeleroCfg
 	// the snapshots of AWS may be still in pending status when do the restore, wait for a while
 	// to avoid this https://github.com/vmware-tanzu/velero/issues/1799
@@ -205,7 +198,7 @@ func (t *TestCase) Restore() error {
 		if t.RestorePhaseExpect == "" {
 			t.RestorePhaseExpect = velerov1api.RestorePhaseCompleted
 		}
-		Expect(VeleroRestoreExec(ctx, veleroCfg.VeleroCLI, veleroCfg.VeleroNamespace, t.RestoreName, t.RestoreArgs, t.RestorePhaseExpect)).To(Succeed(), func() string {
+		Expect(VeleroRestoreExec(t.Ctx, veleroCfg.VeleroCLI, veleroCfg.VeleroNamespace, t.RestoreName, t.RestoreArgs, t.RestorePhaseExpect)).To(Succeed(), func() string {
 			RunDebug(context.Background(), veleroCfg.VeleroCLI, veleroCfg.VeleroNamespace, "", t.RestoreName)
 			return "Fail to restore workload"
 		})
@@ -218,15 +211,13 @@ func (t *TestCase) Verify() error {
 }
 
 func (t *TestCase) Clean() error {
-	ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
-	defer ctxCancel()
 	veleroCfg := t.GetTestCase().VeleroCfg
 	if !veleroCfg.Debug {
 		By(fmt.Sprintf("Clean namespace with prefix %s after test", t.CaseBaseName), func() {
-			CleanupNamespaces(ctx, t.Client, t.CaseBaseName)
+			CleanupNamespaces(t.Ctx, t.Client, t.CaseBaseName)
 		})
 		By("Clean backups after test", func() {
-			DeleteBackups(ctx, t.Client)
+			DeleteBackups(t.Ctx, t.Client)
 		})
 	}
 	return nil