vendor cleanup: remove unused,non-go and test files

vendor/k8s.io/kubernetes/pkg/util/mount/BUILD

@@ -1,160 +0,0 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "doc.go",
-        "exec.go",
-        "fake.go",
-        "mount.go",
-    ] + select({
-        "@io_bazel_rules_go//go/platform:android": [
-            "exec_mount_unsupported.go",
-            "mount_unsupported.go",
-            "nsenter_mount_unsupported.go",
-        ],
-        "@io_bazel_rules_go//go/platform:darwin": [
-            "exec_mount_unsupported.go",
-            "mount_unsupported.go",
-            "nsenter_mount_unsupported.go",
-        ],
-        "@io_bazel_rules_go//go/platform:dragonfly": [
-            "exec_mount_unsupported.go",
-            "mount_unsupported.go",
-            "nsenter_mount_unsupported.go",
-        ],
-        "@io_bazel_rules_go//go/platform:freebsd": [
-            "exec_mount_unsupported.go",
-            "mount_unsupported.go",
-            "nsenter_mount_unsupported.go",
-        ],
-        "@io_bazel_rules_go//go/platform:linux": [
-            "exec_mount.go",
-            "mount_linux.go",
-            "nsenter_mount.go",
-        ],
-        "@io_bazel_rules_go//go/platform:nacl": [
-            "exec_mount_unsupported.go",
-            "mount_unsupported.go",
-            "nsenter_mount_unsupported.go",
-        ],
-        "@io_bazel_rules_go//go/platform:netbsd": [
-            "exec_mount_unsupported.go",
-            "mount_unsupported.go",
-            "nsenter_mount_unsupported.go",
-        ],
-        "@io_bazel_rules_go//go/platform:openbsd": [
-            "exec_mount_unsupported.go",
-            "mount_unsupported.go",
-            "nsenter_mount_unsupported.go",
-        ],
-        "@io_bazel_rules_go//go/platform:plan9": [
-            "exec_mount_unsupported.go",
-            "mount_unsupported.go",
-            "nsenter_mount_unsupported.go",
-        ],
-        "@io_bazel_rules_go//go/platform:solaris": [
-            "exec_mount_unsupported.go",
-            "mount_unsupported.go",
-            "nsenter_mount_unsupported.go",
-        ],
-        "@io_bazel_rules_go//go/platform:windows": [
-            "exec_mount_unsupported.go",
-            "mount_windows.go",
-            "nsenter_mount_unsupported.go",
-        ],
-        "//conditions:default": [],
-    }),
-    importpath = "k8s.io/kubernetes/pkg/util/mount",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//vendor/github.com/golang/glog:go_default_library",
-        "//vendor/k8s.io/utils/exec:go_default_library",
-    ] + select({
-        "@io_bazel_rules_go//go/platform:android": [
-            "//pkg/util/nsenter:go_default_library",
-        ],
-        "@io_bazel_rules_go//go/platform:darwin": [
-            "//pkg/util/nsenter:go_default_library",
-        ],
-        "@io_bazel_rules_go//go/platform:dragonfly": [
-            "//pkg/util/nsenter:go_default_library",
-        ],
-        "@io_bazel_rules_go//go/platform:freebsd": [
-            "//pkg/util/nsenter:go_default_library",
-        ],
-        "@io_bazel_rules_go//go/platform:linux": [
-            "//pkg/util/file:go_default_library",
-            "//pkg/util/io:go_default_library",
-            "//pkg/util/nsenter:go_default_library",
-            "//vendor/golang.org/x/sys/unix:go_default_library",
-            "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
-        ],
-        "@io_bazel_rules_go//go/platform:nacl": [
-            "//pkg/util/nsenter:go_default_library",
-        ],
-        "@io_bazel_rules_go//go/platform:netbsd": [
-            "//pkg/util/nsenter:go_default_library",
-        ],
-        "@io_bazel_rules_go//go/platform:openbsd": [
-            "//pkg/util/nsenter:go_default_library",
-        ],
-        "@io_bazel_rules_go//go/platform:plan9": [
-            "//pkg/util/nsenter:go_default_library",
-        ],
-        "@io_bazel_rules_go//go/platform:solaris": [
-            "//pkg/util/nsenter:go_default_library",
-        ],
-        "@io_bazel_rules_go//go/platform:windows": [
-            "//pkg/util/file:go_default_library",
-            "//pkg/util/nsenter:go_default_library",
-        ],
-        "//conditions:default": [],
-    }),
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "safe_format_and_mount_test.go",
-    ] + select({
-        "@io_bazel_rules_go//go/platform:linux": [
-            "exec_mount_test.go",
-            "mount_linux_test.go",
-            "nsenter_mount_test.go",
-        ],
-        "@io_bazel_rules_go//go/platform:windows": [
-            "mount_windows_test.go",
-        ],
-        "//conditions:default": [],
-    }),
-    embed = [":go_default_library"],
-    deps = [
-        "//vendor/k8s.io/utils/exec/testing:go_default_library",
-    ] + select({
-        "@io_bazel_rules_go//go/platform:linux": [
-            "//pkg/util/nsenter:go_default_library",
-            "//vendor/github.com/golang/glog:go_default_library",
-            "//vendor/golang.org/x/sys/unix:go_default_library",
-            "//vendor/k8s.io/utils/exec:go_default_library",
-        ],
-        "@io_bazel_rules_go//go/platform:windows": [
-            "//vendor/github.com/stretchr/testify/assert:go_default_library",
-        ],
-        "//conditions:default": [],
-    }),
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-    visibility = ["//visibility:public"],
-)

vendor/k8s.io/kubernetes/pkg/util/mount/OWNERS

@@ -1,11 +0,0 @@
-reviewers:
-  - jingxu97
-  - saad-ali
-  - jsafrane
-  - msau42
-  - andyzhangx
-approvers:
-  - jingxu97
-  - saad-ali
-  - jsafrane
-

vendor/k8s.io/kubernetes/pkg/util/mount/exec_mount_test.go

