Merge pull request #3187 from tstromberg/consistent_err_formatting

Globally replace %s format directives with %v for error strings

cmd/minikube/cmd/cache.go

@@ -18,12 +18,13 @@ package cmd
 
 import (
 	"fmt"
+	"os"
+
 	"github.com/spf13/cobra"
 	cmdConfig "k8s.io/minikube/cmd/minikube/cmd/config"
 	"k8s.io/minikube/pkg/minikube/config"
 	"k8s.io/minikube/pkg/minikube/constants"
 	"k8s.io/minikube/pkg/minikube/machine"
-	"os"
 )
 
 // cacheCmd represents the cache command
@@ -41,12 +42,12 @@ var addCacheCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		// Cache and load images into docker daemon
 		if err := machine.CacheAndLoadImages(args); err != nil {
-			fmt.Fprintf(os.Stderr, "Error caching and loading images: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error caching and loading images: %v\n", err)
 			os.Exit(1)
 		}
 		// Add images to config file
 		if err := cmdConfig.AddToConfigMap(constants.Cache, args); err != nil {
-			fmt.Fprintf(os.Stderr, "Error adding cached images to config file: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error adding cached images to config file: %v\n", err)
 			os.Exit(1)
 		}
 	},
@@ -60,12 +61,12 @@ var deleteCacheCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		// Delete images from config file
 		if err := cmdConfig.DeleteFromConfigMap(constants.Cache, args); err != nil {
-			fmt.Fprintf(os.Stderr, "Error deleting images from config file: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error deleting images from config file: %v\n", err)
 			os.Exit(1)
 		}
 		// Delete images from cache/images directory
 		if err := machine.DeleteFromImageCacheDir(args); err != nil {
-			fmt.Fprintf(os.Stderr, "Error deleting images: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error deleting images: %v\n", err)
 			os.Exit(1)
 		}
 	},

cmd/minikube/cmd/cache_list.go

@@ -41,11 +41,11 @@ var listCacheCmd = &cobra.Command{
 		// list images from config file
 		images, err := cmdConfig.ListConfigMap(constants.Cache)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error listing image entries from config: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error listing image entries from config: %v\n", err)
 			os.Exit(1)
 		}
 		if err := cacheList(images); err != nil {
-			fmt.Fprintf(os.Stderr, "Error listing images: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error listing images: %v\n", err)
 			os.Exit(1)
 		}
 	},
@@ -62,13 +62,13 @@ func cacheList(images []string) error {
 	for _, image := range images {
 		tmpl, err := template.New("list").Parse(cacheListFormat)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error creating list template: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error creating list template: %v\n", err)
 			os.Exit(1)
 		}
 		listTmplt := CacheListTemplate{image}
 		err = tmpl.Execute(os.Stdout, listTmplt)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error executing list template: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error executing list template: %v\n", err)
 			os.Exit(1)
 		}
 	}

cmd/minikube/cmd/config/config_test.go

