kubernetes
/
minikube
mirror of https://github.com/kubernetes/minikube.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #3184 from tstromberg/directives 

Remove lint issues from integration tests, mostly by adding error checks
pull/3189/head
k8s-ci-robot 2018-09-28 19:24:40 -07:00 committed by GitHub
parent 9f46473d71 4b1ee9cffb
commit 27d8234d4b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 54 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pkg/minikube/bootstrapper/exec_runner.go
View File

@ -89,7 +89,7 @@ func (*ExecRunner) Copy(f assets.CopyableFile) error {
}
perms, err := strconv.Atoi(f.GetPermissions())
if err != nil {
return errors.Wrapf(err, "error converting permissions %s to integer", perms)
return errors.Wrapf(err, "error converting permissions %s to integer", f.GetPermissions())
}
if err := os.Chmod(targetPath, os.FileMode(perms)); err != nil {
return errors.Wrapf(err, "error changing file permissions for %s", targetPath)

23
test/integration/addons_test.go
View File

@ -37,7 +37,7 @@ func testAddons(t *testing.T) {
t.Parallel()
client, err := pkgutil.GetClient()
if err != nil {
t.Fatalf("Could not get kubernetes client: %s", err)
t.Fatalf("Could not get kubernetes client: %v", err)
}
selector := labels.SelectorFromSet(labels.Set(map[string]string{"component": "kube-addon-manager"}))
if err := pkgutil.WaitForPodsWithLabelRunning(client, "kube-system", selector); err != nil {
@ -65,7 +65,7 @@ func testDashboard(t *testing.T) {
}
if err := util.Retry(t, checkDashboard, 2*time.Second, 60); err != nil {
t.Fatalf("error checking dashboard URL: %s", err)
t.Fatalf("error checking dashboard URL: %v", err)
}
if u.Scheme != "http" {
@ -87,25 +87,25 @@ func testIngressController(t *testing.T) {
minikubeRunner.RunCommand("addons enable ingress", true)
if err := util.WaitForIngressControllerRunning(t); err != nil {
t.Fatalf("waiting for ingress-controller to be up: %s", err)
t.Fatalf("waiting for ingress-controller to be up: %v", err)
}
if err := util.WaitForIngressDefaultBackendRunning(t); err != nil {
t.Fatalf("waiting for default-http-backend to be up: %s", err)
t.Fatalf("waiting for default-http-backend to be up: %v", err)
}
ingressPath, _ := filepath.Abs("testdata/nginx-ing.yaml")
if _, err := kubectlRunner.RunCommand([]string{"create", "-f", ingressPath}); err != nil {
t.Fatalf("creating nginx ingress resource: %s", err)
t.Fatalf("creating nginx ingress resource: %v", err)
}
podPath, _ := filepath.Abs("testdata/nginx-pod-svc.yaml")
if _, err := kubectlRunner.RunCommand([]string{"create", "-f", podPath}); err != nil {
t.Fatalf("creating nginx ingress resource: %s", err)
t.Fatalf("creating nginx ingress resource: %v", err)
}
if err := util.WaitForNginxRunning(t); err != nil {
t.Fatalf("waiting for nginx to be up: %s", err)
t.Fatalf("waiting for nginx to be up: %v", err)
}
checkIngress := func() error {
@ -122,8 +122,13 @@ func testIngressController(t *testing.T) {
t.Fatalf(err.Error())
}
defer kubectlRunner.RunCommand([]string{"delete", "-f", podPath})
defer kubectlRunner.RunCommand([]string{"delete", "-f", ingressPath})
defer func() {
for _, p := range []string{podPath, ingressPath} {
if out, err := kubectlRunner.RunCommand([]string{"delete", "-f", p}); err != nil {
t.Logf("delete -f %s failed: %v\noutput: %s\n", p, err, out)
}
}
}()
minikubeRunner.RunCommand("addons disable ingress", true)
}

2
test/integration/cluster_dns_test.go
View File

@ -37,7 +37,7 @@ func testClusterDNS(t *testing.T) {
t.Parallel()
client, err := pkgutil.GetClient()
if err != nil {
t.Fatalf("Error getting kubernetes client %s", err)
t.Fatalf("Error getting kubernetes client %v", err)
}
waitForDNS(t, client)

2
test/integration/cluster_env_test.go
View File

@ -33,7 +33,7 @@ func testClusterEnv(t *testing.T) {
dockerEnvVars := minikubeRunner.RunCommand("docker-env", true)
if err := minikubeRunner.SetEnvFromEnvCmdOutput(dockerEnvVars); err != nil {
t.Fatalf("Error parsing output: %s", err)
t.Fatalf("Error parsing output: %v", err)
}
path, err := exec.LookPath("docker")

6
test/integration/cluster_status_test.go
View File

@ -23,7 +23,7 @@ import (
"testing"
"time"
api "k8s.io/api/core/v1"
api "k8s.io/kubernetes/pkg/apis/core"
"k8s.io/minikube/test/integration/util"
)
@ -47,7 +47,7 @@ func testClusterStatus(t *testing.T) {
}
if status != api.ConditionTrue {
err := fmt.Errorf("Component %s is not Healthy! Status: %s", i.GetName(), status)
t.Logf("Retrying, %s", err)
t.Logf("Retrying, %v", err)
return err
}
}
@ -55,6 +55,6 @@ func testClusterStatus(t *testing.T) {
}
if err := util.Retry(t, healthy, 1*time.Second, 5); err != nil {
t.Fatalf("Cluster is not healthy: %s", err)
t.Fatalf("Cluster is not healthy: %v", err)
}
}

3
test/integration/docker_test.go
View File

@ -32,7 +32,8 @@ func TestDocker(t *testing.T) {
}
minikubeRunner.RunCommand("delete", false)
startCmd := fmt.Sprintf("start %s %s %s", minikubeRunner.StartArgs, minikubeRunner.Args, "--docker-env=FOO=BAR --docker-env=BAZ=BAT --docker-opt=debug --docker-opt=icc=true")
startCmd := fmt.Sprintf("start %s %s %s", minikubeRunner.StartArgs, minikubeRunner.Args,
"--docker-env=FOO=BAR --docker-env=BAZ=BAT --docker-opt=debug --docker-opt=icc=true")
minikubeRunner.RunCommand(startCmd, true)
minikubeRunner.EnsureRunning()

2
test/integration/flags.go
View File

@ -32,7 +32,7 @@ func TestMain(m *testing.M) {
var binaryPath = flag.String("binary", "../../out/minikube", "path to minikube binary")
var args = flag.String("minikube-args", "", "Arguments to pass to minikube")
var startArgs = flag.String("minikube-start-args", "", "Arguments to pass to minikube start")
var testdataDir = flag.String("testdata-dir", "testdata", "the directory relative to test/integration where the testdata lives")
var testdataDir = flag.String("testdata-dir", "testdata", "source of testdata relative to test/integration")
func NewMinikubeRunner(t *testing.T) util.MinikubeRunner {
return util.MinikubeRunner{

2
test/integration/functional_test.go
View File

@ -41,6 +41,6 @@ func TestFunctional(t *testing.T) {
t.Run("EnvVars", testClusterEnv)
t.Run("SSH", testClusterSSH)
t.Run("IngressController", testIngressController)
// t.Run("Mounting", testMounting)
t.Run("Mounting", testMounting)
}
}

19
test/integration/mount_test.go
View File

@ -41,13 +41,18 @@ func testMounting(t *testing.T) {
tempDir, err := ioutil.TempDir("", "mounttest")
if err != nil {
t.Fatalf("Unexpected error while creating tempDir: %s", err)
t.Fatalf("Unexpected error while creating tempDir: %v", err)
}
defer os.RemoveAll(tempDir)
mountCmd := fmt.Sprintf("mount %s:/mount-9p", tempDir)
cmd := minikubeRunner.RunDaemon(mountCmd)
defer cmd.Process.Kill()
defer func() {
err := cmd.Process.Kill()
if err != nil {
t.Logf("Failed to kill mount command: %v", err)
}
}()
kubectlRunner := util.NewKubectlRunner(t)
podName := "busybox-mount"
@ -71,7 +76,11 @@ func testMounting(t *testing.T) {
}
return nil
}
defer kubectlRunner.RunCommand([]string{"delete", "-f", podPath})
defer func() {
if out, err := kubectlRunner.RunCommand([]string{"delete", "-f", podPath}); err != nil {
t.Logf("delete -f %s failed: %v\noutput: %s\n", podPath, err, out)
}
}()
if err := util.Retry(t, setupTest, 5*time.Second, 40); err != nil {
t.Fatal("mountTest failed with error:", err)
@ -79,11 +88,11 @@ func testMounting(t *testing.T) {
client, err := pkgutil.GetClient()
if err != nil {
t.Fatalf("getting kubernetes client: %s", err)
t.Fatalf("getting kubernetes client: %v", err)
}
selector := labels.SelectorFromSet(labels.Set(map[string]string{"integration-test": "busybox-mount"}))
if err := pkgutil.WaitForPodsWithLabelRunning(client, "default", selector); err != nil {
t.Fatalf("Error waiting for busybox mount pod to be up: %s", err)
t.Fatalf("Error waiting for busybox mount pod to be up: %v", err)
}
mountTest := func() error {

8
test/integration/persistence_test.go
View File

@ -40,16 +40,16 @@ func TestPersistence(t *testing.T) {
// Create a pod and wait for it to be running.
if _, err := kubectlRunner.RunCommand([]string{"create", "-f", podPath}); err != nil {
t.Fatalf("Error creating test pod: %s", err)
t.Fatalf("Error creating test pod: %v", err)
}
verify := func(t *testing.T) {
if err := util.WaitForDashboardRunning(t); err != nil {
t.Fatalf("waiting for dashboard to be up: %s", err)
t.Fatalf("waiting for dashboard to be up: %v", err)
}
if err := util.WaitForBusyboxRunning(t, "default"); err != nil {
t.Fatalf("waiting for busybox to be up: %s", err)
t.Fatalf("waiting for busybox to be up: %v", err)
}
}
@ -66,7 +66,7 @@ func TestPersistence(t *testing.T) {
}
if err := util.Retry(t, checkStop, 5*time.Second, 6); err != nil {
t.Fatalf("timed out while checking stopped status: %s", err)
t.Fatalf("timed out while checking stopped status: %v", err)
}
minikubeRunner.Start()

13
test/integration/pv_test.go
View File

@ -43,7 +43,9 @@ func testProvisioning(t *testing.T) {
kubectlRunner := util.NewKubectlRunner(t)
defer func() {
kubectlRunner.RunCommand([]string{"delete", "pvc", pvcName})
if out, err := kubectlRunner.RunCommand([]string{"delete", "pvc", pvcName}); err != nil {
t.Logf("delete pvc %s failed: %v\noutput: %s\n", pvcName, err, out)
}
}()
// We have to make sure the addon-manager has created the StorageClass before creating
@ -51,15 +53,18 @@ func testProvisioning(t *testing.T) {
checkStorageClass := func() error {
scl := storage.StorageClassList{}
kubectlRunner.RunCommandParseOutput([]string{"get", "storageclass"}, &scl)
if err := kubectlRunner.RunCommandParseOutput([]string{"get", "storageclass"}, &scl); err != nil {
return fmt.Errorf("get storageclass: %v", err)
}
if len(scl.Items) > 0 {
return nil
}
return fmt.Errorf("No default StorageClass yet.")
return fmt.Errorf("no StorageClass yet")
}
if err := util.Retry(t, checkStorageClass, 5*time.Second, 20); err != nil {
t.Fatalf("No default storage class: %s", err)
t.Fatalf("no default storage class after retry: %v", err)
}
// Check that the storage provisioner pod is running

2
test/integration/start_stop_delete_test.go
View File

@ -50,7 +50,7 @@ func TestStartStop(t *testing.T) {
}
if err := util.Retry(t, checkStop, 5*time.Second, 6); err != nil {
t.Fatalf("timed out while checking stopped status: %s", err)
t.Fatalf("timed out while checking stopped status: %v", err)
}
runner.Start()

4
test/integration/util/util.go
View File

@ -183,7 +183,7 @@ func (k *KubectlRunner) RunCommand(args []string) (stdout []byte, err error) {
stdout, err = cmd.CombinedOutput()
if err != nil {
k.T.Logf("Error %s running command %s. Return code: %s", stdout, args, err)
return &commonutil.RetriableError{Err: fmt.Errorf("Error running command. Error %s. Output: %s", err, stdout)}
return &commonutil.RetriableError{Err: fmt.Errorf("Error running command: %v. Output: %s", err, stdout)}
}
return nil
}
@ -196,7 +196,7 @@ 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: %s", err)
k.T.Fatalf("Error creating namespace: %v", err)
}
return name
}