@@ -1,182 +0,0 @@
-// +build linux
-
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package mount
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-var (
-	sourcePath      = "/mnt/srv"
-	destinationPath = "/mnt/dst"
-	fsType          = "xfs"
-	mountOptions    = []string{"vers=1", "foo=bar"}
-)
-
-func TestMount(t *testing.T) {
-	exec := NewFakeExec(func(cmd string, args ...string) ([]byte, error) {
-		if cmd != "mount" {
-			t.Errorf("expected mount command, got %q", cmd)
-		}
-		// mount -t fstype -o options source target
-		expectedArgs := []string{"-t", fsType, "-o", strings.Join(mountOptions, ","), sourcePath, destinationPath}
-		if !reflect.DeepEqual(expectedArgs, args) {
-			t.Errorf("expected arguments %q, got %q", strings.Join(expectedArgs, " "), strings.Join(args, " "))
-		}
-		return nil, nil
-	})
-
-	wrappedMounter := &fakeMounter{t}
-	mounter := NewExecMounter(exec, wrappedMounter)
-
-	mounter.Mount(sourcePath, destinationPath, fsType, mountOptions)
-}
-
-func TestBindMount(t *testing.T) {
-	cmdCount := 0
-	exec := NewFakeExec(func(cmd string, args ...string) ([]byte, error) {
-		cmdCount++
-		if cmd != "mount" {
-			t.Errorf("expected mount command, got %q", cmd)
-		}
-		var expectedArgs []string
-		switch cmdCount {
-		case 1:
-			// mount -t fstype -o "bind" source target
-			expectedArgs = []string{"-t", fsType, "-o", "bind", sourcePath, destinationPath}
-		case 2:
-			// mount -t fstype -o "remount,opts" source target
-			expectedArgs = []string{"-t", fsType, "-o", "bind,remount," + strings.Join(mountOptions, ","), sourcePath, destinationPath}
-		}
-		if !reflect.DeepEqual(expectedArgs, args) {
-			t.Errorf("expected arguments %q, got %q", strings.Join(expectedArgs, " "), strings.Join(args, " "))
-		}
-		return nil, nil
-	})
-
-	wrappedMounter := &fakeMounter{t}
-	mounter := NewExecMounter(exec, wrappedMounter)
-	bindOptions := append(mountOptions, "bind")
-	mounter.Mount(sourcePath, destinationPath, fsType, bindOptions)
-}
-
-func TestUnmount(t *testing.T) {
-	exec := NewFakeExec(func(cmd string, args ...string) ([]byte, error) {
-		if cmd != "umount" {
-			t.Errorf("expected unmount command, got %q", cmd)
-		}
-		// unmount $target
-		expectedArgs := []string{destinationPath}
-		if !reflect.DeepEqual(expectedArgs, args) {
-			t.Errorf("expected arguments %q, got %q", strings.Join(expectedArgs, " "), strings.Join(args, " "))
-		}
-		return nil, nil
-	})
-
-	wrappedMounter := &fakeMounter{t}
-	mounter := NewExecMounter(exec, wrappedMounter)
-
-	mounter.Unmount(destinationPath)
-}
-
-/* Fake wrapped mounter */
-type fakeMounter struct {
-	t *testing.T
-}
-
-func (fm *fakeMounter) Mount(source string, target string, fstype string, options []string) error {
-	// Mount() of wrapped mounter should never be called. We call exec instead.
-	fm.t.Errorf("Unexpected wrapped mount call")
-	return fmt.Errorf("Unexpected wrapped mount call")
-}
-
-func (fm *fakeMounter) Unmount(target string) error {
-	// umount() of wrapped mounter should never be called. We call exec instead.
-	fm.t.Errorf("Unexpected wrapped mount call")
-	return fmt.Errorf("Unexpected wrapped mount call")
-}
-
-func (fm *fakeMounter) List() ([]MountPoint, error) {
-	return nil, nil
-}
-func (fm *fakeMounter) IsMountPointMatch(mp MountPoint, dir string) bool {
-	return false
-}
-func (fm *fakeMounter) IsNotMountPoint(file string) (bool, error) {
-	return false, nil
-}
-func (fm *fakeMounter) IsLikelyNotMountPoint(file string) (bool, error) {
-	return false, nil
-}
-func (fm *fakeMounter) DeviceOpened(pathname string) (bool, error) {
-	return false, nil
-}
-func (fm *fakeMounter) PathIsDevice(pathname string) (bool, error) {
-	return false, nil
-}
-func (fm *fakeMounter) GetDeviceNameFromMount(mountPath, pluginDir string) (string, error) {
-	return "", nil
-}
-func (fm *fakeMounter) MakeRShared(path string) error {
-	return nil
-}
-func (fm *fakeMounter) MakeFile(pathname string) error {
-	return nil
-}
-func (fm *fakeMounter) MakeDir(pathname string) error {
-	return nil
-}
-func (fm *fakeMounter) ExistsPath(pathname string) (bool, error) {
-	return false, errors.New("not implemented")
-}
-func (fm *fakeMounter) GetFileType(pathname string) (FileType, error) {
-	return FileTypeFile, nil
-}
-func (fm *fakeMounter) PrepareSafeSubpath(subPath Subpath) (newHostPath string, cleanupAction func(), err error) {
-	return subPath.Path, nil, nil
-}
-
-func (fm *fakeMounter) CleanSubPaths(podDir string, volumeName string) error {
-	return nil
-}
-
-func (fm *fakeMounter) SafeMakeDir(pathname string, base string, perm os.FileMode) error {
-	return nil
-}
-
-func (fm *fakeMounter) GetMountRefs(pathname string) ([]string, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (fm *fakeMounter) GetFSGroup(pathname string) (int64, error) {
-	return -1, errors.New("not implemented")
-}
-
-func (fm *fakeMounter) GetSELinuxSupport(pathname string) (bool, error) {
-	return false, errors.New("not implemented")
-}
-
-func (fm *fakeMounter) GetMode(pathname string) (os.FileMode, error) {
-	return 0, errors.New("not implemented")
-}

vendor/k8s.io/kubernetes/pkg/util/mount/mount_windows_test.go

@@ -1,795 +0,0 @@
-// +build windows
-
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package mount
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNormalizeWindowsPath(t *testing.T) {
-	path := `/var/lib/kubelet/pods/146f8428-83e7-11e7-8dd4-000d3a31dac4/volumes/kubernetes.io~azure-disk`
-	normalizedPath := normalizeWindowsPath(path)
-	if normalizedPath != `c:\var\lib\kubelet\pods\146f8428-83e7-11e7-8dd4-000d3a31dac4\volumes\kubernetes.io~azure-disk` {
-		t.Errorf("normizeWindowsPath test failed, normalizedPath : %q", normalizedPath)
-	}
-
-	path = `/var/lib/kubelet/pods/146f8428-83e7-11e7-8dd4-000d3a31dac4\volumes\kubernetes.io~azure-disk`
-	normalizedPath = normalizeWindowsPath(path)
-	if normalizedPath != `c:\var\lib\kubelet\pods\146f8428-83e7-11e7-8dd4-000d3a31dac4\volumes\kubernetes.io~azure-disk` {
-		t.Errorf("normizeWindowsPath test failed, normalizedPath : %q", normalizedPath)
-	}
-
-	path = `/`
-	normalizedPath = normalizeWindowsPath(path)
-	if normalizedPath != `c:\` {
-		t.Errorf("normizeWindowsPath test failed, normalizedPath : %q", normalizedPath)
-	}
-}
-
-func TestValidateDiskNumber(t *testing.T) {
-	diskNum := "0"
-	if err := ValidateDiskNumber(diskNum); err != nil {
-		t.Errorf("TestValidateDiskNumber test failed, disk number : %s", diskNum)
-	}
-
-	diskNum = "99"
-	if err := ValidateDiskNumber(diskNum); err != nil {
-		t.Errorf("TestValidateDiskNumber test failed, disk number : %s", diskNum)
-	}
-
-	diskNum = "ab"
-	if err := ValidateDiskNumber(diskNum); err == nil {
-		t.Errorf("TestValidateDiskNumber test failed, disk number : %s", diskNum)
-	}
-
-	diskNum = "100"
-	if err := ValidateDiskNumber(diskNum); err == nil {
-		t.Errorf("TestValidateDiskNumber test failed, disk number : %s", diskNum)
-	}
-}
-
-func makeLink(link, target string) error {
-	if output, err := exec.Command("cmd", "/c", "mklink", "/D", link, target).CombinedOutput(); err != nil {
-		return fmt.Errorf("mklink failed: %v, link(%q) target(%q) output: %q", err, link, target, string(output))
-	}
-	return nil
-}
-
-func removeLink(link string) error {
-	if output, err := exec.Command("cmd", "/c", "rmdir", link).CombinedOutput(); err != nil {
-		return fmt.Errorf("rmdir failed: %v, output: %q", err, string(output))
-	}
-	return nil
-}
-
-func setEquivalent(set1, set2 []string) bool {
-	map1 := make(map[string]bool)
-	map2 := make(map[string]bool)
-	for _, s := range set1 {
-		map1[s] = true
-	}
-	for _, s := range set2 {
-		map2[s] = true
-	}
-
-	for s := range map1 {
-		if !map2[s] {
-			return false
-		}
-	}
-	for s := range map2 {
-		if !map1[s] {
-			return false
-		}
-	}
-	return true
-}
-
-// this func must run in admin mode, otherwise it will fail
-func TestGetMountRefs(t *testing.T) {
-	fm := &FakeMounter{MountPoints: []MountPoint{}}
-	mountPath := `c:\secondmountpath`
-	expectedRefs := []string{`c:\`, `c:\firstmountpath`, mountPath}
-
-	// remove symbolic links first
-	for i := 1; i < len(expectedRefs); i++ {
-		removeLink(expectedRefs[i])
-	}
-
-	// create symbolic links
-	for i := 1; i < len(expectedRefs); i++ {
-		if err := makeLink(expectedRefs[i], expectedRefs[i-1]); err != nil {
-			t.Errorf("makeLink failed: %v", err)
-		}
-	}
-
-	if refs, err := GetMountRefs(fm, mountPath); err != nil || !setEquivalent(expectedRefs, refs) {
-		t.Errorf("getMountRefs(%q) = %v, error: %v; expected %v", mountPath, refs, err, expectedRefs)
-	}
-
-	// remove symbolic links
-	for i := 1; i < len(expectedRefs); i++ {
-		if err := removeLink(expectedRefs[i]); err != nil {
-			t.Errorf("removeLink failed: %v", err)
-		}
-	}
-}
-
-func TestDoSafeMakeDir(t *testing.T) {
-	base, err := ioutil.TempDir("", "TestDoSafeMakeDir")
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-
-	defer os.RemoveAll(base)
-
-	testingVolumePath := filepath.Join(base, "testingVolumePath")
-	os.MkdirAll(testingVolumePath, 0755)
-	defer os.RemoveAll(testingVolumePath)
-
-	tests := []struct {
-		volumePath    string
-		subPath       string
-		expectError   bool
-		symlinkTarget string
-	}{
-		{
-			volumePath:    testingVolumePath,
-			subPath:       ``,
-			expectError:   true,
-			symlinkTarget: "",
-		},
-		{
-			volumePath:    testingVolumePath,
-			subPath:       filepath.Join(testingVolumePath, `x`),
-			expectError:   false,
-			symlinkTarget: "",
-		},
-		{
-			volumePath:    testingVolumePath,
-			subPath:       filepath.Join(testingVolumePath, `a\b\c\d`),
-			expectError:   false,
-			symlinkTarget: "",
-		},
-		{
-			volumePath:    testingVolumePath,
-			subPath:       filepath.Join(testingVolumePath, `symlink`),
-			expectError:   false,
-			symlinkTarget: base,
-		},
-		{
-			volumePath:    testingVolumePath,
-			subPath:       filepath.Join(testingVolumePath, `symlink\c\d`),
-			expectError:   true,
-			symlinkTarget: "",
-		},
-		{
-			volumePath:    testingVolumePath,
-			subPath:       filepath.Join(testingVolumePath, `symlink\y926`),
-			expectError:   true,
-			symlinkTarget: "",
-		},
-		{
-			volumePath:    testingVolumePath,
-			subPath:       filepath.Join(testingVolumePath, `a\b\symlink`),
-			expectError:   false,
-			symlinkTarget: base,
-		},
-		{
-			volumePath:    testingVolumePath,
-			subPath:       filepath.Join(testingVolumePath, `a\x\symlink`),
-			expectError:   false,
-			symlinkTarget: filepath.Join(testingVolumePath, `a`),
-		},
-	}
-
-	for _, test := range tests {
-		if len(test.volumePath) > 0 && len(test.subPath) > 0 && len(test.symlinkTarget) > 0 {
-			// make all parent sub directories
-			if parent := filepath.Dir(test.subPath); parent != "." {
-				os.MkdirAll(parent, 0755)
-			}
-
-			// make last element as symlink
-			linkPath := test.subPath
-			if _, err := os.Stat(linkPath); err != nil && os.IsNotExist(err) {
-				if err := makeLink(linkPath, test.symlinkTarget); err != nil {
-					t.Fatalf("unexpected error: %v", fmt.Errorf("mklink link(%q) target(%q) error: %q", linkPath, test.symlinkTarget, err))
-				}
-			}
-		}
-
-		err := doSafeMakeDir(test.subPath, test.volumePath, os.FileMode(0755))
-		if test.expectError {
-			assert.NotNil(t, err, "Expect error during doSafeMakeDir(%s, %s)", test.subPath, test.volumePath)
-			continue
-		}
-		assert.Nil(t, err, "Expect no error during doSafeMakeDir(%s, %s)", test.subPath, test.volumePath)
-		if _, err := os.Stat(test.subPath); os.IsNotExist(err) {
-			t.Errorf("subPath should exists after doSafeMakeDir(%s, %s)", test.subPath, test.volumePath)
-		}
-	}
-}
-
-func TestLockAndCheckSubPath(t *testing.T) {
-	base, err := ioutil.TempDir("", "TestLockAndCheckSubPath")
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-
-	defer os.RemoveAll(base)
-
-	testingVolumePath := filepath.Join(base, "testingVolumePath")
-
-	tests := []struct {
-		volumePath          string
-		subPath             string
-		expectedHandleCount int
-		expectError         bool
-		symlinkTarget       string
-	}{
-		{
-			volumePath:          `c:\`,
-			subPath:             ``,
-			expectedHandleCount: 0,
-			expectError:         false,
-			symlinkTarget:       "",
-		},
-		{
-			volumePath:          ``,
-			subPath:             `a`,
-			expectedHandleCount: 0,
-			expectError:         false,
-			symlinkTarget:       "",
-		},
-		{
-			volumePath:          testingVolumePath,
-			subPath:             filepath.Join(testingVolumePath, `a`),
-			expectedHandleCount: 1,
-			expectError:         false,
-			symlinkTarget:       "",
-		},
-		{
-			volumePath:          testingVolumePath,
-			subPath:             filepath.Join(testingVolumePath, `a\b\c\d`),
-			expectedHandleCount: 4,
-			expectError:         false,
-			symlinkTarget:       "",
-		},
-		{
-			volumePath:          testingVolumePath,
-			subPath:             filepath.Join(testingVolumePath, `symlink`),
-			expectedHandleCount: 0,
-			expectError:         true,
-			symlinkTarget:       base,
-		},
-		{
-			volumePath:          testingVolumePath,
-			subPath:             filepath.Join(testingVolumePath, `a\b\c\symlink`),
-			expectedHandleCount: 0,
-			expectError:         true,
-			symlinkTarget:       base,
-		},
-		{
-			volumePath:          testingVolumePath,
-			subPath:             filepath.Join(testingVolumePath, `a\b\c\d\symlink`),
-			expectedHandleCount: 2,
-			expectError:         false,
-			symlinkTarget:       filepath.Join(testingVolumePath, `a\b`),
-		},
-	}
-
-	for _, test := range tests {
-		if len(test.volumePath) > 0 && len(test.subPath) > 0 {
-			os.MkdirAll(test.volumePath, 0755)
-			if len(test.symlinkTarget) == 0 {
-				// make all intermediate sub directories
-				os.MkdirAll(test.subPath, 0755)
-			} else {
-				// make all parent sub directories
-				if parent := filepath.Dir(test.subPath); parent != "." {
-					os.MkdirAll(parent, 0755)
-				}
-
-				// make last element as symlink
-				linkPath := test.subPath
-				if _, err := os.Stat(linkPath); err != nil && os.IsNotExist(err) {
-					if err := makeLink(linkPath, test.symlinkTarget); err != nil {
-						t.Fatalf("unexpected error: %v", fmt.Errorf("mklink link(%q) target(%q) error: %q", linkPath, test.symlinkTarget, err))
-					}
-				}
-			}
-		}
-
-		fileHandles, err := lockAndCheckSubPath(test.volumePath, test.subPath)
-		unlockPath(fileHandles)
-		assert.Equal(t, test.expectedHandleCount, len(fileHandles))
-		if test.expectError {
-			assert.NotNil(t, err, "Expect error during LockAndCheckSubPath(%s, %s)", test.volumePath, test.subPath)
-			continue
-		}
-		assert.Nil(t, err, "Expect no error during LockAndCheckSubPath(%s, %s)", test.volumePath, test.subPath)
-	}
-
-	// remove dir will happen after closing all file handles
-	assert.Nil(t, os.RemoveAll(testingVolumePath), "Expect no error during remove dir %s", testingVolumePath)
-}
-
-func TestLockAndCheckSubPathWithoutSymlink(t *testing.T) {
-	base, err := ioutil.TempDir("", "TestLockAndCheckSubPathWithoutSymlink")
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-
-	defer os.RemoveAll(base)
-
-	testingVolumePath := filepath.Join(base, "testingVolumePath")
-
-	tests := []struct {
-		volumePath          string
-		subPath             string
-		expectedHandleCount int
-		expectError         bool
-		symlinkTarget       string
-	}{
-		{
-			volumePath:          `c:\`,
-			subPath:             ``,
-			expectedHandleCount: 0,
-			expectError:         false,
-			symlinkTarget:       "",
-		},
-		{
-			volumePath:          ``,
-			subPath:             `a`,
-			expectedHandleCount: 0,
-			expectError:         false,
-			symlinkTarget:       "",
-		},
-		{
-			volumePath:          testingVolumePath,
-			subPath:             filepath.Join(testingVolumePath, `a`),
-			expectedHandleCount: 1,
-			expectError:         false,
-			symlinkTarget:       "",
-		},
-		{
-			volumePath:          testingVolumePath,
-			subPath:             filepath.Join(testingVolumePath, `a\b\c\d`),
-			expectedHandleCount: 4,
-			expectError:         false,
-			symlinkTarget:       "",
-		},
-		{
-			volumePath:          testingVolumePath,
-			subPath:             filepath.Join(testingVolumePath, `symlink`),
-			expectedHandleCount: 1,
-			expectError:         true,
-			symlinkTarget:       base,
-		},
-		{
-			volumePath:          testingVolumePath,
-			subPath:             filepath.Join(testingVolumePath, `a\b\c\symlink`),
-			expectedHandleCount: 4,
-			expectError:         true,
-			symlinkTarget:       base,
-		},
-		{
-			volumePath:          testingVolumePath,
-			subPath:             filepath.Join(testingVolumePath, `a\b\c\d\symlink`),
-			expectedHandleCount: 5,
-			expectError:         true,
-			symlinkTarget:       filepath.Join(testingVolumePath, `a\b`),
-		},
-	}
-
-	for _, test := range tests {
-		if len(test.volumePath) > 0 && len(test.subPath) > 0 {
-			os.MkdirAll(test.volumePath, 0755)
-			if len(test.symlinkTarget) == 0 {
-				// make all intermediate sub directories
-				os.MkdirAll(test.subPath, 0755)
-			} else {
-				// make all parent sub directories
-				if parent := filepath.Dir(test.subPath); parent != "." {
-					os.MkdirAll(parent, 0755)
-				}
-
-				// make last element as symlink
-				linkPath := test.subPath
-				if _, err := os.Stat(linkPath); err != nil && os.IsNotExist(err) {
-					if err := makeLink(linkPath, test.symlinkTarget); err != nil {
-						t.Fatalf("unexpected error: %v", fmt.Errorf("mklink link(%q) target(%q) error: %q", linkPath, test.symlinkTarget, err))
-					}
-				}
-			}
-		}
-
-		fileHandles, err := lockAndCheckSubPathWithoutSymlink(test.volumePath, test.subPath)
-		unlockPath(fileHandles)
-		assert.Equal(t, test.expectedHandleCount, len(fileHandles))
-		if test.expectError {
-			assert.NotNil(t, err, "Expect error during LockAndCheckSubPath(%s, %s)", test.volumePath, test.subPath)
-			continue
-		}
-		assert.Nil(t, err, "Expect no error during LockAndCheckSubPath(%s, %s)", test.volumePath, test.subPath)
-	}
-
-	// remove dir will happen after closing all file handles
-	assert.Nil(t, os.RemoveAll(testingVolumePath), "Expect no error during remove dir %s", testingVolumePath)
-}
-
-func TestFindExistingPrefix(t *testing.T) {
-	base, err := ioutil.TempDir("", "TestFindExistingPrefix")
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-
-	defer os.RemoveAll(base)
-
-	testingVolumePath := filepath.Join(base, "testingVolumePath")
-
-	tests := []struct {
-		base                    string
-		pathname                string
-		expectError             bool
-		expectedExistingPath    string
-		expectedToCreateDirs    []string
-		createSubPathBeforeTest bool
-	}{
-		{
-			base:                    `c:\tmp\a`,
-			pathname:                `c:\tmp\b`,
-			expectError:             true,
-			expectedExistingPath:    "",
-			expectedToCreateDirs:    []string{},
-			createSubPathBeforeTest: false,
-		},
-		{
-			base:                    ``,
-			pathname:                `c:\tmp\b`,
-			expectError:             true,
-			expectedExistingPath:    "",
-			expectedToCreateDirs:    []string{},
-			createSubPathBeforeTest: false,
-		},
-		{
-			base:                    `c:\tmp\a`,
-			pathname:                `d:\tmp\b`,
-			expectError:             true,
-			expectedExistingPath:    "",
-			expectedToCreateDirs:    []string{},
-			createSubPathBeforeTest: false,
-		},
-		{
-			base:                    testingVolumePath,
-			pathname:                testingVolumePath,
-			expectError:             false,
-			expectedExistingPath:    testingVolumePath,
-			expectedToCreateDirs:    []string{},
-			createSubPathBeforeTest: false,
-		},
-		{
-			base:                    testingVolumePath,
-			pathname:                filepath.Join(testingVolumePath, `a\b`),
-			expectError:             false,
-			expectedExistingPath:    filepath.Join(testingVolumePath, `a\b`),
-			expectedToCreateDirs:    []string{},
-			createSubPathBeforeTest: true,
-		},
-		{
-			base:                    testingVolumePath,
-			pathname:                filepath.Join(testingVolumePath, `a\b\c\`),
-			expectError:             false,
-			expectedExistingPath:    filepath.Join(testingVolumePath, `a\b`),
-			expectedToCreateDirs:    []string{`c`},
-			createSubPathBeforeTest: false,
-		},
-		{
-			base:                    testingVolumePath,
-			pathname:                filepath.Join(testingVolumePath, `a\b\c\d`),
-			expectError:             false,
-			expectedExistingPath:    filepath.Join(testingVolumePath, `a\b`),
-			expectedToCreateDirs:    []string{`c`, `d`},
-			createSubPathBeforeTest: false,
-		},
-	}
-
-	for _, test := range tests {
-		if test.createSubPathBeforeTest {
-			os.MkdirAll(test.pathname, 0755)
-		}
-
-		existingPath, toCreate, err := findExistingPrefix(test.base, test.pathname)
-		if test.expectError {
-			assert.NotNil(t, err, "Expect error during findExistingPrefix(%s, %s)", test.base, test.pathname)
-			continue
-		}
-		assert.Nil(t, err, "Expect no error during findExistingPrefix(%s, %s)", test.base, test.pathname)
-
-		assert.Equal(t, test.expectedExistingPath, existingPath, "Expect result not equal with findExistingPrefix(%s, %s) return: %q, expected: %q",
-			test.base, test.pathname, existingPath, test.expectedExistingPath)
-
-		assert.Equal(t, test.expectedToCreateDirs, toCreate, "Expect result not equal with findExistingPrefix(%s, %s) return: %q, expected: %q",
-			test.base, test.pathname, toCreate, test.expectedToCreateDirs)
-
-	}
-	// remove dir will happen after closing all file handles
-	assert.Nil(t, os.RemoveAll(testingVolumePath), "Expect no error during remove dir %s", testingVolumePath)
-}
-
-func TestPathWithinBase(t *testing.T) {
-	tests := []struct {
-		fullPath       string
-		basePath       string
-		expectedResult bool
-	}{
-		{
-			fullPath:       `c:\tmp\a\b\c`,
-			basePath:       `c:\tmp`,
-			expectedResult: true,
-		},
-		{
-			fullPath:       `c:\tmp1`,
-			basePath:       `c:\tmp2`,
-			expectedResult: false,
-		},
-		{
-			fullPath:       `c:\tmp`,
-			basePath:       `c:\tmp`,
-			expectedResult: true,
-		},
-		{
-			fullPath:       `c:\tmp`,
-			basePath:       `c:\tmp\a\b\c`,
-			expectedResult: false,
-		},
-		{
-			fullPath:       `c:\kubelet\pods\uuid\volumes\kubernetes.io~configmap\config\..timestamp\file.txt`,
-			basePath:       `c:\kubelet\pods\uuid\volumes\kubernetes.io~configmap\config`,
-			expectedResult: true,
-		},
-	}
-
-	for _, test := range tests {
-		result := pathWithinBase(test.fullPath, test.basePath)
-		assert.Equal(t, result, test.expectedResult, "Expect result not equal with pathWithinBase(%s, %s) return: %q, expected: %q",
-			test.fullPath, test.basePath, result, test.expectedResult)
-	}
-}
-
-func TestGetFileType(t *testing.T) {
-	mounter := New("fake/path")
-
-	testCase := []struct {
-		name         string
-		expectedType FileType
-		setUp        func() (string, string, error)
-	}{
-		{
-			"Directory Test",
-			FileTypeDirectory,
-			func() (string, string, error) {
-				tempDir, err := ioutil.TempDir("", "test-get-filetype-")
-				return tempDir, tempDir, err
-			},
-		},
-		{
-			"File Test",
-			FileTypeFile,
-			func() (string, string, error) {
-				tempFile, err := ioutil.TempFile("", "test-get-filetype")
-				if err != nil {
-					return "", "", err
-				}
-				tempFile.Close()
-				return tempFile.Name(), tempFile.Name(), nil
-			},
-		},
-	}
-
-	for idx, tc := range testCase {
-		path, cleanUpPath, err := tc.setUp()
-		if err != nil {
-			t.Fatalf("[%d-%s] unexpected error : %v", idx, tc.name, err)
-		}
-		if len(cleanUpPath) > 0 {
-			defer os.RemoveAll(cleanUpPath)
-		}
-
-		fileType, err := mounter.GetFileType(path)
-		if err != nil {
-			t.Fatalf("[%d-%s] unexpected error : %v", idx, tc.name, err)
-		}
-		if fileType != tc.expectedType {
-			t.Fatalf("[%d-%s] expected %s, but got %s", idx, tc.name, tc.expectedType, fileType)
-		}
-	}
-}
-
-func TestIsLikelyNotMountPoint(t *testing.T) {
-	mounter := Mounter{"fake/path"}
-
-	tests := []struct {
-		fileName       string
-		targetLinkName string
-		setUp          func(base, fileName, targetLinkName string) error
-		expectedResult bool
-		expectError    bool
-	}{
-		{
-			"Dir",
-			"",
-			func(base, fileName, targetLinkName string) error {
-				return os.Mkdir(filepath.Join(base, fileName), 0750)
-			},
-			true,
-			false,
-		},
-		{
-			"InvalidDir",
-			"",
-			func(base, fileName, targetLinkName string) error {
-				return nil
-			},
-			true,
-			true,
-		},
-		{
-			"ValidSymLink",
-			"targetSymLink",
-			func(base, fileName, targetLinkName string) error {
-				targeLinkPath := filepath.Join(base, targetLinkName)
-				if err := os.Mkdir(targeLinkPath, 0750); err != nil {
-					return err
-				}
-
-				filePath := filepath.Join(base, fileName)
-				if err := makeLink(filePath, targeLinkPath); err != nil {
-					return err
-				}
-				return nil
-			},
-			false,
-			false,
-		},
-		{
-			"InvalidSymLink",
-			"targetSymLink2",
-			func(base, fileName, targetLinkName string) error {
-				targeLinkPath := filepath.Join(base, targetLinkName)
-				if err := os.Mkdir(targeLinkPath, 0750); err != nil {
-					return err
-				}
-
-				filePath := filepath.Join(base, fileName)
-				if err := makeLink(filePath, targeLinkPath); err != nil {
-					return err
-				}
-				return removeLink(targeLinkPath)
-			},
-			true,
-			false,
-		},
-	}
-
-	for _, test := range tests {
-		base, err := ioutil.TempDir("", test.fileName)
-		if err != nil {
-			t.Fatalf(err.Error())
-		}
-
-		defer os.RemoveAll(base)
-
-		if err := test.setUp(base, test.fileName, test.targetLinkName); err != nil {
-			t.Fatalf("unexpected error in setUp(%s, %s): %v", test.fileName, test.targetLinkName, err)
-		}
-
-		filePath := filepath.Join(base, test.fileName)
-		result, err := mounter.IsLikelyNotMountPoint(filePath)
-		assert.Equal(t, result, test.expectedResult, "Expect result not equal with IsLikelyNotMountPoint(%s) return: %q, expected: %q",
-			filePath, result, test.expectedResult)
-
-		if test.expectError {
-			assert.NotNil(t, err, "Expect error during IsLikelyNotMountPoint(%s)", filePath)
-		} else {
-			assert.Nil(t, err, "Expect error is nil during IsLikelyNotMountPoint(%s)", filePath)
-		}
-	}
-}
-
-func TestFormatAndMount(t *testing.T) {
-	fakeMounter := ErrorMounter{&FakeMounter{}, 0, nil}
-	execCallback := func(cmd string, args ...string) ([]byte, error) {
-		for j := range args {
-			if strings.Contains(args[j], "Get-Disk -Number") {
-				return []byte("0"), nil
-			}
-
-			if strings.Contains(args[j], "Get-Partition -DiskNumber") {
-				return []byte("0"), nil
-			}
-
-			if strings.Contains(args[j], "mklink") {
-				return nil, nil
-			}
-		}
-		return nil, fmt.Errorf("Unexpected cmd %s, args %v", cmd, args)
-	}
-	fakeExec := NewFakeExec(execCallback)
-
-	mounter := SafeFormatAndMount{
-		Interface: &fakeMounter,
-		Exec:      fakeExec,
-	}
-
-	tests := []struct {
-		device       string
-		target       string
-		fstype       string
-		mountOptions []string
-		expectError  bool
-	}{
-		{
-			"0",
-			"disk",
-			"NTFS",
-			[]string{},
-			false,
-		},
-		{
-			"0",
-			"disk",
-			"",
-			[]string{},
-			false,
-		},
-		{
-			"invalidDevice",
-			"disk",
-			"NTFS",
-			[]string{},
-			true,
-		},
-	}
-
-	for _, test := range tests {
-		base, err := ioutil.TempDir("", test.device)
-		if err != nil {
-			t.Fatalf(err.Error())
-		}
-		defer os.RemoveAll(base)
-
-		target := filepath.Join(base, test.target)
-		err = mounter.FormatAndMount(test.device, target, test.fstype, test.mountOptions)
-		if test.expectError {
-			assert.NotNil(t, err, "Expect error during FormatAndMount(%s, %s, %s, %v)", test.device, test.target, test.fstype, test.mountOptions)
-		} else {
-			assert.Nil(t, err, "Expect error is nil during FormatAndMount(%s, %s, %s, %v)", test.device, test.target, test.fstype, test.mountOptions)
-		}
-	}
-}

vendor/k8s.io/kubernetes/pkg/util/mount/nsenter_mount_test.go

@@ -1,709 +0,0 @@
-// +build linux
-
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package mount
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"golang.org/x/sys/unix"
-	"k8s.io/kubernetes/pkg/util/nsenter"
-)
-
-func TestParseFindMnt(t *testing.T) {
-	tests := []struct {
-		input       string
-		target      string
-		expectError bool
-	}{
-		{
-			// standard mount name, e.g. for AWS
-			"/var/lib/kubelet/plugins/kubernetes.io/aws-ebs/mounts/aws/us-east-1d/vol-020f82b0759f72389 ext4\n",
-			"/var/lib/kubelet/plugins/kubernetes.io/aws-ebs/mounts/aws/us-east-1d/vol-020f82b0759f72389",
-			false,
-		},
-		{
-			// mount name with space, e.g. vSphere
-			"/var/lib/kubelet/plugins/kubernetes.io/vsphere-volume/mounts/[datastore1] kubevols/kubernetes-dynamic-pvc-4aacaa9b-6ba5-11e7-8f64-0050569f1b82.vmdk ext2\n",
-			"/var/lib/kubelet/plugins/kubernetes.io/vsphere-volume/mounts/[datastore1] kubevols/kubernetes-dynamic-pvc-4aacaa9b-6ba5-11e7-8f64-0050569f1b82.vmdk",
-			false,
-		},
-		{
-			// hypotetic mount with several spaces
-			"/var/lib/kubelet/plugins/kubernetes.io/vsphere-volume/mounts/[ d a t a s t o r e 1 ] kubevols/kubernetes-dynamic-pvc-4aacaa9b-6ba5-11e7-8f64-0050569f1b82.vmdk ext2\n",
-			"/var/lib/kubelet/plugins/kubernetes.io/vsphere-volume/mounts/[ d a t a s t o r e 1 ] kubevols/kubernetes-dynamic-pvc-4aacaa9b-6ba5-11e7-8f64-0050569f1b82.vmdk",
-			false,
-		},
-		{
-			// invalid output - no filesystem type
-			"/var/lib/kubelet/plugins/kubernetes.io/vsphere-volume/mounts/blabla",
-			"",
-			true,
-		},
-	}
-
-	for i, test := range tests {
-		target, err := parseFindMnt(test.input)
-		if test.expectError && err == nil {
-			t.Errorf("test %d expected error, got nil", i)
-		}
-		if !test.expectError && err != nil {
-			t.Errorf("test %d returned error: %s", i, err)
-		}
-		if target != test.target {
-			t.Errorf("test %d expected %q, got %q", i, test.target, target)
-		}
-	}
-}
-
-func TestCheckDeviceInode(t *testing.T) {
-	testDir, err := ioutil.TempDir("", "nsenter-mounter-device-")
-	if err != nil {
-		t.Fatalf("Cannot create temporary directory: %s", err)
-	}
-	defer os.RemoveAll(testDir)
-
-	tests := []struct {
-		name        string
-		srcPath     string
-		dstPath     string
-		expectError string
-	}{
-		{
-			name:        "the same file",
-			srcPath:     filepath.Join(testDir, "1"),
-			dstPath:     filepath.Join(testDir, "1"),
-			expectError: "",
-		},
-		{
-			name:        "different file on the same FS",
-			srcPath:     filepath.Join(testDir, "2.1"),
-			dstPath:     filepath.Join(testDir, "2.2"),
-			expectError: "different inode",
-		},
-		{
-			name:    "different file on different device",
-			srcPath: filepath.Join(testDir, "3"),
-			// /proc is always on a different "device" than /tmp (or $TEMP)
-			dstPath:     "/proc/self/status",
-			expectError: "different device",
-		},
-	}
-
-	for _, test := range tests {
-		if err := ioutil.WriteFile(test.srcPath, []byte{}, 0644); err != nil {
-			t.Errorf("Test %q: cannot create srcPath %s: %s", test.name, test.srcPath, err)
-			continue
-		}
-
-		// Don't create dst if it exists
-		if _, err := os.Stat(test.dstPath); os.IsNotExist(err) {
-			if err := ioutil.WriteFile(test.dstPath, []byte{}, 0644); err != nil {
-				t.Errorf("Test %q: cannot create dstPath %s: %s", test.name, test.dstPath, err)
-				continue
-			}
-		} else if err != nil {
-			t.Errorf("Test %q: cannot check existence of dstPath %s: %s", test.name, test.dstPath, err)
-			continue
-		}
-
-		fd, err := unix.Open(test.srcPath, unix.O_CREAT, 0644)
-		if err != nil {
-			t.Errorf("Test %q: cannot open srcPath %s: %s", test.name, test.srcPath, err)
-			continue
-		}
-
-		err = checkDeviceInode(fd, test.dstPath)
-
-		if test.expectError == "" && err != nil {
-			t.Errorf("Test %q: expected no error, got %s", test.name, err)
-		}
-		if test.expectError != "" {
-			if err == nil {
-				t.Errorf("Test %q: expected error, got none", test.name)
-			} else {
-				if !strings.Contains(err.Error(), test.expectError) {
-					t.Errorf("Test %q: expected error %q, got %q", test.name, test.expectError, err)
-				}
-			}
-		}
-	}
-}
-
-func newFakeNsenterMounter(tmpdir string, t *testing.T) (mounter *NsenterMounter, rootfsPath string, varlibPath string, err error) {
-	rootfsPath = filepath.Join(tmpdir, "rootfs")
-	if err := os.Mkdir(rootfsPath, 0755); err != nil {
-		return nil, "", "", err
-	}
-	ne, err := nsenter.NewFakeNsenter(rootfsPath)
-	if err != nil {
-		return nil, "", "", err
-	}
-
-	varlibPath = filepath.Join(tmpdir, "/var/lib/kubelet")
-	if err := os.MkdirAll(varlibPath, 0755); err != nil {
-		return nil, "", "", err
-	}
-
-	return NewNsenterMounter(varlibPath, ne), rootfsPath, varlibPath, nil
-}
-
-func TestNsenterExistsFile(t *testing.T) {
-	tests := []struct {
-		name           string
-		prepare        func(base, rootfs string) (string, error)
-		expectedOutput bool
-		expectError    bool
-	}{
-		{
-			name: "simple existing file",
-			prepare: func(base, rootfs string) (string, error) {
-				// On the host: /base/file
-				path := filepath.Join(base, "file")
-				if err := ioutil.WriteFile(path, []byte{}, 0644); err != nil {
-					return "", err
-				}
-				// In kubelet: /rootfs/base/file
-				if _, err := writeRootfsFile(rootfs, path, 0644); err != nil {
-					return "", err
-				}
-				return path, nil
-			},
-			expectedOutput: true,
-		},
-		{
-			name: "simple non-existing file",
-			prepare: func(base, rootfs string) (string, error) {
-				path := filepath.Join(base, "file")
-				return path, nil
-			},
-			expectedOutput: false,
-		},
-		{
-			name: "simple non-accessible file",
-			prepare: func(base, rootfs string) (string, error) {
-				// On the host:
-				// create /base/dir/file, then make the dir inaccessible
-				dir := filepath.Join(base, "dir")
-				if err := os.MkdirAll(dir, 0755); err != nil {
-					return "", err
-				}
-				path := filepath.Join(dir, "file")
-				if err := ioutil.WriteFile(path, []byte{}, 0); err != nil {
-					return "", err
-				}
-				if err := os.Chmod(dir, 0644); err != nil {
-					return "", err
-				}
-
-				// In kubelet: do the same with /rootfs/base/dir/file
-				rootfsPath, err := writeRootfsFile(rootfs, path, 0777)
-				if err != nil {
-					return "", err
-				}
-				rootfsDir := filepath.Dir(rootfsPath)
-				if err := os.Chmod(rootfsDir, 0644); err != nil {
-					return "", err
-				}
-
-				return path, nil
-			},
-			expectedOutput: false,
-			expectError:    true,
-		},
-		{
-			name: "relative symlink to existing file",
-			prepare: func(base, rootfs string) (string, error) {
-				// On the host: /base/link -> file
-				file := filepath.Join(base, "file")
-				if err := ioutil.WriteFile(file, []byte{}, 0); err != nil {
-					return "", err
-				}
-				path := filepath.Join(base, "link")
-				if err := os.Symlink("file", path); err != nil {
-					return "", err
-				}
-				// In kubelet: /rootfs/base/file
-				if _, err := writeRootfsFile(rootfs, file, 0644); err != nil {
-					return "", err
-				}
-				return path, nil
-			},
-			expectedOutput: true,
-		},
-		{
-			name: "absolute symlink to existing file",
-			prepare: func(base, rootfs string) (string, error) {
-				// On the host: /base/link -> /base/file
-				file := filepath.Join(base, "file")
-				if err := ioutil.WriteFile(file, []byte{}, 0); err != nil {
-					return "", err
-				}
-				path := filepath.Join(base, "link")
-				if err := os.Symlink(file, path); err != nil {
-					return "", err
-				}
-				// In kubelet: /rootfs/base/file
-				if _, err := writeRootfsFile(rootfs, file, 0644); err != nil {
-					return "", err
-				}
-
-				return path, nil
-			},
-			expectedOutput: true,
-		},
-		{
-			name: "relative symlink to non-existing file",
-			prepare: func(base, rootfs string) (string, error) {
-				path := filepath.Join(base, "link")
-				if err := os.Symlink("file", path); err != nil {
-					return "", err
-				}
-				return path, nil
-			},
-			expectedOutput: false,
-		},
-		{
-			name: "absolute symlink to non-existing file",
-			prepare: func(base, rootfs string) (string, error) {
-				file := filepath.Join(base, "file")
-				path := filepath.Join(base, "link")
-				if err := os.Symlink(file, path); err != nil {
-					return "", err
-				}
-				return path, nil
-			},
-			expectedOutput: false,
-		},
-		{
-			name: "symlink loop",
-			prepare: func(base, rootfs string) (string, error) {
-				path := filepath.Join(base, "link")
-				if err := os.Symlink(path, path); err != nil {
-					return "", err
-				}
-				return path, nil
-			},
-			expectedOutput: false,
-			// TODO: realpath -m is not able to detect symlink loop. Should we care?
-			expectError: false,
-		},
-	}
-
-	for _, test := range tests {
-		tmpdir, err := ioutil.TempDir("", "nsenter-exists-file")
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		defer os.RemoveAll(tmpdir)
-
-		testBase := filepath.Join(tmpdir, "base")
-		if err := os.Mkdir(testBase, 0755); err != nil {
-			t.Error(err)
-			continue
-		}
-
-		mounter, rootfs, _, err := newFakeNsenterMounter(tmpdir, t)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-
-		path, err := test.prepare(testBase, rootfs)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-
-		out, err := mounter.ExistsPath(path)
-		if err != nil && !test.expectError {
-			t.Errorf("Test %q: unexpected error: %s", test.name, err)
-		}
-		if err == nil && test.expectError {
-			t.Errorf("Test %q: expected error, got none", test.name)
-		}
-
-		if out != test.expectedOutput {
-			t.Errorf("Test %q: expected return value %v, got %v", test.name, test.expectedOutput, out)
-		}
-	}
-}
-
-func TestNsenterGetMode(t *testing.T) {
-	tests := []struct {
-		name         string
-		prepare      func(base, rootfs string) (string, error)
-		expectedMode os.FileMode
-		expectError  bool
-	}{
-		{
-			name: "simple file",
-			prepare: func(base, rootfs string) (string, error) {
-				// On the host: /base/file
-				path := filepath.Join(base, "file")
-				if err := ioutil.WriteFile(path, []byte{}, 0644); err != nil {
-					return "", err
-				}
-
-				// Prepare a different file as /rootfs/base/file (="the host
-				// visible from container") to check that NsEnterMounter calls
-				// stat on this file and not on /base/file.
-				// Visible from kubelet: /rootfs/base/file
-				if _, err := writeRootfsFile(rootfs, path, 0777); err != nil {
-					return "", err
-				}
-
-				return path, nil
-			},
-			expectedMode: 0777,
-		},
-		{
-			name: "non-existing file",
-			prepare: func(base, rootfs string) (string, error) {
-				path := filepath.Join(base, "file")
-				return path, nil
-			},
-			expectedMode: 0,
-			expectError:  true,
-		},
-		{
-			name: "absolute symlink to existing file",
-			prepare: func(base, rootfs string) (string, error) {
-				// On the host: /base/link -> /base/file
-				file := filepath.Join(base, "file")
-				if err := ioutil.WriteFile(file, []byte{}, 0644); err != nil {
-					return "", err
-				}
-				path := filepath.Join(base, "link")
-				if err := os.Symlink(file, path); err != nil {
-					return "", err
-				}
-
-				// Visible from kubelet:
-				// /rootfs/base/file
-				if _, err := writeRootfsFile(rootfs, file, 0747); err != nil {
-					return "", err
-				}
-
-				return path, nil
-			},
-			expectedMode: 0747,
-		},
-		{
-			name: "relative symlink to existing file",
-			prepare: func(base, rootfs string) (string, error) {
-				// On the host: /base/link -> file
-				file := filepath.Join(base, "file")
-				if err := ioutil.WriteFile(file, []byte{}, 0741); err != nil {
-					return "", err
-				}
-				path := filepath.Join(base, "link")
-				if err := os.Symlink("file", path); err != nil {
-					return "", err
-				}
-
-				// Visible from kubelet:
-				// /rootfs/base/file
-				if _, err := writeRootfsFile(rootfs, file, 0647); err != nil {
-					return "", err
-				}
-
-				return path, nil
-			},
-			expectedMode: 0647,
-		},
-	}
-
-	for _, test := range tests {
-		tmpdir, err := ioutil.TempDir("", "nsenter-get-mode-")
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		defer os.RemoveAll(tmpdir)
-
-		testBase := filepath.Join(tmpdir, "base")
-		if err := os.Mkdir(testBase, 0755); err != nil {
-			t.Error(err)
-			continue
-		}
-
-		mounter, rootfs, _, err := newFakeNsenterMounter(tmpdir, t)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-
-		path, err := test.prepare(testBase, rootfs)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-
-		mode, err := mounter.GetMode(path)
-		if err != nil && !test.expectError {
-			t.Errorf("Test %q: unexpected error: %s", test.name, err)
-		}
-		if err == nil && test.expectError {
-			t.Errorf("Test %q: expected error, got none", test.name)
-		}
-
-		if mode != test.expectedMode {
-			t.Errorf("Test %q: expected return value %v, got %v", test.name, test.expectedMode, mode)
-		}
-	}
-}
-
-func writeRootfsFile(rootfs, path string, mode os.FileMode) (string, error) {
-	fullPath := filepath.Join(rootfs, path)
-	dir := filepath.Dir(fullPath)
-	if err := os.MkdirAll(dir, 0755); err != nil {
-		return "", err
-	}
-	if err := ioutil.WriteFile(fullPath, []byte{}, mode); err != nil {
-		return "", err
-	}
-	// Use chmod, io.WriteFile is affected by umask
-	if err := os.Chmod(fullPath, mode); err != nil {
-		return "", err
-	}
-	return fullPath, nil
-}
-
-func TestNsenterSafeMakeDir(t *testing.T) {
-	tests := []struct {
-		name        string
-		prepare     func(base, rootfs, varlib string) (expectedDir string, err error)
-		subdir      string
-		expectError bool
-		// If true, "base" directory for SafeMakeDir will be /var/lib/kubelet
-		baseIsVarLib bool
-	}{
-		{
-			name: "simple directory",
-			// evaluated in base
-			subdir: "some/subdirectory/structure",
-			prepare: func(base, rootfs, varlib string) (expectedDir string, err error) {
-				// expected to be created in /roots/
-				expectedDir = filepath.Join(rootfs, base, "some/subdirectory/structure")
-				return expectedDir, nil
-			},
-		},
-		{
-			name: "simple existing directory",
-			// evaluated in base
-			subdir: "some/subdirectory/structure",
-			prepare: func(base, rootfs, varlib string) (expectedDir string, err error) {
-				// On the host: directory exists
-				hostPath := filepath.Join(base, "some/subdirectory/structure")
-				if err := os.MkdirAll(hostPath, 0755); err != nil {
-					return "", err
-				}
-				// In rootfs: directory exists
-				kubeletPath := filepath.Join(rootfs, hostPath)
-				if err := os.MkdirAll(kubeletPath, 0755); err != nil {
-					return "", err
-				}
-				// expected to be created in /roots/
-				expectedDir = kubeletPath
-				return expectedDir, nil
-			},
-		},
-		{
-			name: "absolute symlink into safe place",
-			// evaluated in base
-			subdir: "some/subdirectory/structure",
-			prepare: func(base, rootfs, varlib string) (expectedDir string, err error) {
-				// On the host: /base/other/subdirectory exists, /base/some is link to /base/other
-				hostPath := filepath.Join(base, "other/subdirectory")
-				if err := os.MkdirAll(hostPath, 0755); err != nil {
-					return "", err
-				}
-				somePath := filepath.Join(base, "some")
-				otherPath := filepath.Join(base, "other")
-				if err := os.Symlink(otherPath, somePath); err != nil {
-					return "", err
-				}
-
-				// In rootfs: /base/other/subdirectory exists
-				kubeletPath := filepath.Join(rootfs, hostPath)
-				if err := os.MkdirAll(kubeletPath, 0755); err != nil {
-					return "", err
-				}
-				// expected 'structure' to be created
-				expectedDir = filepath.Join(rootfs, hostPath, "structure")
-				return expectedDir, nil
-			},
-		},
-		{
-			name: "relative symlink into safe place",
-			// evaluated in base
-			subdir: "some/subdirectory/structure",
-			prepare: func(base, rootfs, varlib string) (expectedDir string, err error) {
-				// On the host: /base/other/subdirectory exists, /base/some is link to other
-				hostPath := filepath.Join(base, "other/subdirectory")
-				if err := os.MkdirAll(hostPath, 0755); err != nil {
-					return "", err
-				}
-				somePath := filepath.Join(base, "some")
-				if err := os.Symlink("other", somePath); err != nil {
-					return "", err
-				}
-
-				// In rootfs: /base/other/subdirectory exists
-				kubeletPath := filepath.Join(rootfs, hostPath)
-				if err := os.MkdirAll(kubeletPath, 0755); err != nil {
-					return "", err
-				}
-				// expected 'structure' to be created
-				expectedDir = filepath.Join(rootfs, hostPath, "structure")
-				return expectedDir, nil
-			},
-		},
-		{
-			name: "symlink into unsafe place",
-			// evaluated in base
-			subdir: "some/subdirectory/structure",
-			prepare: func(base, rootfs, varlib string) (expectedDir string, err error) {
-				// On the host: /base/some is link to /bin/other
-				somePath := filepath.Join(base, "some")
-				if err := os.Symlink("/bin", somePath); err != nil {
-					return "", err
-				}
-				return "", nil
-			},
-			expectError: true,
-		},
-		{
-			name: "simple directory in /var/lib/kubelet",
-			// evaluated in varlib
-			subdir:       "some/subdirectory/structure",
-			baseIsVarLib: true,
-			prepare: func(base, rootfs, varlib string) (expectedDir string, err error) {
-				// expected to be created in /base/var/lib/kubelet, not in /rootfs!
-				expectedDir = filepath.Join(varlib, "some/subdirectory/structure")
-				return expectedDir, nil
-			},
-		},
-		{
-			name: "safe symlink in /var/lib/kubelet",
-			// evaluated in varlib
-			subdir:       "some/subdirectory/structure",
-			baseIsVarLib: true,
-			prepare: func(base, rootfs, varlib string) (expectedDir string, err error) {
-				// On the host: /varlib/kubelet/other/subdirectory exists, /varlib/some is link to other
-				hostPath := filepath.Join(varlib, "other/subdirectory")
-				if err := os.MkdirAll(hostPath, 0755); err != nil {
-					return "", err
-				}
-				somePath := filepath.Join(varlib, "some")
-				if err := os.Symlink("other", somePath); err != nil {
-					return "", err
-				}
-
-				// expected to be created in /base/var/lib/kubelet, not in /rootfs!
-				expectedDir = filepath.Join(varlib, "other/subdirectory/structure")
-				return expectedDir, nil
-			},
-		},
-		{
-			name: "unsafe symlink in /var/lib/kubelet",
-			// evaluated in varlib
-			subdir:       "some/subdirectory/structure",
-			baseIsVarLib: true,
-			prepare: func(base, rootfs, varlib string) (expectedDir string, err error) {
-				// On the host: /varlib/some is link to /bin
-				somePath := filepath.Join(varlib, "some")
-				if err := os.Symlink("/bin", somePath); err != nil {
-					return "", err
-				}
-
-				return "", nil
-			},
-			expectError: true,
-		},
-	}
-	for _, test := range tests {
-		tmpdir, err := ioutil.TempDir("", "nsenter-get-mode-")
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		defer os.RemoveAll(tmpdir)
-
-		mounter, rootfs, varlib, err := newFakeNsenterMounter(tmpdir, t)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		// Prepare base directory for the test
-		testBase := filepath.Join(tmpdir, "base")
-		if err := os.Mkdir(testBase, 0755); err != nil {
-			t.Error(err)
-			continue
-		}
-		// Prepare base directory also in /rootfs
-		rootfsBase := filepath.Join(rootfs, testBase)
-		if err := os.MkdirAll(rootfsBase, 0755); err != nil {
-			t.Error(err)
-			continue
-		}
-
-		expectedDir := ""
-		if test.prepare != nil {
-			expectedDir, err = test.prepare(testBase, rootfs, varlib)
-			if err != nil {
-				t.Error(err)
-				continue
-			}
-		}
-
-		if test.baseIsVarLib {
-			// use /var/lib/kubelet as the test base so we can test creating
-			// subdirs there directly in /var/lib/kubenet and not in
-			// /rootfs/var/lib/kubelet
-			testBase = varlib
-		}
-
-		err = mounter.SafeMakeDir(test.subdir, testBase, 0755)
-		if err != nil && !test.expectError {
-			t.Errorf("Test %q: unexpected error: %s", test.name, err)
-		}
-		if test.expectError {
-			if err == nil {
-				t.Errorf("Test %q: expected error, got none", test.name)
-			} else {
-				if !strings.Contains(err.Error(), "is outside of allowed base") {
-					t.Errorf("Test %q: expected error to contain \"is outside of allowed base\", got this one instead: %s", test.name, err)
-				}
-			}
-		}
-
-		if expectedDir != "" {
-			_, err := os.Stat(expectedDir)
-			if err != nil {
-				t.Errorf("Test %q: expected %q to exist, got error: %s", test.name, expectedDir, err)
-			}
-		}
-	}
-}

vendor/k8s.io/kubernetes/pkg/util/mount/safe_format_and_mount_test.go

@@ -1,242 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package mount
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"runtime"
-	"testing"
-
-	fakeexec "k8s.io/utils/exec/testing"
-)
-
-type ErrorMounter struct {
-	*FakeMounter
-	errIndex int
-	err      []error
-}
-
-func (mounter *ErrorMounter) Mount(source string, target string, fstype string, options []string) error {
-	i := mounter.errIndex
-	mounter.errIndex++
-	if mounter.err != nil && mounter.err[i] != nil {
-		return mounter.err[i]
-	}
-	return mounter.FakeMounter.Mount(source, target, fstype, options)
-}
-
-type ExecArgs struct {
-	command string
-	args    []string
-	output  string
-	err     error
-}
-
-func TestSafeFormatAndMount(t *testing.T) {
-	if runtime.GOOS == "darwin" || runtime.GOOS == "windows" {
-		t.Skipf("not supported on GOOS=%s", runtime.GOOS)
-	}
-	mntDir, err := ioutil.TempDir(os.TempDir(), "mount")
-	if err != nil {
-		t.Fatalf("failed to create tmp dir: %v", err)
-	}
-	defer os.RemoveAll(mntDir)
-	tests := []struct {
-		description   string
-		fstype        string
-		mountOptions  []string
-		execScripts   []ExecArgs
-		mountErrs     []error
-		expectedError error
-	}{
-		{
-			description:  "Test a read only mount",
-			fstype:       "ext4",
-			mountOptions: []string{"ro"},
-		},
-		{
-			description: "Test a normal mount",
-			fstype:      "ext4",
-			execScripts: []ExecArgs{
-				{"fsck", []string{"-a", "/dev/foo"}, "", nil},
-			},
-		},
-		{
-			description: "Test 'fsck' fails with exit status 4",
-			fstype:      "ext4",
-			execScripts: []ExecArgs{
-				{"fsck", []string{"-a", "/dev/foo"}, "", &fakeexec.FakeExitError{Status: 4}},
-			},
-			expectedError: fmt.Errorf("'fsck' found errors on device /dev/foo but could not correct them: ."),
-		},
-		{
-			description: "Test 'fsck' fails with exit status 1 (errors found and corrected)",
-			fstype:      "ext4",
-			execScripts: []ExecArgs{
-				{"fsck", []string{"-a", "/dev/foo"}, "", &fakeexec.FakeExitError{Status: 1}},
-			},
-		},
-		{
-			description: "Test 'fsck' fails with exit status other than 1 and 4 (likely unformatted device)",
-			fstype:      "ext4",
-			execScripts: []ExecArgs{
-				{"fsck", []string{"-a", "/dev/foo"}, "", &fakeexec.FakeExitError{Status: 8}},
-			},
-		},
-		{
-			description: "Test that 'blkid' is called and fails",
-			fstype:      "ext4",
-			mountErrs:   []error{fmt.Errorf("unknown filesystem type '(null)'")},
-			execScripts: []ExecArgs{
-				{"fsck", []string{"-a", "/dev/foo"}, "", nil},
-				{"blkid", []string{"-p", "-s", "TYPE", "-s", "PTTYPE", "-o", "export", "/dev/foo"}, "DEVNAME=/dev/foo\nTYPE=ext4\n", nil},
-			},
-			expectedError: fmt.Errorf("unknown filesystem type '(null)'"),
-		},
-		{
-			description: "Test that 'blkid' is called and confirms unformatted disk, format fails",
-			fstype:      "ext4",
-			mountErrs:   []error{fmt.Errorf("unknown filesystem type '(null)'")},
-			execScripts: []ExecArgs{
-				{"fsck", []string{"-a", "/dev/foo"}, "", nil},
-				{"blkid", []string{"-p", "-s", "TYPE", "-s", "PTTYPE", "-o", "export", "/dev/foo"}, "", &fakeexec.FakeExitError{Status: 2}},
-				{"mkfs.ext4", []string{"-F", "-m0", "/dev/foo"}, "", fmt.Errorf("formatting failed")},
-			},
-			expectedError: fmt.Errorf("formatting failed"),
-		},
-		{
-			description: "Test that 'blkid' is called and confirms unformatted disk, format passes, second mount fails",
-			fstype:      "ext4",
-			mountErrs:   []error{fmt.Errorf("unknown filesystem type '(null)'"), fmt.Errorf("Still cannot mount")},
-			execScripts: []ExecArgs{
-				{"fsck", []string{"-a", "/dev/foo"}, "", nil},
-				{"blkid", []string{"-p", "-s", "TYPE", "-s", "PTTYPE", "-o", "export", "/dev/foo"}, "", &fakeexec.FakeExitError{Status: 2}},
-				{"mkfs.ext4", []string{"-F", "-m0", "/dev/foo"}, "", nil},
-			},
-			expectedError: fmt.Errorf("Still cannot mount"),
-		},
-		{
-			description: "Test that 'blkid' is called and confirms unformatted disk, format passes, second mount passes",
-			fstype:      "ext4",
-			mountErrs:   []error{fmt.Errorf("unknown filesystem type '(null)'"), nil},
-			execScripts: []ExecArgs{
-				{"fsck", []string{"-a", "/dev/foo"}, "", nil},
-				{"blkid", []string{"-p", "-s", "TYPE", "-s", "PTTYPE", "-o", "export", "/dev/foo"}, "", &fakeexec.FakeExitError{Status: 2}},
-				{"mkfs.ext4", []string{"-F", "-m0", "/dev/foo"}, "", nil},
-			},
-			expectedError: nil,
-		},
-		{
-			description: "Test that 'blkid' is called and confirms unformatted disk, format passes, second mount passes with ext3",
-			fstype:      "ext3",
-			mountErrs:   []error{fmt.Errorf("unknown filesystem type '(null)'"), nil},
-			execScripts: []ExecArgs{
-				{"fsck", []string{"-a", "/dev/foo"}, "", nil},
-				{"blkid", []string{"-p", "-s", "TYPE", "-s", "PTTYPE", "-o", "export", "/dev/foo"}, "", &fakeexec.FakeExitError{Status: 2}},
-				{"mkfs.ext3", []string{"-F", "-m0", "/dev/foo"}, "", nil},
-			},
-			expectedError: nil,
-		},
-		{
-			description: "test that none ext4 fs does not get called with ext4 options.",
-			fstype:      "xfs",
-			mountErrs:   []error{fmt.Errorf("unknown filesystem type '(null)'"), nil},
-			execScripts: []ExecArgs{
-				{"fsck", []string{"-a", "/dev/foo"}, "", nil},
-				{"blkid", []string{"-p", "-s", "TYPE", "-s", "PTTYPE", "-o", "export", "/dev/foo"}, "", &fakeexec.FakeExitError{Status: 2}},
-				{"mkfs.xfs", []string{"/dev/foo"}, "", nil},
-			},
-			expectedError: nil,
-		},
-		{
-			description: "Test that 'blkid' is called and reports ext4 partition",
-			fstype:      "ext3",
-			mountErrs:   []error{fmt.Errorf("unknown filesystem type '(null)'")},
-			execScripts: []ExecArgs{
-				{"fsck", []string{"-a", "/dev/foo"}, "", nil},
-				{"blkid", []string{"-p", "-s", "TYPE", "-s", "PTTYPE", "-o", "export", "/dev/foo"}, "DEVNAME=/dev/foo\nPTTYPE=dos\n", nil},
-			},
-			expectedError: fmt.Errorf("failed to mount the volume as \"ext3\", it already contains unknown data, probably partitions. Mount error: unknown filesystem type '(null)'"),
-		},
-		{
-			description: "Test that 'blkid' is called but has some usage or other errors (an exit code of 4 is returned)",
-			fstype:      "xfs",
-			mountErrs:   []error{fmt.Errorf("unknown filesystem type '(null)'"), nil},
-			execScripts: []ExecArgs{
-				{"fsck", []string{"-a", "/dev/foo"}, "", nil},
-				{"blkid", []string{"-p", "-s", "TYPE", "-s", "PTTYPE", "-o", "export", "/dev/foo"}, "", &fakeexec.FakeExitError{Status: 4}},
-				{"mkfs.xfs", []string{"/dev/foo"}, "", nil},
-			},
-			expectedError: fmt.Errorf("exit 4"),
-		},
-	}
-
-	for _, test := range tests {
-		execCallCount := 0
-		execCallback := func(cmd string, args ...string) ([]byte, error) {
-			if len(test.execScripts) <= execCallCount {
-				t.Errorf("Unexpected command: %s %v", cmd, args)
-				return nil, nil
-			}
-			script := test.execScripts[execCallCount]
-			execCallCount++
-			if script.command != cmd {
-				t.Errorf("Unexpected command %s. Expecting %s", cmd, script.command)
-			}
-			for j := range args {
-				if args[j] != script.args[j] {
-					t.Errorf("Unexpected args %v. Expecting %v", args, script.args)
-				}
-			}
-			return []byte(script.output), script.err
-		}
-
-		fakeMounter := ErrorMounter{&FakeMounter{}, 0, test.mountErrs}
-		fakeExec := NewFakeExec(execCallback)
-		mounter := SafeFormatAndMount{
-			Interface: &fakeMounter,
-			Exec:      fakeExec,
-		}
-
-		device := "/dev/foo"
-		dest := mntDir
-		err := mounter.FormatAndMount(device, dest, test.fstype, test.mountOptions)
-		if test.expectedError == nil {
-			if err != nil {
-				t.Errorf("test \"%s\" unexpected non-error: %v", test.description, err)
-			}
-
-			// Check that something was mounted on the directory
-			isNotMountPoint, err := fakeMounter.IsLikelyNotMountPoint(dest)
-			if err != nil || isNotMountPoint {
-				t.Errorf("test \"%s\" the directory was not mounted", test.description)
-			}
-
-			//check that the correct device was mounted
-			mountedDevice, _, err := GetDeviceNameFromMount(fakeMounter.FakeMounter, dest)
-			if err != nil || mountedDevice != device {
-				t.Errorf("test \"%s\" the correct device was not mounted", test.description)
-			}
-		} else {
-			if err == nil || test.expectedError.Error() != err.Error() {
-				t.Errorf("test \"%s\" unexpected error: \n          [%v]. \nExpecting [%v]", test.description, err, test.expectedError)
-			}
-		}
-	}
-}