@@ -80,7 +80,7 @@ func TestHiddenPrint(t *testing.T) {
 		}
 		result, err := concealableAskForStaticValue(b, "hello", false)
 		if err != nil && !test.ShouldError {
-			t.Errorf("Error asking for concealable static value: %s", err)
+			t.Errorf("Error asking for concealable static value: %v", err)
 			continue
 		}
 		if result != test.TestString {
@@ -94,7 +94,7 @@ func TestWriteConfig(t *testing.T) {
 	for _, tt := range configTestCases {
 		err := encode(&b, tt.config)
 		if err != nil {
-			t.Errorf("Error encoding: %s", err)
+			t.Errorf("Error encoding: %v", err)
 		}
 		if b.String() != tt.data {
 			t.Errorf("Did not write config correctly, \n\n expected:\n %+v \n\n actual:\n %+v", tt.data, b.String())

cmd/minikube/cmd/config/open.go

@@ -61,7 +61,7 @@ var addonsOpenCmd = &cobra.Command{
 		//TODO(r2d4): config should not reference API, pull this out
 		api, err := machine.NewAPIClient()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 			os.Exit(1)
 		}
 		defer api.Close()
@@ -91,7 +91,7 @@ minikube addons enable %s`, addonName, addonName))
 
 		serviceList, err := service.GetServiceListByLabel(namespace, key, addonName)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting service with namespace: %s and labels %s:%s: %s\n", namespace, key, addonName, err)
+			fmt.Fprintf(os.Stderr, "Error getting service with namespace: %s and labels %s:%s: %v\n", namespace, key, addonName, err)
 			os.Exit(1)
 		}
 		if len(serviceList.Items) == 0 {

cmd/minikube/cmd/config/util.go

@@ -104,7 +104,7 @@ func EnableOrDisableAddon(name string, val string) error {
 	//TODO(r2d4): config package should not reference API, pull this out
 	api, err := machine.NewAPIClient()
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+		fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 		os.Exit(1)
 	}
 	defer api.Close()

cmd/minikube/cmd/config/util_test.go

@@ -38,7 +38,7 @@ func TestFindSettingNotFound(t *testing.T) {
 func TestFindSetting(t *testing.T) {
 	s, err := findSetting("vm-driver")
 	if err != nil {
-		t.Fatalf("Couldn't find setting, vm-driver: %s", err)
+		t.Fatalf("Couldn't find setting, vm-driver: %v", err)
 	}
 	if s.name != "vm-driver" {
 		t.Fatalf("Found wrong setting, expected vm-driver, got %s", s.name)
@@ -48,14 +48,14 @@ func TestFindSetting(t *testing.T) {
 func TestSetString(t *testing.T) {
 	err := SetString(minikubeConfig, "vm-driver", "virtualbox")
 	if err != nil {
-		t.Fatalf("Couldnt set string: %s", err)
+		t.Fatalf("Couldnt set string: %v", err)
 	}
 }
 
 func TestSetInt(t *testing.T) {
 	err := SetInt(minikubeConfig, "cpus", "22")
 	if err != nil {
-		t.Fatalf("Couldn't set int in config: %s", err)
+		t.Fatalf("Couldn't set int in config: %v", err)
 	}
 	val, ok := minikubeConfig["cpus"].(int)
 	if !ok {
@@ -69,7 +69,7 @@ func TestSetInt(t *testing.T) {
 func TestSetBool(t *testing.T) {
 	err := SetBool(minikubeConfig, "show-libmachine-logs", "true")
 	if err != nil {
-		t.Fatalf("Couldn't set bool in config: %s", err)
+		t.Fatalf("Couldn't set bool in config: %v", err)
 	}
 	val, ok := minikubeConfig["show-libmachine-logs"].(bool)
 	if !ok {

cmd/minikube/cmd/dashboard.go

@@ -59,7 +59,7 @@ var dashboardCmd = &cobra.Command{
 		}()
 
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error creating client: %v\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 			os.Exit(1)
 		}
 		cluster.EnsureMinikubeRunningOrExit(api, 1)

cmd/minikube/cmd/delete.go

@@ -44,7 +44,7 @@ associated files.`,
 		fmt.Println("Deleting local Kubernetes cluster...")
 		api, err := machine.NewAPIClient()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 			os.Exit(1)
 		}
 		defer api.Close()

cmd/minikube/cmd/env.go

@@ -302,13 +302,13 @@ var dockerEnvCmd = &cobra.Command{
 
 		api, err := machine.NewAPIClient()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 			os.Exit(1)
 		}
 		defer api.Close()
 		host, err := cluster.CheckIfHostExistsAndLoad(api, config.GetMachineName())
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting host: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting host: %v\n", err)
 			os.Exit(1)
 		}
 		if host.Driver.DriverName() == "none" {

cmd/minikube/cmd/env_test.go

@@ -248,7 +248,7 @@ func TestShellCfgSet(t *testing.T) {
 				t.Errorf("Shell cfgs differ: expected %+v, \n\n got %+v", test.expectedShellCfg, shellCfg)
 			}
 			if err != nil && !test.shouldErr {
-				t.Errorf("Test should have failed but didn't return error: %s, error: %s", test.description, err)
+				t.Errorf("Test should have failed but didn't return error: %s, error: %v", test.description, err)
 			}
 			if err == nil && test.shouldErr {
 				t.Errorf("Test didn't return error but should have: %s", test.description)

cmd/minikube/cmd/ip.go

@@ -34,7 +34,7 @@ var ipCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		api, err := machine.NewAPIClient()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 			os.Exit(1)
 		}
 		defer api.Close()

cmd/minikube/cmd/logs.go

@@ -41,13 +41,13 @@ var logsCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		api, err := machine.NewAPIClient()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 			os.Exit(1)
 		}
 		defer api.Close()
 		clusterBootstrapper, err := GetClusterBootstrapper(api, viper.GetString(cmdcfg.Bootstrapper))
 		if err != nil {
-			glog.Exitf("Error getting cluster bootstrapper: %s", err)
+			glog.Exitf("Error getting cluster bootstrapper: %v", err)
 		}
 
 		err = clusterBootstrapper.GetClusterLogsTo(follow, os.Stdout)

cmd/minikube/cmd/mount.go

@@ -93,7 +93,7 @@ var mountCmd = &cobra.Command{
 		}
 		api, err := machine.NewAPIClient()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 			os.Exit(1)
 		}
 		defer api.Close()

cmd/minikube/cmd/root.go

@@ -70,7 +70,7 @@ var RootCmd = &cobra.Command{
 	PersistentPreRun: func(cmd *cobra.Command, args []string) {
 		for _, path := range dirs {
 			if err := os.MkdirAll(path, 0777); err != nil {
-				glog.Exitf("Error creating minikube directory: %s", err)
+				glog.Exitf("Error creating minikube directory: %v", err)
 			}
 		}
 
@@ -143,7 +143,7 @@ func initConfig() {
 	viper.SetConfigType("json")
 	err := viper.ReadInConfig()
 	if err != nil {
-		glog.Warningf("Error reading config file at %s: %s", configPath, err)
+		glog.Warningf("Error reading config file at %s: %v", configPath, err)
 	}
 	setupViper()
 }

cmd/minikube/cmd/service.go

@@ -65,7 +65,7 @@ var serviceCmd = &cobra.Command{
 		svc := args[0]
 		api, err := machine.NewAPIClient()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 			os.Exit(1)
 		}
 		defer api.Close()
@@ -74,7 +74,7 @@ var serviceCmd = &cobra.Command{
 		err = service.WaitAndMaybeOpenService(api, namespace, svc,
 			serviceURLTemplate, serviceURLMode, https, wait, interval)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error opening service: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error opening service: %v\n", err)
 			os.Exit(1)
 		}
 	},

cmd/minikube/cmd/service_list.go

@@ -39,7 +39,7 @@ var serviceListCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		api, err := machine.NewAPIClient()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 			os.Exit(1)
 		}
 		defer api.Close()

cmd/minikube/cmd/ssh.go

@@ -36,13 +36,13 @@ var sshCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		api, err := machine.NewAPIClient()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 			os.Exit(1)
 		}
 		defer api.Close()
 		host, err := cluster.CheckIfHostExistsAndLoad(api, config.GetMachineName())
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting host: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting host: %v\n", err)
 			os.Exit(1)
 		}
 		if host.Driver.DriverName() == "none" {

cmd/minikube/cmd/start.go

@@ -112,14 +112,14 @@ func runStart(cmd *cobra.Command, args []string) {
 
 	api, err := machine.NewAPIClient()
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+		fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 		os.Exit(1)
 	}
 	defer api.Close()
 
 	exists, err := api.Exists(cfg.GetMachineName())
 	if err != nil {
-		glog.Exitf("checking if machine exists: %s", err)
+		glog.Exitf("checking if machine exists: %v", err)
 	}
 
 	diskSize := viper.GetString(humanReadableDiskSize)
@@ -165,7 +165,7 @@ func runStart(cmd *cobra.Command, args []string) {
 	start := func() (err error) {
 		host, err = cluster.StartHost(api, config)
 		if err != nil {
-			glog.Errorf("Error starting host: %s.\n\n Retrying.\n", err)
+			glog.Errorf("Error starting host: %v.\n\n Retrying.\n", err)
 		}
 		return err
 	}
@@ -228,7 +228,7 @@ func runStart(cmd *cobra.Command, args []string) {
 
 	k8sBootstrapper, err := GetClusterBootstrapper(api, clusterBootstrapper)
 	if err != nil {
-		glog.Exitf("Error getting cluster bootstrapper: %s", err)
+		glog.Exitf("Error getting cluster bootstrapper: %v", err)
 	}
 
 	// Write profile cluster configuration to file
@@ -321,12 +321,12 @@ func runStart(cmd *cobra.Command, args []string) {
 		}
 		err = mountCmd.Start()
 		if err != nil {
-			glog.Errorf("Error running command minikube mount %s", err)
+			glog.Errorf("Error running command minikube mount %v", err)
 			cmdutil.MaybeReportErrorAndExit(err)
 		}
 		err = ioutil.WriteFile(filepath.Join(constants.GetMinipath(), constants.MountProcessFileName), []byte(strconv.Itoa(mountCmd.Process.Pid)), 0644)
 		if err != nil {
-			glog.Errorf("Error writing mount process pid to file: %s", err)
+			glog.Errorf("Error writing mount process pid to file: %v", err)
 			cmdutil.MaybeReportErrorAndExit(err)
 		}
 	}

cmd/minikube/cmd/status.go

@@ -61,7 +61,7 @@ var statusCmd = &cobra.Command{
 		var returnCode = 0
 		api, err := machine.NewAPIClient()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 			os.Exit(internalErrorCode)
 		}
 		defer api.Close()
@@ -77,7 +77,7 @@ var statusCmd = &cobra.Command{
 		if ms == state.Running.String() {
 			clusterBootstrapper, err := GetClusterBootstrapper(api, viper.GetString(cmdcfg.Bootstrapper))
 			if err != nil {
-				glog.Errorf("Error getting cluster bootstrapper: %s", err)
+				glog.Errorf("Error getting cluster bootstrapper: %v", err)
 				cmdUtil.MaybeReportErrorAndExitWithCode(err, internalErrorCode)
 			}
 			cs, err = clusterBootstrapper.GetClusterStatus()

cmd/minikube/cmd/stop.go

@@ -36,7 +36,7 @@ itself, leaving all files intact. The cluster can be started again with the "sta
 		fmt.Println("Stopping local Kubernetes cluster...")
 		api, err := machine.NewAPIClient()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 			os.Exit(1)
 		}
 		defer api.Close()

cmd/minikube/cmd/update-context.go

@@ -39,7 +39,7 @@ var updateContextCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		api, err := machine.NewAPIClient()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting client: %s\n", err)
+			fmt.Fprintf(os.Stderr, "Error getting client: %v\n", err)
 			os.Exit(1)
 		}
 		defer api.Close()

cmd/storage-provisioner/main.go

@@ -28,7 +28,7 @@ import (
 func main() {
 	// Glog requires that /tmp exists.
 	if err := os.MkdirAll("/tmp", 0755); err != nil {
-		fmt.Printf("Error creating tmpdir: %s\n", err)
+		fmt.Printf("Error creating tmpdir: %v\n", err)
 		os.Exit(1)
 	}
 	flag.Parse()

cmd/util/util_test.go

@@ -48,7 +48,7 @@ func TestFormatError(t *testing.T) {
 
 	_, err := FormatError(testErr)
 	if err != nil {
-		t.Fatalf("Unexpected error: %s", err)
+		t.Fatalf("Unexpected error: %v", err)
 	}
 }
 
@@ -59,7 +59,7 @@ func TestMarshallError(t *testing.T) {
 
 	errMsg, _ := FormatError(testErr)
 	if _, err := MarshallError(errMsg, "default", version.GetVersion()); err != nil {
-		t.Fatalf("Unexpected error: %s", err)
+		t.Fatalf("Unexpected error: %v", err)
 	}
 }
 
@@ -75,7 +75,7 @@ func TestUploadError(t *testing.T) {
 	}))
 
 	if err := UploadError(jsonErrMsg, server.URL); err != nil {
-		t.Fatalf("Unexpected error: %s", err)
+		t.Fatalf("Unexpected error: %v", err)
 	}
 
 	server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

deploy/minikube/release_sanity_test.go

@@ -50,7 +50,7 @@ func getShaFromURL(url string) (string, error) {
 func TestReleasesJson(t *testing.T) {
 	releases, err := notify.GetAllVersionsFromURL(constants.GithubMinikubeReleasesURL)
 	if err != nil {
-		t.Fatalf("Error getting releases.json: %s", err)
+		t.Fatalf("Error getting releases.json: %v", err)
 	}
 
 	for _, r := range releases {
@@ -59,7 +59,7 @@ func TestReleasesJson(t *testing.T) {
 			fmt.Printf("Checking SHA for %s.\n", platform)
 			actualSha, err := getShaFromURL(util.GetBinaryDownloadURL(r.Name, platform))
 			if err != nil {
-				t.Errorf("Error calculating SHA for %s-%s. Error: %s", r.Name, platform, err)
+				t.Errorf("Error calculating SHA for %s-%s. Error: %v", r.Name, platform, err)
 				continue
 			}
 			if actualSha != sha {

pkg/drivers/hyperkit/driver.go

@@ -151,7 +151,7 @@ func (d *Driver) Kill() error {
 func (d *Driver) Remove() error {
 	s, err := d.GetState()
 	if err != nil || s == state.Error {
-		log.Infof("Error checking machine status: %s, assuming it has been removed already", err)
+		log.Infof("Error checking machine status: %v, assuming it has been removed already", err)
 	}
 	if s == state.Running {
 		if err := d.Stop(); err != nil {
@@ -229,7 +229,8 @@ func (d *Driver) Start() error {
 		time.Sleep(time.Second * 30)
 		err = d.setupNFSShare()
 		if err != nil {
-			log.Errorf("NFS setup failed: %s", err.Error())
+			// TODO(tstromberg): Check that logging an and error and return it is appropriate. Seems weird.
+			log.Errorf("NFS setup failed: %v", err)
 			return err
 		}
 	}
@@ -350,13 +351,13 @@ func (d *Driver) getPid() int {
 
 	f, err := os.Open(pidPath)
 	if err != nil {
-		log.Warnf("Error reading pid file: %s", err)
+		log.Warnf("Error reading pid file: %v", err)
 		return 0
 	}
 	dec := json.NewDecoder(f)
 	config := hyperkit.HyperKit{}
 	if err := dec.Decode(&config); err != nil {
-		log.Warnf("Error decoding pid file: %s", err)
+		log.Warnf("Error decoding pid file: %v", err)
 		return 0
 	}
 
@@ -368,12 +369,12 @@ func (d *Driver) cleanupNfsExports() {
 		log.Infof("You must be root to remove NFS shared folders. Please type root password.")
 		for _, share := range d.NFSShares {
 			if _, err := nfsexports.Remove("", d.nfsExportIdentifier(share)); err != nil {
-				log.Errorf("failed removing nfs share (%s): %s", share, err.Error())
+				log.Errorf("failed removing nfs share (%s): %v", share, err)
 			}
 		}
 
 		if err := nfsexports.ReloadDaemon(); err != nil {
-			log.Errorf("failed to reload the nfs daemon: %s", err.Error())
+			log.Errorf("failed to reload the nfs daemon: %v", err)
 		}
 	}
 }

pkg/drivers/kvm/kvm.go

@@ -370,7 +370,7 @@ func (d *Driver) Remove() error {
 	// Tear down network if it exists and is not in use by another minikube instance
 	log.Debug("Trying to delete the networks (if possible)")
 	if err := d.deleteNetwork(); err != nil {
-		log.Warnf("Deleting of networks failed: %s", err.Error())
+		log.Warnf("Deleting of networks failed: %v", err)
 	} else {
 		log.Info("Successfully deleted networks")
 	}

pkg/drivers/kvm/network.go

@@ -277,7 +277,7 @@ func (d *Driver) lookupIPFromStatusFile(conn *libvirt.Connect) (string, error) {
 
 	bridge, err := network.GetBridgeName()
 	if err != nil {
-		log.Warnf("Failed to get network bridge: %s", err)
+		log.Warnf("Failed to get network bridge: %v", err)
 		return "", err
 	}
 	statusFile := fmt.Sprintf("/var/lib/libvirt/dnsmasq/%s.status", bridge)

pkg/drivers/none/none.go

@@ -124,7 +124,7 @@ func (d *Driver) Kill() error {
 	} {
 		cmd := exec.Command("sudo", cmdStr...)
 		if out, err := cmd.CombinedOutput(); err != nil {
-			glog.Warningf("Error %s running command: %s. Output: %s", err, cmdStr, string(out))
+			glog.Warningf("Error %v running command: %s. Output: %s", err, cmdStr, out)
 		}
 	}
 	return nil
@@ -138,7 +138,7 @@ func (d *Driver) Remove() error {
 
 	for _, cmdStr := range []string{rmCmd, dockerkillcmd} {
 		if out, err := runCommand(cmdStr, true); err != nil {
-			glog.Warningf("Error %s running command: %s, Output: %s", err, cmdStr, out)
+			glog.Warningf("Error %v running command: %s, Output: %s", err, cmdStr, out)
 		}
 	}
 
@@ -192,7 +192,7 @@ fi
 		}
 	}
 	if out, err := runCommand(dockerstopcmd, false); err != nil {
-		glog.Warningf("Error %s running command %s. Output: %s", err, dockerstopcmd, out)
+		glog.Warningf("Error %v running command %s. Output: %s", err, dockerstopcmd, out)
 	}
 	return nil
 }

pkg/minikube/bootstrapper/certs_test.go

@@ -44,7 +44,7 @@ func TestSetupCerts(t *testing.T) {
 	}
 
 	if err := SetupCerts(f, k8s); err != nil {
-		t.Fatalf("Error starting cluster: %s", err)
+		t.Fatalf("Error starting cluster: %v", err)
 	}
 	for _, cert := range filesToBeTransferred {
 		_, err := f.GetFileToContents(cert)

pkg/minikube/bootstrapper/kubeadm/kubeadm_test.go

@@ -234,7 +234,7 @@ schedulerExtraArgs:
 		t.Run(test.description, func(t *testing.T) {
 			actualCfg, err := generateConfig(test.cfg)
 			if err != nil && !test.shouldErr {
-				t.Errorf("got unexpected error generating config: %s", err)
+				t.Errorf("got unexpected error generating config: %v", err)
 				return
 			}
 			if err == nil && test.shouldErr {

pkg/minikube/bootstrapper/kubeadm/versions_test.go

@@ -96,7 +96,7 @@ func TestVersionIsBetween(t *testing.T) {
 func TestParseKubernetesVersion(t *testing.T) {
 	version, err := ParseKubernetesVersion("v1.8.0-alpha.5")
 	if err != nil {
-		t.Fatalf("Error parsing version: %s", err)
+		t.Fatalf("Error parsing version: %v", err)
 	}
 	if version.NE(semver.MustParse("1.8.0-alpha.5")) {
 		t.Errorf("Expected: %s, Actual:%s", "1.8.0-alpha.5", version)
@@ -141,7 +141,7 @@ func TestParseFeatureArgs(t *testing.T) {
 			kubeadm, component, err := ParseFeatureArgs(test.featureGates)
 
 			if err != nil {
-				t.Fatalf("Error parsing feature args: %s", err)
+				t.Fatalf("Error parsing feature args: %v", err)
 			}
 
 			if !reflect.DeepEqual(kubeadm, test.expectedKubeadmFeatureArgs) {

pkg/minikube/cluster/cluster_test.go

@@ -229,7 +229,7 @@ func TestDeleteHost(t *testing.T) {
 	createHost(api, defaultMachineConfig)
 
 	if err := DeleteHost(api); err != nil {
-		t.Fatalf("Unexpected error deleting host: %s", err)
+		t.Fatalf("Unexpected error deleting host: %v", err)
 	}
 }
 
@@ -274,7 +274,7 @@ func TestDeleteHostMultipleErrors(t *testing.T) {
 	expectedErrors := []string{"error removing " + config.GetMachineName(), "error deleting machine"}
 	for _, expectedError := range expectedErrors {
 		if !strings.Contains(err.Error(), expectedError) {
-			t.Fatalf("Error %s expected to contain: %s.", err, expectedError)
+			t.Fatalf("Error %v expected to contain: %s.", err, expectedError)
 		}
 	}
 }
@@ -285,7 +285,7 @@ func TestGetHostStatus(t *testing.T) {
 	checkState := func(expected string) {
 		s, err := GetHostStatus(api)
 		if err != nil {
-			t.Fatalf("Unexpected error getting status: %s", err)
+			t.Fatalf("Unexpected error getting status: %v", err)
 		}
 		if s != expected {
 			t.Fatalf("Expected status: %s, got %s", s, expected)
@@ -319,7 +319,7 @@ func TestGetHostDockerEnv(t *testing.T) {
 
 	envMap, err := GetHostDockerEnv(api)
 	if err != nil {
-		t.Fatalf("Unexpected error getting env: %s", err)
+		t.Fatalf("Unexpected error getting env: %v", err)
 	}
 
 	dockerEnvKeys := [...]string{
@@ -352,7 +352,7 @@ func TestGetHostDockerEnvIPv6(t *testing.T) {
 
 	envMap, err := GetHostDockerEnv(api)
 	if err != nil {
-		t.Fatalf("Unexpected error getting env: %s", err)
+		t.Fatalf("Unexpected error getting env: %v", err)
 	}
 
 	expected := "tcp://[fe80::215:5dff:fe00:a903]:2376"
@@ -368,7 +368,7 @@ func TestCreateSSHShell(t *testing.T) {
 	s, _ := tests.NewSSHServer()
 	port, err := s.Start()
 	if err != nil {
-		t.Fatalf("Error starting ssh server: %s", err)
+		t.Fatalf("Error starting ssh server: %v", err)
 	}
 
 	d := &tests.MockDriver{
@@ -383,7 +383,7 @@ func TestCreateSSHShell(t *testing.T) {
 
 	cliArgs := []string{"exit"}
 	if err := CreateSSHShell(api, cliArgs); err != nil {
-		t.Fatalf("Error running ssh command: %s", err)
+		t.Fatalf("Error running ssh command: %v", err)
 	}
 
 	if !s.IsSessionRequested() {

pkg/minikube/cluster/cluster_windows.go

@@ -62,7 +62,7 @@ func detectVBoxManageCmd() string {
 func findVBoxInstallDirInRegistry() (string, error) {
 	registryKey, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Oracle\VirtualBox`, registry.QUERY_VALUE)
 	if err != nil {
-		errorMessage := fmt.Sprintf("Can't find VirtualBox registry entries, is VirtualBox really installed properly? %s", err)
+		errorMessage := fmt.Sprintf("Can't find VirtualBox registry entries, is VirtualBox really installed properly? %v", err)
 		glog.Errorf(errorMessage)
 		return "", errors.New(errorMessage)
 	}
@@ -71,7 +71,7 @@ func findVBoxInstallDirInRegistry() (string, error) {
 
 	installDir, _, err := registryKey.GetStringValue("InstallDir")
 	if err != nil {
-		errorMessage := fmt.Sprintf("Can't find InstallDir registry key within VirtualBox registries entries, is VirtualBox really installed properly? %s", err)
+		errorMessage := fmt.Sprintf("Can't find InstallDir registry key within VirtualBox registries entries, is VirtualBox really installed properly? %v", err)
 		glog.Errorf(errorMessage)
 		return "", errors.New(errorMessage)
 	}

pkg/minikube/config/config.go

@@ -65,13 +65,13 @@ func ReadConfig() (MinikubeConfig, error) {
 		if os.IsNotExist(err) {
 			return make(map[string]interface{}), nil
 		}
-		return nil, fmt.Errorf("Could not open file %s: %s", constants.ConfigFile, err)
+		return nil, fmt.Errorf("Could not open file %s: %v", constants.ConfigFile, err)
 	}
 	defer f.Close()
 
 	m, err := decode(f)
 	if err != nil {
-		return nil, fmt.Errorf("Could not decode config %s: %s", constants.ConfigFile, err)
+		return nil, fmt.Errorf("Could not decode config %s: %v", constants.ConfigFile, err)
 	}
 
 	return m, nil

pkg/minikube/machine/cache_images_test.go

@@ -26,7 +26,7 @@ import (
 func TestReplaceWinDriveLetterToVolumeName(t *testing.T) {
 	path, err := ioutil.TempDir("", "repwindl2vn")
 	if err != nil {
-		t.Fatalf("Error make tmp directory: %s", err)
+		t.Fatalf("Error make tmp directory: %v", err)
 	}
 	defer os.RemoveAll(path)
 
@@ -40,7 +40,7 @@ func TestReplaceWinDriveLetterToVolumeName(t *testing.T) {
 	}
 
 	if _, err := replaceWinDriveLetterToVolumeName(path); err != nil {
-		t.Errorf("Error replace a Windows drive letter to a volume name: %s", err)
+		t.Errorf("Error replace a Windows drive letter to a volume name: %v", err)
 	}
 }
 

pkg/minikube/machine/client_test.go

@@ -102,7 +102,7 @@ func TestLocalClientNewHost(t *testing.T) {
 				}
 			}
 			if err != nil && !test.err {
-				t.Errorf("Unexpected error: %s", err)
+				t.Errorf("Unexpected error: %v", err)
 			}
 			if err == nil && test.err {
 				t.Errorf("No error returned, but expected err")

pkg/minikube/service/service.go

@@ -78,7 +78,7 @@ func (*K8sClientGetter) GetClientset() (*kubernetes.Clientset, error) {
 	kubeConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, configOverrides)
 	clientConfig, err := kubeConfig.ClientConfig()
 	if err != nil {
-		return nil, fmt.Errorf("Error creating kubeConfig: %s", err)
+		return nil, fmt.Errorf("Error creating kubeConfig: %v", err)
 	}
 	clientConfig.Timeout = 1 * time.Second
 	client, err := kubernetes.NewForConfig(clientConfig)

pkg/minikube/service/service_test.go

@@ -236,7 +236,7 @@ func TestPrintURLsForService(t *testing.T) {
 			t.Parallel()
 			urls, err := printURLsForService(client, "127.0.0.1", test.serviceName, test.namespace, test.tmpl)
 			if err != nil && !test.err {
-				t.Errorf("Error: %s", err)
+				t.Errorf("Error: %v", err)
 			}
 			if err == nil && test.err {
 				t.Errorf("Expected error but got none")
@@ -364,7 +364,7 @@ func TestGetServiceURLs(t *testing.T) {
 			}
 			urls, err := GetServiceURLs(test.api, test.namespace, defaultTemplate)
 			if err != nil && !test.err {
-				t.Errorf("Error GetServiceURLs %s", err)
+				t.Errorf("Error GetServiceURLs %v", err)
 			}
 			if err == nil && test.err {
 				t.Errorf("Test should have failed, but didn't")
@@ -431,7 +431,7 @@ func TestGetServiceURLsForService(t *testing.T) {
 			}
 			urls, err := GetServiceURLsForService(test.api, test.namespace, test.service, defaultTemplate)
 			if err != nil && !test.err {
-				t.Errorf("Error GetServiceURLsForService %s", err)
+				t.Errorf("Error GetServiceURLsForService %v", err)
 			}
 			if err == nil && test.err {
 				t.Errorf("Test should have failed, but didn't")

pkg/minikube/sshutil/sshutil_test.go

@@ -28,7 +28,7 @@ func TestNewSSHClient(t *testing.T) {
 	s, _ := tests.NewSSHServer()
 	port, err := s.Start()
 	if err != nil {
-		t.Fatalf("Error starting ssh server: %s", err)
+		t.Fatalf("Error starting ssh server: %v", err)
 	}
 	d := &tests.MockDriver{
 		Port: port,
@@ -39,7 +39,7 @@ func TestNewSSHClient(t *testing.T) {
 	}
 	c, err := NewSSHClient(d)
 	if err != nil {
-		t.Fatalf("Unexpected error: %s", err)
+		t.Fatalf("Unexpected error: %v", err)
 	}
 
 	cmd := "foo"
@@ -75,7 +75,7 @@ func TestNewSSHHost(t *testing.T) {
 
 	h, err := newSSHHost(&d)
 	if err != nil {
-		t.Fatalf("Unexpected error creating host: %s", err)
+		t.Fatalf("Unexpected error creating host: %v", err)
 	}
 
 	if h.SSHKeyPath != sshKeyPath {

pkg/minikube/tests/ssh_mock.go

@@ -120,7 +120,7 @@ func (s *SSHServer) Start() (int, error) {
 							// Note: string(req.Payload) adds additional characters to start of input.
 							var cmd execRequest
 							if err := ssh.Unmarshal(req.Payload, &cmd); err != nil {
-								glog.Errorf("Unmarshall encountered error: %s with req: %v", err, req.Type)
+								glog.Errorf("Unmarshall encountered error: %v with req: %v", err, req.Type)
 								return
 							}
 							s.Commands[cmd.Command] = 1

pkg/provision/buildroot.go

@@ -208,7 +208,7 @@ CRIO_MINIKUBE_OPTIONS='{{ range .EngineOptions.InsecureRegistry }}--insecure-reg
 
 	// This is unlikely to cause issues unless the user has explicitly requested CRIO, so just log a warning.
 	if err := p.Service("crio", serviceaction.Restart); err != nil {
-		log.Warn("Unable to restart crio service. Error: %s", err)
+		log.Warn("Unable to restart crio service. Error: %v", err)
 	}
 
 	return nil
@@ -264,7 +264,7 @@ func configureAuth(p *BuildrootProvisioner) error {
 	})
 
 	if err != nil {
-		return fmt.Errorf("error generating server cert: %s", err)
+		return fmt.Errorf("error generating server cert: %v", err)
 	}
 
 	remoteCerts := map[string]string{

pkg/util/config.go

@@ -66,19 +66,19 @@ func setElement(e reflect.Value, v string) error {
 	case net.IPNet:
 		_, cidr, err := net.ParseCIDR(v)
 		if err != nil {
-			return fmt.Errorf("Error converting input %s to a CIDR: %s", v, err)
+			return fmt.Errorf("Error converting input %s to a CIDR: %v", v, err)
 		}
 		e.Set(reflect.ValueOf(*cidr))
 	case utilnet.PortRange:
 		pr, err := utilnet.ParsePortRange(v)
 		if err != nil {
-			return fmt.Errorf("Error converting input %s to PortRange: %s", v, err)
+			return fmt.Errorf("Error converting input %s to PortRange: %v", v, err)
 		}
 		e.Set(reflect.ValueOf(*pr))
 	case time.Duration:
 		dur, err := time.ParseDuration(v)
 		if err != nil {
-			return fmt.Errorf("Error converting input %s to Duration: %s", v, err)
+			return fmt.Errorf("Error converting input %s to Duration: %v", v, err)
 		}
 		e.Set(reflect.ValueOf(dur))
 	case []string:
@@ -126,7 +126,7 @@ func convertMap(e reflect.Value, v string) error {
 func convertInt(e reflect.Value, v string) error {
 	i, err := strconv.Atoi(v)
 	if err != nil {
-		return fmt.Errorf("Error converting input %s to an integer: %s", v, err)
+		return fmt.Errorf("Error converting input %s to an integer: %v", v, err)
 	}
 	e.SetInt(int64(i))
 	return nil
@@ -140,7 +140,7 @@ func convertString(e reflect.Value, v string) error {
 func convertFloat(e reflect.Value, v string) error {
 	f, err := strconv.ParseFloat(v, 64)
 	if err != nil {
-		return fmt.Errorf("Error converting input %s to a float: %s", v, err)
+		return fmt.Errorf("Error converting input %s to a float: %v", v, err)
 	}
 	e.SetFloat(f)
 	return nil
@@ -149,7 +149,7 @@ func convertFloat(e reflect.Value, v string) error {
 func convertBool(e reflect.Value, v string) error {
 	b, err := strconv.ParseBool(v)
 	if err != nil {
-		return fmt.Errorf("Error converting input %s to a bool: %s", v, err)
+		return fmt.Errorf("Error converting input %s to a bool: %v", v, err)
 	}
 	e.SetBool(b)
 	return nil

pkg/util/config_test.go

@@ -104,7 +104,7 @@ func TestFindNestedStrings(t *testing.T) {
 	} {
 		v, err := findNestedElement(tc.input, &a)
 		if err != nil {
-			t.Fatalf("Did not expect error. Got: %s", err)
+			t.Fatalf("Did not expect error. Got: %v", err)
 		}
 		if v.String() != tc.output {
 			t.Fatalf("Expected: %s, got %s", tc.output, v.String())
@@ -126,7 +126,7 @@ func TestFindNestedInts(t *testing.T) {
 	} {
 		v, err := findNestedElement(tc.input, &a)
 		if err != nil {
-			t.Fatalf("Did not expect error. Got: %s", err)
+			t.Fatalf("Did not expect error. Got: %v", err)
 		}
 		if v.Int() != tc.output {
 			t.Fatalf("Expected: %d, got %d", tc.output, v.Int())
@@ -151,7 +151,7 @@ func TestFindNestedFloats(t *testing.T) {
 	} {
 		v, err := findNestedElement(tc.input, &a)
 		if err != nil {
-			t.Fatalf("Did not expect error. Got: %s", err)
+			t.Fatalf("Did not expect error. Got: %v", err)
 		}
 
 		// Floating point comparison is tricky.
@@ -187,7 +187,7 @@ func TestSetElement(t *testing.T) {
 	} {
 		a := buildConfig()
 		if err := FindAndSet(tc.path, &a, tc.newval); err != nil {
-			t.Fatalf("Error setting value: %s", err)
+			t.Fatalf("Error setting value: %v", err)
 		}
 		if !tc.checker(a) {
 			t.Fatalf("Error, values not correct: %v, %s, %s", a, tc.newval, tc.path)

pkg/util/downloader_test.go

@@ -59,7 +59,7 @@ func TestCacheMinikubeISOFromURL(t *testing.T) {
 	}))
 	isoURL := server.URL + "/minikube-test.iso"
 	if err := dler.CacheMinikubeISOFromURL(isoURL); err != nil {
-		t.Fatalf("Unexpected error from CacheMinikubeISOFromURL: %s", err)
+		t.Fatalf("Unexpected error from CacheMinikubeISOFromURL: %v", err)
 	}
 
 	transferred, err := ioutil.ReadFile(filepath.Join(isoPath))

pkg/util/extra_options_test.go

@@ -70,7 +70,7 @@ func TestValidFlags(t *testing.T) {
 		var e ExtraOptionSlice
 		flags.Var(&e, "e", "usage")
 		if err := flags.Parse(tc.args); err != nil {
-			t.Errorf("Unexpected error: %s for %s.", err, tc)
+			t.Errorf("Unexpected error: %v for %s.", err, tc)
 		}
 
 		if !reflect.DeepEqual(e, tc.values) {

pkg/util/kubeconfig/config_test.go

@@ -143,7 +143,7 @@ func TestSetupKubeConfig(t *testing.T) {
 			t.Parallel()
 			tmpDir, err := ioutil.TempDir("", "")
 			if err != nil {
-				t.Fatalf("Error making temp directory %s", err)
+				t.Fatalf("Error making temp directory %v", err)
 			}
 			test.cfg.SetKubeConfigFile(filepath.Join(tmpDir, "kubeconfig"))
 			if len(test.existingCfg) != 0 {
@@ -151,14 +151,14 @@ func TestSetupKubeConfig(t *testing.T) {
 			}
 			err = SetupKubeConfig(test.cfg)
 			if err != nil && !test.err {
-				t.Errorf("Got unexpected error: %s", err)
+				t.Errorf("Got unexpected error: %v", err)
 			}
 			if err == nil && test.err {
 				t.Errorf("Expected error but got none")
 			}
 			config, err := ReadConfigOrNew(test.cfg.GetKubeConfigFile())
 			if err != nil {
-				t.Errorf("Error reading kubeconfig file: %s", err)
+				t.Errorf("Error reading kubeconfig file: %v", err)
 			}
 			if test.cfg.KeepContext && config.CurrentContext == test.cfg.ClusterName {
 				t.Errorf("Context was changed even though KeepContext was true")
@@ -213,10 +213,10 @@ func TestGetKubeConfigStatus(t *testing.T) {
 			configFilename := tempFile(t, test.existing)
 			statusActual, err := GetKubeConfigStatus(test.ip, configFilename, "minikube")
 			if err != nil && !test.err {
-				t.Errorf("Got unexpected error: %s", err)
+				t.Errorf("Got unexpected error: %v", err)
 			}
 			if err == nil && test.err {
-				t.Errorf("Expected error but got none: %s", err)
+				t.Errorf("Expected error but got none: %v", err)
 			}
 			if test.status != statusActual {
 				t.Errorf("Expected status %t, but got %t", test.status, statusActual)
@@ -270,10 +270,10 @@ func TestUpdateKubeconfigIP(t *testing.T) {
 			configFilename := tempFile(t, test.existing)
 			statusActual, err := UpdateKubeconfigIP(test.ip, configFilename, "minikube")
 			if err != nil && !test.err {
-				t.Errorf("Got unexpected error: %s", err)
+				t.Errorf("Got unexpected error: %v", err)
 			}
 			if err == nil && test.err {
-				t.Errorf("Expected error but got none: %s", err)
+				t.Errorf("Expected error but got none: %v", err)
 			}
 			if test.status != statusActual {
 				t.Errorf("Expected status %t, but got %t", test.status, statusActual)
@@ -357,10 +357,10 @@ func TestGetIPFromKubeConfig(t *testing.T) {
 			configFilename := tempFile(t, test.cfg)
 			ip, err := getIPFromKubeConfig(configFilename, "minikube")
 			if err != nil && !test.err {
-				t.Errorf("Got unexpected error: %s", err)
+				t.Errorf("Got unexpected error: %v", err)
 			}
 			if err == nil && test.err {
-				t.Errorf("Expected error but got none: %s", err)
+				t.Errorf("Expected error but got none: %v", err)
 			}
 			if !ip.Equal(test.ip) {
 				t.Errorf("IP returned: %s does not match ip given: %s", ip, test.ip)

pkg/util/kubernetes.go

@@ -66,7 +66,7 @@ func GetClient() (kubernetes.Interface, error) {
 	kubeConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, configOverrides)
 	config, err := kubeConfig.ClientConfig()
 	if err != nil {
-		return nil, fmt.Errorf("Error creating kubeConfig: %s", err)
+		return nil, fmt.Errorf("Error creating kubeConfig: %v", err)
 	}
 	client, err := kubernetes.NewForConfig(config)
 	if err != nil {

pkg/util/utils.go

@@ -46,7 +46,7 @@ func (r RetriableError) Error() string { return "Temporary Error: " + r.Err.Erro
 func CalculateDiskSizeInMB(humanReadableDiskSize string) int {
 	diskSize, err := units.FromHumanSize(humanReadableDiskSize)
 	if err != nil {
-		glog.Errorf("Invalid disk size: %s", err)
+		glog.Errorf("Invalid disk size: %v", err)
 	}
 	return int(diskSize / units.MB)
 }

pkg/util/utils_test.go

@@ -130,12 +130,12 @@ func TestMultiError(t *testing.T) {
 	expected := `Error 1
 Error 2`
 	if err.Error() != expected {
-		t.Fatalf("%s != %s", err, expected)
+		t.Fatalf("%s != %s", err.Error(), expected)
 	}
 
 	m = MultiError{}
 	if err := m.ToError(); err != nil {
-		t.Fatalf("Unexpected error: %s", err)
+		t.Fatalf("Unexpected error: %v", err)
 	}
 }
 

test/integration/cluster_dns_test.go

@@ -48,7 +48,7 @@ func testClusterDNS(t *testing.T) {
 	// The query result is not as important as service reachability
 	out, err := kr.RunCommand([]string{"exec", busybox, "nslookup", "localhost"})
 	if err != nil {
-		t.Errorf("nslookup within busybox failed: %s", err)
+		t.Errorf("nslookup within busybox failed: %v", err)
 	}
 	clusterIP := []byte("10.96.0.1")
 	if !bytes.Contains(out, clusterIP) {
@@ -73,7 +73,7 @@ func busyBoxPod(t *testing.T, c kubernetes.Interface, kr *util.KubectlRunner) st
 	}
 	// TODO(tstromberg): Refactor WaitForBusyboxRunning to return name of pod.
 	if err := util.WaitForBusyboxRunning(t, "default"); err != nil {
-		t.Fatalf("Waiting for busybox pod to be up: %s", err)
+		t.Fatalf("Waiting for busybox pod to be up: %v", err)
 	}
 
 	pods, err := c.CoreV1().Pods("default").List(metav1.ListOptions{LabelSelector: "integration-test=busybox"})

test/integration/cluster_env_test.go

@@ -62,6 +62,6 @@ func testClusterEnv(t *testing.T) {
 		return nil
 	}
 	if err := util.Retry(t, dockerPs, 3*time.Second, 5); err != nil {
-		t.Fatalf("Error running command: %s. Error: %s Output: %s", "docker ps", err, output)
+		t.Fatalf("Error running command: %s. Error: %v Output: %s", "docker ps", err, output)
 	}
 }

test/integration/docker_test.go

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

test/integration/flags.go

@@ -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", "source of testdata relative to test/integration")
+var testdataDir = flag.String("testdata-dir", "testdata", "the directory relative to test/integration where the testdata lives")
 
 func NewMinikubeRunner(t *testing.T) util.MinikubeRunner {
 	return util.MinikubeRunner{

test/integration/iso_test.go

@@ -74,7 +74,7 @@ func testPackages(t *testing.T) {
 
 	for _, pkg := range packages {
 		if output, err := minikubeRunner.SSH(fmt.Sprintf("which %s", pkg)); err != nil {
-			t.Errorf("Error finding package: %s. Error: %s. Output: %s", pkg, err, output)
+			t.Errorf("Error finding package: %s. Error: %v. Output: %s", pkg, err, output)
 		}
 	}
 
@@ -94,7 +94,7 @@ func testPersistence(t *testing.T) {
 	} {
 		output, err := minikubeRunner.SSH(fmt.Sprintf("df %s | tail -n 1 | awk '{print $1}'", dir))
 		if err != nil {
-			t.Errorf("Error checking device for %s. Error: %s.", dir, err)
+			t.Errorf("Error checking device for %s. Error: %v", dir, err)
 		}
 		if !strings.Contains(output, "/dev/sda1") {
 			t.Errorf("Path %s is not mounted persistently. %s", dir, output)

test/integration/mount_test.go

@@ -65,7 +65,7 @@ func testMounting(t *testing.T) {
 		path := filepath.Join(tempDir, file)
 		err = ioutil.WriteFile(path, []byte(expected), 0644)
 		if err != nil {
-			t.Fatalf("Unexpected error while writing file %s: %s.", path, err)
+			t.Fatalf("Unexpected error while writing file %s: %v", path, err)
 		}
 	}
 
@@ -123,13 +123,13 @@ func testMounting(t *testing.T) {
 		// test that frompodremove can be deleted on the host
 		path = filepath.Join(tempDir, "frompodremove")
 		if err := os.Remove(path); err != nil {
-			t.Fatalf("Unexpected error removing file %s: %s", path, err)
+			t.Fatalf("Unexpected error removing file %s: %v", path, err)
 		}
 
 		return nil
 	}
 	if err := util.Retry(t, mountTest, 5*time.Second, 40); err != nil {
-		t.Fatal("mountTest failed with error:", err)
+		t.Fatalf("mountTest failed with error: %v", err)
 	}
 
 }

test/integration/pv_test.go

@@ -60,7 +60,7 @@ func testProvisioning(t *testing.T) {
 		if len(scl.Items) > 0 {
 			return nil
 		}
-		return fmt.Errorf("no StorageClass yet")
+		return fmt.Errorf("No default StorageClass yet.")
 	}
 
 	if err := util.Retry(t, checkStorageClass, 5*time.Second, 20); err != nil {
@@ -83,13 +83,13 @@ func testProvisioning(t *testing.T) {
 	}
 
 	if err := checkPodRunning(); err != nil {
-		t.Fatal("Check storage-provisioner pod running failed with error: ", err)
+		t.Fatalf("Check storage-provisioner pod running failed with error: %v", err)
 	}
 
 	// Now create the PVC
 	pvcPath := filepath.Join(*testdataDir, "pvc.yaml")
 	if _, err := kubectlRunner.RunCommand([]string{"create", "-f", pvcPath}); err != nil {
-		t.Fatalf("Error creating pvc")
+		t.Fatalf("Error creating pvc: %v", err)
 	}
 
 	// And check that it gets bound to a PV.
@@ -106,7 +106,7 @@ func testProvisioning(t *testing.T) {
 	}
 
 	if err := util.Retry(t, checkStorage, 2*time.Second, 5); err != nil {
-		t.Fatal("PV Creation failed with error:", err)
+		t.Fatalf("PV Creation failed with error: %v", err)
 	}
 
 }

test/integration/util/util.go

@@ -75,7 +75,7 @@ func (m *MinikubeRunner) RunCommand(command string, checkError bool) string {
 		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 %s. Output: %s", command, err, stdout)
+			m.T.Fatalf("Error running command: %s %v. Output: %s", command, err, stdout)
 		}
 	}
 	return string(stdout)
@@ -87,7 +87,7 @@ func (m *MinikubeRunner) RunDaemon(command string) (*exec.Cmd, *bufio.Reader) {
 	cmd := exec.Command(path, commandArr...)
 	stdoutPipe, err := cmd.StdoutPipe()
 	if err != nil {
-		m.T.Fatalf("stdout pipe failed: %v", err)
+		m.T.Fatalf("stdout pipe failed: %s %v", command, err)
 	}
 
 	err = cmd.Start()
@@ -183,7 +183,7 @@ func (k *KubectlRunner) RunCommand(args []string) (stdout []byte, err error) {
 		cmd := exec.Command(k.BinaryPath, args...)
 		stdout, err = cmd.CombinedOutput()
 		if err != nil {
-			k.T.Logf("Error %s running command %s. Return code: %s", stdout, args, err)
+			k.T.Logf("Error %s running command %s. Return code: %v", stdout, args, err)
 			return &commonutil.RetriableError{Err: fmt.Errorf("Error running command: %v. Output: %s", err, stdout)}
 		}
 		return nil