vendor files

vendor/k8s.io/kubernetes/pkg/kubelet/container/testing/BUILD

@@ -0,0 +1,41 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "fake_cache.go",
+        "fake_runtime.go",
+        "fake_runtime_helper.go",
+        "mock_runtime_cache.go",
+        "mockfileinfo.go",
+        "os.go",
+        "runtime_mock.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/kubelet/container/testing",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//pkg/kubelet/apis/cri/v1alpha1/runtime:go_default_library",
+        "//pkg/kubelet/container:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//vendor/github.com/golang/mock/gomock:go_default_library",
+        "//vendor/github.com/stretchr/testify/mock:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/client-go/tools/remotecommand:go_default_library",
+        "//vendor/k8s.io/client-go/util/flowcontrol:go_default_library",
+    ],
+)
+
+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/kubelet/container/testing/fake_cache.go

@@ -0,0 +1,49 @@
+/*
+Copyright 2016 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 testing
+
+import (
+	"time"
+
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/kubernetes/pkg/kubelet/container"
+)
+
+type fakeCache struct {
+	runtime container.Runtime
+}
+
+func NewFakeCache(runtime container.Runtime) container.Cache {
+	return &fakeCache{runtime: runtime}
+}
+
+func (c *fakeCache) Get(id types.UID) (*container.PodStatus, error) {
+	return c.runtime.GetPodStatus(id, "", "")
+}
+
+func (c *fakeCache) GetNewerThan(id types.UID, minTime time.Time) (*container.PodStatus, error) {
+	return c.Get(id)
+}
+
+func (c *fakeCache) Set(id types.UID, status *container.PodStatus, err error, timestamp time.Time) {
+}
+
+func (c *fakeCache) Delete(id types.UID) {
+}
+
+func (c *fakeCache) UpdateTime(_ time.Time) {
+}

vendor/k8s.io/kubernetes/pkg/kubelet/container/testing/fake_runtime.go

@@ -0,0 +1,500 @@
+/*
+Copyright 2015 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 testing
+
+import (
+	"fmt"
+	"io"
+	"net/url"
+	"reflect"
+	"sync"
+	"time"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/tools/remotecommand"
+	"k8s.io/client-go/util/flowcontrol"
+	. "k8s.io/kubernetes/pkg/kubelet/container"
+	"k8s.io/kubernetes/pkg/volume"
+)
+
+type FakePod struct {
+	Pod       *Pod
+	NetnsPath string
+}
+
+// FakeRuntime is a fake container runtime for testing.
+type FakeRuntime struct {
+	sync.Mutex
+	CalledFunctions   []string
+	PodList           []*FakePod
+	AllPodList        []*FakePod
+	ImageList         []Image
+	APIPodStatus      v1.PodStatus
+	PodStatus         PodStatus
+	StartedPods       []string
+	KilledPods        []string
+	StartedContainers []string
+	KilledContainers  []string
+	RuntimeStatus     *RuntimeStatus
+	VersionInfo       string
+	APIVersionInfo    string
+	RuntimeType       string
+	Err               error
+	InspectErr        error
+	StatusErr         error
+}
+
+type FakeDirectStreamingRuntime struct {
+	*FakeRuntime
+
+	// Arguments to streaming method calls.
+	Args struct {
+		// Attach / Exec args
+		ContainerID ContainerID
+		Cmd         []string
+		Stdin       io.Reader
+		Stdout      io.WriteCloser
+		Stderr      io.WriteCloser
+		TTY         bool
+		// Port-forward args
+		Pod    *Pod
+		Port   int32
+		Stream io.ReadWriteCloser
+	}
+}
+
+var _ DirectStreamingRuntime = &FakeDirectStreamingRuntime{}
+
+const FakeHost = "localhost:12345"
+
+type FakeIndirectStreamingRuntime struct {
+	*FakeRuntime
+}
+
+var _ IndirectStreamingRuntime = &FakeIndirectStreamingRuntime{}
+
+// FakeRuntime should implement Runtime.
+var _ Runtime = &FakeRuntime{}
+
+type FakeVersion struct {
+	Version string
+}
+
+func (fv *FakeVersion) String() string {
+	return fv.Version
+}
+
+func (fv *FakeVersion) Compare(other string) (int, error) {
+	result := 0
+	if fv.Version > other {
+		result = 1
+	} else if fv.Version < other {
+		result = -1
+	}
+	return result, nil
+}
+
+type podsGetter interface {
+	GetPods(bool) ([]*Pod, error)
+}
+
+type FakeRuntimeCache struct {
+	getter podsGetter
+}
+
+func NewFakeRuntimeCache(getter podsGetter) RuntimeCache {
+	return &FakeRuntimeCache{getter}
+}
+
+func (f *FakeRuntimeCache) GetPods() ([]*Pod, error) {
+	return f.getter.GetPods(false)
+}
+
+func (f *FakeRuntimeCache) ForceUpdateIfOlder(time.Time) error {
+	return nil
+}
+
+// ClearCalls resets the FakeRuntime to the initial state.
+func (f *FakeRuntime) ClearCalls() {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = []string{}
+	f.PodList = []*FakePod{}
+	f.AllPodList = []*FakePod{}
+	f.APIPodStatus = v1.PodStatus{}
+	f.StartedPods = []string{}
+	f.KilledPods = []string{}
+	f.StartedContainers = []string{}
+	f.KilledContainers = []string{}
+	f.RuntimeStatus = nil
+	f.VersionInfo = ""
+	f.RuntimeType = ""
+	f.Err = nil
+	f.InspectErr = nil
+	f.StatusErr = nil
+}
+
+// UpdatePodCIDR fulfills the cri interface.
+func (f *FakeRuntime) UpdatePodCIDR(c string) error {
+	return nil
+}
+
+func (f *FakeRuntime) assertList(expect []string, test []string) error {
+	if !reflect.DeepEqual(expect, test) {
+		return fmt.Errorf("expected %#v, got %#v", expect, test)
+	}
+	return nil
+}
+
+// AssertCalls test if the invoked functions are as expected.
+func (f *FakeRuntime) AssertCalls(calls []string) error {
+	f.Lock()
+	defer f.Unlock()
+	return f.assertList(calls, f.CalledFunctions)
+}
+
+func (f *FakeRuntime) AssertStartedPods(pods []string) error {
+	f.Lock()
+	defer f.Unlock()
+	return f.assertList(pods, f.StartedPods)
+}
+
+func (f *FakeRuntime) AssertKilledPods(pods []string) error {
+	f.Lock()
+	defer f.Unlock()
+	return f.assertList(pods, f.KilledPods)
+}
+
+func (f *FakeRuntime) AssertStartedContainers(containers []string) error {
+	f.Lock()
+	defer f.Unlock()
+	return f.assertList(containers, f.StartedContainers)
+}
+
+func (f *FakeRuntime) AssertKilledContainers(containers []string) error {
+	f.Lock()
+	defer f.Unlock()
+	return f.assertList(containers, f.KilledContainers)
+}
+
+func (f *FakeRuntime) Type() string {
+	return f.RuntimeType
+}
+
+func (f *FakeRuntime) Version() (Version, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "Version")
+	return &FakeVersion{Version: f.VersionInfo}, f.Err
+}
+
+func (f *FakeRuntime) APIVersion() (Version, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "APIVersion")
+	return &FakeVersion{Version: f.APIVersionInfo}, f.Err
+}
+
+func (f *FakeRuntime) Status() (*RuntimeStatus, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "Status")
+	return f.RuntimeStatus, f.StatusErr
+}
+
+func (f *FakeRuntime) GetPods(all bool) ([]*Pod, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	var pods []*Pod
+
+	f.CalledFunctions = append(f.CalledFunctions, "GetPods")
+	if all {
+		for _, fakePod := range f.AllPodList {
+			pods = append(pods, fakePod.Pod)
+		}
+	} else {
+		for _, fakePod := range f.PodList {
+			pods = append(pods, fakePod.Pod)
+		}
+	}
+	return pods, f.Err
+}
+
+func (f *FakeRuntime) SyncPod(pod *v1.Pod, _ v1.PodStatus, _ *PodStatus, _ []v1.Secret, backOff *flowcontrol.Backoff) (result PodSyncResult) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "SyncPod")
+	f.StartedPods = append(f.StartedPods, string(pod.UID))
+	for _, c := range pod.Spec.Containers {
+		f.StartedContainers = append(f.StartedContainers, c.Name)
+	}
+	// TODO(random-liu): Add SyncResult for starting and killing containers
+	if f.Err != nil {
+		result.Fail(f.Err)
+	}
+	return
+}
+
+func (f *FakeRuntime) KillPod(pod *v1.Pod, runningPod Pod, gracePeriodOverride *int64) error {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "KillPod")
+	f.KilledPods = append(f.KilledPods, string(runningPod.ID))
+	for _, c := range runningPod.Containers {
+		f.KilledContainers = append(f.KilledContainers, c.Name)
+	}
+	return f.Err
+}
+
+func (f *FakeRuntime) RunContainerInPod(container v1.Container, pod *v1.Pod, volumeMap map[string]volume.VolumePlugin) error {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "RunContainerInPod")
+	f.StartedContainers = append(f.StartedContainers, container.Name)
+
+	pod.Spec.Containers = append(pod.Spec.Containers, container)
+	for _, c := range pod.Spec.Containers {
+		if c.Name == container.Name { // Container already in the pod.
+			return f.Err
+		}
+	}
+	pod.Spec.Containers = append(pod.Spec.Containers, container)
+	return f.Err
+}
+
+func (f *FakeRuntime) KillContainerInPod(container v1.Container, pod *v1.Pod) error {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "KillContainerInPod")
+	f.KilledContainers = append(f.KilledContainers, container.Name)
+
+	var containers []v1.Container
+	for _, c := range pod.Spec.Containers {
+		if c.Name == container.Name {
+			continue
+		}
+		containers = append(containers, c)
+	}
+	return f.Err
+}
+
+func (f *FakeRuntime) GetPodStatus(uid types.UID, name, namespace string) (*PodStatus, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "GetPodStatus")
+	status := f.PodStatus
+	return &status, f.Err
+}
+
+func (f *FakeDirectStreamingRuntime) ExecInContainer(containerID ContainerID, cmd []string, stdin io.Reader, stdout, stderr io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize, timeout time.Duration) error {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "ExecInContainer")
+	f.Args.ContainerID = containerID
+	f.Args.Cmd = cmd
+	f.Args.Stdin = stdin
+	f.Args.Stdout = stdout
+	f.Args.Stderr = stderr
+	f.Args.TTY = tty
+
+	return f.Err
+}
+
+func (f *FakeDirectStreamingRuntime) AttachContainer(containerID ContainerID, stdin io.Reader, stdout, stderr io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize) error {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "AttachContainer")
+	f.Args.ContainerID = containerID
+	f.Args.Stdin = stdin
+	f.Args.Stdout = stdout
+	f.Args.Stderr = stderr
+	f.Args.TTY = tty
+
+	return f.Err
+}
+
+func (f *FakeRuntime) GetContainerLogs(pod *v1.Pod, containerID ContainerID, logOptions *v1.PodLogOptions, stdout, stderr io.Writer) (err error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "GetContainerLogs")
+	return f.Err
+}
+
+func (f *FakeRuntime) PullImage(image ImageSpec, pullSecrets []v1.Secret) (string, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "PullImage")
+	return image.Image, f.Err
+}
+
+func (f *FakeRuntime) GetImageRef(image ImageSpec) (string, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "GetImageRef")
+	for _, i := range f.ImageList {
+		if i.ID == image.Image {
+			return i.ID, nil
+		}
+	}
+	return "", f.InspectErr
+}
+
+func (f *FakeRuntime) ListImages() ([]Image, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "ListImages")
+	return f.ImageList, f.Err
+}
+
+func (f *FakeRuntime) RemoveImage(image ImageSpec) error {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "RemoveImage")
+	index := 0
+	for i := range f.ImageList {
+		if f.ImageList[i].ID == image.Image {
+			index = i
+			break
+		}
+	}
+	f.ImageList = append(f.ImageList[:index], f.ImageList[index+1:]...)
+
+	return f.Err
+}
+
+func (f *FakeDirectStreamingRuntime) PortForward(pod *Pod, port int32, stream io.ReadWriteCloser) error {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "PortForward")
+	f.Args.Pod = pod
+	f.Args.Port = port
+	f.Args.Stream = stream
+
+	return f.Err
+}
+
+func (f *FakeRuntime) GetNetNS(containerID ContainerID) (string, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "GetNetNS")
+
+	for _, fp := range f.AllPodList {
+		for _, c := range fp.Pod.Containers {
+			if c.ID == containerID {
+				return fp.NetnsPath, nil
+			}
+		}
+	}
+
+	return "", f.Err
+}
+
+func (f *FakeRuntime) GetPodContainerID(pod *Pod) (ContainerID, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "GetPodContainerID")
+	return ContainerID{}, f.Err
+}
+
+func (f *FakeRuntime) GarbageCollect(gcPolicy ContainerGCPolicy, ready bool, evictNonDeletedPods bool) error {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "GarbageCollect")
+	return f.Err
+}
+
+func (f *FakeRuntime) DeleteContainer(containerID ContainerID) error {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "DeleteContainer")
+	return f.Err
+}
+
+func (f *FakeRuntime) ImageStats() (*ImageStats, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "ImageStats")
+	return nil, f.Err
+}
+
+func (f *FakeIndirectStreamingRuntime) GetExec(id ContainerID, cmd []string, stdin, stdout, stderr, tty bool) (*url.URL, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "GetExec")
+	return &url.URL{Host: FakeHost}, f.Err
+}
+
+func (f *FakeIndirectStreamingRuntime) GetAttach(id ContainerID, stdin, stdout, stderr, tty bool) (*url.URL, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "GetAttach")
+	return &url.URL{Host: FakeHost}, f.Err
+}
+
+func (f *FakeIndirectStreamingRuntime) GetPortForward(podName, podNamespace string, podUID types.UID, ports []int32) (*url.URL, error) {
+	f.Lock()
+	defer f.Unlock()
+
+	f.CalledFunctions = append(f.CalledFunctions, "GetPortForward")
+	return &url.URL{Host: FakeHost}, f.Err
+}
+
+type FakeContainerCommandRunner struct {
+	// what to return
+	Stdout string
+	Err    error
+
+	// actual values when invoked
+	ContainerID ContainerID
+	Cmd         []string
+}
+
+var _ ContainerCommandRunner = &FakeContainerCommandRunner{}
+
+func (f *FakeContainerCommandRunner) RunInContainer(containerID ContainerID, cmd []string, timeout time.Duration) ([]byte, error) {
+	// record invoked values
+	f.ContainerID = containerID
+	f.Cmd = cmd
+
+	return []byte(f.Stdout), f.Err
+}

vendor/k8s.io/kubernetes/pkg/kubelet/container/testing/fake_runtime_helper.go

@@ -0,0 +1,67 @@
+/*
+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 testing
+
+import (
+	"k8s.io/api/core/v1"
+	kubetypes "k8s.io/apimachinery/pkg/types"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/apis/cri/v1alpha1/runtime"
+	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
+)
+
+// FakeRuntimeHelper implements RuntimeHelper interfaces for testing purposes.
+type FakeRuntimeHelper struct {
+	DNSServers      []string
+	DNSSearches     []string
+	DNSOptions      []string
+	HostName        string
+	HostDomain      string
+	PodContainerDir string
+	Err             error
+}
+
+func (f *FakeRuntimeHelper) GenerateRunContainerOptions(pod *v1.Pod, container *v1.Container, podIP string) (*kubecontainer.RunContainerOptions, error) {
+	var opts kubecontainer.RunContainerOptions
+	if len(container.TerminationMessagePath) != 0 {
+		opts.PodContainerDir = f.PodContainerDir
+	}
+	return &opts, nil
+}
+
+func (f *FakeRuntimeHelper) GetPodCgroupParent(pod *v1.Pod) string {
+	return ""
+}
+
+func (f *FakeRuntimeHelper) GetPodDNS(pod *v1.Pod) (*runtimeapi.DNSConfig, error) {
+	return &runtimeapi.DNSConfig{
+		Servers:  f.DNSServers,
+		Searches: f.DNSSearches,
+		Options:  f.DNSOptions}, f.Err
+}
+
+// This is not used by docker runtime.
+func (f *FakeRuntimeHelper) GeneratePodHostNameAndDomain(pod *v1.Pod) (string, string, error) {
+	return f.HostName, f.HostDomain, f.Err
+}
+
+func (f *FakeRuntimeHelper) GetPodDir(podUID kubetypes.UID) string {
+	return "/poddir/" + string(podUID)
+}
+
+func (f *FakeRuntimeHelper) GetExtraSupplementalGroupsForPod(pod *v1.Pod) []int64 {
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/kubelet/container/testing/mock_runtime_cache.go

@@ -0,0 +1,64 @@
+/*
+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.
+*/
+
+// Code generated by mockery v1.0.0
+package testing
+
+import container "k8s.io/kubernetes/pkg/kubelet/container"
+import mock "github.com/stretchr/testify/mock"
+import time "time"
+
+// MockRuntimeCache is an autogenerated mock type for the RuntimeCache type
+type MockRuntimeCache struct {
+	mock.Mock
+}
+
+// ForceUpdateIfOlder provides a mock function with given fields: _a0
+func (_m *MockRuntimeCache) ForceUpdateIfOlder(_a0 time.Time) error {
+	ret := _m.Called(_a0)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(time.Time) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// GetPods provides a mock function with given fields:
+func (_m *MockRuntimeCache) GetPods() ([]*container.Pod, error) {
+	ret := _m.Called()
+
+	var r0 []*container.Pod
+	if rf, ok := ret.Get(0).(func() []*container.Pod); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*container.Pod)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}

