Added timeout for start

hack/jenkins/linux_integration_tests_kvm.sh

@@ -28,7 +28,7 @@ set -e
 OS_ARCH="linux-amd64"
 VM_DRIVER="kvm2"
 JOB_NAME="Linux-KVM"
-PARALLEL_COUNT=4
+PARALLEL_COUNT=2
 
 # Download files and set permissions
 source ./common.sh

hack/jenkins/linux_integration_tests_virtualbox.sh

@@ -28,7 +28,7 @@ set -e
 OS_ARCH="linux-amd64"
 VM_DRIVER="virtualbox"
 JOB_NAME="Linux-VirtualBox"
-PARALLEL_COUNT=4
+PARALLEL_COUNT=3
 
 # Download files and set permissions
 source ./common.sh

test/integration/a_download_only_test.go

@@ -19,10 +19,8 @@ limitations under the License.
 // a_download_only_test.go filename starts with a, for the purpose that it runs before all parallel tests and downloads the images and caches them.
 package integration
 
-
 import (
 	"testing"
-	"time"
 )
 
 // TestDownloadOnly downloads ISOs also tests the --download-only option
@@ -38,7 +36,7 @@ func TestDownloadOnly(t *testing.T) {
 		defer mk.TearDown(t)
 	}
 
-	stdout, stderr, err := mk.StartWithStds(15*time.Minute, "--download-only")
+	stdout, stderr, err := mk.Start("--download-only")
 	if err != nil {
 		t.Fatalf("%s minikube start failed : %v\nstdout: %s\nstderr: %s", p, err, stdout, stderr)
 	}

test/integration/containerd_test.go

