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

Update integration test: 

- skip, if sudo needs a password
- improve temp files processing
- do not preload
pull/9365/head
Ilya Zuyev 2020-10-12 20:27:49 -07:00
parent 08da82702d
commit 9b70ec8dda
4 changed files with 107 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
go.mod
View File

@ -4,6 +4,7 @@ go 1.13
require (
cloud.google.com/go/storage v1.8.0
github.com/Azure/azure-sdk-for-go v42.3.0+incompatible
github.com/Microsoft/go-winio v0.4.15-0.20190919025122-fc70bd9a86b5 // indirect
github.com/Parallels/docker-machine-parallels v1.3.0
github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d // indirect

1
go.sum
View File

@ -51,6 +51,7 @@ github.com/Azure/azure-sdk-for-go v29.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9mo
github.com/Azure/azure-sdk-for-go v30.1.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-sdk-for-go v35.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-sdk-for-go v38.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-sdk-for-go v42.3.0+incompatible h1:PAHkmPqd/vQV4LJcqzEUM1elCyTMWjbrO8oFMl0dvBE=
github.com/Azure/azure-sdk-for-go v42.3.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-service-bus-go v0.9.1/go.mod h1:yzBx6/BUGfjfeqbRZny9AQIbIe3AcV9WZbAdpkoXOa0=
github.com/Azure/azure-storage-blob-go v0.8.0/go.mod h1:lPI3aLPpuLTeUwh1sViKXFxwl2B6teiRqI0deQUvsw0=

16
pkg/minikube/driver/install.go
View File

@ -41,24 +41,16 @@ func InstallOrUpdate(name string, directory string, v semver.Version, interactiv
if name != KVM2 && name != HyperKit {
return nil
}
path, err := AssureDriverBinary(name, directory, v, autoUpdate)
if err != nil {
return err
}
return fixDriverPermissions(name, path, interactive)
}
// AssureDriverBinary does the same as InstallOrUpdate
// but doesn't set root permissions in case the driver is downloaded
func AssureDriverBinary(name string, directory string, v semver.Version, autoUpdate bool) (string, error) {
executable := fmt.Sprintf("docker-machine-driver-%s", name)
// Lock before we check for existence to avoid thundering herd issues
spec := lock.PathMutexSpec(executable)
spec.Timeout = 10 * time.Minute
glog.Infof("acquiring lock: %+v", spec)
releaser, err := mutex.Acquire(spec)
if err != nil {
return "", errors.Wrapf(err, "unable to acquire lock for %+v", spec)
return errors.Wrapf(err, "unable to acquire lock for %+v", spec)
}
defer releaser.Release()
@ -68,10 +60,10 @@ func AssureDriverBinary(name string, directory string, v semver.Version, autoUpd
glog.Warningf("%s: %v", executable, err)
path = filepath.Join(directory, executable)
if err := download.Driver(executable, path, v); err != nil {
return "", err
return err
}
}
return path, nil
return fixDriverPermissions(name, path, interactive)
}
// fixDriverPermissions fixes the permissions on a driver

157
test/integration/driver_install_or_update_test.go
View File

@ -25,6 +25,7 @@ import (
"runtime"
"testing"
"github.com/Azure/azure-sdk-for-go/tools/apidiff/ioext"
"github.com/blang/semver"
"k8s.io/minikube/pkg/minikube/driver"
@ -159,7 +160,7 @@ func TestHyperKitDriverInstallOrUpdate(t *testing.T) {
t.Fatalf("Expected new semver. test: %v, got: %v", tc.name, err)
}
if err := exec.Command("sudo", "-n", "ls").Run(); err != nil {
if sudoNeedsPassword() {
t.Skipf("password required to execute 'ls', skipping remaining test: %v", err)
}
@ -179,80 +180,124 @@ func TestHyperKitDriverSkipUpgrade(t *testing.T) {
if runtime.GOOS != "darwin" {
t.Skip("Skip if not darwin.")
}
if sudoNeedsPassword() {
t.Skipf(
"password required to execute 'ls', skipping remaining test")
}
MaybeParallel(t)
tests := []struct {
name string
path string
downloadExpected bool
name string
path string
expectedVersion string
}{
{
name: "upgrade-v1.11.0-to-current",
path: filepath.Join(*testdataDir, "hyperkit-driver-version-1.11.0"),
downloadExpected: false,
name: "upgrade-v1.11.0-to-current",
path: filepath.Join(*testdataDir, "hyperkit-driver-version-1.11.0"),
expectedVersion: "v1.11.0",
},
{
name: "upgrade-v1.2.0-to-current",
path: filepath.Join(*testdataDir, "hyperkit-driver-older-version"),
downloadExpected: true,
name: "upgrade-v1.2.0-to-current",
path: filepath.Join(*testdataDir, "hyperkit-driver-older-version"),
expectedVersion: version.GetVersion(),
},
}
sudoPath, err := exec.LookPath("sudo")
if err != nil {
t.Fatalf("No sudo in path: %v", err)
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
originalPath := os.Getenv("PATH")
// setup temp .minikube
mkDir, drvPath, err := tempMinikubeDir(tc.name, tc.path)
if err != nil {
t.Fatalf("Failed to prepare tempdir. test: %s, got: %v", tc.name, err)
}
defer func() {
if err := os.Setenv("PATH", originalPath); err != nil {
t.Errorf("failed to restore PATH: %v", err)
if err := os.RemoveAll(mkDir); err != nil {
t.Errorf("Failed to remove mkDir %q: %v", mkDir, err)
}
}()
dir, err := ioutil.TempDir("", tc.name)
// start "minikube start --download-only --driver=hyperkit --preload=false"
cmd := exec.Command(Target(), "start", "--download-only", "--driver=hyperkit", "--preload=false")
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stdout
// set PATH=<tmp_minikube>/bin:<path_to_sudo>
// MINIKUBE_PATH=<tmp_minikube>
cmd.Env = append(os.Environ(),
fmt.Sprintf("PATH=%v%c%v", filepath.Dir(drvPath), filepath.ListSeparator, filepath.Dir(sudoPath)),
"MINIKUBE_HOME="+mkDir)
if err = cmd.Run(); err != nil {
t.Fatalf("failed to run minikube. got: %v", err)
}
upgradedVersion, err := driverVersion(drvPath)
if err != nil {
t.Fatalf("Expected to create tempdir. test: %s, got: %v", tc.name, err)
}
defer func() {
if err := os.RemoveAll(dir); err != nil {
t.Errorf("Failed to remove dir %q: %v", dir, err)
}
}()
pwd, err := os.Getwd()
if err != nil {
t.Fatalf("Error not expected when getting working directory. test: %s, got: %v", tc.name, err)
t.Fatalf("failed to check driver version. got: %v", err)
}
driverPath := filepath.Join(pwd, tc.path, "docker-machine-driver-hyperkit")
if _, err = os.Stat(driverPath); err != nil {
t.Fatalf("Expected driver to exist. test: %s, got: %v", tc.name, err)
}
// change permission to allow driver to be executable
if err = os.Chmod(driverPath, 0700); err != nil {
t.Fatalf("Expected not expected when changing driver permission. test: %s, got: %v", tc.name, err)
}
if err = os.Setenv("PATH", filepath.Dir(driverPath)); err != nil {
t.Fatalf("Unexpected error on SetEn, got: %v", err)
}
curVersion, err := version.GetSemverVersion()
if err != nil {
t.Fatalf("Expected new semver. test: %v, got: %v", tc.name, err)
}
if _, err = driver.AssureDriverBinary("hyperkit", dir, curVersion, true); err != nil {
t.Fatalf("Failed to update driver to %v. test: %s, got: %v", curVersion, tc.name, err)
}
_, err = os.Stat(filepath.Join(dir, "docker-machine-driver-hyperkit"))
if tc.downloadExpected {
if err != nil {
t.Fatalf("driver downlad expected. test: %s, got: %v", tc.name, err)
}
} else {
if err == nil {
t.Fatalf("driver downlad NOT expected. test: %s", tc.name)
}
if upgradedVersion != tc.expectedVersion {
t.Fatalf("invalid driver version. expected: %v, got: %v", tc.expectedVersion, upgradedVersion)
}
})
}
}
func sudoNeedsPassword() bool {
err := exec.Command("sudo", "-n", "ls").Run()
return err != nil
}
func driverVersion(path string) (string, error) {
output, err := exec.Command(path, "version").Output()
if err != nil {
return "", err
}
var resultVersion string
_, err = fmt.Sscanf(string(output), "version: %s\n", &resultVersion)
if err != nil {
return "", err
}
return resultVersion, nil
}
func tempMinikubeDir(name, driver string) (string, string, error) {
// setup temp .minikube
temp, err := ioutil.TempDir("", name)
if err != nil {
return "", "", fmt.Errorf("failed to create tempdir: %v", err)
}
mkDir := filepath.Join(temp, ".minikube")
mkBinDir := filepath.Join(mkDir, "bin")
err = os.MkdirAll(mkBinDir, 0777)
if err != nil {
return "", "", fmt.Errorf("failed to prepare tempdir: %v", err)
}
pwd, err := os.Getwd()
if err != nil {
return "", "", fmt.Errorf("failed to get working directory: %v", err)
}
testDataDriverPath := filepath.Join(pwd, driver, "docker-machine-driver-hyperkit")
if _, err = os.Stat(testDataDriverPath); err != nil {
return "", "", fmt.Errorf("expected driver to exist: %v", err)
}
// copy driver to temp bin
testDriverPath := filepath.Join(mkBinDir, "docker-machine-driver-hyperkit")
if err = ioext.CopyFile(testDataDriverPath, testDriverPath, false); err != nil {
return "", "", fmt.Errorf("failed to setup current hyperkit driver: %v", err)
}
// change permission to allow driver to be executable
if err = os.Chmod(testDriverPath, 0777); err != nil {
return "", "", fmt.Errorf("failed to set driver permission: %v", err)
}
return temp, testDriverPath, nil
}