vendor/k8s.io/kubernetes/pkg/kubelet/container/testing/mockfileinfo.go

@@ -0,0 +1,109 @@
+/*
+Copyright 2016 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.
+*/
+
+// Generated via: mockgen os FileInfo
+// Edited to include required boilerplate
+// Source: os (interfaces: FileInfo)
+
+package testing
+
+import (
+	os "os"
+	time "time"
+
+	gomock "github.com/golang/mock/gomock"
+)
+
+// Mock of FileInfo interface
+type MockFileInfo struct {
+	ctrl     *gomock.Controller
+	recorder *_MockFileInfoRecorder
+}
+
+// Recorder for MockFileInfo (not exported)
+type _MockFileInfoRecorder struct {
+	mock *MockFileInfo
+}
+
+func NewMockFileInfo(ctrl *gomock.Controller) *MockFileInfo {
+	mock := &MockFileInfo{ctrl: ctrl}
+	mock.recorder = &_MockFileInfoRecorder{mock}
+	return mock
+}
+
+func (_m *MockFileInfo) EXPECT() *_MockFileInfoRecorder {
+	return _m.recorder
+}
+
+func (_m *MockFileInfo) IsDir() bool {
+	ret := _m.ctrl.Call(_m, "IsDir")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+func (_mr *_MockFileInfoRecorder) IsDir() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "IsDir")
+}
+
+func (_m *MockFileInfo) ModTime() time.Time {
+	ret := _m.ctrl.Call(_m, "ModTime")
+	ret0, _ := ret[0].(time.Time)
+	return ret0
+}
+
+func (_mr *_MockFileInfoRecorder) ModTime() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ModTime")
+}
+
+func (_m *MockFileInfo) Mode() os.FileMode {
+	ret := _m.ctrl.Call(_m, "Mode")
+	ret0, _ := ret[0].(os.FileMode)
+	return ret0
+}
+
+func (_mr *_MockFileInfoRecorder) Mode() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Mode")
+}
+
+func (_m *MockFileInfo) Name() string {
+	ret := _m.ctrl.Call(_m, "Name")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+func (_mr *_MockFileInfoRecorder) Name() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Name")
+}
+
+func (_m *MockFileInfo) Size() int64 {
+	ret := _m.ctrl.Call(_m, "Size")
+	ret0, _ := ret[0].(int64)
+	return ret0
+}
+
+func (_mr *_MockFileInfoRecorder) Size() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Size")
+}
+
+func (_m *MockFileInfo) Sys() interface{} {
+	ret := _m.ctrl.Call(_m, "Sys")
+	ret0, _ := ret[0].(interface{})
+	return ret0
+}
+
+func (_mr *_MockFileInfoRecorder) Sys() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Sys")
+}