@@ -21,7 +21,6 @@ package integration
 import (
 	"path/filepath"
 	"testing"
-	"time"
 
 	"github.com/docker/machine/libmachine/state"
 	"k8s.io/minikube/test/integration/util"
@@ -30,24 +29,22 @@ import (
 func TestContainerd(t *testing.T) {
 	p := profile(t)
 	if isTestNoneDriver() {
-		p = "minikube"
-	} else {
-		t.Parallel()
+		t.Skip("Can't run containerd backend with none driver")
 	}
-
+	t.Parallel()
 	mk := NewMinikubeRunner(t, p)
-	if !isTestNoneDriver() { // none driver doesnt need to be deleted
+	if !isTestNoneDriver() { // none driver doesn't need to be deleted
 		defer mk.TearDown(t)
 	}
 
-	if isTestNoneDriver() {
-		t.Skip("Can't run containerd backend with none driver")
-	}
-
 	if mk.GetStatus() != state.None.String() {
 		mk.RunCommand("delete", true)
 	}
-	mk.Start("--container-runtime=containerd", "--docker-opt containerd=/var/run/containerd/containerd.sock")
+	stdout, stderr, err := mk.Start("--container-runtime=containerd", "--docker-opt containerd=/var/run/containerd/containerd.sock")
+	if err != nil {
+		t.Fatalf("%s minikube start failed : %v\nstdout: %s\nstderr: %s", t.Name(), err, stdout, stderr)
+	}
+
 	t.Run("Gvisor", testGvisor)
 	t.Run("GvisorRestart", testGvisorRestart)
 }
@@ -99,7 +96,7 @@ func testGvisorRestart(t *testing.T) {
 	// TODO: @priyawadhwa to add test for stop as well
 	mk.RunCommand("delete", false)
 	mk.CheckStatus(state.None.String())
-	stdout, stderr, err := mk.StartWithStds(15 * time.Minute)
+	stdout, stderr, err := mk.Start()
 	if err != nil {
 		t.Fatalf("%s minikube start failed : %v\nstdout: %s\nstderr: %s", t.Name(), err, stdout, stderr)
 	}

test/integration/docker_test.go

@@ -44,7 +44,7 @@ func TestDocker(t *testing.T) {
 		t.Logf("pre-delete failed (probably ok): %v", err)
 	}
 
-	stdout, stderr, err := mk.StartWithStds(13*time.Minute, "--docker-env=FOO=BAR", "--docker-env=BAZ=BAT", "--docker-opt=debug", " --docker-opt=icc=true")
+	stdout, stderr, err := mk.Start("--docker-env=FOO=BAR", "--docker-env=BAZ=BAT", "--docker-opt=debug", " --docker-opt=icc=true")
 	if err != nil {
 		t.Fatalf("TestDocker minikube start failed : %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
 	}

test/integration/flags.go

@@ -21,6 +21,7 @@ import (
 	"os"
 	"strings"
 	"testing"
+	"time"
 
 	"k8s.io/minikube/test/integration/util"
 )
@@ -31,6 +32,7 @@ func TestMain(m *testing.M) {
 	os.Exit(m.Run())
 }
 
+var startTimeout = flag.Int("timeout", 18, "number of minutes to wait for minikube start")
 var binaryPath = flag.String("binary", "../../out/minikube", "path to minikube binary")
 var globalArgs = flag.String("minikube-args", "", "Arguments to pass to minikube")
 var startArgs = flag.String("minikube-start-args", "", "Arguments to pass to minikube start")
@@ -40,12 +42,13 @@ var testdataDir = flag.String("testdata-dir", "testdata", "the directory relativ
 // NewMinikubeRunner creates a new MinikubeRunner
 func NewMinikubeRunner(t *testing.T, profile string, extraStartArgs ...string) util.MinikubeRunner {
 	return util.MinikubeRunner{
-		Profile:    profile,
-		BinaryPath: *binaryPath,
-		StartArgs:  *startArgs + " " + strings.Join(extraStartArgs, " "),
-		GlobalArgs: *globalArgs,
-		MountArgs:  *mountArgs,
-		T:          t,
+		Profile:      profile,
+		BinaryPath:   *binaryPath,
+		StartArgs:    *startArgs + " " + strings.Join(extraStartArgs, " "),
+		GlobalArgs:   *globalArgs,
+		MountArgs:    *mountArgs,
+		TimeOutStart: time.Duration(*startTimeout) * time.Minute,
+		T:            t,
 	}
 }
 

test/integration/fn_test.go

@@ -20,13 +20,16 @@ package integration
 
 import (
 	"testing"
-	"time"
 )
 
 func TestFunctional(t *testing.T) {
 	p := "minikube"
+	// if !isTestNoneDriver() {
+	// 	t.Parallel()
+	// }
+
 	mk := NewMinikubeRunner(t, p)
-	stdout, stderr, err := mk.StartWithStds(15 * time.Minute)
+	stdout, stderr, err := mk.Start()
 	if err != nil {
 		t.Fatalf("%s minikube start failed : %v\nstdout: %s\nstderr: %s", t.Name(), err, stdout, stderr)
 	}

test/integration/iso_test.go

@@ -22,7 +22,6 @@ import (
 	"fmt"
 	"strings"
 	"testing"
-	"time"
 )
 
 func TestISO(t *testing.T) {
@@ -35,7 +34,7 @@ func TestISO(t *testing.T) {
 
 	mk := NewMinikubeRunner(t, p, "--wait=false")
 	mk.RunCommand("delete", false)
-	stdout, stderr, err := mk.StartWithStds(15 * time.Minute)
+	stdout, stderr, err := mk.Start()
 	if err != nil {
 		t.Fatalf("%s minikube start failed : %v\nstdout: %s\nstderr: %s", t.Name(), err, stdout, stderr)
 	}

test/integration/persistence_test.go

@@ -61,7 +61,7 @@ func TestPersistence(t *testing.T) {
 		t.Fatalf("TestPersistence Failed to stop minikube : %v", err)
 	}
 
-	stdout, stderr, err := mk.StartWithStds(15 * time.Minute)
+	stdout, stderr, err := mk.Start()
 	if err != nil {
 		t.Fatalf("%s minikube start failed : %v\nstdout: %s\nstderr: %s", t.Name(), err, stdout, stderr)
 	}

test/integration/proxy_test.go

@@ -65,14 +65,18 @@ func setUpProxy(t *testing.T) (*http.Server, error) {
 
 func TestProxy(t *testing.T) {
 	origHP := os.Getenv("HTTP_PROXY")
-	origNP := os.Getenv("NO_PROXY")
+	origNP := os.Getenv("NO_PROXY")	
+	p := profile(t) // profile name
+	if isTestNoneDriver() {
+		p = "minikube"
+	} 
+
 	srv, err := setUpProxy(t)
 	if err != nil {
 		t.Fatalf("Failed to set up the test proxy: %s", err)
 	}
 
 	// making sure there is no running minikube to avoid https://github.com/kubernetes/minikube/issues/4132
-	p := profile(t)
 	mk := NewMinikubeRunner(t, p)
 	defer mk.TearDown(t)
 
@@ -94,16 +98,19 @@ func TestProxy(t *testing.T) {
 		mk.RunCommand("delete", true)
 	}(t)
 
-	t.Run("Proxy Console Warnning", testProxyWarning)
-	t.Run("Proxy Dashboard", testProxyDashboard)
+	t.Run("ProxyConsoleWarnning", testProxyWarning)
+	t.Run("ProxyDashboard", testProxyDashboard)
 
 }
 
 // testProxyWarning checks user is warned correctly about the proxy related env vars
 func testProxyWarning(t *testing.T) {
-	p := profile(t)
+	p := profile(t) // profile name
+	if isTestNoneDriver() {
+		p = "minikube"
+	} 
 	mk := NewMinikubeRunner(t, p)
-	stdout, stderr, err := mk.StartWithStds(15 * time.Minute)
+	stdout, stderr, err := mk.Start()
 	if err != nil {
 		t.Fatalf("%s minikube start failed : %v\nstdout: %s\nstderr: %s", t.Name(), err, stdout, stderr)
 	}

test/integration/start_stop_delete_test.go

@@ -86,7 +86,7 @@ func TestStartStop(t *testing.T) {
 			mk.RunCommand("delete", false)
 			mk.CheckStatus(state.None.String())
 
-			stdout, stderr, err := mk.StartWithStds(15 * time.Minute)
+			stdout, stderr, err := mk.Start()
 			if err != nil {
 				t.Fatalf("%s minikube start failed : %v\nstdout: %s\nstderr: %s", p, err, stdout, stderr)
 			}
@@ -127,7 +127,11 @@ func TestStartStop(t *testing.T) {
 			// 	t.Logf("current-context is not set to minikube")
 			// }
 
-			mk.Start(tc.args...)
+			stdout, stderr, err = mk.Start(tc.args...)
+			if err != nil {
+				t.Fatalf("%s minikube start failed : %v\nstdout: %s\nstderr: %s", t.Name(), err, stdout, stderr)
+			}
+
 			mk.CheckStatus(state.Running.String())
 
 			mk.RunCommand("delete", true)

test/integration/util/minikube_runner.go

@@ -36,13 +36,14 @@ import (
 
 // MinikubeRunner runs a command
 type MinikubeRunner struct {
-	Profile    string
-	T          *testing.T
-	BinaryPath string
-	GlobalArgs string
-	StartArgs  string
-	MountArgs  string
-	Runtime    string
+	Profile      string
+	T            *testing.T
+	BinaryPath   string
+	GlobalArgs   string
+	StartArgs    string
+	MountArgs    string
+	Runtime      string
+	TimeOutStart time.Duration // time to wait for minikube start before killing it
 }
 
 // Copy copies a file
@@ -205,15 +206,9 @@ func (m *MinikubeRunner) SSH(cmdStr string) (string, error) {
 	return string(stdout), nil
 }
 
-// Start starts the cluster
-func (m *MinikubeRunner) Start(opts ...string) string {
-	cmd := fmt.Sprintf("start %s %s %s --alsologtostderr --v=2", m.StartArgs, m.GlobalArgs, strings.Join(opts, " "))
-	return m.RunCommand(cmd, true)
-}
-
-// StartWithStds starts the cluster with console output without verbose log
-func (m *MinikubeRunner) StartWithStds(timeout time.Duration, opts ...string) (stdout string, stderr string, err error) {
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+// Start starts the cluster with console output without verbose log
+func (m *MinikubeRunner) Start(opts ...string) (stdout string, stderr string, err error) {
+	ctx, cancel := context.WithTimeout(context.Background(), m.TimeOutStart)
 	defer cancel()
 	cmd := fmt.Sprintf("start %s %s %s", m.StartArgs, m.GlobalArgs, strings.Join(opts, " "))
 	return m.RunWithContext(ctx, cmd)
@@ -233,7 +228,10 @@ func (m *MinikubeRunner) TearDown(t *testing.T) {
 // EnsureRunning makes sure the container runtime is running
 func (m *MinikubeRunner) EnsureRunning(opts ...string) {
 	if m.GetStatus() != state.Running.String() {
-		m.Start(opts...)
+		_, _, err := m.Start(opts...)
+		if err != nil {
+			m.T.Errorf("error starting while running EnsureRunning : %v", err)
+		}
 	}
 	m.CheckStatus(state.Running.String())
 }

test/integration/version_upgrade_test.go

@@ -94,7 +94,7 @@ func TestVersionUpgrade(t *testing.T) {
 	mkRelease := NewMinikubeRunner(t, p)
 	mkRelease.BinaryPath = fname
 	// For full coverage: also test upgrading from oldest to newest supported k8s release
-	stdout, stderr, err := mkRelease.StartWithStds(15*time.Minute, fmt.Sprintf("--kubernetes-version=%s", constants.OldestKubernetesVersion))
+	stdout, stderr, err := mkRelease.Start(fmt.Sprintf("--kubernetes-version=%s", constants.OldestKubernetesVersion))
 	if err != nil {
 		t.Fatalf("TestVersionUpgrade minikube start failed : %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
 	}
@@ -104,7 +104,7 @@ func TestVersionUpgrade(t *testing.T) {
 	mkRelease.CheckStatus(state.Stopped.String())
 
 	// Trim the leading "v" prefix to assert that we handle it properly.
-	stdout, stderr, err = mkRelease.StartWithStds(15*time.Minute, fmt.Sprintf("--kubernetes-version=%s", strings.TrimPrefix(constants.NewestKubernetesVersion, "v")))
+	stdout, stderr, err = mkRelease.Start(fmt.Sprintf("--kubernetes-version=%s", strings.TrimPrefix(constants.NewestKubernetesVersion, "v")))
 	if err != nil {
 		t.Fatalf("TestVersionUpgrade minikube start failed : %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
 	}