From 4be502826b0d277a75db72e2f3581c3f25ed5425 Mon Sep 17 00:00:00 2001 From: Medya Gh Date: Thu, 1 Aug 2019 10:39:59 -0700 Subject: [PATCH] move helpers to test file, remove more unused funcs --- test/integration/containerd_test.go | 27 +- test/integration/fn_addons.go | 45 ++- test/integration/util/common.go | 114 -------- test/integration/util/util.go | 432 ---------------------------- 4 files changed, 65 insertions(+), 553 deletions(-) delete mode 100644 test/integration/util/util.go diff --git a/test/integration/containerd_test.go b/test/integration/containerd_test.go index 6f0064c50..b0664aec1 100644 --- a/test/integration/containerd_test.go +++ b/test/integration/containerd_test.go @@ -23,6 +23,9 @@ import ( "testing" "github.com/docker/machine/libmachine/state" + "github.com/pkg/errors" + "k8s.io/apimachinery/pkg/labels" + commonutil "k8s.io/minikube/pkg/util" "k8s.io/minikube/test/integration/util" ) @@ -53,7 +56,7 @@ func testGvisorRestart(t *testing.T) { mk.RunCommand("addons enable gvisor", true) t.Log("waiting for gvisor controller to come up") - if err := waitForGvisorControllerRunning(t, p); err != nil { + if err := waitForGvisorControllerRunning(p); err != nil { t.Fatalf("waiting for gvisor controller to be up: %v", err) } @@ -72,13 +75,13 @@ func testGvisorRestart(t *testing.T) { mk.CheckStatus(state.Running.String()) t.Log("waiting for gvisor controller to come up") - if err := util.WaitForGvisorControllerRunning(t, p); err != nil { + if err := waitForGvisorControllerRunning(p); err != nil { t.Fatalf("waiting for gvisor controller to be up: %v", err) } createUntrustedWorkload(t, p) t.Log("making sure untrusted workload is Running") - if err := util.WaitForUntrustedNginxRunning(p); err != nil { + if err := waitForUntrustedNginxRunning(p); err != nil { t.Fatalf("waiting for nginx to be up: %v", err) } deleteUntrustedWorkload(t, p) @@ -102,8 +105,8 @@ func deleteUntrustedWorkload(t *testing.T, profile string) { } // waitForGvisorControllerRunning waits for the gvisor controller pod to be running -func waitForGvisorControllerRunning(t *testing.T) error { - client, err := commonutil.GetClient() +func waitForGvisorControllerRunning(p string) error { + client, err := commonutil.GetClient(p) if err != nil { return errors.Wrap(err, "getting kubernetes client") } @@ -114,3 +117,17 @@ func waitForGvisorControllerRunning(t *testing.T) error { } return nil } + +// waitForUntrustedNginxRunning waits for the untrusted nginx pod to start running +func waitForUntrustedNginxRunning(miniProfile string) error { + client, err := commonutil.GetClient(miniProfile) + if err != nil { + return errors.Wrap(err, "getting kubernetes client") + } + + selector := labels.SelectorFromSet(labels.Set(map[string]string{"run": "nginx"})) + if err := commonutil.WaitForPodsWithLabelRunning(client, "default", selector); err != nil { + return errors.Wrap(err, "waiting for nginx pods") + } + return nil +} diff --git a/test/integration/fn_addons.go b/test/integration/fn_addons.go index a0227127e..a4a156316 100644 --- a/test/integration/fn_addons.go +++ b/test/integration/fn_addons.go @@ -30,8 +30,11 @@ import ( "testing" "time" + "github.com/pkg/errors" + retryablehttp "github.com/hashicorp/go-retryablehttp" "k8s.io/apimachinery/pkg/labels" + commonutil "k8s.io/minikube/pkg/util" pkgutil "k8s.io/minikube/pkg/util" "k8s.io/minikube/test/integration/util" ) @@ -126,7 +129,7 @@ func testIngressController(t *testing.T) { kr := util.NewKubectlRunner(t, p) mk.RunCommand("addons enable ingress", true) - if err := util.WaitForIngressControllerRunning(t, p); err != nil { + if err := waitForIngressControllerRunning(p); err != nil { t.Fatalf("Failed waiting for ingress-controller to be up: %v", err) } @@ -140,7 +143,7 @@ func testIngressController(t *testing.T) { t.Fatalf("Failed creating nginx ingress resource: %v", err) } - if err := util.WaitForNginxRunning(t, p); err != nil { + if err := waitForNginxRunning(t, p); err != nil { t.Fatalf("Failed waiting for nginx to be up: %v", err) } @@ -259,3 +262,41 @@ func testRegistry(t *testing.T) { }() mk.RunCommand("addons disable registry", true) } + +// waitForNginxRunning waits for nginx service to be up +func waitForNginxRunning(t *testing.T, miniProfile string) error { + client, err := commonutil.GetClient(miniProfile) + + if err != nil { + return errors.Wrap(err, "getting kubernetes client") + } + + selector := labels.SelectorFromSet(labels.Set(map[string]string{"run": "nginx"})) + if err := commonutil.WaitForPodsWithLabelRunning(client, "default", selector); err != nil { + return errors.Wrap(err, "waiting for nginx pods") + } + + if err := commonutil.WaitForService(client, "default", "nginx", true, time.Millisecond*500, time.Minute*10); err != nil { + t.Errorf("Error waiting for nginx service to be up") + } + return nil +} + +// waitForIngressControllerRunning waits until ingress controller pod to be running +func waitForIngressControllerRunning(miniProfile string) error { + client, err := commonutil.GetClient(miniProfile) + if err != nil { + return errors.Wrap(err, "getting kubernetes client") + } + + if err := commonutil.WaitForDeploymentToStabilize(client, "kube-system", "nginx-ingress-controller", time.Minute*10); err != nil { + return errors.Wrap(err, "waiting for ingress-controller deployment to stabilize") + } + + selector := labels.SelectorFromSet(labels.Set(map[string]string{"app.kubernetes.io/name": "nginx-ingress-controller"})) + if err := commonutil.WaitForPodsWithLabelRunning(client, "kube-system", selector); err != nil { + return errors.Wrap(err, "waiting for ingress-controller pods") + } + + return nil +} diff --git a/test/integration/util/common.go b/test/integration/util/common.go index 6b310e3e4..34c6a9e07 100644 --- a/test/integration/util/common.go +++ b/test/integration/util/common.go @@ -37,120 +37,6 @@ func WaitForBusyboxRunning(t *testing.T, namespace string, miniProfile string) e return commonutil.WaitForPodsWithLabelRunning(client, namespace, selector) } -// WaitForIngressControllerRunning waits until ingress controller pod to be running -func WaitForIngressControllerRunning(t *testing.T, miniProfile string) error { - client, err := commonutil.GetClient(miniProfile) - if err != nil { - return errors.Wrap(err, "getting kubernetes client") - } - - if err := commonutil.WaitForDeploymentToStabilize(client, "kube-system", "nginx-ingress-controller", time.Minute*10); err != nil { - return errors.Wrap(err, "waiting for ingress-controller deployment to stabilize") - } - - selector := labels.SelectorFromSet(labels.Set(map[string]string{"app.kubernetes.io/name": "nginx-ingress-controller"})) - if err := commonutil.WaitForPodsWithLabelRunning(client, "kube-system", selector); err != nil { - return errors.Wrap(err, "waiting for ingress-controller pods") - } - - return nil -} - -// WaitForIngressDefaultBackendRunning waits until ingress default backend pod to be running -func WaitForIngressDefaultBackendRunning(t *testing.T, miniProfile string) error { - client, err := commonutil.GetClient(miniProfile) - if err != nil { - return errors.Wrap(err, "getting kubernetes client") - } - - if err := commonutil.WaitForDeploymentToStabilize(client, "kube-system", "default-http-backend", time.Minute*10); err != nil { - return errors.Wrap(err, "waiting for default-http-backend deployment to stabilize") - } - - if err := commonutil.WaitForService(client, "kube-system", "default-http-backend", true, time.Millisecond*500, time.Minute*10); err != nil { - return errors.Wrap(err, "waiting for default-http-backend service to be up") - } - - if err := commonutil.WaitForServiceEndpointsNum(client, "kube-system", "default-http-backend", 1, time.Second*3, time.Minute*10); err != nil { - return errors.Wrap(err, "waiting for one default-http-backend endpoint to be up") - } - - return nil -} - -// WaitForGvisorControllerRunning waits for the gvisor controller pod to be running -func WaitForGvisorControllerRunning(t *testing.T, miniProfile string) error { - client, err := commonutil.GetClient(miniProfile) - if err != nil { - return errors.Wrap(err, "getting kubernetes client") - } - - selector := labels.SelectorFromSet(labels.Set(map[string]string{"kubernetes.io/minikube-addons": "gvisor"})) - if err := commonutil.WaitForPodsWithLabelRunning(client, "kube-system", selector); err != nil { - return errors.Wrap(err, "waiting for gvisor controller pod to stabilize") - } - return nil -} - -// WaitForGvisorControllerDeleted waits for the gvisor controller pod to be deleted -func WaitForGvisorControllerDeleted(miniProfile string) error { - client, err := commonutil.GetClient(miniProfile) - if err != nil { - return errors.Wrap(err, "getting kubernetes client") - } - - selector := labels.SelectorFromSet(labels.Set(map[string]string{"kubernetes.io/minikube-addons": "gvisor"})) - if err := commonutil.WaitForPodDelete(client, "kube-system", selector); err != nil { - return errors.Wrap(err, "waiting for gvisor controller pod deletion") - } - return nil -} - -// WaitForUntrustedNginxRunning waits for the untrusted nginx pod to start running -func WaitForUntrustedNginxRunning(miniProfile string) error { - client, err := commonutil.GetClient(miniProfile) - if err != nil { - return errors.Wrap(err, "getting kubernetes client") - } - - selector := labels.SelectorFromSet(labels.Set(map[string]string{"run": "nginx"})) - if err := commonutil.WaitForPodsWithLabelRunning(client, "default", selector); err != nil { - return errors.Wrap(err, "waiting for nginx pods") - } - return nil -} - -// WaitForFailedCreatePodSandBoxEvent waits for a FailedCreatePodSandBox event to appear -func WaitForFailedCreatePodSandBoxEvent(miniProfile string) error { - client, err := commonutil.GetClient(miniProfile) - if err != nil { - return errors.Wrap(err, "getting kubernetes client") - } - if err := commonutil.WaitForEvent(client, "default", "FailedCreatePodSandBox"); err != nil { - return errors.Wrap(err, "waiting for FailedCreatePodSandBox event") - } - return nil -} - -// WaitForNginxRunning waits for nginx service to be up -func WaitForNginxRunning(t *testing.T, miniProfile string) error { - client, err := commonutil.GetClient(miniProfile) - - if err != nil { - return errors.Wrap(err, "getting kubernetes client") - } - - selector := labels.SelectorFromSet(labels.Set(map[string]string{"run": "nginx"})) - if err := commonutil.WaitForPodsWithLabelRunning(client, "default", selector); err != nil { - return errors.Wrap(err, "waiting for nginx pods") - } - - if err := commonutil.WaitForService(client, "default", "nginx", true, time.Millisecond*500, time.Minute*10); err != nil { - t.Errorf("Error waiting for nginx service to be up") - } - return nil -} - // Retry tries the callback for a number of attempts, with a delay between attempts func Retry(t *testing.T, callback func() error, d time.Duration, attempts int) (err error) { for i := 0; i < attempts; i++ { diff --git a/test/integration/util/util.go b/test/integration/util/util.go deleted file mode 100644 index 5287e8c80..000000000 --- a/test/integration/util/util.go +++ /dev/null @@ -1,432 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors All rights reserved. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package util - -import ( - "bufio" - "bytes" - "context" - "encoding/json" - "fmt" - "math/rand" - "os/exec" - "path/filepath" - "regexp" - "strings" - "sync" - "testing" - "time" - - "github.com/pkg/errors" - "k8s.io/apimachinery/pkg/labels" - "k8s.io/minikube/pkg/minikube/assets" - commonutil "k8s.io/minikube/pkg/util" -) - -const kubectlBinary = "kubectl" - -// MinikubeRunner runs a command -type MinikubeRunner struct { - T *testing.T - BinaryPath string - GlobalArgs string - StartArgs string - MountArgs string - Runtime string -} - -// Logf writes logs to stdout if -v is set. -func Logf(str string, args ...interface{}) { - if !testing.Verbose() { - return - } - fmt.Printf(" %s | ", time.Now().Format("15:04:05")) - fmt.Println(fmt.Sprintf(str, args...)) -} - -// Run executes a command -func (m *MinikubeRunner) Run(cmd string) error { - _, err := m.SSH(cmd) - return err -} - -// Copy copies a file -func (m *MinikubeRunner) Copy(f assets.CopyableFile) error { - path, _ := filepath.Abs(m.BinaryPath) - cmd := exec.Command("/bin/bash", "-c", path, "ssh", "--", fmt.Sprintf("cat >> %s", filepath.Join(f.GetTargetDir(), f.GetTargetName()))) - Logf("Running: %s", cmd.Args) - return cmd.Run() -} - -// CombinedOutput executes a command, returning the combined stdout and stderr -func (m *MinikubeRunner) CombinedOutput(cmd string) (string, error) { - return m.SSH(cmd) -} - -// Remove removes a file -func (m *MinikubeRunner) Remove(f assets.CopyableFile) error { - _, err := m.SSH(fmt.Sprintf("rm -rf %s", filepath.Join(f.GetTargetDir(), f.GetTargetName()))) - return err -} - -// teeRun runs a command, streaming stdout, stderr to console -func (m *MinikubeRunner) teeRun(cmd *exec.Cmd) (string, string, error) { - errPipe, err := cmd.StderrPipe() - if err != nil { - return "", "", err - } - outPipe, err := cmd.StdoutPipe() - if err != nil { - return "", "", err - } - - if err := cmd.Start(); err != nil { - return "", "", err - } - var outB bytes.Buffer - var errB bytes.Buffer - var wg sync.WaitGroup - wg.Add(2) - go func() { - if err := commonutil.TeePrefix(commonutil.ErrPrefix, errPipe, &errB, Logf); err != nil { - m.T.Logf("tee: %v", err) - } - wg.Done() - }() - go func() { - if err := commonutil.TeePrefix(commonutil.OutPrefix, outPipe, &outB, Logf); err != nil { - m.T.Logf("tee: %v", err) - } - wg.Done() - }() - err = cmd.Wait() - wg.Wait() - return outB.String(), errB.String(), err -} - -// RunCommand executes a command, optionally checking for error -func (m *MinikubeRunner) RunCommand(command string, checkError bool) string { - commandArr := strings.Split(command, " ") - path, _ := filepath.Abs(m.BinaryPath) - cmd := exec.Command(path, commandArr...) - Logf("Run: %s", cmd.Args) - stdout, stderr, err := m.teeRun(cmd) - if checkError && err != nil { - if exitError, ok := err.(*exec.ExitError); ok { - m.T.Fatalf("Error running command: %s %s. Output: %s", command, exitError.Stderr, stdout) - } else { - m.T.Fatalf("Error running command: %s %v. Output: %s", command, err, stderr) - } - } - return stdout -} - -// RunWithContext calls the minikube command with a context, useful for timeouts. -func (m *MinikubeRunner) RunWithContext(ctx context.Context, command string) (string, string, error) { - commandArr := strings.Split(command, " ") - path, _ := filepath.Abs(m.BinaryPath) - cmd := exec.CommandContext(ctx, path, commandArr...) - Logf("Run: %s", cmd.Args) - return m.teeRun(cmd) -} - -// RunDaemon executes a command, returning the stdout -func (m *MinikubeRunner) RunDaemon(command string) (*exec.Cmd, *bufio.Reader) { - commandArr := strings.Split(command, " ") - path, _ := filepath.Abs(m.BinaryPath) - cmd := exec.Command(path, commandArr...) - stdoutPipe, err := cmd.StdoutPipe() - if err != nil { - m.T.Fatalf("stdout pipe failed: %s %v", command, err) - } - stderrPipe, err := cmd.StderrPipe() - if err != nil { - m.T.Fatalf("stderr pipe failed: %s %v", command, err) - } - - var errB bytes.Buffer - go func() { - if err := commonutil.TeePrefix(commonutil.ErrPrefix, stderrPipe, &errB, Logf); err != nil { - m.T.Logf("tee: %v", err) - } - }() - - err = cmd.Start() - if err != nil { - m.T.Fatalf("Error running command: %s %v", command, err) - } - return cmd, bufio.NewReader(stdoutPipe) - -} - -// RunDaemon2 executes a command, returning the stdout and stderr -func (m *MinikubeRunner) RunDaemon2(command string) (*exec.Cmd, *bufio.Reader, *bufio.Reader) { - commandArr := strings.Split(command, " ") - path, _ := filepath.Abs(m.BinaryPath) - cmd := exec.Command(path, commandArr...) - stdoutPipe, err := cmd.StdoutPipe() - if err != nil { - m.T.Fatalf("stdout pipe failed: %s %v", command, err) - } - stderrPipe, err := cmd.StderrPipe() - if err != nil { - m.T.Fatalf("stderr pipe failed: %s %v", command, err) - } - - err = cmd.Start() - if err != nil { - m.T.Fatalf("Error running command: %s %v", command, err) - } - return cmd, bufio.NewReader(stdoutPipe), bufio.NewReader(stderrPipe) -} - -// SSH returns the output of running a command using SSH -func (m *MinikubeRunner) SSH(command string) (string, error) { - path, _ := filepath.Abs(m.BinaryPath) - cmd := exec.Command(path, "ssh", command) - Logf("SSH: %s", command) - - stdout, err := cmd.CombinedOutput() - Logf("Output: %s", stdout) - if err, ok := err.(*exec.ExitError); ok { - return string(stdout), err - } - return string(stdout), nil -} - -// Start starts the cluster -func (m *MinikubeRunner) Start(opts ...string) { - cmd := fmt.Sprintf("start %s %s %s --alsologtostderr --v=2", m.StartArgs, m.GlobalArgs, strings.Join(opts, " ")) - m.RunCommand(cmd, true) -} - -// EnsureRunning makes sure the container runtime is running -func (m *MinikubeRunner) EnsureRunning() { - if m.GetStatus() != "Running" { - m.Start() - } - m.CheckStatus("Running") -} - -// ParseEnvCmdOutput parses the output of `env` (assumes bash) -func (m *MinikubeRunner) ParseEnvCmdOutput(out string) map[string]string { - env := map[string]string{} - re := regexp.MustCompile(`(\w+?) ?= ?"?(.+?)"?\n`) - for _, m := range re.FindAllStringSubmatch(out, -1) { - env[m[1]] = m[2] - } - return env -} - -// GetStatus returns the status of a service -func (m *MinikubeRunner) GetStatus() string { - return m.RunCommand(fmt.Sprintf("status --format={{.Host}} %s", m.GlobalArgs), false) -} - -// GetLogs returns the logs of a service -func (m *MinikubeRunner) GetLogs() string { - return m.RunCommand(fmt.Sprintf("logs %s", m.GlobalArgs), true) -} - -// CheckStatus makes sure the service has the desired status, or cause fatal error -func (m *MinikubeRunner) CheckStatus(desired string) { - if err := m.CheckStatusNoFail(desired); err != nil { - m.T.Fatalf("%v", err) - } -} - -// CheckStatusNoFail makes sure the service has the desired status, returning error -func (m *MinikubeRunner) CheckStatusNoFail(desired string) error { - s := m.GetStatus() - if s != desired { - return fmt.Errorf("got state: %q, expected %q", s, desired) - } - return nil -} - -// KubectlRunner runs a command using kubectl -type KubectlRunner struct { - T *testing.T - BinaryPath string -} - -// NewKubectlRunner creates a new KubectlRunner -func NewKubectlRunner(t *testing.T) *KubectlRunner { - p, err := exec.LookPath(kubectlBinary) - if err != nil { - t.Fatalf("Couldn't find kubectl on path.") - } - return &KubectlRunner{BinaryPath: p, T: t} -} - -// RunCommandParseOutput runs a command and parses the JSON output -func (k *KubectlRunner) RunCommandParseOutput(args []string, outputObj interface{}) error { - args = append(args, "-o=json") - output, err := k.RunCommand(args) - if err != nil { - return err - } - d := json.NewDecoder(bytes.NewReader(output)) - if err := d.Decode(outputObj); err != nil { - return err - } - return nil -} - -// RunCommand runs a command, returning stdout -func (k *KubectlRunner) RunCommand(args []string) (stdout []byte, err error) { - inner := func() error { - cmd := exec.Command(k.BinaryPath, args...) - stdout, err = cmd.CombinedOutput() - if err != nil { - retriable := &commonutil.RetriableError{Err: fmt.Errorf("error running command %s: %v. Stdout: \n %s", args, err, stdout)} - k.T.Log(retriable) - return retriable - } - return nil - } - - err = commonutil.RetryAfter(3, inner, 2*time.Second) - return stdout, err -} - -// CreateRandomNamespace creates a random namespace -func (k *KubectlRunner) CreateRandomNamespace() string { - const strLen = 20 - name := genRandString(strLen) - if _, err := k.RunCommand([]string{"create", "namespace", name}); err != nil { - k.T.Fatalf("Error creating namespace: %v", err) - } - return name -} - -func genRandString(strLen int) string { - const chars = "abcdefghijklmnopqrstuvwxyz0123456789" - rand.Seed(time.Now().UTC().UnixNano()) - result := make([]byte, strLen) - for i := 0; i < strLen; i++ { - result[i] = chars[rand.Intn(len(chars))] - } - return string(result) -} - -// DeleteNamespace deletes the namespace -func (k *KubectlRunner) DeleteNamespace(namespace string) error { - _, err := k.RunCommand([]string{"delete", "namespace", namespace}) - return err -} - -// WaitForBusyboxRunning waits until busybox pod to be running -func WaitForBusyboxRunning(t *testing.T, namespace string) error { - client, err := commonutil.GetClient() - if err != nil { - return errors.Wrap(err, "getting kubernetes client") - } - selector := labels.SelectorFromSet(labels.Set(map[string]string{"integration-test": "busybox"})) - return commonutil.WaitForPodsWithLabelRunning(client, namespace, selector) -} - -// WaitForIngressControllerRunning waits until ingress controller pod to be running -func WaitForIngressControllerRunning(t *testing.T) error { - client, err := commonutil.GetClient() - if err != nil { - return errors.Wrap(err, "getting kubernetes client") - } - - if err := commonutil.WaitForDeploymentToStabilize(client, "kube-system", "nginx-ingress-controller", time.Minute*10); err != nil { - return errors.Wrap(err, "waiting for ingress-controller deployment to stabilize") - } - - selector := labels.SelectorFromSet(labels.Set(map[string]string{"app.kubernetes.io/name": "nginx-ingress-controller"})) - if err := commonutil.WaitForPodsWithLabelRunning(client, "kube-system", selector); err != nil { - return errors.Wrap(err, "waiting for ingress-controller pods") - } - - return nil -} - - -// WaitForGvisorControllerDeleted waits for the gvisor controller pod to be deleted -func WaitForGvisorControllerDeleted() error { - client, err := commonutil.GetClient() - if err != nil { - return errors.Wrap(err, "getting kubernetes client") - } - - selector := labels.SelectorFromSet(labels.Set(map[string]string{"kubernetes.io/minikube-addons": "gvisor"})) - if err := commonutil.WaitForPodDelete(client, "kube-system", selector); err != nil { - return errors.Wrap(err, "waiting for gvisor controller pod deletion") - } - return nil -} - -// WaitForUntrustedNginxRunning waits for the untrusted nginx pod to start running -func WaitForUntrustedNginxRunning() error { - client, err := commonutil.GetClient() - if err != nil { - return errors.Wrap(err, "getting kubernetes client") - } - - selector := labels.SelectorFromSet(labels.Set(map[string]string{"run": "nginx"})) - if err := commonutil.WaitForPodsWithLabelRunning(client, "default", selector); err != nil { - return errors.Wrap(err, "waiting for nginx pods") - } - return nil -} - -// WaitForFailedCreatePodSandBoxEvent waits for a FailedCreatePodSandBox event to appear -func WaitForFailedCreatePodSandBoxEvent() error { - client, err := commonutil.GetClient() - if err != nil { - return errors.Wrap(err, "getting kubernetes client") - } - if err := commonutil.WaitForEvent(client, "default", "FailedCreatePodSandBox"); err != nil { - return errors.Wrap(err, "waiting for FailedCreatePodSandBox event") - } - return nil -} - -// WaitForNginxRunning waits for nginx service to be up -func WaitForNginxRunning(t *testing.T) error { - client, err := commonutil.GetClient() - - if err != nil { - return errors.Wrap(err, "getting kubernetes client") - } - - selector := labels.SelectorFromSet(labels.Set(map[string]string{"run": "nginx"})) - if err := commonutil.WaitForPodsWithLabelRunning(client, "default", selector); err != nil { - return errors.Wrap(err, "waiting for nginx pods") - } - - if err := commonutil.WaitForService(client, "default", "nginx", true, time.Millisecond*500, time.Minute*10); err != nil { - t.Errorf("Error waiting for nginx service to be up") - } - return nil -} - -// Retry tries the callback for a number of attempts, with a delay between attempts -func Retry(t *testing.T, callback func() error, d time.Duration, attempts int) (err error) { - for i := 0; i < attempts; i++ { - err = callback() - if err == nil { - return nil - } - time.Sleep(d) - } - return err -} -- GitLab