vendor/k8s.io/kubernetes/pkg/kubelet/container/testing/os.go

@@ -0,0 +1,117 @@
+/*
+Copyright 2016 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 testing
+
+import (
+	"errors"
+	"os"
+	"time"
+)
+
+// FakeOS mocks out certain OS calls to avoid perturbing the filesystem
+// If a member of the form `*Fn` is set, that function will be called in place
+// of the real call.
+type FakeOS struct {
+	StatFn     func(string) (os.FileInfo, error)
+	ReadDirFn  func(string) ([]os.FileInfo, error)
+	MkdirAllFn func(string, os.FileMode) error
+	SymlinkFn  func(string, string) error
+	HostName   string
+	Removes    []string
+	Files      map[string][]*os.FileInfo
+}
+
+func NewFakeOS() *FakeOS {
+	return &FakeOS{
+		Removes: []string{},
+		Files:   make(map[string][]*os.FileInfo),
+	}
+}
+
+// Mkdir is a fake call that just returns nil.
+func (f *FakeOS) MkdirAll(path string, perm os.FileMode) error {
+	if f.MkdirAllFn != nil {
+		return f.MkdirAllFn(path, perm)
+	}
+	return nil
+}
+
+// Symlink is a fake call that just returns nil.
+func (f *FakeOS) Symlink(oldname string, newname string) error {
+	if f.SymlinkFn != nil {
+		return f.SymlinkFn(oldname, newname)
+	}
+	return nil
+}
+
+// Stat is a fake that returns an error
+func (f FakeOS) Stat(path string) (os.FileInfo, error) {
+	if f.StatFn != nil {
+		return f.StatFn(path)
+	}
+	return nil, errors.New("unimplemented testing mock")
+}
+
+// Remove is a fake call that returns nil.
+func (f *FakeOS) Remove(path string) error {
+	f.Removes = append(f.Removes, path)
+	return nil
+}
+
+// RemoveAll is a fake call that just returns nil.
+func (f *FakeOS) RemoveAll(path string) error {
+	f.Removes = append(f.Removes, path)
+	return nil
+}
+
+// Create is a fake call that returns nil.
+func (FakeOS) Create(path string) (*os.File, error) {
+	return nil, nil
+}
+
+// Chmod is a fake call that returns nil.
+func (FakeOS) Chmod(path string, perm os.FileMode) error {
+	return nil
+}
+
+// Hostname is a fake call that returns nil.
+func (f *FakeOS) Hostname() (name string, err error) {
+	return f.HostName, nil
+}
+
+// Chtimes is a fake call that returns nil.
+func (FakeOS) Chtimes(path string, atime time.Time, mtime time.Time) error {
+	return nil
+}
+
+// Pipe is a fake call that returns nil.
+func (FakeOS) Pipe() (r *os.File, w *os.File, err error) {
+	return nil, nil, nil
+}
+
+// ReadDir is a fake call that returns the files under the directory.
+func (f *FakeOS) ReadDir(dirname string) ([]os.FileInfo, error) {
+	if f.ReadDirFn != nil {
+		return f.ReadDirFn(dirname)
+	}
+	return nil, nil
+}
+
+// Glob is a fake call that returns nil.
+func (f *FakeOS) Glob(pattern string) ([]string, error) {
+	return nil, nil
+}

vendor/k8s.io/kubernetes/pkg/kubelet/container/testing/runtime_mock.go

@@ -0,0 +1,161 @@
+/*
+Copyright 2015 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 testing
+
+import (
+	"io"
+	"time"
+
+	"github.com/stretchr/testify/mock"
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/tools/remotecommand"
+	"k8s.io/client-go/util/flowcontrol"
+	. "k8s.io/kubernetes/pkg/kubelet/container"
+	"k8s.io/kubernetes/pkg/volume"
+)
+
+type Mock struct {
+	mock.Mock
+}
+
+var _ Runtime = new(Mock)
+
+func (r *Mock) Start() error {
+	args := r.Called()
+	return args.Error(0)
+}
+
+func (r *Mock) Type() string {
+	args := r.Called()
+	return args.Get(0).(string)
+}
+
+func (r *Mock) Version() (Version, error) {
+	args := r.Called()
+	return args.Get(0).(Version), args.Error(1)
+}
+
+func (r *Mock) APIVersion() (Version, error) {
+	args := r.Called()
+	return args.Get(0).(Version), args.Error(1)
+}
+
+func (r *Mock) Status() (*RuntimeStatus, error) {
+	args := r.Called()
+	return args.Get(0).(*RuntimeStatus), args.Error(0)
+}
+
+func (r *Mock) GetPods(all bool) ([]*Pod, error) {
+	args := r.Called(all)
+	return args.Get(0).([]*Pod), args.Error(1)
+}
+
+func (r *Mock) SyncPod(pod *v1.Pod, apiStatus v1.PodStatus, status *PodStatus, secrets []v1.Secret, backOff *flowcontrol.Backoff) PodSyncResult {
+	args := r.Called(pod, apiStatus, status, secrets, backOff)
+	return args.Get(0).(PodSyncResult)
+}
+
+func (r *Mock) KillPod(pod *v1.Pod, runningPod Pod, gracePeriodOverride *int64) error {
+	args := r.Called(pod, runningPod, gracePeriodOverride)
+	return args.Error(0)
+}
+
+func (r *Mock) RunContainerInPod(container v1.Container, pod *v1.Pod, volumeMap map[string]volume.VolumePlugin) error {
+	args := r.Called(pod, pod, volumeMap)
+	return args.Error(0)
+}
+
+func (r *Mock) KillContainerInPod(container v1.Container, pod *v1.Pod) error {
+	args := r.Called(pod, pod)
+	return args.Error(0)
+}
+
+func (r *Mock) GetPodStatus(uid types.UID, name, namespace string) (*PodStatus, error) {
+	args := r.Called(uid, name, namespace)
+	return args.Get(0).(*PodStatus), args.Error(1)
+}
+
+func (r *Mock) ExecInContainer(containerID ContainerID, cmd []string, stdin io.Reader, stdout, stderr io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize, timeout time.Duration) error {
+	args := r.Called(containerID, cmd, stdin, stdout, stderr, tty)
+	return args.Error(0)
+}
+
+func (r *Mock) AttachContainer(containerID ContainerID, stdin io.Reader, stdout, stderr io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize) error {
+	args := r.Called(containerID, stdin, stdout, stderr, tty)
+	return args.Error(0)
+}
+
+func (r *Mock) GetContainerLogs(pod *v1.Pod, containerID ContainerID, logOptions *v1.PodLogOptions, stdout, stderr io.Writer) (err error) {
+	args := r.Called(pod, containerID, logOptions, stdout, stderr)
+	return args.Error(0)
+}
+
+func (r *Mock) PullImage(image ImageSpec, pullSecrets []v1.Secret) (string, error) {
+	args := r.Called(image, pullSecrets)
+	return image.Image, args.Error(0)
+}
+
+func (r *Mock) GetImageRef(image ImageSpec) (string, error) {
+	args := r.Called(image)
+	return args.Get(0).(string), args.Error(1)
+}
+
+func (r *Mock) ListImages() ([]Image, error) {
+	args := r.Called()
+	return args.Get(0).([]Image), args.Error(1)
+}
+
+func (r *Mock) RemoveImage(image ImageSpec) error {
+	args := r.Called(image)
+	return args.Error(0)
+}
+
+func (r *Mock) PortForward(pod *Pod, port uint16, stream io.ReadWriteCloser) error {
+	args := r.Called(pod, port, stream)
+	return args.Error(0)
+}
+
+func (r *Mock) GetNetNS(containerID ContainerID) (string, error) {
+	args := r.Called(containerID)
+	return "", args.Error(0)
+}
+
+func (r *Mock) GetPodContainerID(pod *Pod) (ContainerID, error) {
+	args := r.Called(pod)
+	return ContainerID{}, args.Error(0)
+}
+
+func (r *Mock) GarbageCollect(gcPolicy ContainerGCPolicy, ready bool, evictNonDeletedPods bool) error {
+	args := r.Called(gcPolicy, ready, evictNonDeletedPods)
+	return args.Error(0)
+}
+
+func (r *Mock) DeleteContainer(containerID ContainerID) error {
+	args := r.Called(containerID)
+	return args.Error(0)
+}
+
+func (r *Mock) ImageStats() (*ImageStats, error) {
+	args := r.Called()
+	return args.Get(0).(*ImageStats), args.Error(1)
+}
+
+// UpdatePodCIDR fulfills the cri interface.
+func (r *Mock) UpdatePodCIDR(c string) error {
+	return nil
+}