mirrors/velero
1
0
Fork 0
mirror of https://github.com/vmware-tanzu/velero.git synced 2026-09-19 14:34:17 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Adjust E2E context

Browse Source 
Signed-off-by: Ming <mqiu@vmware.com>
This commit is contained in:
Ming
2023-05-17 14:05:15 +00:00
parent c12a0ac731
commit 54d6cffb45
20 changed files with 147 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/e2e/basic/resources-check/namespaces.go
+5 -10
View File
@@ -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
+3 -6
View File
@@ -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
+11 -16
View File
@@ -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")
}