diff --git a/test/integration/cluster_env_test.go b/test/integration/cluster_env_test.go
index cf1fb101a5e38a1e00b840ac4a904045a4593b1a..f4889382b58ff75819da0708e59f3816d26ec1e5 100644
--- a/test/integration/cluster_env_test.go
+++ b/test/integration/cluster_env_test.go
@@ -30,11 +30,11 @@ import (
 // Assert that docker-env subcommand outputs usable information for "docker ps"
 func testClusterEnv(t *testing.T) {
 	t.Parallel()
-	r := NewMinikubeRunner(t, "--wait=false")
+	mk := NewMinikubeRunner(t, "--wait=false")
 
 	// Set a specific shell syntax so that we don't have to handle every possible user shell
-	envOut := r.RunCommand("docker-env --shell=bash", true)
-	vars := r.ParseEnvCmdOutput(envOut)
+	envOut := mk.RunCommand("docker-env --shell=bash", true)
+	vars := mk.ParseEnvCmdOutput(envOut)
 	if len(vars) == 0 {
 		t.Fatalf("Failed to parse env vars:\n%s", envOut)
 	}
diff --git a/test/integration/functional_test.go b/test/integration/functional_test.go
index 5b7d1ba82b86e7b6c0890a3209539770bfb04539..111e390bcc9b63152807af52cb84f8a9465c6a50 100644
--- a/test/integration/functional_test.go
+++ b/test/integration/functional_test.go
@@ -27,8 +27,8 @@ import (
 )
 
 func TestFunctional(t *testing.T) {
-	r := NewMinikubeRunner(t)
-	r.EnsureRunning()
+	mk := NewMinikubeRunner(t)
+	mk.EnsureRunning()
 	// This one is not parallel, and ensures the cluster comes up
 	// before we run any other tests.
 	t.Run("Status", testClusterStatus)
@@ -42,7 +42,7 @@ func TestFunctional(t *testing.T) {
 	t.Run("Provisioning", testProvisioning)
 	t.Run("Tunnel", testTunnel)
 
-	if !usingNoneDriver(r) {
+	if !usingNoneDriver(mk) {
 		t.Run("EnvVars", testClusterEnv)
 		t.Run("SSH", testClusterSSH)
 		t.Run("IngressController", testIngressController)
@@ -51,19 +51,19 @@ func TestFunctional(t *testing.T) {
 }
 
 func TestFunctionalContainerd(t *testing.T) {
-	r := NewMinikubeRunner(t)
+	mk := NewMinikubeRunner(t)
 
-	if usingNoneDriver(r) {
+	if usingNoneDriver(mk) {
 		t.Skip("Can't run containerd backend with none driver")
 	}
 
-	if r.GetStatus() != state.None.String() {
-		r.RunCommand("delete", true)
+	if mk.GetStatus() != state.None.String() {
+		mk.RunCommand("delete", true)
 	}
-	r.Start("--container-runtime=containerd", "--docker-opt containerd=/var/run/containerd/containerd.sock")
+	mk.Start("--container-runtime=containerd", "--docker-opt containerd=/var/run/containerd/containerd.sock")
 	t.Run("Gvisor", testGvisor)
 	t.Run("GvisorRestart", testGvisorRestart)
-	r.RunCommand("delete", true)
+	mk.RunCommand("delete", true)
 }
 
 // usingNoneDriver returns true if using the none driver
diff --git a/test/integration/proxy_test.go b/test/integration/proxy_test.go
index 3241d80b562a5129c37319feec56e84357bf2d80..602b9a080221bdc39e7a3c631d517ee34e7ff329 100644
--- a/test/integration/proxy_test.go
+++ b/test/integration/proxy_test.go
@@ -72,10 +72,10 @@ func TestProxy(t *testing.T) {
 	}
 
 	// making sure there is no running minikube to avoid https://github.com/kubernetes/minikube/issues/4132
-	r := NewMinikubeRunner(t)
+	mk := NewMinikubeRunner(t)
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
 	defer cancel()
-	_, _, err = r.RunWithContext(ctx, "delete")
+	_, _, err = mk.RunWithContext(ctx, "delete")
 	if err != nil {
 		t.Logf("Error deleting minikube before test setup %s : ", err)
 	}
@@ -96,7 +96,7 @@ func TestProxy(t *testing.T) {
 			t.Errorf("Error shutting down the http proxy")
 		}
 
-		_, _, err = r.RunWithContext(ctx, "delete")
+		_, _, err = mk.RunWithContext(ctx, "delete")
 		if err != nil {
 			t.Logf("Error deleting minikube when cleaning up proxy setup: %s", err)
 		}
@@ -109,11 +109,11 @@ func TestProxy(t *testing.T) {
 
 // testProxyWarning checks user is warned correctly about the proxy related env vars
 func testProxyWarning(t *testing.T) {
-	r := NewMinikubeRunner(t, "--wait=false")
+	mk := NewMinikubeRunner(t, "--wait=false")
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
 	defer cancel()
-	startCmd := fmt.Sprintf("start %s %s", r.StartArgs, r.GlobalArgs)
-	stdout, stderr, err := r.RunWithContext(ctx, startCmd)
+	startCmd := fmt.Sprintf("start %s %s", mk.StartArgs, mk.GlobalArgs)
+	stdout, stderr, err := mk.RunWithContext(ctx, startCmd)
 	if err != nil {
 		t.Fatalf("start: %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
 	}
diff --git a/test/integration/start_stop_delete_test.go b/test/integration/start_stop_delete_test.go
index 58109193594d22e2bfe4036afc716b6e24f00d02..a707a036389dbf638beecfcf2cc1d5b58dbfbe18 100644
--- a/test/integration/start_stop_delete_test.go
+++ b/test/integration/start_stop_delete_test.go
@@ -65,18 +65,18 @@ func TestStartStop(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			r := NewMinikubeRunner(t)
-			if !strings.Contains(test.name, "docker") && usingNoneDriver(r) {
+			mk := NewMinikubeRunner(t)
+			if !strings.Contains(test.name, "docker") && usingNoneDriver(mk) {
 				t.Skipf("skipping %s - incompatible with none driver", test.name)
 			}
 
-			r.RunCommand("config set WantReportErrorPrompt false", true)
-			r.RunCommand("delete", false)
-			r.CheckStatus(state.None.String())
-			r.Start(test.args...)
-			r.CheckStatus(state.Running.String())
+			mk.RunCommand("config set WantReportErrorPrompt false", true)
+			mk.RunCommand("delete", false)
+			mk.CheckStatus(state.None.String())
+			mk.Start(test.args...)
+			mk.CheckStatus(state.Running.String())
 
-			ip := r.RunCommand("ip", true)
+			ip := mk.RunCommand("ip", true)
 			ip = strings.TrimRight(ip, "\n")
 			if net.ParseIP(ip) == nil {
 				t.Fatalf("IP command returned an invalid address: %s", ip)
@@ -93,8 +93,8 @@ func TestStartStop(t *testing.T) {
 			}
 
 			checkStop := func() error {
-				r.RunCommand("stop", true)
-				return r.CheckStatusNoFail(state.Stopped.String())
+				mk.RunCommand("stop", true)
+				return mk.CheckStatusNoFail(state.Stopped.String())
 			}
 
 			if err := util.Retry(t, checkStop, 5*time.Second, 6); err != nil {
@@ -102,15 +102,15 @@ func TestStartStop(t *testing.T) {
 			}
 
 			// running this command results in error when the current-context is not set
-			if err := r.Run("config current-context"); err != nil {
+			if err := mk.Run("config current-context"); err != nil {
 				t.Logf("current-context is not set to minikube")
 			}
 
-			r.Start(test.args...)
-			r.CheckStatus(state.Running.String())
+			mk.Start(test.args...)
+			mk.CheckStatus(state.Running.String())
 
-			r.RunCommand("delete", true)
-			r.CheckStatus(state.None.String())
+			mk.RunCommand("delete", true)
+			mk.CheckStatus(state.None.String())
 		})
 	}
 }
diff --git a/test/integration/tunnel_test.go b/test/integration/tunnel_test.go
index c0b2c15ddb0a3b553a9e0a0acbbf6a2b678ba10d..83a224f5961db296a8853852d2d919c415e04d60 100644
--- a/test/integration/tunnel_test.go
+++ b/test/integration/tunnel_test.go
@@ -46,9 +46,9 @@ func testTunnel(t *testing.T) {
 	}
 
 	t.Log("starting tunnel test...")
-	runner := NewMinikubeRunner(t, "--wait=false")
+	mk := NewMinikubeRunner(t, "--wait=false")
 	go func() {
-		output := runner.RunCommand("tunnel --alsologtostderr -v 8 --logtostderr", true)
+		output := mk.RunCommand("tunnel --alsologtostderr -v 8 --logtostderr", true)
 		if t.Failed() {
 			fmt.Println(output)
 		}
diff --git a/test/integration/version_upgrade_test.go b/test/integration/version_upgrade_test.go
index 8b92f259cd3994acfa46c1979c7377bd3dc3ff29..df058e70344b19192f7aa55909639896066645a7 100644
--- a/test/integration/version_upgrade_test.go
+++ b/test/integration/version_upgrade_test.go
@@ -66,26 +66,26 @@ func downloadMinikubeBinary(version string) (*os.File, error) {
 // the odlest supported k8s version and then runs the current head minikube
 // and it tries to upgrade from the older supported k8s to news supported k8s
 func TestVersionUpgrade(t *testing.T) {
-	currentRunner := NewMinikubeRunner(t)
-	currentRunner.RunCommand("delete", true)
-	currentRunner.CheckStatus(state.None.String())
+	mkCurrent := NewMinikubeRunner(t)
+	mkCurrent.RunCommand("delete", true)
+	mkCurrent.CheckStatus(state.None.String())
 	tf, err := downloadMinikubeBinary("latest")
 	if err != nil || tf == nil {
 		t.Fatal(errors.Wrap(err, "Failed to download minikube binary."))
 	}
 	defer os.Remove(tf.Name())
 
-	releaseRunner := NewMinikubeRunner(t)
-	releaseRunner.BinaryPath = tf.Name()
+	mkRelease := NewMinikubeRunner(t)
+	mkRelease.BinaryPath = tf.Name()
 	// For full coverage: also test upgrading from oldest to newest supported k8s release
-	releaseRunner.Start(fmt.Sprintf("--kubernetes-version=%s", constants.OldestKubernetesVersion))
-	releaseRunner.CheckStatus(state.Running.String())
-	releaseRunner.RunCommand("stop", true)
-	releaseRunner.CheckStatus(state.Stopped.String())
+	mkRelease.Start(fmt.Sprintf("--kubernetes-version=%s", constants.OldestKubernetesVersion))
+	mkRelease.CheckStatus(state.Running.String())
+	mkRelease.RunCommand("stop", true)
+	mkRelease.CheckStatus(state.Stopped.String())
 
 	// Trim the leading "v" prefix to assert that we handle it properly.
-	currentRunner.Start(fmt.Sprintf("--kubernetes-version=%s", strings.TrimPrefix(constants.NewestKubernetesVersion, "v")))
-	currentRunner.CheckStatus(state.Running.String())
-	currentRunner.RunCommand("delete", true)
-	currentRunner.CheckStatus(state.None.String())
+	mkCurrent.Start(fmt.Sprintf("--kubernetes-version=%s", strings.TrimPrefix(constants.NewestKubernetesVersion, "v")))
+	mkCurrent.CheckStatus(state.Running.String())
+	mkCurrent.RunCommand("delete", true)
+	mkCurrent.CheckStatus(state.None.String())
 }