mockery to mockgen conversion

pkg/kubelet/apis/podresources/server_v1_test.go

@@ -22,16 +22,15 @@ import (
 	"sort"
 	"testing"
 
-	"k8s.io/api/core/v1"
+	"github.com/golang/mock/gomock"
+	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	featuregatetesting "k8s.io/component-base/featuregate/testing"
 	podresourcesapi "k8s.io/kubelet/pkg/apis/podresources/v1"
 	pkgfeatures "k8s.io/kubernetes/pkg/features"
-	"k8s.io/kubernetes/pkg/kubelet/cm/cpuset"
+	podresourcetest "k8s.io/kubernetes/pkg/kubelet/apis/podresources/testing"
-	"k8s.io/kubernetes/pkg/kubelet/cm/devicemanager"
-	"k8s.io/kubernetes/pkg/kubelet/cm/memorymanager/state"
 )
 
 func TestListPodResourcesV1(t *testing.T) {
@@ -41,6 +40,9 @@ func TestListPodResourcesV1(t *testing.T) {
 	containerName := "container-name"
 	numaID := int64(1)
 
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	devs := []*podresourcesapi.ContainerDevices{
 		{
 			ResourceName: "resource",
@@ -156,16 +158,21 @@ func TestListPodResourcesV1(t *testing.T) {
 		},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
-			m := new(mockProvider)
+			mockDevicesProvider := podresourcetest.NewMockDevicesProvider(mockCtrl)
-			m.On("GetPods").Return(tc.pods)
+			mockPodsProvider := podresourcetest.NewMockPodsProvider(mockCtrl)
-			m.On("GetDevices", string(podUID), containerName).Return(tc.devices)
+			mockCPUsProvider := podresourcetest.NewMockCPUsProvider(mockCtrl)
-			m.On("GetCPUs", string(podUID), containerName).Return(tc.cpus)
+			mockMemoryProvider := podresourcetest.NewMockMemoryProvider(mockCtrl)
-			m.On("GetMemory", string(podUID), containerName).Return(tc.memory)
+
-			m.On("UpdateAllocatedDevices").Return()
+			mockPodsProvider.EXPECT().GetPods().Return(tc.pods).AnyTimes().AnyTimes()
-			m.On("GetAllocatableCPUs").Return(cpuset.CPUSet{})
+			mockDevicesProvider.EXPECT().GetDevices(string(podUID), containerName).Return(tc.devices).AnyTimes()
-			m.On("GetAllocatableDevices").Return(devicemanager.NewResourceDeviceInstances())
+			mockCPUsProvider.EXPECT().GetCPUs(string(podUID), containerName).Return(tc.cpus).AnyTimes()
-			m.On("GetAllocatableMemory").Return([]state.Block{})
+			mockMemoryProvider.EXPECT().GetMemory(string(podUID), containerName).Return(tc.memory).AnyTimes()
-			server := NewV1PodResourcesServer(m, m, m, m)
+			mockDevicesProvider.EXPECT().UpdateAllocatedDevices().Return().AnyTimes()
+			mockCPUsProvider.EXPECT().GetAllocatableCPUs().Return([]int64{}).AnyTimes()
+			mockDevicesProvider.EXPECT().GetAllocatableDevices().Return([]*podresourcesapi.ContainerDevices{}).AnyTimes()
+			mockMemoryProvider.EXPECT().GetAllocatableMemory().Return([]*podresourcesapi.ContainerMemory{}).AnyTimes()
+
+			server := NewV1PodResourcesServer(mockPodsProvider, mockDevicesProvider, mockCPUsProvider, mockMemoryProvider)
 			resp, err := server.List(context.TODO(), &podresourcesapi.ListPodResourcesRequest{})
 			if err != nil {
 				t.Errorf("want err = %v, got %q", nil, err)
@@ -180,6 +187,9 @@ func TestListPodResourcesV1(t *testing.T) {
 func TestAllocatableResources(t *testing.T) {
 	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, pkgfeatures.KubeletPodResourcesGetAllocatable, true)()
 
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	allDevs := []*podresourcesapi.ContainerDevices{
 		{
 			ResourceName: "resource",
@@ -436,15 +446,20 @@ func TestAllocatableResources(t *testing.T) {
 		},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
-			m := new(mockProvider)
+			mockDevicesProvider := podresourcetest.NewMockDevicesProvider(mockCtrl)
-			m.On("GetDevices", "", "").Return([]*podresourcesapi.ContainerDevices{})
+			mockPodsProvider := podresourcetest.NewMockPodsProvider(mockCtrl)
-			m.On("GetCPUs", "", "").Return([]int64{})
+			mockCPUsProvider := podresourcetest.NewMockCPUsProvider(mockCtrl)
-			m.On("GetMemory", "", "").Return([]*podresourcesapi.ContainerMemory{})
+			mockMemoryProvider := podresourcetest.NewMockMemoryProvider(mockCtrl)
-			m.On("UpdateAllocatedDevices").Return()
+
-			m.On("GetAllocatableDevices").Return(tc.allDevices)
+			mockDevicesProvider.EXPECT().GetDevices("", "").Return([]*podresourcesapi.ContainerDevices{}).AnyTimes()
-			m.On("GetAllocatableCPUs").Return(tc.allCPUs)
+			mockCPUsProvider.EXPECT().GetCPUs("", "").Return([]int64{}).AnyTimes()
-			m.On("GetAllocatableMemory").Return(tc.allMemory)
+			mockMemoryProvider.EXPECT().GetMemory("", "").Return([]*podresourcesapi.ContainerMemory{}).AnyTimes()
-			server := NewV1PodResourcesServer(m, m, m, m)
+			mockDevicesProvider.EXPECT().UpdateAllocatedDevices().Return().AnyTimes()
+			mockDevicesProvider.EXPECT().GetAllocatableDevices().Return(tc.allDevices).AnyTimes()
+			mockCPUsProvider.EXPECT().GetAllocatableCPUs().Return(tc.allCPUs).AnyTimes()
+			mockMemoryProvider.EXPECT().GetAllocatableMemory().Return(tc.allMemory).AnyTimes()
+
+			server := NewV1PodResourcesServer(mockPodsProvider, mockDevicesProvider, mockCPUsProvider, mockMemoryProvider)
 
 			resp, err := server.GetAllocatableResources(context.TODO(), &podresourcesapi.AllocatableResourcesRequest{})
 			if err != nil {

pkg/kubelet/apis/podresources/server_v1alpha1_test.go

@@ -20,58 +20,15 @@ import (
 	"context"
 	"testing"
 
-	"github.com/stretchr/testify/mock"
+	"github.com/golang/mock/gomock"
-
+	v1 "k8s.io/api/core/v1"
-	"k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	podresourcesv1 "k8s.io/kubelet/pkg/apis/podresources/v1"
 	"k8s.io/kubelet/pkg/apis/podresources/v1alpha1"
+	podresourcetest "k8s.io/kubernetes/pkg/kubelet/apis/podresources/testing"
 )
 
-type mockProvider struct {
-	mock.Mock
-}
-
-func (m *mockProvider) GetPods() []*v1.Pod {
-	args := m.Called()
-	return args.Get(0).([]*v1.Pod)
-}
-
-func (m *mockProvider) GetDevices(podUID, containerName string) []*podresourcesv1.ContainerDevices {
-	args := m.Called(podUID, containerName)
-	return args.Get(0).([]*podresourcesv1.ContainerDevices)
-}
-
-func (m *mockProvider) GetCPUs(podUID, containerName string) []int64 {
-	args := m.Called(podUID, containerName)
-	return args.Get(0).([]int64)
-}
-
-func (m *mockProvider) GetMemory(podUID, containerName string) []*podresourcesv1.ContainerMemory {
-	args := m.Called(podUID, containerName)
-	return args.Get(0).([]*podresourcesv1.ContainerMemory)
-}
-
-func (m *mockProvider) UpdateAllocatedDevices() {
-	m.Called()
-}
-
-func (m *mockProvider) GetAllocatableDevices() []*podresourcesv1.ContainerDevices {
-	args := m.Called()
-	return args.Get(0).([]*podresourcesv1.ContainerDevices)
-}
-
-func (m *mockProvider) GetAllocatableCPUs() []int64 {
-	args := m.Called()
-	return args.Get(0).([]int64)
-}
-
-func (m *mockProvider) GetAllocatableMemory() []*podresourcesv1.ContainerMemory {
-	args := m.Called()
-	return args.Get(0).([]*podresourcesv1.ContainerMemory)
-}
-
 func TestListPodResourcesV1alpha1(t *testing.T) {
 	podName := "pod-name"
 	podNamespace := "pod-namespace"
@@ -85,6 +42,9 @@ func TestListPodResourcesV1alpha1(t *testing.T) {
 		},
 	}
 
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	for _, tc := range []struct {
 		desc             string
 		pods             []*v1.Pod
@@ -167,11 +127,14 @@ func TestListPodResourcesV1alpha1(t *testing.T) {
 		},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
-			m := new(mockProvider)
+			mockDevicesProvider := podresourcetest.NewMockDevicesProvider(mockCtrl)
-			m.On("GetPods").Return(tc.pods)
+			mockPodsProvider := podresourcetest.NewMockPodsProvider(mockCtrl)
-			m.On("GetDevices", string(podUID), containerName).Return(tc.devices)
+
-			m.On("UpdateAllocatedDevices").Return()
+			mockPodsProvider.EXPECT().GetPods().Return(tc.pods).AnyTimes()
-			server := NewV1alpha1PodResourcesServer(m, m)
+			mockDevicesProvider.EXPECT().GetDevices(string(podUID), containerName).Return(tc.devices).AnyTimes()
+			mockDevicesProvider.EXPECT().UpdateAllocatedDevices().Return().AnyTimes()
+
+			server := NewV1alpha1PodResourcesServer(mockPodsProvider, mockDevicesProvider)
 			resp, err := server.List(context.TODO(), &v1alpha1.ListPodResourcesRequest{})
 			if err != nil {
 				t.Errorf("want err = %v, got %q", nil, err)

pkg/kubelet/apis/podresources/testing/provider_mock.go

@@ -0,0 +1,230 @@
+/*
+Copyright 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 MockGen. DO NOT EDIT.
+// Source: types.go
+
+// Package testing is a generated GoMock package.
+package testing
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	v1 "k8s.io/api/core/v1"
+	v10 "k8s.io/kubelet/pkg/apis/podresources/v1"
+	reflect "reflect"
+)
+
+// MockDevicesProvider is a mock of DevicesProvider interface
+type MockDevicesProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockDevicesProviderMockRecorder
+}
+
+// MockDevicesProviderMockRecorder is the mock recorder for MockDevicesProvider
+type MockDevicesProviderMockRecorder struct {
+	mock *MockDevicesProvider
+}
+
+// NewMockDevicesProvider creates a new mock instance
+func NewMockDevicesProvider(ctrl *gomock.Controller) *MockDevicesProvider {
+	mock := &MockDevicesProvider{ctrl: ctrl}
+	mock.recorder = &MockDevicesProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockDevicesProvider) EXPECT() *MockDevicesProviderMockRecorder {
+	return m.recorder
+}
+
+// UpdateAllocatedDevices mocks base method
+func (m *MockDevicesProvider) UpdateAllocatedDevices() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "UpdateAllocatedDevices")
+}
+
+// UpdateAllocatedDevices indicates an expected call of UpdateAllocatedDevices
+func (mr *MockDevicesProviderMockRecorder) UpdateAllocatedDevices() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAllocatedDevices", reflect.TypeOf((*MockDevicesProvider)(nil).UpdateAllocatedDevices))
+}
+
+// GetDevices mocks base method
+func (m *MockDevicesProvider) GetDevices(podUID, containerName string) []*v10.ContainerDevices {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDevices", podUID, containerName)
+	ret0, _ := ret[0].([]*v10.ContainerDevices)
+	return ret0
+}
+
+// GetDevices indicates an expected call of GetDevices
+func (mr *MockDevicesProviderMockRecorder) GetDevices(podUID, containerName interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDevices", reflect.TypeOf((*MockDevicesProvider)(nil).GetDevices), podUID, containerName)
+}
+
+// GetAllocatableDevices mocks base method
+func (m *MockDevicesProvider) GetAllocatableDevices() []*v10.ContainerDevices {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAllocatableDevices")
+	ret0, _ := ret[0].([]*v10.ContainerDevices)
+	return ret0
+}
+
+// GetAllocatableDevices indicates an expected call of GetAllocatableDevices
+func (mr *MockDevicesProviderMockRecorder) GetAllocatableDevices() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllocatableDevices", reflect.TypeOf((*MockDevicesProvider)(nil).GetAllocatableDevices))
+}
+
+// MockPodsProvider is a mock of PodsProvider interface
+type MockPodsProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockPodsProviderMockRecorder
+}
+
+// MockPodsProviderMockRecorder is the mock recorder for MockPodsProvider
+type MockPodsProviderMockRecorder struct {
+	mock *MockPodsProvider
+}
+
+// NewMockPodsProvider creates a new mock instance
+func NewMockPodsProvider(ctrl *gomock.Controller) *MockPodsProvider {
+	mock := &MockPodsProvider{ctrl: ctrl}
+	mock.recorder = &MockPodsProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockPodsProvider) EXPECT() *MockPodsProviderMockRecorder {
+	return m.recorder
+}
+
+// GetPods mocks base method
+func (m *MockPodsProvider) GetPods() []*v1.Pod {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPods")
+	ret0, _ := ret[0].([]*v1.Pod)
+	return ret0
+}
+
+// GetPods indicates an expected call of GetPods
+func (mr *MockPodsProviderMockRecorder) GetPods() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockPodsProvider)(nil).GetPods))
+}
+
+// MockCPUsProvider is a mock of CPUsProvider interface
+type MockCPUsProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockCPUsProviderMockRecorder
+}
+
+// MockCPUsProviderMockRecorder is the mock recorder for MockCPUsProvider
+type MockCPUsProviderMockRecorder struct {
+	mock *MockCPUsProvider
+}
+
+// NewMockCPUsProvider creates a new mock instance
+func NewMockCPUsProvider(ctrl *gomock.Controller) *MockCPUsProvider {
+	mock := &MockCPUsProvider{ctrl: ctrl}
+	mock.recorder = &MockCPUsProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockCPUsProvider) EXPECT() *MockCPUsProviderMockRecorder {
+	return m.recorder
+}
+
+// GetCPUs mocks base method
+func (m *MockCPUsProvider) GetCPUs(podUID, containerName string) []int64 {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCPUs", podUID, containerName)
+	ret0, _ := ret[0].([]int64)
+	return ret0
+}
+
+// GetCPUs indicates an expected call of GetCPUs
+func (mr *MockCPUsProviderMockRecorder) GetCPUs(podUID, containerName interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCPUs", reflect.TypeOf((*MockCPUsProvider)(nil).GetCPUs), podUID, containerName)
+}
+
+// GetAllocatableCPUs mocks base method
+func (m *MockCPUsProvider) GetAllocatableCPUs() []int64 {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAllocatableCPUs")
+	ret0, _ := ret[0].([]int64)
+	return ret0
+}
+
+// GetAllocatableCPUs indicates an expected call of GetAllocatableCPUs
+func (mr *MockCPUsProviderMockRecorder) GetAllocatableCPUs() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllocatableCPUs", reflect.TypeOf((*MockCPUsProvider)(nil).GetAllocatableCPUs))
+}
+
+// MockMemoryProvider is a mock of MemoryProvider interface
+type MockMemoryProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockMemoryProviderMockRecorder
+}
+
+// MockMemoryProviderMockRecorder is the mock recorder for MockMemoryProvider
+type MockMemoryProviderMockRecorder struct {
+	mock *MockMemoryProvider
+}
+
+// NewMockMemoryProvider creates a new mock instance
+func NewMockMemoryProvider(ctrl *gomock.Controller) *MockMemoryProvider {
+	mock := &MockMemoryProvider{ctrl: ctrl}
+	mock.recorder = &MockMemoryProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockMemoryProvider) EXPECT() *MockMemoryProviderMockRecorder {
+	return m.recorder
+}
+
+// GetMemory mocks base method
+func (m *MockMemoryProvider) GetMemory(podUID, containerName string) []*v10.ContainerMemory {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetMemory", podUID, containerName)
+	ret0, _ := ret[0].([]*v10.ContainerMemory)
+	return ret0
+}
+
+// GetMemory indicates an expected call of GetMemory
+func (mr *MockMemoryProviderMockRecorder) GetMemory(podUID, containerName interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMemory", reflect.TypeOf((*MockMemoryProvider)(nil).GetMemory), podUID, containerName)
+}
+
+// GetAllocatableMemory mocks base method
+func (m *MockMemoryProvider) GetAllocatableMemory() []*v10.ContainerMemory {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAllocatableMemory")
+	ret0, _ := ret[0].([]*v10.ContainerMemory)
+	return ret0
+}
+
+// GetAllocatableMemory indicates an expected call of GetAllocatableMemory
+func (mr *MockMemoryProviderMockRecorder) GetAllocatableMemory() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllocatableMemory", reflect.TypeOf((*MockMemoryProvider)(nil).GetAllocatableMemory))
+}

pkg/kubelet/apis/podresources/types.go

@@ -14,10 +14,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+//go:generate mockgen -source=types.go -destination=testing/provider_mock.go -package=testing DevicesProvider,PodsProvider,CPUsProvider,MemoryProvider
 package podresources
 
 import (
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	podresourcesapi "k8s.io/kubelet/pkg/apis/podresources/v1"
 )
 

pkg/kubelet/cadvisor/testing/cadvisor_mock.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2015 The Kubernetes Authors.
+Copyright 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.
@@ -14,91 +14,256 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+// Code generated by MockGen. DO NOT EDIT.
+// Source: types.go
+
+// Package testing is a generated GoMock package.
 package testing
 
 import (
-	"github.com/google/cadvisor/events"
+	gomock "github.com/golang/mock/gomock"
-	cadvisorapi "github.com/google/cadvisor/info/v1"
+	events "github.com/google/cadvisor/events"
-	cadvisorapiv2 "github.com/google/cadvisor/info/v2"
+	v1 "github.com/google/cadvisor/info/v1"
-	"github.com/stretchr/testify/mock"
+	v2 "github.com/google/cadvisor/info/v2"
-	"k8s.io/kubernetes/pkg/kubelet/cadvisor"
+	reflect "reflect"
 )
 
-// Mock cadvisor.Interface implementation.
+// MockInterface is a mock of Interface interface
-type Mock struct {
+type MockInterface struct {
-	mock.Mock
+	ctrl     *gomock.Controller
+	recorder *MockInterfaceMockRecorder
 }
 
-var _ cadvisor.Interface = new(Mock)
+// MockInterfaceMockRecorder is the mock recorder for MockInterface
-
+type MockInterfaceMockRecorder struct {
-// Start is a mock implementation of Interface.Start.
+	mock *MockInterface
-func (c *Mock) Start() error {
-	args := c.Called()
-	return args.Error(0)
 }
 
-// ContainerInfo is a mock implementation of Interface.ContainerInfo.
+// NewMockInterface creates a new mock instance
-func (c *Mock) ContainerInfo(name string, req *cadvisorapi.ContainerInfoRequest) (*cadvisorapi.ContainerInfo, error) {
+func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
-	args := c.Called(name, req)
+	mock := &MockInterface{ctrl: ctrl}
-	return args.Get(0).(*cadvisorapi.ContainerInfo), args.Error(1)
+	mock.recorder = &MockInterfaceMockRecorder{mock}
+	return mock
 }
 
-// ContainerInfoV2 is a mock implementation of Interface.ContainerInfoV2.
+// EXPECT returns an object that allows the caller to indicate expected use
-func (c *Mock) ContainerInfoV2(name string, options cadvisorapiv2.RequestOptions) (map[string]cadvisorapiv2.ContainerInfo, error) {
+func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
-	args := c.Called(name, options)
+	return m.recorder
-	return args.Get(0).(map[string]cadvisorapiv2.ContainerInfo), args.Error(1)
 }
 
-// GetRequestedContainersInfo is a fake implementation if Interface.GetRequestedContainersInfo
+// Start mocks base method
-func (c *Mock) GetRequestedContainersInfo(containerName string, options cadvisorapiv2.RequestOptions) (map[string]*cadvisorapi.ContainerInfo, error) {
+func (m *MockInterface) Start() error {
-	args := c.Called(containerName, options)
+	m.ctrl.T.Helper()
-	return args.Get(0).(map[string]*cadvisorapi.ContainerInfo), args.Error(1)
+	ret := m.ctrl.Call(m, "Start")
+	ret0, _ := ret[0].(error)
+	return ret0
 }
 
-// SubcontainerInfo is a mock implementation of Interface.SubcontainerInfo.
+// Start indicates an expected call of Start
-func (c *Mock) SubcontainerInfo(name string, req *cadvisorapi.ContainerInfoRequest) (map[string]*cadvisorapi.ContainerInfo, error) {
+func (mr *MockInterfaceMockRecorder) Start() *gomock.Call {
-	args := c.Called(name, req)
+	mr.mock.ctrl.T.Helper()
-	return args.Get(0).(map[string]*cadvisorapi.ContainerInfo), args.Error(1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockInterface)(nil).Start))
 }
 
-// DockerContainer is a mock implementation of Interface.DockerContainer.
+// DockerContainer mocks base method
-func (c *Mock) DockerContainer(name string, req *cadvisorapi.ContainerInfoRequest) (cadvisorapi.ContainerInfo, error) {
+func (m *MockInterface) DockerContainer(name string, req *v1.ContainerInfoRequest) (v1.ContainerInfo, error) {
-	args := c.Called(name, req)
+	m.ctrl.T.Helper()
-	return args.Get(0).(cadvisorapi.ContainerInfo), args.Error(1)
+	ret := m.ctrl.Call(m, "DockerContainer", name, req)
+	ret0, _ := ret[0].(v1.ContainerInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
 }
 
-// MachineInfo is a mock implementation of Interface.MachineInfo.
+// DockerContainer indicates an expected call of DockerContainer
-func (c *Mock) MachineInfo() (*cadvisorapi.MachineInfo, error) {
+func (mr *MockInterfaceMockRecorder) DockerContainer(name, req interface{}) *gomock.Call {
-	args := c.Called()
+	mr.mock.ctrl.T.Helper()
-	return args.Get(0).(*cadvisorapi.MachineInfo), args.Error(1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DockerContainer", reflect.TypeOf((*MockInterface)(nil).DockerContainer), name, req)
 }
 
-// VersionInfo is a mock implementation of Interface.VersionInfo.
+// ContainerInfo mocks base method
-func (c *Mock) VersionInfo() (*cadvisorapi.VersionInfo, error) {
+func (m *MockInterface) ContainerInfo(name string, req *v1.ContainerInfoRequest) (*v1.ContainerInfo, error) {
-	args := c.Called()
+	m.ctrl.T.Helper()
-	return args.Get(0).(*cadvisorapi.VersionInfo), args.Error(1)
+	ret := m.ctrl.Call(m, "ContainerInfo", name, req)
+	ret0, _ := ret[0].(*v1.ContainerInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
 }
 
-// ImagesFsInfo is a mock implementation of Interface.ImagesFsInfo.
+// ContainerInfo indicates an expected call of ContainerInfo
-func (c *Mock) ImagesFsInfo() (cadvisorapiv2.FsInfo, error) {
+func (mr *MockInterfaceMockRecorder) ContainerInfo(name, req interface{}) *gomock.Call {
-	args := c.Called()
+	mr.mock.ctrl.T.Helper()
-	return args.Get(0).(cadvisorapiv2.FsInfo), args.Error(1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerInfo", reflect.TypeOf((*MockInterface)(nil).ContainerInfo), name, req)
 }
 
-// RootFsInfo is a mock implementation of Interface.RootFsInfo.
+// ContainerInfoV2 mocks base method
-func (c *Mock) RootFsInfo() (cadvisorapiv2.FsInfo, error) {
+func (m *MockInterface) ContainerInfoV2(name string, options v2.RequestOptions) (map[string]v2.ContainerInfo, error) {
-	args := c.Called()
+	m.ctrl.T.Helper()
-	return args.Get(0).(cadvisorapiv2.FsInfo), args.Error(1)
+	ret := m.ctrl.Call(m, "ContainerInfoV2", name, options)
+	ret0, _ := ret[0].(map[string]v2.ContainerInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
 }
 
-// WatchEvents is a mock implementation of Interface.WatchEvents.
+// ContainerInfoV2 indicates an expected call of ContainerInfoV2
-func (c *Mock) WatchEvents(request *events.Request) (*events.EventChannel, error) {
+func (mr *MockInterfaceMockRecorder) ContainerInfoV2(name, options interface{}) *gomock.Call {
-	args := c.Called()
+	mr.mock.ctrl.T.Helper()
-	return args.Get(0).(*events.EventChannel), args.Error(1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerInfoV2", reflect.TypeOf((*MockInterface)(nil).ContainerInfoV2), name, options)
 }
 
-// GetDirFsInfo is a mock implementation of Interface.GetDirFsInfo.
+// GetRequestedContainersInfo mocks base method
-func (c *Mock) GetDirFsInfo(path string) (cadvisorapiv2.FsInfo, error) {
+func (m *MockInterface) GetRequestedContainersInfo(containerName string, options v2.RequestOptions) (map[string]*v1.ContainerInfo, error) {
-	args := c.Called(path)
+	m.ctrl.T.Helper()
-	return args.Get(0).(cadvisorapiv2.FsInfo), args.Error(1)
+	ret := m.ctrl.Call(m, "GetRequestedContainersInfo", containerName, options)
+	ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRequestedContainersInfo indicates an expected call of GetRequestedContainersInfo
+func (mr *MockInterfaceMockRecorder) GetRequestedContainersInfo(containerName, options interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRequestedContainersInfo", reflect.TypeOf((*MockInterface)(nil).GetRequestedContainersInfo), containerName, options)
+}
+
+// SubcontainerInfo mocks base method
+func (m *MockInterface) SubcontainerInfo(name string, req *v1.ContainerInfoRequest) (map[string]*v1.ContainerInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubcontainerInfo", name, req)
+	ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SubcontainerInfo indicates an expected call of SubcontainerInfo
+func (mr *MockInterfaceMockRecorder) SubcontainerInfo(name, req interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubcontainerInfo", reflect.TypeOf((*MockInterface)(nil).SubcontainerInfo), name, req)
+}
+
+// MachineInfo mocks base method
+func (m *MockInterface) MachineInfo() (*v1.MachineInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MachineInfo")
+	ret0, _ := ret[0].(*v1.MachineInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MachineInfo indicates an expected call of MachineInfo
+func (mr *MockInterfaceMockRecorder) MachineInfo() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MachineInfo", reflect.TypeOf((*MockInterface)(nil).MachineInfo))
+}
+
+// VersionInfo mocks base method
+func (m *MockInterface) VersionInfo() (*v1.VersionInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "VersionInfo")
+	ret0, _ := ret[0].(*v1.VersionInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// VersionInfo indicates an expected call of VersionInfo
+func (mr *MockInterfaceMockRecorder) VersionInfo() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VersionInfo", reflect.TypeOf((*MockInterface)(nil).VersionInfo))
+}
+
+// ImagesFsInfo mocks base method
+func (m *MockInterface) ImagesFsInfo() (v2.FsInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ImagesFsInfo")
+	ret0, _ := ret[0].(v2.FsInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ImagesFsInfo indicates an expected call of ImagesFsInfo
+func (mr *MockInterfaceMockRecorder) ImagesFsInfo() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImagesFsInfo", reflect.TypeOf((*MockInterface)(nil).ImagesFsInfo))
+}
+
+// RootFsInfo mocks base method
+func (m *MockInterface) RootFsInfo() (v2.FsInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RootFsInfo")
+	ret0, _ := ret[0].(v2.FsInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RootFsInfo indicates an expected call of RootFsInfo
+func (mr *MockInterfaceMockRecorder) RootFsInfo() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RootFsInfo", reflect.TypeOf((*MockInterface)(nil).RootFsInfo))
+}
+
+// WatchEvents mocks base method
+func (m *MockInterface) WatchEvents(request *events.Request) (*events.EventChannel, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WatchEvents", request)
+	ret0, _ := ret[0].(*events.EventChannel)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// WatchEvents indicates an expected call of WatchEvents
+func (mr *MockInterfaceMockRecorder) WatchEvents(request interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchEvents", reflect.TypeOf((*MockInterface)(nil).WatchEvents), request)
+}
+
+// GetDirFsInfo mocks base method
+func (m *MockInterface) GetDirFsInfo(path string) (v2.FsInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDirFsInfo", path)
+	ret0, _ := ret[0].(v2.FsInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDirFsInfo indicates an expected call of GetDirFsInfo
+func (mr *MockInterfaceMockRecorder) GetDirFsInfo(path interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDirFsInfo", reflect.TypeOf((*MockInterface)(nil).GetDirFsInfo), path)
+}
+
+// MockImageFsInfoProvider is a mock of ImageFsInfoProvider interface
+type MockImageFsInfoProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockImageFsInfoProviderMockRecorder
+}
+
+// MockImageFsInfoProviderMockRecorder is the mock recorder for MockImageFsInfoProvider
+type MockImageFsInfoProviderMockRecorder struct {
+	mock *MockImageFsInfoProvider
+}
+
+// NewMockImageFsInfoProvider creates a new mock instance
+func NewMockImageFsInfoProvider(ctrl *gomock.Controller) *MockImageFsInfoProvider {
+	mock := &MockImageFsInfoProvider{ctrl: ctrl}
+	mock.recorder = &MockImageFsInfoProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockImageFsInfoProvider) EXPECT() *MockImageFsInfoProviderMockRecorder {
+	return m.recorder
+}
+
+// ImageFsInfoLabel mocks base method
+func (m *MockImageFsInfoProvider) ImageFsInfoLabel() (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ImageFsInfoLabel")
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ImageFsInfoLabel indicates an expected call of ImageFsInfoLabel
+func (mr *MockImageFsInfoProviderMockRecorder) ImageFsInfoLabel() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageFsInfoLabel", reflect.TypeOf((*MockImageFsInfoProvider)(nil).ImageFsInfoLabel))
 }

pkg/kubelet/cadvisor/types.go

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+//go:generate mockgen -source=types.go -destination=testing/cadvisor_mock.go -package=testing Interface
 package cadvisor
 
 import (

pkg/kubelet/container/runtime.go

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+//go:generate mockgen -source=runtime.go -destination=testing/runtime_mock.go -package=testing Runtime
 package container
 
 import (

pkg/kubelet/container/runtime_cache.go

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+//go:generate mockgen -source=runtime_cache.go  -destination=testing/mock_runtime_cache.go -package=testing RuntimeCache
 package container
 
 import (

pkg/kubelet/container/testing/mock_runtime_cache.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 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.
@@ -14,51 +14,105 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by mockery v1.0.0
+// Code generated by MockGen. DO NOT EDIT.
+// Source: runtime_cache.go
+
+// Package testing is a generated GoMock package.
 package testing
 
-import container "k8s.io/kubernetes/pkg/kubelet/container"
+import (
-import mock "github.com/stretchr/testify/mock"
+	gomock "github.com/golang/mock/gomock"
-import time "time"
+	container "k8s.io/kubernetes/pkg/kubelet/container"
+	reflect "reflect"
+	time "time"
+)
 
-// MockRuntimeCache is an autogenerated mock type for the RuntimeCache type
+// MockRuntimeCache is a mock of RuntimeCache interface
 type MockRuntimeCache struct {
-	mock.Mock
+	ctrl     *gomock.Controller
+	recorder *MockRuntimeCacheMockRecorder
 }
 
-// ForceUpdateIfOlder provides a mock function with given fields: _a0
+// MockRuntimeCacheMockRecorder is the mock recorder for MockRuntimeCache
-func (_m *MockRuntimeCache) ForceUpdateIfOlder(_a0 time.Time) error {
+type MockRuntimeCacheMockRecorder struct {
-	ret := _m.Called(_a0)
+	mock *MockRuntimeCache
-
-	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:
+// NewMockRuntimeCache creates a new mock instance
-func (_m *MockRuntimeCache) GetPods() ([]*container.Pod, error) {
+func NewMockRuntimeCache(ctrl *gomock.Controller) *MockRuntimeCache {
-	ret := _m.Called()
+	mock := &MockRuntimeCache{ctrl: ctrl}
-
+	mock.recorder = &MockRuntimeCacheMockRecorder{mock}
-	var r0 []*container.Pod
+	return mock
-	if rf, ok := ret.Get(0).(func() []*container.Pod); ok {
+}
-		r0 = rf()
+
-	} else {
+// EXPECT returns an object that allows the caller to indicate expected use
-		if ret.Get(0) != nil {
+func (m *MockRuntimeCache) EXPECT() *MockRuntimeCacheMockRecorder {
-			r0 = ret.Get(0).([]*container.Pod)
+	return m.recorder
-		}
+}
-	}
+
-
+// GetPods mocks base method
-	var r1 error
+func (m *MockRuntimeCache) GetPods() ([]*container.Pod, error) {
-	if rf, ok := ret.Get(1).(func() error); ok {
+	m.ctrl.T.Helper()
-		r1 = rf()
+	ret := m.ctrl.Call(m, "GetPods")
-	} else {
+	ret0, _ := ret[0].([]*container.Pod)
-		r1 = ret.Error(1)
+	ret1, _ := ret[1].(error)
-	}
+	return ret0, ret1
-
+}
-	return r0, r1
+
+// GetPods indicates an expected call of GetPods
+func (mr *MockRuntimeCacheMockRecorder) GetPods() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockRuntimeCache)(nil).GetPods))
+}
+
+// ForceUpdateIfOlder mocks base method
+func (m *MockRuntimeCache) ForceUpdateIfOlder(arg0 time.Time) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ForceUpdateIfOlder", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ForceUpdateIfOlder indicates an expected call of ForceUpdateIfOlder
+func (mr *MockRuntimeCacheMockRecorder) ForceUpdateIfOlder(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceUpdateIfOlder", reflect.TypeOf((*MockRuntimeCache)(nil).ForceUpdateIfOlder), arg0)
+}
+
+// MockpodsGetter is a mock of podsGetter interface
+type MockpodsGetter struct {
+	ctrl     *gomock.Controller
+	recorder *MockpodsGetterMockRecorder
+}
+
+// MockpodsGetterMockRecorder is the mock recorder for MockpodsGetter
+type MockpodsGetterMockRecorder struct {
+	mock *MockpodsGetter
+}
+
+// NewMockpodsGetter creates a new mock instance
+func NewMockpodsGetter(ctrl *gomock.Controller) *MockpodsGetter {
+	mock := &MockpodsGetter{ctrl: ctrl}
+	mock.recorder = &MockpodsGetterMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockpodsGetter) EXPECT() *MockpodsGetterMockRecorder {
+	return m.recorder
+}
+
+// GetPods mocks base method
+func (m *MockpodsGetter) GetPods(arg0 bool) ([]*container.Pod, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPods", arg0)
+	ret0, _ := ret[0].([]*container.Pod)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPods indicates an expected call of GetPods
+func (mr *MockpodsGetterMockRecorder) GetPods(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockpodsGetter)(nil).GetPods), arg0)
 }

pkg/kubelet/container/testing/runtime_mock.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2015 The Kubernetes Authors.
+Copyright 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.
@@ -14,145 +14,599 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+// Code generated by MockGen. DO NOT EDIT.
+// Source: runtime.go
+
+// Package testing is a generated GoMock package.
 package testing
 
 import (
-	"context"
+	context "context"
-	"io"
+	gomock "github.com/golang/mock/gomock"
-	"time"
+	io "io"
-
+	v1 "k8s.io/api/core/v1"
-	"github.com/stretchr/testify/mock"
+	types "k8s.io/apimachinery/pkg/types"
-	"k8s.io/api/core/v1"
+	remotecommand "k8s.io/client-go/tools/remotecommand"
-	"k8s.io/apimachinery/pkg/types"
+	flowcontrol "k8s.io/client-go/util/flowcontrol"
-	"k8s.io/client-go/tools/remotecommand"
+	v1alpha2 "k8s.io/cri-api/pkg/apis/runtime/v1alpha2"
-	"k8s.io/client-go/util/flowcontrol"
+	container "k8s.io/kubernetes/pkg/kubelet/container"
-	runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1alpha2"
+	url "net/url"
-	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
+	reflect "reflect"
-	"k8s.io/kubernetes/pkg/volume"
+	time "time"
 )
 
-type Mock struct {
+// MockVersion is a mock of Version interface
-	mock.Mock
+type MockVersion struct {
+	ctrl     *gomock.Controller
+	recorder *MockVersionMockRecorder
 }
 
-var _ kubecontainer.Runtime = new(Mock)
+// MockVersionMockRecorder is the mock recorder for MockVersion
-
+type MockVersionMockRecorder struct {
-func (r *Mock) Start() error {
+	mock *MockVersion
-	args := r.Called()
-	return args.Error(0)
 }
 
-func (r *Mock) Type() string {
+// NewMockVersion creates a new mock instance
-	args := r.Called()
+func NewMockVersion(ctrl *gomock.Controller) *MockVersion {
-	return args.Get(0).(string)
+	mock := &MockVersion{ctrl: ctrl}
+	mock.recorder = &MockVersionMockRecorder{mock}
+	return mock
 }
 
-func (r *Mock) SupportsSingleFileMapping() bool {
+// EXPECT returns an object that allows the caller to indicate expected use
-	args := r.Called()
+func (m *MockVersion) EXPECT() *MockVersionMockRecorder {
-	return args.Get(0).(bool)
+	return m.recorder
 }
 
-func (r *Mock) Version() (kubecontainer.Version, error) {
+// Compare mocks base method
-	args := r.Called()
+func (m *MockVersion) Compare(other string) (int, error) {
-	return args.Get(0).(kubecontainer.Version), args.Error(1)
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Compare", other)
+	ret0, _ := ret[0].(int)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
 }
 
-func (r *Mock) APIVersion() (kubecontainer.Version, error) {
+// Compare indicates an expected call of Compare
-	args := r.Called()
+func (mr *MockVersionMockRecorder) Compare(other interface{}) *gomock.Call {
-	return args.Get(0).(kubecontainer.Version), args.Error(1)
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compare", reflect.TypeOf((*MockVersion)(nil).Compare), other)
 }
 
-func (r *Mock) Status() (*kubecontainer.RuntimeStatus, error) {
+// String mocks base method
-	args := r.Called()
+func (m *MockVersion) String() string {
-	return args.Get(0).(*kubecontainer.RuntimeStatus), args.Error(0)
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "String")
+	ret0, _ := ret[0].(string)
+	return ret0
 }
 
-func (r *Mock) GetPods(all bool) ([]*kubecontainer.Pod, error) {
+// String indicates an expected call of String
-	args := r.Called(all)
+func (mr *MockVersionMockRecorder) String() *gomock.Call {
-	return args.Get(0).([]*kubecontainer.Pod), args.Error(1)
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockVersion)(nil).String))
 }
 
-func (r *Mock) SyncPod(pod *v1.Pod, status *kubecontainer.PodStatus, secrets []v1.Secret, backOff *flowcontrol.Backoff) kubecontainer.PodSyncResult {
+// MockRuntime is a mock of Runtime interface
-	args := r.Called(pod, status, secrets, backOff)
+type MockRuntime struct {
-	return args.Get(0).(kubecontainer.PodSyncResult)
+	ctrl     *gomock.Controller
+	recorder *MockRuntimeMockRecorder
 }
 
-func (r *Mock) KillPod(pod *v1.Pod, runningPod kubecontainer.Pod, gracePeriodOverride *int64) error {
+// MockRuntimeMockRecorder is the mock recorder for MockRuntime
-	args := r.Called(pod, runningPod, gracePeriodOverride)
+type MockRuntimeMockRecorder struct {
-	return args.Error(0)
+	mock *MockRuntime
 }
 
-func (r *Mock) RunContainerInPod(container v1.Container, pod *v1.Pod, volumeMap map[string]volume.VolumePlugin) error {
+// NewMockRuntime creates a new mock instance
-	args := r.Called(pod, pod, volumeMap)
+func NewMockRuntime(ctrl *gomock.Controller) *MockRuntime {
-	return args.Error(0)
+	mock := &MockRuntime{ctrl: ctrl}
+	mock.recorder = &MockRuntimeMockRecorder{mock}
+	return mock
 }
 
-func (r *Mock) KillContainerInPod(container v1.Container, pod *v1.Pod) error {
+// EXPECT returns an object that allows the caller to indicate expected use
-	args := r.Called(pod, pod)
+func (m *MockRuntime) EXPECT() *MockRuntimeMockRecorder {
-	return args.Error(0)
+	return m.recorder
 }
 
-func (r *Mock) GetPodStatus(uid types.UID, name, namespace string) (*kubecontainer.PodStatus, error) {
+// Type mocks base method
-	args := r.Called(uid, name, namespace)
+func (m *MockRuntime) Type() string {
-	return args.Get(0).(*kubecontainer.PodStatus), args.Error(1)
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Type")
+	ret0, _ := ret[0].(string)
+	return ret0
 }
 
-func (r *Mock) ExecInContainer(containerID kubecontainer.ContainerID, cmd []string, stdin io.Reader, stdout, stderr io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize, timeout time.Duration) error {
+// Type indicates an expected call of Type
-	args := r.Called(containerID, cmd, stdin, stdout, stderr, tty)
+func (mr *MockRuntimeMockRecorder) Type() *gomock.Call {
-	return args.Error(0)
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockRuntime)(nil).Type))
 }
 
-func (r *Mock) AttachContainer(containerID kubecontainer.ContainerID, stdin io.Reader, stdout, stderr io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize) error {
+// SupportsSingleFileMapping mocks base method
-	args := r.Called(containerID, stdin, stdout, stderr, tty)
+func (m *MockRuntime) SupportsSingleFileMapping() bool {
-	return args.Error(0)
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SupportsSingleFileMapping")
+	ret0, _ := ret[0].(bool)
+	return ret0
 }
 
-func (r *Mock) GetContainerLogs(_ context.Context, pod *v1.Pod, containerID kubecontainer.ContainerID, logOptions *v1.PodLogOptions, stdout, stderr io.Writer) (err error) {
+// SupportsSingleFileMapping indicates an expected call of SupportsSingleFileMapping
-	args := r.Called(pod, containerID, logOptions, stdout, stderr)
+func (mr *MockRuntimeMockRecorder) SupportsSingleFileMapping() *gomock.Call {
-	return args.Error(0)
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupportsSingleFileMapping", reflect.TypeOf((*MockRuntime)(nil).SupportsSingleFileMapping))
 }
 
-func (r *Mock) PullImage(image kubecontainer.ImageSpec, pullSecrets []v1.Secret, podSandboxConfig *runtimeapi.PodSandboxConfig) (string, error) {
+// Version mocks base method
-	args := r.Called(image, pullSecrets)
+func (m *MockRuntime) Version() (container.Version, error) {
-	return image.Image, args.Error(0)
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Version")
+	ret0, _ := ret[0].(container.Version)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
 }
 
-func (r *Mock) GetImageRef(image kubecontainer.ImageSpec) (string, error) {
+// Version indicates an expected call of Version
-	args := r.Called(image)
+func (mr *MockRuntimeMockRecorder) Version() *gomock.Call {
-	return args.Get(0).(string), args.Error(1)
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockRuntime)(nil).Version))
 }
 
-func (r *Mock) ListImages() ([]kubecontainer.Image, error) {
+// APIVersion mocks base method
-	args := r.Called()
+func (m *MockRuntime) APIVersion() (container.Version, error) {
-	return args.Get(0).([]kubecontainer.Image), args.Error(1)
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "APIVersion")
+	ret0, _ := ret[0].(container.Version)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
 }
 
-func (r *Mock) RemoveImage(image kubecontainer.ImageSpec) error {
+// APIVersion indicates an expected call of APIVersion
-	args := r.Called(image)
+func (mr *MockRuntimeMockRecorder) APIVersion() *gomock.Call {
-	return args.Error(0)
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "APIVersion", reflect.TypeOf((*MockRuntime)(nil).APIVersion))
 }
 
-func (r *Mock) PortForward(pod *kubecontainer.Pod, port uint16, stream io.ReadWriteCloser) error {
+// Status mocks base method
-	args := r.Called(pod, port, stream)
+func (m *MockRuntime) Status() (*container.RuntimeStatus, error) {
-	return args.Error(0)
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Status")
+	ret0, _ := ret[0].(*container.RuntimeStatus)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
 }
 
-func (r *Mock) GarbageCollect(gcPolicy kubecontainer.GCPolicy, ready bool, evictNonDeletedPods bool) error {
+// Status indicates an expected call of Status
-	args := r.Called(gcPolicy, ready, evictNonDeletedPods)
+func (mr *MockRuntimeMockRecorder) Status() *gomock.Call {
-	return args.Error(0)
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockRuntime)(nil).Status))
 }
 
-func (r *Mock) DeleteContainer(containerID kubecontainer.ContainerID) error {
+// GetPods mocks base method
-	args := r.Called(containerID)
+func (m *MockRuntime) GetPods(all bool) ([]*container.Pod, error) {
-	return args.Error(0)
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPods", all)
+	ret0, _ := ret[0].([]*container.Pod)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
 }
 
-func (r *Mock) ImageStats() (*kubecontainer.ImageStats, error) {
+// GetPods indicates an expected call of GetPods
-	args := r.Called()
+func (mr *MockRuntimeMockRecorder) GetPods(all interface{}) *gomock.Call {
-	return args.Get(0).(*kubecontainer.ImageStats), args.Error(1)
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockRuntime)(nil).GetPods), all)
 }
 
-// UpdatePodCIDR fulfills the cri interface.
+// GarbageCollect mocks base method
-func (r *Mock) UpdatePodCIDR(c string) error {
+func (m *MockRuntime) GarbageCollect(gcPolicy container.GCPolicy, allSourcesReady, evictNonDeletedPods bool) error {
-	return nil
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GarbageCollect", gcPolicy, allSourcesReady, evictNonDeletedPods)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// GarbageCollect indicates an expected call of GarbageCollect
+func (mr *MockRuntimeMockRecorder) GarbageCollect(gcPolicy, allSourcesReady, evictNonDeletedPods interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GarbageCollect", reflect.TypeOf((*MockRuntime)(nil).GarbageCollect), gcPolicy, allSourcesReady, evictNonDeletedPods)
+}
+
+// SyncPod mocks base method
+func (m *MockRuntime) SyncPod(pod *v1.Pod, podStatus *container.PodStatus, pullSecrets []v1.Secret, backOff *flowcontrol.Backoff) container.PodSyncResult {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SyncPod", pod, podStatus, pullSecrets, backOff)
+	ret0, _ := ret[0].(container.PodSyncResult)
+	return ret0
+}
+
+// SyncPod indicates an expected call of SyncPod
+func (mr *MockRuntimeMockRecorder) SyncPod(pod, podStatus, pullSecrets, backOff interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncPod", reflect.TypeOf((*MockRuntime)(nil).SyncPod), pod, podStatus, pullSecrets, backOff)
+}
+
+// KillPod mocks base method
+func (m *MockRuntime) KillPod(pod *v1.Pod, runningPod container.Pod, gracePeriodOverride *int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "KillPod", pod, runningPod, gracePeriodOverride)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// KillPod indicates an expected call of KillPod
+func (mr *MockRuntimeMockRecorder) KillPod(pod, runningPod, gracePeriodOverride interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KillPod", reflect.TypeOf((*MockRuntime)(nil).KillPod), pod, runningPod, gracePeriodOverride)
+}
+
+// GetPodStatus mocks base method
+func (m *MockRuntime) GetPodStatus(uid types.UID, name, namespace string) (*container.PodStatus, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPodStatus", uid, name, namespace)
+	ret0, _ := ret[0].(*container.PodStatus)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPodStatus indicates an expected call of GetPodStatus
+func (mr *MockRuntimeMockRecorder) GetPodStatus(uid, name, namespace interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodStatus", reflect.TypeOf((*MockRuntime)(nil).GetPodStatus), uid, name, namespace)
+}
+
+// GetContainerLogs mocks base method
+func (m *MockRuntime) GetContainerLogs(ctx context.Context, pod *v1.Pod, containerID container.ContainerID, logOptions *v1.PodLogOptions, stdout, stderr io.Writer) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetContainerLogs", ctx, pod, containerID, logOptions, stdout, stderr)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// GetContainerLogs indicates an expected call of GetContainerLogs
+func (mr *MockRuntimeMockRecorder) GetContainerLogs(ctx, pod, containerID, logOptions, stdout, stderr interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerLogs", reflect.TypeOf((*MockRuntime)(nil).GetContainerLogs), ctx, pod, containerID, logOptions, stdout, stderr)
+}
+
+// DeleteContainer mocks base method
+func (m *MockRuntime) DeleteContainer(containerID container.ContainerID) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteContainer", containerID)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteContainer indicates an expected call of DeleteContainer
+func (mr *MockRuntimeMockRecorder) DeleteContainer(containerID interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainer", reflect.TypeOf((*MockRuntime)(nil).DeleteContainer), containerID)
+}
+
+// PullImage mocks base method
+func (m *MockRuntime) PullImage(image container.ImageSpec, pullSecrets []v1.Secret, podSandboxConfig *v1alpha2.PodSandboxConfig) (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PullImage", image, pullSecrets, podSandboxConfig)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PullImage indicates an expected call of PullImage
+func (mr *MockRuntimeMockRecorder) PullImage(image, pullSecrets, podSandboxConfig interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockRuntime)(nil).PullImage), image, pullSecrets, podSandboxConfig)
+}
+
+// GetImageRef mocks base method
+func (m *MockRuntime) GetImageRef(image container.ImageSpec) (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetImageRef", image)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetImageRef indicates an expected call of GetImageRef
+func (mr *MockRuntimeMockRecorder) GetImageRef(image interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageRef", reflect.TypeOf((*MockRuntime)(nil).GetImageRef), image)
+}
+
+// ListImages mocks base method
+func (m *MockRuntime) ListImages() ([]container.Image, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListImages")
+	ret0, _ := ret[0].([]container.Image)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListImages indicates an expected call of ListImages
+func (mr *MockRuntimeMockRecorder) ListImages() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImages", reflect.TypeOf((*MockRuntime)(nil).ListImages))
+}
+
+// RemoveImage mocks base method
+func (m *MockRuntime) RemoveImage(image container.ImageSpec) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RemoveImage", image)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RemoveImage indicates an expected call of RemoveImage
+func (mr *MockRuntimeMockRecorder) RemoveImage(image interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveImage", reflect.TypeOf((*MockRuntime)(nil).RemoveImage), image)
+}
+
+// ImageStats mocks base method
+func (m *MockRuntime) ImageStats() (*container.ImageStats, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ImageStats")
+	ret0, _ := ret[0].(*container.ImageStats)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ImageStats indicates an expected call of ImageStats
+func (mr *MockRuntimeMockRecorder) ImageStats() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageStats", reflect.TypeOf((*MockRuntime)(nil).ImageStats))
+}
+
+// UpdatePodCIDR mocks base method
+func (m *MockRuntime) UpdatePodCIDR(podCIDR string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdatePodCIDR", podCIDR)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdatePodCIDR indicates an expected call of UpdatePodCIDR
+func (mr *MockRuntimeMockRecorder) UpdatePodCIDR(podCIDR interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePodCIDR", reflect.TypeOf((*MockRuntime)(nil).UpdatePodCIDR), podCIDR)
+}
+
+// MockStreamingRuntime is a mock of StreamingRuntime interface
+type MockStreamingRuntime struct {
+	ctrl     *gomock.Controller
+	recorder *MockStreamingRuntimeMockRecorder
+}
+
+// MockStreamingRuntimeMockRecorder is the mock recorder for MockStreamingRuntime
+type MockStreamingRuntimeMockRecorder struct {
+	mock *MockStreamingRuntime
+}
+
+// NewMockStreamingRuntime creates a new mock instance
+func NewMockStreamingRuntime(ctrl *gomock.Controller) *MockStreamingRuntime {
+	mock := &MockStreamingRuntime{ctrl: ctrl}
+	mock.recorder = &MockStreamingRuntimeMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockStreamingRuntime) EXPECT() *MockStreamingRuntimeMockRecorder {
+	return m.recorder
+}
+
+// GetExec mocks base method
+func (m *MockStreamingRuntime) GetExec(id container.ContainerID, cmd []string, stdin, stdout, stderr, tty bool) (*url.URL, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetExec", id, cmd, stdin, stdout, stderr, tty)
+	ret0, _ := ret[0].(*url.URL)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetExec indicates an expected call of GetExec
+func (mr *MockStreamingRuntimeMockRecorder) GetExec(id, cmd, stdin, stdout, stderr, tty interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExec", reflect.TypeOf((*MockStreamingRuntime)(nil).GetExec), id, cmd, stdin, stdout, stderr, tty)
+}
+
+// GetAttach mocks base method
+func (m *MockStreamingRuntime) GetAttach(id container.ContainerID, stdin, stdout, stderr, tty bool) (*url.URL, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAttach", id, stdin, stdout, stderr, tty)
+	ret0, _ := ret[0].(*url.URL)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAttach indicates an expected call of GetAttach
+func (mr *MockStreamingRuntimeMockRecorder) GetAttach(id, stdin, stdout, stderr, tty interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttach", reflect.TypeOf((*MockStreamingRuntime)(nil).GetAttach), id, stdin, stdout, stderr, tty)
+}
+
+// GetPortForward mocks base method
+func (m *MockStreamingRuntime) GetPortForward(podName, podNamespace string, podUID types.UID, ports []int32) (*url.URL, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPortForward", podName, podNamespace, podUID, ports)
+	ret0, _ := ret[0].(*url.URL)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPortForward indicates an expected call of GetPortForward
+func (mr *MockStreamingRuntimeMockRecorder) GetPortForward(podName, podNamespace, podUID, ports interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPortForward", reflect.TypeOf((*MockStreamingRuntime)(nil).GetPortForward), podName, podNamespace, podUID, ports)
+}
+
+// MockImageService is a mock of ImageService interface
+type MockImageService struct {
+	ctrl     *gomock.Controller
+	recorder *MockImageServiceMockRecorder
+}
+
+// MockImageServiceMockRecorder is the mock recorder for MockImageService
+type MockImageServiceMockRecorder struct {
+	mock *MockImageService
+}
+
+// NewMockImageService creates a new mock instance
+func NewMockImageService(ctrl *gomock.Controller) *MockImageService {
+	mock := &MockImageService{ctrl: ctrl}
+	mock.recorder = &MockImageServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockImageService) EXPECT() *MockImageServiceMockRecorder {
+	return m.recorder
+}
+
+// PullImage mocks base method
+func (m *MockImageService) PullImage(image container.ImageSpec, pullSecrets []v1.Secret, podSandboxConfig *v1alpha2.PodSandboxConfig) (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PullImage", image, pullSecrets, podSandboxConfig)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PullImage indicates an expected call of PullImage
+func (mr *MockImageServiceMockRecorder) PullImage(image, pullSecrets, podSandboxConfig interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockImageService)(nil).PullImage), image, pullSecrets, podSandboxConfig)
+}
+
+// GetImageRef mocks base method
+func (m *MockImageService) GetImageRef(image container.ImageSpec) (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetImageRef", image)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetImageRef indicates an expected call of GetImageRef
+func (mr *MockImageServiceMockRecorder) GetImageRef(image interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageRef", reflect.TypeOf((*MockImageService)(nil).GetImageRef), image)
+}
+
+// ListImages mocks base method
+func (m *MockImageService) ListImages() ([]container.Image, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListImages")
+	ret0, _ := ret[0].([]container.Image)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListImages indicates an expected call of ListImages
+func (mr *MockImageServiceMockRecorder) ListImages() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImages", reflect.TypeOf((*MockImageService)(nil).ListImages))
+}
+
+// RemoveImage mocks base method
+func (m *MockImageService) RemoveImage(image container.ImageSpec) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RemoveImage", image)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RemoveImage indicates an expected call of RemoveImage
+func (mr *MockImageServiceMockRecorder) RemoveImage(image interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveImage", reflect.TypeOf((*MockImageService)(nil).RemoveImage), image)
+}
+
+// ImageStats mocks base method
+func (m *MockImageService) ImageStats() (*container.ImageStats, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ImageStats")
+	ret0, _ := ret[0].(*container.ImageStats)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ImageStats indicates an expected call of ImageStats
+func (mr *MockImageServiceMockRecorder) ImageStats() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageStats", reflect.TypeOf((*MockImageService)(nil).ImageStats))
+}
+
+// MockAttacher is a mock of Attacher interface
+type MockAttacher struct {
+	ctrl     *gomock.Controller
+	recorder *MockAttacherMockRecorder
+}
+
+// MockAttacherMockRecorder is the mock recorder for MockAttacher
+type MockAttacherMockRecorder struct {
+	mock *MockAttacher
+}
+
+// NewMockAttacher creates a new mock instance
+func NewMockAttacher(ctrl *gomock.Controller) *MockAttacher {
+	mock := &MockAttacher{ctrl: ctrl}
+	mock.recorder = &MockAttacherMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockAttacher) EXPECT() *MockAttacherMockRecorder {
+	return m.recorder
+}
+
+// AttachContainer mocks base method
+func (m *MockAttacher) AttachContainer(id container.ContainerID, stdin io.Reader, stdout, stderr io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AttachContainer", id, stdin, stdout, stderr, tty, resize)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AttachContainer indicates an expected call of AttachContainer
+func (mr *MockAttacherMockRecorder) AttachContainer(id, stdin, stdout, stderr, tty, resize interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachContainer", reflect.TypeOf((*MockAttacher)(nil).AttachContainer), id, stdin, stdout, stderr, tty, resize)
+}
+
+// MockCommandRunner is a mock of CommandRunner interface
+type MockCommandRunner struct {
+	ctrl     *gomock.Controller
+	recorder *MockCommandRunnerMockRecorder
+}
+
+// MockCommandRunnerMockRecorder is the mock recorder for MockCommandRunner
+type MockCommandRunnerMockRecorder struct {
+	mock *MockCommandRunner
+}
+
+// NewMockCommandRunner creates a new mock instance
+func NewMockCommandRunner(ctrl *gomock.Controller) *MockCommandRunner {
+	mock := &MockCommandRunner{ctrl: ctrl}
+	mock.recorder = &MockCommandRunnerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockCommandRunner) EXPECT() *MockCommandRunnerMockRecorder {
+	return m.recorder
+}
+
+// RunInContainer mocks base method
+func (m *MockCommandRunner) RunInContainer(id container.ContainerID, cmd []string, timeout time.Duration) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RunInContainer", id, cmd, timeout)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RunInContainer indicates an expected call of RunInContainer
+func (mr *MockCommandRunnerMockRecorder) RunInContainer(id, cmd, timeout interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInContainer", reflect.TypeOf((*MockCommandRunner)(nil).RunInContainer), id, cmd, timeout)
 }

pkg/kubelet/eviction/eviction_manager_test.go

@@ -21,6 +21,7 @@ import (
 	"testing"
 	"time"
 
+	gomock "github.com/golang/mock/gomock"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	"k8s.io/apimachinery/pkg/types"
@@ -1551,8 +1552,11 @@ func TestUpdateMemcgThreshold(t *testing.T) {
 	}
 	summaryProvider := &fakeSummaryProvider{result: makeMemoryStats("2Gi", map[*v1.Pod]statsapi.PodStats{})}
 
-	thresholdNotifier := &MockThresholdNotifier{}
+	mockCtrl := gomock.NewController(t)
-	thresholdNotifier.On("UpdateThreshold", summaryProvider.result).Return(nil).Twice()
+	defer mockCtrl.Finish()
+
+	thresholdNotifier := NewMockThresholdNotifier(mockCtrl)
+	thresholdNotifier.EXPECT().UpdateThreshold(summaryProvider.result).Return(nil).Times(2)
 
 	manager := &managerImpl{
 		clock:                        fakeClock,
@@ -1568,29 +1572,24 @@ func TestUpdateMemcgThreshold(t *testing.T) {
 		thresholdNotifiers:           []ThresholdNotifier{thresholdNotifier},
 	}
 
-	manager.synchronize(diskInfoProvider, activePodsFunc)
 	// The UpdateThreshold method should have been called once, since this is the first run.
-	thresholdNotifier.AssertNumberOfCalls(t, "UpdateThreshold", 1)
-
 	manager.synchronize(diskInfoProvider, activePodsFunc)
-	// The UpdateThreshold method should not have been called again, since not enough time has passed
-	thresholdNotifier.AssertNumberOfCalls(t, "UpdateThreshold", 1)
 
+	// The UpdateThreshold method should not have been called again, since not enough time has passed
+	manager.synchronize(diskInfoProvider, activePodsFunc)
+
+	// The UpdateThreshold method should be called again since enough time has passed
 	fakeClock.Step(2 * notifierRefreshInterval)
 	manager.synchronize(diskInfoProvider, activePodsFunc)
-	// The UpdateThreshold method should be called again since enough time has passed
-	thresholdNotifier.AssertNumberOfCalls(t, "UpdateThreshold", 2)
 
 	// new memory threshold notifier that returns an error
-	thresholdNotifier = &MockThresholdNotifier{}
+	thresholdNotifier = NewMockThresholdNotifier(mockCtrl)
-	thresholdNotifier.On("UpdateThreshold", summaryProvider.result).Return(fmt.Errorf("error updating threshold"))
+	thresholdNotifier.EXPECT().UpdateThreshold(summaryProvider.result).Return(fmt.Errorf("error updating threshold")).Times(1)
-	thresholdNotifier.On("Description").Return("mock thresholdNotifier").Once()
+	thresholdNotifier.EXPECT().Description().Return("mock thresholdNotifier").Times(1)
 	manager.thresholdNotifiers = []ThresholdNotifier{thresholdNotifier}
 
-	fakeClock.Step(2 * notifierRefreshInterval)
-	manager.synchronize(diskInfoProvider, activePodsFunc)
 	// The UpdateThreshold method should be called because at least notifierRefreshInterval time has passed.
 	// The Description method should be called because UpdateThreshold returned an error
-	thresholdNotifier.AssertNumberOfCalls(t, "UpdateThreshold", 1)
+	fakeClock.Step(2 * notifierRefreshInterval)
-	thresholdNotifier.AssertNumberOfCalls(t, "Description", 1)
+	manager.synchronize(diskInfoProvider, activePodsFunc)
 }

pkg/kubelet/eviction/memory_threshold_notifier_test.go

@@ -23,6 +23,7 @@ import (
 	"testing"
 	"time"
 
+	gomock "github.com/golang/mock/gomock"
 	"k8s.io/apimachinery/pkg/api/resource"
 	statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
 	evictionapi "k8s.io/kubernetes/pkg/kubelet/eviction/api"
@@ -129,23 +130,24 @@ func TestUpdateThreshold(t *testing.T) {
 		},
 	}
 
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	for _, tc := range testCases {
 		t.Run(tc.description, func(t *testing.T) {
-			notifierFactory := &MockNotifierFactory{}
+			notifierFactory := NewMockNotifierFactory(mockCtrl)
-			notifier := &MockCgroupNotifier{}
+			notifier := NewMockCgroupNotifier(mockCtrl)
+
 			m := newTestMemoryThresholdNotifier(tc.evictionThreshold, notifierFactory, nil)
-			notifierFactory.On("NewCgroupNotifier", testCgroupPath, memoryUsageAttribute, tc.expectedThreshold.Value()).Return(notifier, tc.updateThresholdErr)
+			notifierFactory.EXPECT().NewCgroupNotifier(testCgroupPath, memoryUsageAttribute, tc.expectedThreshold.Value()).Return(notifier, tc.updateThresholdErr).Times(1)
 			var events chan<- struct{} = m.events
-			notifier.On("Start", events).Return()
+			notifier.EXPECT().Start(events).Return().AnyTimes()
 			err := m.UpdateThreshold(nodeSummary(tc.available, tc.workingSet, tc.usage, isAllocatableEvictionThreshold(tc.evictionThreshold)))
 			if err != nil && !tc.expectErr {
 				t.Errorf("Unexpected error updating threshold: %v", err)
 			} else if err == nil && tc.expectErr {
 				t.Errorf("Expected error updating threshold, but got nil")
 			}
-			if !tc.expectErr {
-				notifierFactory.AssertNumberOfCalls(t, "NewCgroupNotifier", 1)
-			}
 		})
 	}
 }
@@ -159,24 +161,26 @@ func TestStart(t *testing.T) {
 			Quantity: &noResources,
 		},
 	}
-	notifier := &MockCgroupNotifier{}
+	mockCtrl := gomock.NewController(t)
-	notifierFactory := &MockNotifierFactory{}
+	defer mockCtrl.Finish()
+	notifierFactory := NewMockNotifierFactory(mockCtrl)
+	notifier := NewMockCgroupNotifier(mockCtrl)
 
 	var wg sync.WaitGroup
 	wg.Add(4)
 	m := newTestMemoryThresholdNotifier(threshold, notifierFactory, func(string) {
 		wg.Done()
 	})
-	notifierFactory.On("NewCgroupNotifier", testCgroupPath, memoryUsageAttribute, int64(0)).Return(notifier, nil)
+	notifierFactory.EXPECT().NewCgroupNotifier(testCgroupPath, memoryUsageAttribute, int64(0)).Return(notifier, nil).Times(1)
+
 	var events chan<- struct{} = m.events
-	notifier.On("Start", events).Return()
+	notifier.EXPECT().Start(events).Return()
-	notifier.On("Stop").Return()
+	notifier.EXPECT().Stop().Return().AnyTimes()
 
 	err := m.UpdateThreshold(nodeSummary(noResources, noResources, noResources, isAllocatableEvictionThreshold(threshold)))
 	if err != nil {
 		t.Errorf("Unexpected error updating threshold: %v", err)
 	}
-	notifierFactory.AssertNumberOfCalls(t, "NewCgroupNotifier", 1)
 
 	go m.Start()
 

pkg/kubelet/eviction/mock_threshold_notifier_test.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2018 The Kubernetes Authors.
+Copyright 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.
@@ -14,85 +14,352 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+// Code generated by MockGen. DO NOT EDIT.
+// Source: types.go
+
+// Package eviction is a generated GoMock package.
 package eviction
 
 import (
-	mock "github.com/stretchr/testify/mock"
+	gomock "github.com/golang/mock/gomock"
-	statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
+	v1alpha1 "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
+	reflect "reflect"
+	time "time"
 )
 
-// MockCgroupNotifier is a mock implementation of the CgroupNotifier interface
+// MockManager is a mock of Manager interface
+type MockManager struct {
+	ctrl     *gomock.Controller
+	recorder *MockManagerMockRecorder
+}
+
+// MockManagerMockRecorder is the mock recorder for MockManager
+type MockManagerMockRecorder struct {
+	mock *MockManager
+}
+
+// NewMockManager creates a new mock instance
+func NewMockManager(ctrl *gomock.Controller) *MockManager {
+	mock := &MockManager{ctrl: ctrl}
+	mock.recorder = &MockManagerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockManager) EXPECT() *MockManagerMockRecorder {
+	return m.recorder
+}
+
+// Start mocks base method
+func (m *MockManager) Start(diskInfoProvider DiskInfoProvider, podFunc ActivePodsFunc, podCleanedUpFunc PodCleanedUpFunc, monitoringInterval time.Duration) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Start", diskInfoProvider, podFunc, podCleanedUpFunc, monitoringInterval)
+}
+
+// Start indicates an expected call of Start
+func (mr *MockManagerMockRecorder) Start(diskInfoProvider, podFunc, podCleanedUpFunc, monitoringInterval interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockManager)(nil).Start), diskInfoProvider, podFunc, podCleanedUpFunc, monitoringInterval)
+}
+
+// IsUnderMemoryPressure mocks base method
+func (m *MockManager) IsUnderMemoryPressure() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsUnderMemoryPressure")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// IsUnderMemoryPressure indicates an expected call of IsUnderMemoryPressure
+func (mr *MockManagerMockRecorder) IsUnderMemoryPressure() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUnderMemoryPressure", reflect.TypeOf((*MockManager)(nil).IsUnderMemoryPressure))
+}
+
+// IsUnderDiskPressure mocks base method
+func (m *MockManager) IsUnderDiskPressure() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsUnderDiskPressure")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// IsUnderDiskPressure indicates an expected call of IsUnderDiskPressure
+func (mr *MockManagerMockRecorder) IsUnderDiskPressure() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUnderDiskPressure", reflect.TypeOf((*MockManager)(nil).IsUnderDiskPressure))
+}
+
+// IsUnderPIDPressure mocks base method
+func (m *MockManager) IsUnderPIDPressure() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsUnderPIDPressure")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// IsUnderPIDPressure indicates an expected call of IsUnderPIDPressure
+func (mr *MockManagerMockRecorder) IsUnderPIDPressure() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUnderPIDPressure", reflect.TypeOf((*MockManager)(nil).IsUnderPIDPressure))
+}
+
+// MockDiskInfoProvider is a mock of DiskInfoProvider interface
+type MockDiskInfoProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockDiskInfoProviderMockRecorder
+}
+
+// MockDiskInfoProviderMockRecorder is the mock recorder for MockDiskInfoProvider
+type MockDiskInfoProviderMockRecorder struct {
+	mock *MockDiskInfoProvider
+}
+
+// NewMockDiskInfoProvider creates a new mock instance
+func NewMockDiskInfoProvider(ctrl *gomock.Controller) *MockDiskInfoProvider {
+	mock := &MockDiskInfoProvider{ctrl: ctrl}
+	mock.recorder = &MockDiskInfoProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockDiskInfoProvider) EXPECT() *MockDiskInfoProviderMockRecorder {
+	return m.recorder
+}
+
+// HasDedicatedImageFs mocks base method
+func (m *MockDiskInfoProvider) HasDedicatedImageFs() (bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HasDedicatedImageFs")
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HasDedicatedImageFs indicates an expected call of HasDedicatedImageFs
+func (mr *MockDiskInfoProviderMockRecorder) HasDedicatedImageFs() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasDedicatedImageFs", reflect.TypeOf((*MockDiskInfoProvider)(nil).HasDedicatedImageFs))
+}
+
+// MockImageGC is a mock of ImageGC interface
+type MockImageGC struct {
+	ctrl     *gomock.Controller
+	recorder *MockImageGCMockRecorder
+}
+
+// MockImageGCMockRecorder is the mock recorder for MockImageGC
+type MockImageGCMockRecorder struct {
+	mock *MockImageGC
+}
+
+// NewMockImageGC creates a new mock instance
+func NewMockImageGC(ctrl *gomock.Controller) *MockImageGC {
+	mock := &MockImageGC{ctrl: ctrl}
+	mock.recorder = &MockImageGCMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockImageGC) EXPECT() *MockImageGCMockRecorder {
+	return m.recorder
+}
+
+// DeleteUnusedImages mocks base method
+func (m *MockImageGC) DeleteUnusedImages() error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteUnusedImages")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteUnusedImages indicates an expected call of DeleteUnusedImages
+func (mr *MockImageGCMockRecorder) DeleteUnusedImages() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUnusedImages", reflect.TypeOf((*MockImageGC)(nil).DeleteUnusedImages))
+}
+
+// MockContainerGC is a mock of ContainerGC interface
+type MockContainerGC struct {
+	ctrl     *gomock.Controller
+	recorder *MockContainerGCMockRecorder
+}
+
+// MockContainerGCMockRecorder is the mock recorder for MockContainerGC
+type MockContainerGCMockRecorder struct {
+	mock *MockContainerGC
+}
+
+// NewMockContainerGC creates a new mock instance
+func NewMockContainerGC(ctrl *gomock.Controller) *MockContainerGC {
+	mock := &MockContainerGC{ctrl: ctrl}
+	mock.recorder = &MockContainerGCMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockContainerGC) EXPECT() *MockContainerGCMockRecorder {
+	return m.recorder
+}
+
+// DeleteAllUnusedContainers mocks base method
+func (m *MockContainerGC) DeleteAllUnusedContainers() error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteAllUnusedContainers")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteAllUnusedContainers indicates an expected call of DeleteAllUnusedContainers
+func (mr *MockContainerGCMockRecorder) DeleteAllUnusedContainers() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllUnusedContainers", reflect.TypeOf((*MockContainerGC)(nil).DeleteAllUnusedContainers))
+}
+
+// MockCgroupNotifier is a mock of CgroupNotifier interface
 type MockCgroupNotifier struct {
-	mock.Mock
+	ctrl     *gomock.Controller
+	recorder *MockCgroupNotifierMockRecorder
 }
 
-// Start implements the NotifierFactory interface
+// MockCgroupNotifierMockRecorder is the mock recorder for MockCgroupNotifier
-func (m *MockCgroupNotifier) Start(a0 chan<- struct{}) {
+type MockCgroupNotifierMockRecorder struct {
-	m.Called(a0)
+	mock *MockCgroupNotifier
 }
 
-// Stop implements the NotifierFactory interface
+// NewMockCgroupNotifier creates a new mock instance
+func NewMockCgroupNotifier(ctrl *gomock.Controller) *MockCgroupNotifier {
+	mock := &MockCgroupNotifier{ctrl: ctrl}
+	mock.recorder = &MockCgroupNotifierMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockCgroupNotifier) EXPECT() *MockCgroupNotifierMockRecorder {
+	return m.recorder
+}
+
+// Start mocks base method
+func (m *MockCgroupNotifier) Start(eventCh chan<- struct{}) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Start", eventCh)
+}
+
+// Start indicates an expected call of Start
+func (mr *MockCgroupNotifierMockRecorder) Start(eventCh interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockCgroupNotifier)(nil).Start), eventCh)
+}
+
+// Stop mocks base method
 func (m *MockCgroupNotifier) Stop() {
-	m.Called()
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Stop")
 }
 
-// MockNotifierFactory is a mock of the NotifierFactory interface
+// Stop indicates an expected call of Stop
+func (mr *MockCgroupNotifierMockRecorder) Stop() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockCgroupNotifier)(nil).Stop))
+}
+
+// MockNotifierFactory is a mock of NotifierFactory interface
 type MockNotifierFactory struct {
-	mock.Mock
+	ctrl     *gomock.Controller
+	recorder *MockNotifierFactoryMockRecorder
 }
 
-// NewCgroupNotifier implements the NotifierFactory interface
+// MockNotifierFactoryMockRecorder is the mock recorder for MockNotifierFactory
-func (m *MockNotifierFactory) NewCgroupNotifier(a0, a1 string, a2 int64) (CgroupNotifier, error) {
+type MockNotifierFactoryMockRecorder struct {
-	ret := m.Called(a0, a1, a2)
+	mock *MockNotifierFactory
-
-	var r0 CgroupNotifier
-	if rf, ok := ret.Get(0).(func(string, string, int64) CgroupNotifier); ok {
-		r0 = rf(a0, a1, a2)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(CgroupNotifier)
-		}
-	}
-	var r1 error
-	if rf, ok := ret.Get(1).(func(string, string, int64) error); ok {
-		r1 = rf(a0, a1, a2)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
 }
 
-// MockThresholdNotifier is a mock implementation of the ThresholdNotifier interface
+// NewMockNotifierFactory creates a new mock instance
+func NewMockNotifierFactory(ctrl *gomock.Controller) *MockNotifierFactory {
+	mock := &MockNotifierFactory{ctrl: ctrl}
+	mock.recorder = &MockNotifierFactoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockNotifierFactory) EXPECT() *MockNotifierFactoryMockRecorder {
+	return m.recorder
+}
+
+// NewCgroupNotifier mocks base method
+func (m *MockNotifierFactory) NewCgroupNotifier(path, attribute string, threshold int64) (CgroupNotifier, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "NewCgroupNotifier", path, attribute, threshold)
+	ret0, _ := ret[0].(CgroupNotifier)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NewCgroupNotifier indicates an expected call of NewCgroupNotifier
+func (mr *MockNotifierFactoryMockRecorder) NewCgroupNotifier(path, attribute, threshold interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCgroupNotifier", reflect.TypeOf((*MockNotifierFactory)(nil).NewCgroupNotifier), path, attribute, threshold)
+}
+
+// MockThresholdNotifier is a mock of ThresholdNotifier interface
 type MockThresholdNotifier struct {
-	mock.Mock
+	ctrl     *gomock.Controller
+	recorder *MockThresholdNotifierMockRecorder
 }
 
-// Start implements the ThresholdNotifier interface
+// MockThresholdNotifierMockRecorder is the mock recorder for MockThresholdNotifier
+type MockThresholdNotifierMockRecorder struct {
+	mock *MockThresholdNotifier
+}
+
+// NewMockThresholdNotifier creates a new mock instance
+func NewMockThresholdNotifier(ctrl *gomock.Controller) *MockThresholdNotifier {
+	mock := &MockThresholdNotifier{ctrl: ctrl}
+	mock.recorder = &MockThresholdNotifierMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockThresholdNotifier) EXPECT() *MockThresholdNotifierMockRecorder {
+	return m.recorder
+}
+
+// Start mocks base method
 func (m *MockThresholdNotifier) Start() {
-	m.Called()
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Start")
 }
 
-// UpdateThreshold implements the ThresholdNotifier interface
+// Start indicates an expected call of Start
-func (m *MockThresholdNotifier) UpdateThreshold(a0 *statsapi.Summary) error {
+func (mr *MockThresholdNotifierMockRecorder) Start() *gomock.Call {
-	ret := m.Called(a0)
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockThresholdNotifier)(nil).Start))
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*statsapi.Summary) error); ok {
-		r0 = rf(a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
 }
 
-// Description implements the ThresholdNotifier interface
+// UpdateThreshold mocks base method
+func (m *MockThresholdNotifier) UpdateThreshold(summary *v1alpha1.Summary) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateThreshold", summary)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateThreshold indicates an expected call of UpdateThreshold
+func (mr *MockThresholdNotifierMockRecorder) UpdateThreshold(summary interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateThreshold", reflect.TypeOf((*MockThresholdNotifier)(nil).UpdateThreshold), summary)
+}
+
+// Description mocks base method
 func (m *MockThresholdNotifier) Description() string {
-	ret := m.Called()
+	m.ctrl.T.Helper()
-	var r0 string
+	ret := m.ctrl.Call(m, "Description")
-	if rf, ok := ret.Get(0).(func() string); ok {
+	ret0, _ := ret[0].(string)
-		r0 = rf()
+	return ret0
-	} else {
+}
-		r0 = ret.String(0)
+
-	}
+// Description indicates an expected call of Description
-	return r0
+func (mr *MockThresholdNotifierMockRecorder) Description() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Description", reflect.TypeOf((*MockThresholdNotifier)(nil).Description))
 }

pkg/kubelet/eviction/types.go

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+//go:generate mockgen -source=types.go -destination=mock_threshold_notifier_test.go -package=eviction NotifierFactory,ThresholdNotifier
 package eviction
 
 import (

pkg/kubelet/images/image_gc_manager_test.go

@@ -21,6 +21,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -29,15 +30,15 @@ import (
 	statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
 	"k8s.io/kubernetes/pkg/kubelet/container"
 	containertest "k8s.io/kubernetes/pkg/kubelet/container/testing"
+	stats "k8s.io/kubernetes/pkg/kubelet/server/stats"
 	statstest "k8s.io/kubernetes/pkg/kubelet/server/stats/testing"
 )
 
 var zero time.Time
 var sandboxImage = "k8s.gcr.io/pause-amd64:latest"
 
-func newRealImageGCManager(policy ImageGCPolicy) (*realImageGCManager, *containertest.FakeRuntime, *statstest.StatsProvider) {
+func newRealImageGCManager(policy ImageGCPolicy, mockStatsProvider stats.Provider) (*realImageGCManager, *containertest.FakeRuntime) {
 	fakeRuntime := &containertest.FakeRuntime{}
-	mockStatsProvider := new(statstest.StatsProvider)
 	return &realImageGCManager{
 		runtime:       fakeRuntime,
 		policy:        policy,
@@ -45,7 +46,7 @@ func newRealImageGCManager(policy ImageGCPolicy) (*realImageGCManager, *containe
 		statsProvider: mockStatsProvider,
 		recorder:      &record.FakeRecorder{},
 		sandboxImage:  sandboxImage,
-	}, fakeRuntime, mockStatsProvider
+	}, fakeRuntime
 }
 
 // Accessors used for thread-safe testing.
@@ -90,7 +91,11 @@ func makeContainer(id int) *container.Container {
 }
 
 func TestDetectImagesInitialDetect(t *testing.T) {
-	manager, fakeRuntime, _ := newRealImageGCManager(ImageGCPolicy{})
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+
+	manager, fakeRuntime := newRealImageGCManager(ImageGCPolicy{}, mockStatsProvider)
 	fakeRuntime.ImageList = []container.Image{
 		makeImage(0, 1024),
 		makeImage(1, 2048),
@@ -133,8 +138,12 @@ func TestDetectImagesInitialDetect(t *testing.T) {
 }
 
 func TestDetectImagesWithNewImage(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+
 	// Just one image initially.
-	manager, fakeRuntime, _ := newRealImageGCManager(ImageGCPolicy{})
+	manager, fakeRuntime := newRealImageGCManager(ImageGCPolicy{}, mockStatsProvider)
 	fakeRuntime.ImageList = []container.Image{
 		makeImage(0, 1024),
 		makeImage(1, 2048),
@@ -179,7 +188,11 @@ func TestDetectImagesWithNewImage(t *testing.T) {
 }
 
 func TestDeleteUnusedImagesExemptSandboxImage(t *testing.T) {
-	manager, fakeRuntime, _ := newRealImageGCManager(ImageGCPolicy{})
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+
+	manager, fakeRuntime := newRealImageGCManager(ImageGCPolicy{}, mockStatsProvider)
 	fakeRuntime.ImageList = []container.Image{
 		{
 			ID:   sandboxImage,
@@ -194,7 +207,11 @@ func TestDeleteUnusedImagesExemptSandboxImage(t *testing.T) {
 }
 
 func TestDetectImagesContainerStopped(t *testing.T) {
-	manager, fakeRuntime, _ := newRealImageGCManager(ImageGCPolicy{})
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+
+	manager, fakeRuntime := newRealImageGCManager(ImageGCPolicy{}, mockStatsProvider)
 	fakeRuntime.ImageList = []container.Image{
 		makeImage(0, 1024),
 		makeImage(1, 2048),
@@ -230,7 +247,11 @@ func TestDetectImagesContainerStopped(t *testing.T) {
 }
 
 func TestDetectImagesWithRemovedImages(t *testing.T) {
-	manager, fakeRuntime, _ := newRealImageGCManager(ImageGCPolicy{})
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+
+	manager, fakeRuntime := newRealImageGCManager(ImageGCPolicy{}, mockStatsProvider)
 	fakeRuntime.ImageList = []container.Image{
 		makeImage(0, 1024),
 		makeImage(1, 2048),
@@ -256,7 +277,11 @@ func TestDetectImagesWithRemovedImages(t *testing.T) {
 }
 
 func TestFreeSpaceImagesInUseContainersAreIgnored(t *testing.T) {
-	manager, fakeRuntime, _ := newRealImageGCManager(ImageGCPolicy{})
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+
+	manager, fakeRuntime := newRealImageGCManager(ImageGCPolicy{}, mockStatsProvider)
 	fakeRuntime.ImageList = []container.Image{
 		makeImage(0, 1024),
 		makeImage(1, 2048),
@@ -277,7 +302,11 @@ func TestFreeSpaceImagesInUseContainersAreIgnored(t *testing.T) {
 }
 
 func TestDeleteUnusedImagesRemoveAllUnusedImages(t *testing.T) {
-	manager, fakeRuntime, _ := newRealImageGCManager(ImageGCPolicy{})
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+
+	manager, fakeRuntime := newRealImageGCManager(ImageGCPolicy{}, mockStatsProvider)
 	fakeRuntime.ImageList = []container.Image{
 		makeImage(0, 1024),
 		makeImage(1, 2048),
@@ -298,7 +327,11 @@ func TestDeleteUnusedImagesRemoveAllUnusedImages(t *testing.T) {
 }
 
 func TestFreeSpaceRemoveByLeastRecentlyUsed(t *testing.T) {
-	manager, fakeRuntime, _ := newRealImageGCManager(ImageGCPolicy{})
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+
+	manager, fakeRuntime := newRealImageGCManager(ImageGCPolicy{}, mockStatsProvider)
 	fakeRuntime.ImageList = []container.Image{
 		makeImage(0, 1024),
 		makeImage(1, 2048),
@@ -341,7 +374,11 @@ func TestFreeSpaceRemoveByLeastRecentlyUsed(t *testing.T) {
 }
 
 func TestFreeSpaceTiesBrokenByDetectedTime(t *testing.T) {
-	manager, fakeRuntime, _ := newRealImageGCManager(ImageGCPolicy{})
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+
+	manager, fakeRuntime := newRealImageGCManager(ImageGCPolicy{}, mockStatsProvider)
 	fakeRuntime.ImageList = []container.Image{
 		makeImage(0, 1024),
 	}
@@ -379,10 +416,13 @@ func TestGarbageCollectBelowLowThreshold(t *testing.T) {
 		HighThresholdPercent: 90,
 		LowThresholdPercent:  80,
 	}
-	manager, _, mockStatsProvider := newRealImageGCManager(policy)
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+	manager, _ := newRealImageGCManager(policy, mockStatsProvider)
 
 	// Expect 40% usage.
-	mockStatsProvider.On("ImageFsStats").Return(&statsapi.FsStats{
+	mockStatsProvider.EXPECT().ImageFsStats().Return(&statsapi.FsStats{
 		AvailableBytes: uint64Ptr(600),
 		CapacityBytes:  uint64Ptr(1000),
 	}, nil)
@@ -395,9 +435,12 @@ func TestGarbageCollectCadvisorFailure(t *testing.T) {
 		HighThresholdPercent: 90,
 		LowThresholdPercent:  80,
 	}
-	manager, _, mockStatsProvider := newRealImageGCManager(policy)
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+	manager, _ := newRealImageGCManager(policy, mockStatsProvider)
 
-	mockStatsProvider.On("ImageFsStats").Return(&statsapi.FsStats{}, fmt.Errorf("error"))
+	mockStatsProvider.EXPECT().ImageFsStats().Return(&statsapi.FsStats{}, fmt.Errorf("error"))
 	assert.NotNil(t, manager.GarbageCollect())
 }
 
@@ -406,10 +449,14 @@ func TestGarbageCollectBelowSuccess(t *testing.T) {
 		HighThresholdPercent: 90,
 		LowThresholdPercent:  80,
 	}
-	manager, fakeRuntime, mockStatsProvider := newRealImageGCManager(policy)
+
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+	manager, fakeRuntime := newRealImageGCManager(policy, mockStatsProvider)
 
 	// Expect 95% usage and most of it gets freed.
-	mockStatsProvider.On("ImageFsStats").Return(&statsapi.FsStats{
+	mockStatsProvider.EXPECT().ImageFsStats().Return(&statsapi.FsStats{
 		AvailableBytes: uint64Ptr(50),
 		CapacityBytes:  uint64Ptr(1000),
 	}, nil)
@@ -425,10 +472,13 @@ func TestGarbageCollectNotEnoughFreed(t *testing.T) {
 		HighThresholdPercent: 90,
 		LowThresholdPercent:  80,
 	}
-	manager, fakeRuntime, mockStatsProvider := newRealImageGCManager(policy)
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+	manager, fakeRuntime := newRealImageGCManager(policy, mockStatsProvider)
 
 	// Expect 95% usage and little of it gets freed.
-	mockStatsProvider.On("ImageFsStats").Return(&statsapi.FsStats{
+	mockStatsProvider.EXPECT().ImageFsStats().Return(&statsapi.FsStats{
 		AvailableBytes: uint64Ptr(50),
 		CapacityBytes:  uint64Ptr(1000),
 	}, nil)
@@ -446,7 +496,9 @@ func TestGarbageCollectImageNotOldEnough(t *testing.T) {
 		MinAge:               time.Minute * 1,
 	}
 	fakeRuntime := &containertest.FakeRuntime{}
-	mockStatsProvider := new(statstest.StatsProvider)
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
 	manager := &realImageGCManager{
 		runtime:       fakeRuntime,
 		policy:        policy,

pkg/kubelet/metrics/collectors/resource_metrics_test.go

@@ -22,27 +22,13 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/mock"
+	"github.com/golang/mock/gomock"
-
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/component-base/metrics/testutil"
 	statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
+	summaryprovidertest "k8s.io/kubernetes/pkg/kubelet/server/stats/testing"
 )
 
-type mockSummaryProvider struct {
-	mock.Mock
-}
-
-func (m *mockSummaryProvider) Get(updateStats bool) (*statsapi.Summary, error) {
-	args := m.Called(updateStats)
-	return args.Get(0).(*statsapi.Summary), args.Error(1)
-}
-
-func (m *mockSummaryProvider) GetCPUAndMemoryStats() (*statsapi.Summary, error) {
-	args := m.Called()
-	return args.Get(0).(*statsapi.Summary), args.Error(1)
-}
-
 func TestCollectResourceMetrics(t *testing.T) {
 	// a static timestamp: 2021-06-23 05:11:18.302091597 +0800
 	staticTimestamp := time.Unix(0, 1624396278302091597)
@@ -57,6 +43,8 @@ func TestCollectResourceMetrics(t *testing.T) {
 		"pod_cpu_usage_seconds_total",
 		"pod_memory_working_set_bytes",
 	}
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
 
 	tests := []struct {
 		name            string
@@ -219,8 +207,8 @@ func TestCollectResourceMetrics(t *testing.T) {
 	for _, test := range tests {
 		tc := test
 		t.Run(tc.name, func(t *testing.T) {
-			provider := &mockSummaryProvider{}
+			provider := summaryprovidertest.NewMockSummaryProvider(mockCtrl)
-			provider.On("GetCPUAndMemoryStats").Return(tc.summary, tc.summaryErr)
+			provider.EXPECT().GetCPUAndMemoryStats().Return(tc.summary, tc.summaryErr).AnyTimes()
 			collector := NewResourceMetricsCollector(provider)
 
 			if err := testutil.CustomCollectAndCompare(collector, strings.NewReader(tc.expectedMetrics), interestedMetrics...); err != nil {

pkg/kubelet/metrics/collectors/volume_stats_test.go

@@ -20,6 +20,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/golang/mock/gomock"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/component-base/metrics/testutil"
 	statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
@@ -129,9 +130,12 @@ func TestVolumeStatsCollector(t *testing.T) {
 		}
 	)
 
-	mockStatsProvider := new(statstest.StatsProvider)
+	mockCtrl := gomock.NewController(t)
-	mockStatsProvider.On("ListPodStats").Return(podStats, nil)
+	defer mockCtrl.Finish()
-	mockStatsProvider.On("ListPodStatsAndUpdateCPUNanoCoreUsage").Return(podStats, nil)
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
+
+	mockStatsProvider.EXPECT().ListPodStats().Return(podStats, nil).AnyTimes()
+	mockStatsProvider.EXPECT().ListPodStatsAndUpdateCPUNanoCoreUsage().Return(podStats, nil).AnyTimes()
 	if err := testutil.CustomCollectAndCompare(&volumeStatsCollector{statsProvider: mockStatsProvider}, strings.NewReader(want), metrics...); err != nil {
 		t.Errorf("unexpected collecting result:\n%s", err)
 	}

pkg/kubelet/pleg/generic_test.go

@@ -25,6 +25,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 
 	"k8s.io/apimachinery/pkg/types"
@@ -310,8 +311,7 @@ func testReportMissingPods(t *testing.T, numRelists int) {
 	verifyEvents(t, expected, actual)
 }
 
-func newTestGenericPLEGWithRuntimeMock() (*GenericPLEG, *containertest.Mock) {
+func newTestGenericPLEGWithRuntimeMock(runtimeMock kubecontainer.Runtime) *GenericPLEG {
-	runtimeMock := &containertest.Mock{}
 	pleg := &GenericPLEG{
 		relistPeriod: time.Hour,
 		runtime:      runtimeMock,
@@ -320,7 +320,7 @@ func newTestGenericPLEGWithRuntimeMock() (*GenericPLEG, *containertest.Mock) {
 		cache:        kubecontainer.NewCache(),
 		clock:        clock.RealClock{},
 	}
-	return pleg, runtimeMock
+	return pleg
 }
 
 func createTestPodsStatusesAndEvents(num int) ([]*kubecontainer.Pod, []*kubecontainer.PodStatus, []*PodLifecycleEvent) {
@@ -349,15 +349,19 @@ func createTestPodsStatusesAndEvents(num int) ([]*kubecontainer.Pod, []*kubecont
 }
 
 func TestRelistWithCache(t *testing.T) {
-	pleg, runtimeMock := newTestGenericPLEGWithRuntimeMock()
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	runtimeMock := containertest.NewMockRuntime(mockCtrl)
+
+	pleg := newTestGenericPLEGWithRuntimeMock(runtimeMock)
 	ch := pleg.Watch()
 
 	pods, statuses, events := createTestPodsStatusesAndEvents(2)
-	runtimeMock.On("GetPods", true).Return(pods, nil)
+	runtimeMock.EXPECT().GetPods(true).Return(pods, nil).AnyTimes()
-	runtimeMock.On("GetPodStatus", pods[0].ID, "", "").Return(statuses[0], nil).Once()
+	runtimeMock.EXPECT().GetPodStatus(pods[0].ID, "", "").Return(statuses[0], nil).Times(1)
 	// Inject an error when querying runtime for the pod status for pods[1].
 	statusErr := fmt.Errorf("unable to get status")
-	runtimeMock.On("GetPodStatus", pods[1].ID, "", "").Return(&kubecontainer.PodStatus{}, statusErr).Once()
+	runtimeMock.EXPECT().GetPodStatus(pods[1].ID, "", "").Return(&kubecontainer.PodStatus{}, statusErr).Times(1)
 
 	pleg.relist()
 	actualEvents := getEventsFromChannel(ch)
@@ -379,7 +383,7 @@ func TestRelistWithCache(t *testing.T) {
 	assert.Exactly(t, []*PodLifecycleEvent{events[0]}, actualEvents)
 
 	// Return normal status for pods[1].
-	runtimeMock.On("GetPodStatus", pods[1].ID, "", "").Return(statuses[1], nil).Once()
+	runtimeMock.EXPECT().GetPodStatus(pods[1].ID, "", "").Return(statuses[1], nil).Times(1)
 	pleg.relist()
 	actualEvents = getEventsFromChannel(ch)
 	cases = []struct {
@@ -401,15 +405,19 @@ func TestRelistWithCache(t *testing.T) {
 }
 
 func TestRemoveCacheEntry(t *testing.T) {
-	pleg, runtimeMock := newTestGenericPLEGWithRuntimeMock()
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	runtimeMock := containertest.NewMockRuntime(mockCtrl)
+	pleg := newTestGenericPLEGWithRuntimeMock(runtimeMock)
+
 	pods, statuses, _ := createTestPodsStatusesAndEvents(1)
-	runtimeMock.On("GetPods", true).Return(pods, nil).Once()
+	runtimeMock.EXPECT().GetPods(true).Return(pods, nil).Times(1)
-	runtimeMock.On("GetPodStatus", pods[0].ID, "", "").Return(statuses[0], nil).Once()
+	runtimeMock.EXPECT().GetPodStatus(pods[0].ID, "", "").Return(statuses[0], nil).Times(1)
 	// Does a relist to populate the cache.
 	pleg.relist()
 	// Delete the pod from runtime. Verify that the cache entry has been
 	// removed after relisting.
-	runtimeMock.On("GetPods", true).Return([]*kubecontainer.Pod{}, nil).Once()
+	runtimeMock.EXPECT().GetPods(true).Return([]*kubecontainer.Pod{}, nil).Times(1)
 	pleg.relist()
 	actualStatus, actualErr := pleg.cache.Get(pods[0].ID)
 	assert.Equal(t, &kubecontainer.PodStatus{ID: pods[0].ID}, actualStatus)
@@ -444,7 +452,11 @@ func TestHealthy(t *testing.T) {
 }
 
 func TestRelistWithReinspection(t *testing.T) {
-	pleg, runtimeMock := newTestGenericPLEGWithRuntimeMock()
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	runtimeMock := containertest.NewMockRuntime(mockCtrl)
+
+	pleg := newTestGenericPLEGWithRuntimeMock(runtimeMock)
 	ch := pleg.Watch()
 
 	infraContainer := createTestContainer("infra", kubecontainer.ContainerStateRunning)
@@ -454,13 +466,13 @@ func TestRelistWithReinspection(t *testing.T) {
 		ID:         podID,
 		Containers: []*kubecontainer.Container{infraContainer},
 	}}
-	runtimeMock.On("GetPods", true).Return(pods, nil).Once()
+	runtimeMock.EXPECT().GetPods(true).Return(pods, nil).Times(1)
 
 	goodStatus := &kubecontainer.PodStatus{
 		ID:                podID,
 		ContainerStatuses: []*kubecontainer.Status{{ID: infraContainer.ID, State: infraContainer.State}},
 	}
-	runtimeMock.On("GetPodStatus", podID, "", "").Return(goodStatus, nil).Once()
+	runtimeMock.EXPECT().GetPodStatus(podID, "", "").Return(goodStatus, nil).Times(1)
 
 	goodEvent := &PodLifecycleEvent{ID: podID, Type: ContainerStarted, Data: infraContainer.ID.ID}
 
@@ -479,13 +491,13 @@ func TestRelistWithReinspection(t *testing.T) {
 		ID:         podID,
 		Containers: []*kubecontainer.Container{infraContainer, transientContainer},
 	}}
-	runtimeMock.On("GetPods", true).Return(podsWithTransientContainer, nil).Once()
+	runtimeMock.EXPECT().GetPods(true).Return(podsWithTransientContainer, nil).Times(1)
 
 	badStatus := &kubecontainer.PodStatus{
 		ID:                podID,
 		ContainerStatuses: []*kubecontainer.Status{},
 	}
-	runtimeMock.On("GetPodStatus", podID, "", "").Return(badStatus, errors.New("inspection error")).Once()
+	runtimeMock.EXPECT().GetPodStatus(podID, "", "").Return(badStatus, errors.New("inspection error")).Times(1)
 
 	pleg.relist()
 	actualEvents = getEventsFromChannel(ch)
@@ -496,8 +508,8 @@ func TestRelistWithReinspection(t *testing.T) {
 
 	// listing 3 - pretend the transient container has now disappeared, leaving just the infra
 	// container. Make sure the pod is reinspected for its status and the cache is updated.
-	runtimeMock.On("GetPods", true).Return(pods, nil).Once()
+	runtimeMock.EXPECT().GetPods(true).Return(pods, nil).Times(1)
-	runtimeMock.On("GetPodStatus", podID, "", "").Return(goodStatus, nil).Once()
+	runtimeMock.EXPECT().GetPodStatus(podID, "", "").Return(goodStatus, nil).Times(1)
 
 	pleg.relist()
 	actualEvents = getEventsFromChannel(ch)
@@ -594,8 +606,14 @@ func TestRelistIPChange(t *testing.T) {
 			podIPs: []string{"192.168.1.5/24", "2000::"},
 		},
 	}
+
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	for _, tc := range testCases {
-		pleg, runtimeMock := newTestGenericPLEGWithRuntimeMock()
+		runtimeMock := containertest.NewMockRuntime(mockCtrl)
+
+		pleg := newTestGenericPLEGWithRuntimeMock(runtimeMock)
 		ch := pleg.Watch()
 
 		id := types.UID(tc.podID)
@@ -612,8 +630,8 @@ func TestRelistIPChange(t *testing.T) {
 		}
 		event := &PodLifecycleEvent{ID: pod.ID, Type: ContainerStarted, Data: container.ID.ID}
 
-		runtimeMock.On("GetPods", true).Return([]*kubecontainer.Pod{pod}, nil).Once()
+		runtimeMock.EXPECT().GetPods(true).Return([]*kubecontainer.Pod{pod}, nil).Times(1)
-		runtimeMock.On("GetPodStatus", pod.ID, "", "").Return(status, nil).Once()
+		runtimeMock.EXPECT().GetPodStatus(pod.ID, "", "").Return(status, nil).Times(1)
 
 		pleg.relist()
 		actualEvents := getEventsFromChannel(ch)
@@ -633,8 +651,8 @@ func TestRelistIPChange(t *testing.T) {
 			ContainerStatuses: []*kubecontainer.Status{{ID: container.ID, State: kubecontainer.ContainerStateExited}},
 		}
 		event = &PodLifecycleEvent{ID: pod.ID, Type: ContainerDied, Data: container.ID.ID}
-		runtimeMock.On("GetPods", true).Return([]*kubecontainer.Pod{pod}, nil).Once()
+		runtimeMock.EXPECT().GetPods(true).Return([]*kubecontainer.Pod{pod}, nil).Times(1)
-		runtimeMock.On("GetPodStatus", pod.ID, "", "").Return(status, nil).Once()
+		runtimeMock.EXPECT().GetPodStatus(pod.ID, "", "").Return(status, nil).Times(1)
 
 		pleg.relist()
 		actualEvents = getEventsFromChannel(ch)

pkg/kubelet/pod/pod_manager.go

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+//go:generate mockgen -destination=testing/mock_manager.go -package=testing -build_flags=-mod=mod . Manager
 package pod
 
 import (

pkg/kubelet/pod/testing/mock_manager.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 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.
@@ -14,305 +14,277 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Code generated by mockery v1.0.0
+// Code generated by MockGen. DO NOT EDIT.
+// Source: k8s.io/kubernetes/pkg/kubelet/pod (interfaces: Manager)
+
+// Package testing is a generated GoMock package.
 package testing
 
 import (
-	kubelettypes "k8s.io/kubernetes/pkg/kubelet/types"
+	gomock "github.com/golang/mock/gomock"
-
-	mock "github.com/stretchr/testify/mock"
-
-	types "k8s.io/apimachinery/pkg/types"
-
 	v1 "k8s.io/api/core/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	types0 "k8s.io/kubernetes/pkg/kubelet/types"
+	reflect "reflect"
 )
 
-// MockManager is an autogenerated mock type for the Manager type
+// MockManager is a mock of Manager interface
 type MockManager struct {
-	mock.Mock
+	ctrl     *gomock.Controller
+	recorder *MockManagerMockRecorder
 }
 
-// AddPod provides a mock function with given fields: _a0
+// MockManagerMockRecorder is the mock recorder for MockManager
-func (_m *MockManager) AddPod(_a0 *v1.Pod) {
+type MockManagerMockRecorder struct {
-	_m.Called(_a0)
+	mock *MockManager
 }
 
-// CreateMirrorPod provides a mock function with given fields: _a0
+// NewMockManager creates a new mock instance
-func (_m *MockManager) CreateMirrorPod(_a0 *v1.Pod) error {
+func NewMockManager(ctrl *gomock.Controller) *MockManager {
-	ret := _m.Called(_a0)
+	mock := &MockManager{ctrl: ctrl}
-
+	mock.recorder = &MockManagerMockRecorder{mock}
-	var r0 error
+	return mock
-	if rf, ok := ret.Get(0).(func(*v1.Pod) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
 }
 
-// DeleteMirrorPod provides a mock function with given fields: podFullName
+// EXPECT returns an object that allows the caller to indicate expected use
-func (_m *MockManager) DeleteMirrorPod(podFullName string, _ *types.UID) (bool, error) {
+func (m *MockManager) EXPECT() *MockManagerMockRecorder {
-	ret := _m.Called(podFullName)
+	return m.recorder
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(string) error); ok {
-		return true, rf(podFullName)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return false, r0
 }
 
-func (_m *MockManager) GetOrphanedMirrorPodNames() []string {
+// AddPod mocks base method
-	ret := _m.Called()
+func (m *MockManager) AddPod(arg0 *v1.Pod) {
-
+	m.ctrl.T.Helper()
-	var r0 []string
+	m.ctrl.Call(m, "AddPod", arg0)
-	if rf, ok := ret.Get(0).(func() []string); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]string)
-		}
-	}
-	return r0
 }
 
-func (_m *MockManager) GetOrphanedMirrorPodNamesAndUIDs() map[string]kubelettypes.ResolvedPodUID {
+// AddPod indicates an expected call of AddPod
-	ret := _m.Called()
+func (mr *MockManagerMockRecorder) AddPod(arg0 interface{}) *gomock.Call {
-
+	mr.mock.ctrl.T.Helper()
-	var r0 map[string]kubelettypes.ResolvedPodUID
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPod", reflect.TypeOf((*MockManager)(nil).AddPod), arg0)
-	if rf, ok := ret.Get(0).(func() map[string]kubelettypes.ResolvedPodUID); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(map[string]kubelettypes.ResolvedPodUID)
-		}
-	}
-	return r0
 }
 
-// DeletePod provides a mock function with given fields: _a0
+// CreateMirrorPod mocks base method
-func (_m *MockManager) DeletePod(_a0 *v1.Pod) {
+func (m *MockManager) CreateMirrorPod(arg0 *v1.Pod) error {
-	_m.Called(_a0)
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateMirrorPod", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
 }
 
-// GetMirrorPodByPod provides a mock function with given fields: _a0
+// CreateMirrorPod indicates an expected call of CreateMirrorPod
-func (_m *MockManager) GetMirrorPodByPod(_a0 *v1.Pod) (*v1.Pod, bool) {
+func (mr *MockManagerMockRecorder) CreateMirrorPod(arg0 interface{}) *gomock.Call {
-	ret := _m.Called(_a0)
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMirrorPod", reflect.TypeOf((*MockManager)(nil).CreateMirrorPod), arg0)
-	var r0 *v1.Pod
-	if rf, ok := ret.Get(0).(func(*v1.Pod) *v1.Pod); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*v1.Pod)
-		}
-	}
-
-	var r1 bool
-	if rf, ok := ret.Get(1).(func(*v1.Pod) bool); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Get(1).(bool)
-	}
-
-	return r0, r1
 }
 
-// GetPodByFullName provides a mock function with given fields: podFullName
+// DeleteMirrorPod mocks base method
-func (_m *MockManager) GetPodByFullName(podFullName string) (*v1.Pod, bool) {
+func (m *MockManager) DeleteMirrorPod(arg0 string, arg1 *types.UID) (bool, error) {
-	ret := _m.Called(podFullName)
+	m.ctrl.T.Helper()
-
+	ret := m.ctrl.Call(m, "DeleteMirrorPod", arg0, arg1)
-	var r0 *v1.Pod
+	ret0, _ := ret[0].(bool)
-	if rf, ok := ret.Get(0).(func(string) *v1.Pod); ok {
+	ret1, _ := ret[1].(error)
-		r0 = rf(podFullName)
+	return ret0, ret1
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*v1.Pod)
-		}
-	}
-
-	var r1 bool
-	if rf, ok := ret.Get(1).(func(string) bool); ok {
-		r1 = rf(podFullName)
-	} else {
-		r1 = ret.Get(1).(bool)
-	}
-
-	return r0, r1
 }
 
-// GetPodByMirrorPod provides a mock function with given fields: _a0
+// DeleteMirrorPod indicates an expected call of DeleteMirrorPod
-func (_m *MockManager) GetPodByMirrorPod(_a0 *v1.Pod) (*v1.Pod, bool) {
+func (mr *MockManagerMockRecorder) DeleteMirrorPod(arg0, arg1 interface{}) *gomock.Call {
-	ret := _m.Called(_a0)
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMirrorPod", reflect.TypeOf((*MockManager)(nil).DeleteMirrorPod), arg0, arg1)
-	var r0 *v1.Pod
-	if rf, ok := ret.Get(0).(func(*v1.Pod) *v1.Pod); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*v1.Pod)
-		}
-	}
-
-	var r1 bool
-	if rf, ok := ret.Get(1).(func(*v1.Pod) bool); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Get(1).(bool)
-	}
-
-	return r0, r1
 }
 
-// GetPodByName provides a mock function with given fields: namespace, name
+// DeletePod mocks base method
-func (_m *MockManager) GetPodByName(namespace string, name string) (*v1.Pod, bool) {
+func (m *MockManager) DeletePod(arg0 *v1.Pod) {
-	ret := _m.Called(namespace, name)
+	m.ctrl.T.Helper()
-
+	m.ctrl.Call(m, "DeletePod", arg0)
-	var r0 *v1.Pod
-	if rf, ok := ret.Get(0).(func(string, string) *v1.Pod); ok {
-		r0 = rf(namespace, name)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*v1.Pod)
-		}
-	}
-
-	var r1 bool
-	if rf, ok := ret.Get(1).(func(string, string) bool); ok {
-		r1 = rf(namespace, name)
-	} else {
-		r1 = ret.Get(1).(bool)
-	}
-
-	return r0, r1
 }
 
-// GetPodByUID provides a mock function with given fields: _a0
+// DeletePod indicates an expected call of DeletePod
-func (_m *MockManager) GetPodByUID(_a0 types.UID) (*v1.Pod, bool) {
+func (mr *MockManagerMockRecorder) DeletePod(arg0 interface{}) *gomock.Call {
-	ret := _m.Called(_a0)
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePod", reflect.TypeOf((*MockManager)(nil).DeletePod), arg0)
-	var r0 *v1.Pod
-	if rf, ok := ret.Get(0).(func(types.UID) *v1.Pod); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*v1.Pod)
-		}
-	}
-
-	var r1 bool
-	if rf, ok := ret.Get(1).(func(types.UID) bool); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Get(1).(bool)
-	}
-
-	return r0, r1
 }
 
-// GetPods provides a mock function with given fields:
+// GetMirrorPodByPod mocks base method
-func (_m *MockManager) GetPods() []*v1.Pod {
+func (m *MockManager) GetMirrorPodByPod(arg0 *v1.Pod) (*v1.Pod, bool) {
-	ret := _m.Called()
+	m.ctrl.T.Helper()
-
+	ret := m.ctrl.Call(m, "GetMirrorPodByPod", arg0)
-	var r0 []*v1.Pod
+	ret0, _ := ret[0].(*v1.Pod)
-	if rf, ok := ret.Get(0).(func() []*v1.Pod); ok {
+	ret1, _ := ret[1].(bool)
-		r0 = rf()
+	return ret0, ret1
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*v1.Pod)
-		}
-	}
-
-	return r0
 }
 
-// GetPodsAndMirrorPods provides a mock function with given fields:
+// GetMirrorPodByPod indicates an expected call of GetMirrorPodByPod
-func (_m *MockManager) GetPodsAndMirrorPods() ([]*v1.Pod, []*v1.Pod) {
+func (mr *MockManagerMockRecorder) GetMirrorPodByPod(arg0 interface{}) *gomock.Call {
-	ret := _m.Called()
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMirrorPodByPod", reflect.TypeOf((*MockManager)(nil).GetMirrorPodByPod), arg0)
-	var r0 []*v1.Pod
-	if rf, ok := ret.Get(0).(func() []*v1.Pod); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*v1.Pod)
-		}
-	}
-
-	var r1 []*v1.Pod
-	if rf, ok := ret.Get(1).(func() []*v1.Pod); ok {
-		r1 = rf()
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).([]*v1.Pod)
-		}
-	}
-
-	return r0, r1
 }
 
-// GetUIDTranslations provides a mock function with given fields:
+// GetOrphanedMirrorPodNames mocks base method
-func (_m *MockManager) GetUIDTranslations() (map[kubelettypes.ResolvedPodUID]kubelettypes.MirrorPodUID, map[kubelettypes.MirrorPodUID]kubelettypes.ResolvedPodUID) {
+func (m *MockManager) GetOrphanedMirrorPodNames() []string {
-	ret := _m.Called()
+	m.ctrl.T.Helper()
-
+	ret := m.ctrl.Call(m, "GetOrphanedMirrorPodNames")
-	var r0 map[kubelettypes.ResolvedPodUID]kubelettypes.MirrorPodUID
+	ret0, _ := ret[0].([]string)
-	if rf, ok := ret.Get(0).(func() map[kubelettypes.ResolvedPodUID]kubelettypes.MirrorPodUID); ok {
+	return ret0
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(map[kubelettypes.ResolvedPodUID]kubelettypes.MirrorPodUID)
-		}
-	}
-
-	var r1 map[kubelettypes.MirrorPodUID]kubelettypes.ResolvedPodUID
-	if rf, ok := ret.Get(1).(func() map[kubelettypes.MirrorPodUID]kubelettypes.ResolvedPodUID); ok {
-		r1 = rf()
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(map[kubelettypes.MirrorPodUID]kubelettypes.ResolvedPodUID)
-		}
-	}
-
-	return r0, r1
 }
 
-// IsMirrorPodOf provides a mock function with given fields: mirrorPod, _a1
+// GetOrphanedMirrorPodNames indicates an expected call of GetOrphanedMirrorPodNames
-func (_m *MockManager) IsMirrorPodOf(mirrorPod *v1.Pod, _a1 *v1.Pod) bool {
+func (mr *MockManagerMockRecorder) GetOrphanedMirrorPodNames() *gomock.Call {
-	ret := _m.Called(mirrorPod, _a1)
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrphanedMirrorPodNames", reflect.TypeOf((*MockManager)(nil).GetOrphanedMirrorPodNames))
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(*v1.Pod, *v1.Pod) bool); ok {
-		r0 = rf(mirrorPod, _a1)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
 }
 
-// SetPods provides a mock function with given fields: pods
+// GetPodByFullName mocks base method
-func (_m *MockManager) SetPods(pods []*v1.Pod) {
+func (m *MockManager) GetPodByFullName(arg0 string) (*v1.Pod, bool) {
-	_m.Called(pods)
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPodByFullName", arg0)
+	ret0, _ := ret[0].(*v1.Pod)
+	ret1, _ := ret[1].(bool)
+	return ret0, ret1
 }
 
-// TranslatePodUID provides a mock function with given fields: uid
+// GetPodByFullName indicates an expected call of GetPodByFullName
-func (_m *MockManager) TranslatePodUID(uid types.UID) kubelettypes.ResolvedPodUID {
+func (mr *MockManagerMockRecorder) GetPodByFullName(arg0 interface{}) *gomock.Call {
-	ret := _m.Called(uid)
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByFullName", reflect.TypeOf((*MockManager)(nil).GetPodByFullName), arg0)
-	var r0 kubelettypes.ResolvedPodUID
-	if rf, ok := ret.Get(0).(func(types.UID) kubelettypes.ResolvedPodUID); ok {
-		r0 = rf(uid)
-	} else {
-		r0 = ret.Get(0).(kubelettypes.ResolvedPodUID)
-	}
-
-	return r0
 }
 
-// UpdatePod provides a mock function with given fields: _a0
+// GetPodByMirrorPod mocks base method
-func (_m *MockManager) UpdatePod(_a0 *v1.Pod) {
+func (m *MockManager) GetPodByMirrorPod(arg0 *v1.Pod) (*v1.Pod, bool) {
-	_m.Called(_a0)
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPodByMirrorPod", arg0)
+	ret0, _ := ret[0].(*v1.Pod)
+	ret1, _ := ret[1].(bool)
+	return ret0, ret1
+}
+
+// GetPodByMirrorPod indicates an expected call of GetPodByMirrorPod
+func (mr *MockManagerMockRecorder) GetPodByMirrorPod(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByMirrorPod", reflect.TypeOf((*MockManager)(nil).GetPodByMirrorPod), arg0)
+}
+
+// GetPodByName mocks base method
+func (m *MockManager) GetPodByName(arg0, arg1 string) (*v1.Pod, bool) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPodByName", arg0, arg1)
+	ret0, _ := ret[0].(*v1.Pod)
+	ret1, _ := ret[1].(bool)
+	return ret0, ret1
+}
+
+// GetPodByName indicates an expected call of GetPodByName
+func (mr *MockManagerMockRecorder) GetPodByName(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByName", reflect.TypeOf((*MockManager)(nil).GetPodByName), arg0, arg1)
+}
+
+// GetPodByUID mocks base method
+func (m *MockManager) GetPodByUID(arg0 types.UID) (*v1.Pod, bool) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPodByUID", arg0)
+	ret0, _ := ret[0].(*v1.Pod)
+	ret1, _ := ret[1].(bool)
+	return ret0, ret1
+}
+
+// GetPodByUID indicates an expected call of GetPodByUID
+func (mr *MockManagerMockRecorder) GetPodByUID(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByUID", reflect.TypeOf((*MockManager)(nil).GetPodByUID), arg0)
+}
+
+// GetPods mocks base method
+func (m *MockManager) GetPods() []*v1.Pod {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPods")
+	ret0, _ := ret[0].([]*v1.Pod)
+	return ret0
+}
+
+// GetPods indicates an expected call of GetPods
+func (mr *MockManagerMockRecorder) GetPods() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockManager)(nil).GetPods))
+}
+
+// GetPodsAndMirrorPods mocks base method
+func (m *MockManager) GetPodsAndMirrorPods() ([]*v1.Pod, []*v1.Pod) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPodsAndMirrorPods")
+	ret0, _ := ret[0].([]*v1.Pod)
+	ret1, _ := ret[1].([]*v1.Pod)
+	return ret0, ret1
+}
+
+// GetPodsAndMirrorPods indicates an expected call of GetPodsAndMirrorPods
+func (mr *MockManagerMockRecorder) GetPodsAndMirrorPods() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodsAndMirrorPods", reflect.TypeOf((*MockManager)(nil).GetPodsAndMirrorPods))
+}
+
+// GetUIDTranslations mocks base method
+func (m *MockManager) GetUIDTranslations() (map[types0.ResolvedPodUID]types0.MirrorPodUID, map[types0.MirrorPodUID]types0.ResolvedPodUID) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUIDTranslations")
+	ret0, _ := ret[0].(map[types0.ResolvedPodUID]types0.MirrorPodUID)
+	ret1, _ := ret[1].(map[types0.MirrorPodUID]types0.ResolvedPodUID)
+	return ret0, ret1
+}
+
+// GetUIDTranslations indicates an expected call of GetUIDTranslations
+func (mr *MockManagerMockRecorder) GetUIDTranslations() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUIDTranslations", reflect.TypeOf((*MockManager)(nil).GetUIDTranslations))
+}
+
+// IsMirrorPodOf mocks base method
+func (m *MockManager) IsMirrorPodOf(arg0, arg1 *v1.Pod) bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsMirrorPodOf", arg0, arg1)
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// IsMirrorPodOf indicates an expected call of IsMirrorPodOf
+func (mr *MockManagerMockRecorder) IsMirrorPodOf(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsMirrorPodOf", reflect.TypeOf((*MockManager)(nil).IsMirrorPodOf), arg0, arg1)
+}
+
+// SetPods mocks base method
+func (m *MockManager) SetPods(arg0 []*v1.Pod) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "SetPods", arg0)
+}
+
+// SetPods indicates an expected call of SetPods
+func (mr *MockManagerMockRecorder) SetPods(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPods", reflect.TypeOf((*MockManager)(nil).SetPods), arg0)
+}
+
+// TranslatePodUID mocks base method
+func (m *MockManager) TranslatePodUID(arg0 types.UID) types0.ResolvedPodUID {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TranslatePodUID", arg0)
+	ret0, _ := ret[0].(types0.ResolvedPodUID)
+	return ret0
+}
+
+// TranslatePodUID indicates an expected call of TranslatePodUID
+func (mr *MockManagerMockRecorder) TranslatePodUID(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TranslatePodUID", reflect.TypeOf((*MockManager)(nil).TranslatePodUID), arg0)
+}
+
+// UpdatePod mocks base method
+func (m *MockManager) UpdatePod(arg0 *v1.Pod) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "UpdatePod", arg0)
+}
+
+// UpdatePod indicates an expected call of UpdatePod
+func (mr *MockManagerMockRecorder) UpdatePod(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePod", reflect.TypeOf((*MockManager)(nil).UpdatePod), arg0)
 }

pkg/kubelet/runonce_test.go

@@ -21,6 +21,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/golang/mock/gomock"
 	cadvisorapi "github.com/google/cadvisor/info/v1"
 	cadvisorapiv2 "github.com/google/cadvisor/info/v2"
 	"k8s.io/mount-utils"
@@ -51,17 +52,20 @@ import (
 )
 
 func TestRunOnce(t *testing.T) {
-	cadvisor := &cadvisortest.Mock{}
+	mockCtrl := gomock.NewController(t)
-	cadvisor.On("MachineInfo").Return(&cadvisorapi.MachineInfo{}, nil)
+	defer mockCtrl.Finish()
-	cadvisor.On("ImagesFsInfo").Return(cadvisorapiv2.FsInfo{
+
+	cadvisor := cadvisortest.NewMockInterface(mockCtrl)
+	cadvisor.EXPECT().MachineInfo().Return(&cadvisorapi.MachineInfo{}, nil).AnyTimes()
+	cadvisor.EXPECT().ImagesFsInfo().Return(cadvisorapiv2.FsInfo{
 		Usage:     400,
 		Capacity:  1000,
 		Available: 600,
-	}, nil)
+	}, nil).AnyTimes()
-	cadvisor.On("RootFsInfo").Return(cadvisorapiv2.FsInfo{
+	cadvisor.EXPECT().RootFsInfo().Return(cadvisorapiv2.FsInfo{
 		Usage:    9,
 		Capacity: 10,
-	}, nil)
+	}, nil).AnyTimes()
 	fakeSecretManager := secret.NewFakeManager()
 	fakeConfigMapManager := configmap.NewFakeManager()
 	podManager := kubepod.NewBasicPodManager(

pkg/kubelet/server/stats/handler.go

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+//go:generate mockgen -source=handler.go -destination=testing/mock_stats_provider.go -package=testing Provider
 package stats
 
 import (

pkg/kubelet/server/stats/summary.go

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+//go:generate mockgen -source=summary.go -destination=testing/mock_summary_provider.go -package=testing SummaryProvider
 package stats
 
 import (

pkg/kubelet/server/stats/summary_test.go

@@ -23,10 +23,11 @@ import (
 	"testing"
 	"time"
 
+	"github.com/golang/mock/gomock"
 	fuzz "github.com/google/gofuzz"
 	"github.com/stretchr/testify/assert"
 
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
 	"k8s.io/kubernetes/pkg/kubelet/cm"
@@ -69,21 +70,23 @@ func TestSummaryProviderGetStats(t *testing.T) {
 		"/pods":    {cs: getContainerStats(), ns: getNetworkStats()},
 	}
 
-	mockStatsProvider := new(statstest.StatsProvider)
+	mockCtrl := gomock.NewController(t)
-	mockStatsProvider.
+	defer mockCtrl.Finish()
-		On("GetNode").Return(node, nil).
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
-		On("GetNodeConfig").Return(nodeConfig).
+
-		On("GetPodCgroupRoot").Return(cgroupRoot).
+	mockStatsProvider.EXPECT().GetNode().Return(node, nil)
-		On("ListPodStats").Return(podStats, nil).
+	mockStatsProvider.EXPECT().GetNodeConfig().Return(nodeConfig)
-		On("ListPodStatsAndUpdateCPUNanoCoreUsage").Return(podStats, nil).
+	mockStatsProvider.EXPECT().GetPodCgroupRoot().Return(cgroupRoot)
-		On("ImageFsStats").Return(imageFsStats, nil).
+	mockStatsProvider.EXPECT().ListPodStats().Return(podStats, nil).AnyTimes()
-		On("RootFsStats").Return(rootFsStats, nil).
+	mockStatsProvider.EXPECT().ListPodStatsAndUpdateCPUNanoCoreUsage().Return(podStats, nil)
-		On("RlimitStats").Return(rlimitStats, nil).
+	mockStatsProvider.EXPECT().ImageFsStats().Return(imageFsStats, nil)
-		On("GetCgroupStats", "/", true).Return(cgroupStatsMap["/"].cs, cgroupStatsMap["/"].ns, nil).
+	mockStatsProvider.EXPECT().RootFsStats().Return(rootFsStats, nil)
-		On("GetCgroupStats", "/runtime", false).Return(cgroupStatsMap["/runtime"].cs, cgroupStatsMap["/runtime"].ns, nil).
+	mockStatsProvider.EXPECT().RlimitStats().Return(rlimitStats, nil)
-		On("GetCgroupStats", "/misc", false).Return(cgroupStatsMap["/misc"].cs, cgroupStatsMap["/misc"].ns, nil).
+	mockStatsProvider.EXPECT().GetCgroupStats("/", true).Return(cgroupStatsMap["/"].cs, cgroupStatsMap["/"].ns, nil)
-		On("GetCgroupStats", "/kubelet", false).Return(cgroupStatsMap["/kubelet"].cs, cgroupStatsMap["/kubelet"].ns, nil).
+	mockStatsProvider.EXPECT().GetCgroupStats("/runtime", false).Return(cgroupStatsMap["/runtime"].cs, cgroupStatsMap["/runtime"].ns, nil)
-		On("GetCgroupStats", "/kubepods", true).Return(cgroupStatsMap["/pods"].cs, cgroupStatsMap["/pods"].ns, nil)
+	mockStatsProvider.EXPECT().GetCgroupStats("/misc", false).Return(cgroupStatsMap["/misc"].cs, cgroupStatsMap["/misc"].ns, nil)
+	mockStatsProvider.EXPECT().GetCgroupStats("/kubelet", false).Return(cgroupStatsMap["/kubelet"].cs, cgroupStatsMap["/kubelet"].ns, nil)
+	mockStatsProvider.EXPECT().GetCgroupStats("/kubepods", true).Return(cgroupStatsMap["/pods"].cs, cgroupStatsMap["/pods"].ns, nil)
 
 	kubeletCreationTime := metav1.Now()
 	systemBootTime := metav1.Now()
@@ -155,17 +158,19 @@ func TestSummaryProviderGetCPUAndMemoryStats(t *testing.T) {
 		"/pods":    {cs: getVolumeCPUAndMemoryStats()},
 	}
 
-	mockStatsProvider := new(statstest.StatsProvider)
+	mockCtrl := gomock.NewController(t)
-	mockStatsProvider.
+	defer mockCtrl.Finish()
-		On("GetNode").Return(node, nil).
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
-		On("GetNodeConfig").Return(nodeConfig).
+
-		On("GetPodCgroupRoot").Return(cgroupRoot).
+	mockStatsProvider.EXPECT().GetNode().Return(node, nil)
-		On("ListPodCPUAndMemoryStats").Return(podStats, nil).
+	mockStatsProvider.EXPECT().GetNodeConfig().Return(nodeConfig)
-		On("GetCgroupCPUAndMemoryStats", "/", false).Return(cgroupStatsMap["/"].cs, nil).
+	mockStatsProvider.EXPECT().GetPodCgroupRoot().Return(cgroupRoot)
-		On("GetCgroupCPUAndMemoryStats", "/runtime", false).Return(cgroupStatsMap["/runtime"].cs, nil).
+	mockStatsProvider.EXPECT().ListPodCPUAndMemoryStats().Return(podStats, nil)
-		On("GetCgroupCPUAndMemoryStats", "/misc", false).Return(cgroupStatsMap["/misc"].cs, nil).
+	mockStatsProvider.EXPECT().GetCgroupCPUAndMemoryStats("/", false).Return(cgroupStatsMap["/"].cs, nil)
-		On("GetCgroupCPUAndMemoryStats", "/kubelet", false).Return(cgroupStatsMap["/kubelet"].cs, nil).
+	mockStatsProvider.EXPECT().GetCgroupCPUAndMemoryStats("/runtime", false).Return(cgroupStatsMap["/runtime"].cs, nil)
-		On("GetCgroupCPUAndMemoryStats", "/kubepods", false).Return(cgroupStatsMap["/pods"].cs, nil)
+	mockStatsProvider.EXPECT().GetCgroupCPUAndMemoryStats("/misc", false).Return(cgroupStatsMap["/misc"].cs, nil)
+	mockStatsProvider.EXPECT().GetCgroupCPUAndMemoryStats("/kubelet", false).Return(cgroupStatsMap["/kubelet"].cs, nil)
+	mockStatsProvider.EXPECT().GetCgroupCPUAndMemoryStats("/kubepods", false).Return(cgroupStatsMap["/pods"].cs, nil)
 
 	provider := NewSummaryProvider(mockStatsProvider)
 	summary, err := provider.GetCPUAndMemoryStats()

pkg/kubelet/server/stats/summary_windows_test.go

@@ -23,6 +23,7 @@ import (
 	"testing"
 	"time"
 
+	gomock "github.com/golang/mock/gomock"
 	fuzz "github.com/google/gofuzz"
 	"github.com/stretchr/testify/assert"
 
@@ -52,17 +53,19 @@ func TestSummaryProvider(t *testing.T) {
 
 	assert := assert.New(t)
 
-	mockStatsProvider := new(statstest.StatsProvider)
+	mockCtrl := gomock.NewController(t)
-	mockStatsProvider.
+	defer mockCtrl.Finish()
-		On("GetNode").Return(node, nil).
+
-		On("GetNodeConfig").Return(nodeConfig).
+	mockStatsProvider := statstest.NewMockProvider(mockCtrl)
-		On("GetPodCgroupRoot").Return(cgroupRoot).
+	mockStatsProvider.EXPECT().GetNode().Return(node, nil).AnyTimes()
-		On("ListPodStats").Return(podStats, nil).
+	mockStatsProvider.EXPECT().GetNodeConfig().Return(nodeConfig).AnyTimes()
-		On("ListPodStatsAndUpdateCPUNanoCoreUsage").Return(podStats, nil).
+	mockStatsProvider.EXPECT().GetPodCgroupRoot().Return(cgroupRoot).AnyTimes()
-		On("ImageFsStats").Return(imageFsStats, nil).
+	mockStatsProvider.EXPECT().ListPodStats().Return(podStats, nil).AnyTimes()
-		On("RootFsStats").Return(rootFsStats, nil).
+	mockStatsProvider.EXPECT().ListPodStatsAndUpdateCPUNanoCoreUsage().Return(podStats, nil).AnyTimes()
-		On("RlimitStats").Return(nil, nil).
+	mockStatsProvider.EXPECT().ImageFsStats().Return(imageFsStats, nil).AnyTimes()
-		On("GetCgroupStats", "/", true).Return(cgroupStatsMap["/"].cs, cgroupStatsMap["/"].ns, nil)
+	mockStatsProvider.EXPECT().RootFsStats().Return(rootFsStats, nil).AnyTimes()
+	mockStatsProvider.EXPECT().RlimitStats().Return(nil, nil).AnyTimes()
+	mockStatsProvider.EXPECT().GetCgroupStats("/", true).Return(cgroupStatsMap["/"].cs, cgroupStatsMap["/"].ns, nil).AnyTimes()
 
 	provider := NewSummaryProvider(mockStatsProvider)
 	summary, err := provider.Get(true)

pkg/kubelet/server/stats/testing/mock_stats_provider.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2016 The Kubernetes Authors.
+Copyright 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.
@@ -14,408 +14,326 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+// Code generated by MockGen. DO NOT EDIT.
+// Source: handler.go
+
+// Package testing is a generated GoMock package.
 package testing
 
-import cm "k8s.io/kubernetes/pkg/kubelet/cm"
+import (
-import corev1 "k8s.io/api/core/v1"
+	gomock "github.com/golang/mock/gomock"
-import mock "github.com/stretchr/testify/mock"
+	v1 "github.com/google/cadvisor/info/v1"
+	v2 "github.com/google/cadvisor/info/v2"
+	v10 "k8s.io/api/core/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	v1alpha1 "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
+	cm "k8s.io/kubernetes/pkg/kubelet/cm"
+	volume "k8s.io/kubernetes/pkg/volume"
+	reflect "reflect"
+)
 
-import types "k8s.io/apimachinery/pkg/types"
+// MockProvider is a mock of Provider interface
-import v1 "github.com/google/cadvisor/info/v1"
+type MockProvider struct {
-import v2 "github.com/google/cadvisor/info/v2"
+	ctrl     *gomock.Controller
-import v1alpha1 "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
+	recorder *MockProviderMockRecorder
-import volume "k8s.io/kubernetes/pkg/volume"
-
-// GENERATED BY mockery
-
-// StatsProvider is an autogenerated mock type for the StatsProvider type
-type StatsProvider struct {
-	mock.Mock
 }
 
-// GetCgroupStats provides a mock function with given fields: cgroupName, updateStats
+// MockProviderMockRecorder is the mock recorder for MockProvider
-func (_m *StatsProvider) GetCgroupStats(cgroupName string, updateStats bool) (*v1alpha1.ContainerStats, *v1alpha1.NetworkStats, error) {
+type MockProviderMockRecorder struct {
-	ret := _m.Called(cgroupName, updateStats)
+	mock *MockProvider
-
-	var r0 *v1alpha1.ContainerStats
-	if rf, ok := ret.Get(0).(func(string, bool) *v1alpha1.ContainerStats); ok {
-		r0 = rf(cgroupName, updateStats)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*v1alpha1.ContainerStats)
-		}
-	}
-
-	var r1 *v1alpha1.NetworkStats
-	if rf, ok := ret.Get(1).(func(string, bool) *v1alpha1.NetworkStats); ok {
-		r1 = rf(cgroupName, updateStats)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*v1alpha1.NetworkStats)
-		}
-	}
-
-	var r2 error
-	if rf, ok := ret.Get(2).(func(string, bool) error); ok {
-		r2 = rf(cgroupName, updateStats)
-	} else {
-		r2 = ret.Error(2)
-	}
-
-	return r0, r1, r2
 }
 
-// GetCgroupCPUAndMemoryStats provides a mock function with given fields: cgroupName, updateStats
+// NewMockProvider creates a new mock instance
-func (_m *StatsProvider) GetCgroupCPUAndMemoryStats(cgroupName string, updateStats bool) (*v1alpha1.ContainerStats, error) {
+func NewMockProvider(ctrl *gomock.Controller) *MockProvider {
-	ret := _m.Called(cgroupName, updateStats)
+	mock := &MockProvider{ctrl: ctrl}
-
+	mock.recorder = &MockProviderMockRecorder{mock}
-	var r0 *v1alpha1.ContainerStats
+	return mock
-	if rf, ok := ret.Get(0).(func(string, bool) *v1alpha1.ContainerStats); ok {
-		r0 = rf(cgroupName, updateStats)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*v1alpha1.ContainerStats)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(string, bool) error); ok {
-		r1 = rf(cgroupName, updateStats)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
 }
 
-// GetPodByCgroupfs provides the pod that maps to the specified cgroup, as well
+// EXPECT returns an object that allows the caller to indicate expected use
-// as whether the pod was found.
+func (m *MockProvider) EXPECT() *MockProviderMockRecorder {
-func (_m *StatsProvider) GetPodByCgroupfs(cgroupfs string) (*corev1.Pod, bool) {
+	return m.recorder
-	return nil, false
 }
 
-// GetRequestedContainersInfo provides a mock function with given fields: containerName, options
+// ListPodStats mocks base method
-func (_m *StatsProvider) GetRequestedContainersInfo(containerName string, options v2.RequestOptions) (map[string]*v1.ContainerInfo, error) {
+func (m *MockProvider) ListPodStats() ([]v1alpha1.PodStats, error) {
-	ret := _m.Called(containerName, options)
+	m.ctrl.T.Helper()
-	return ret.Get(0).(map[string]*v1.ContainerInfo), ret.Error(1)
+	ret := m.ctrl.Call(m, "ListPodStats")
+	ret0, _ := ret[0].([]v1alpha1.PodStats)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
 }
 
-// GetContainerInfo provides a mock function with given fields: podFullName, uid, containerName, req
+// ListPodStats indicates an expected call of ListPodStats
-func (_m *StatsProvider) GetContainerInfo(podFullName string, uid types.UID, containerName string, req *v1.ContainerInfoRequest) (*v1.ContainerInfo, error) {
+func (mr *MockProviderMockRecorder) ListPodStats() *gomock.Call {
-	ret := _m.Called(podFullName, uid, containerName, req)
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPodStats", reflect.TypeOf((*MockProvider)(nil).ListPodStats))
-	var r0 *v1.ContainerInfo
-	if rf, ok := ret.Get(0).(func(string, types.UID, string, *v1.ContainerInfoRequest) *v1.ContainerInfo); ok {
-		r0 = rf(podFullName, uid, containerName, req)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*v1.ContainerInfo)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(string, types.UID, string, *v1.ContainerInfoRequest) error); ok {
-		r1 = rf(podFullName, uid, containerName, req)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
 }
 
-// GetNode provides a mock function with given fields:
+// ListPodCPUAndMemoryStats mocks base method
-func (_m *StatsProvider) GetNode() (*corev1.Node, error) {
+func (m *MockProvider) ListPodCPUAndMemoryStats() ([]v1alpha1.PodStats, error) {
-	ret := _m.Called()
+	m.ctrl.T.Helper()
-
+	ret := m.ctrl.Call(m, "ListPodCPUAndMemoryStats")
-	var r0 *corev1.Node
+	ret0, _ := ret[0].([]v1alpha1.PodStats)
-	if rf, ok := ret.Get(0).(func() *corev1.Node); ok {
+	ret1, _ := ret[1].(error)
-		r0 = rf()
+	return ret0, ret1
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*corev1.Node)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
 }
 
-// GetNodeConfig provides a mock function with given fields:
+// ListPodCPUAndMemoryStats indicates an expected call of ListPodCPUAndMemoryStats
-func (_m *StatsProvider) GetNodeConfig() cm.NodeConfig {
+func (mr *MockProviderMockRecorder) ListPodCPUAndMemoryStats() *gomock.Call {
-	ret := _m.Called()
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPodCPUAndMemoryStats", reflect.TypeOf((*MockProvider)(nil).ListPodCPUAndMemoryStats))
-	var r0 cm.NodeConfig
-	if rf, ok := ret.Get(0).(func() cm.NodeConfig); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(cm.NodeConfig)
-	}
-
-	return r0
 }
 
-// GetPodCgroupRoot provides a mock function with given fields:
+// ListPodStatsAndUpdateCPUNanoCoreUsage mocks base method
-func (_m *StatsProvider) GetPodCgroupRoot() string {
+func (m *MockProvider) ListPodStatsAndUpdateCPUNanoCoreUsage() ([]v1alpha1.PodStats, error) {
-	ret := _m.Called()
+	m.ctrl.T.Helper()
-
+	ret := m.ctrl.Call(m, "ListPodStatsAndUpdateCPUNanoCoreUsage")
-	var r0 string
+	ret0, _ := ret[0].([]v1alpha1.PodStats)
-	if rf, ok := ret.Get(0).(func() string); ok {
+	ret1, _ := ret[1].(error)
-		r0 = rf()
+	return ret0, ret1
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-
-	return r0
 }
 
-// GetPodByName provides a mock function with given fields: namespace, name
+// ListPodStatsAndUpdateCPUNanoCoreUsage indicates an expected call of ListPodStatsAndUpdateCPUNanoCoreUsage
-func (_m *StatsProvider) GetPodByName(namespace string, name string) (*corev1.Pod, bool) {
+func (mr *MockProviderMockRecorder) ListPodStatsAndUpdateCPUNanoCoreUsage() *gomock.Call {
-	ret := _m.Called(namespace, name)
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPodStatsAndUpdateCPUNanoCoreUsage", reflect.TypeOf((*MockProvider)(nil).ListPodStatsAndUpdateCPUNanoCoreUsage))
-	var r0 *corev1.Pod
-	if rf, ok := ret.Get(0).(func(string, string) *corev1.Pod); ok {
-		r0 = rf(namespace, name)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*corev1.Pod)
-		}
-	}
-
-	var r1 bool
-	if rf, ok := ret.Get(1).(func(string, string) bool); ok {
-		r1 = rf(namespace, name)
-	} else {
-		r1 = ret.Get(1).(bool)
-	}
-
-	return r0, r1
 }
 
-// GetPods provides a mock function with given fields:
+// ImageFsStats mocks base method
-func (_m *StatsProvider) GetPods() []*corev1.Pod {
+func (m *MockProvider) ImageFsStats() (*v1alpha1.FsStats, error) {
-	ret := _m.Called()
+	m.ctrl.T.Helper()
-
+	ret := m.ctrl.Call(m, "ImageFsStats")
-	var r0 []*corev1.Pod
+	ret0, _ := ret[0].(*v1alpha1.FsStats)
-	if rf, ok := ret.Get(0).(func() []*corev1.Pod); ok {
+	ret1, _ := ret[1].(error)
-		r0 = rf()
+	return ret0, ret1
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*corev1.Pod)
-		}
-	}
-
-	return r0
 }
 
-// GetRawContainerInfo provides a mock function with given fields: containerName, req, subcontainers
+// ImageFsStats indicates an expected call of ImageFsStats
-func (_m *StatsProvider) GetRawContainerInfo(containerName string, req *v1.ContainerInfoRequest, subcontainers bool) (map[string]*v1.ContainerInfo, error) {
+func (mr *MockProviderMockRecorder) ImageFsStats() *gomock.Call {
-	ret := _m.Called(containerName, req, subcontainers)
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageFsStats", reflect.TypeOf((*MockProvider)(nil).ImageFsStats))
-	var r0 map[string]*v1.ContainerInfo
-	if rf, ok := ret.Get(0).(func(string, *v1.ContainerInfoRequest, bool) map[string]*v1.ContainerInfo); ok {
-		r0 = rf(containerName, req, subcontainers)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(map[string]*v1.ContainerInfo)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(string, *v1.ContainerInfoRequest, bool) error); ok {
-		r1 = rf(containerName, req, subcontainers)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
 }
 
-// ImageFsStats provides a mock function with given fields:
+// GetCgroupStats mocks base method
-func (_m *StatsProvider) ImageFsStats() (*v1alpha1.FsStats, error) {
+func (m *MockProvider) GetCgroupStats(cgroupName string, updateStats bool) (*v1alpha1.ContainerStats, *v1alpha1.NetworkStats, error) {
-	ret := _m.Called()
+	m.ctrl.T.Helper()
-
+	ret := m.ctrl.Call(m, "GetCgroupStats", cgroupName, updateStats)
-	var r0 *v1alpha1.FsStats
+	ret0, _ := ret[0].(*v1alpha1.ContainerStats)
-	if rf, ok := ret.Get(0).(func() *v1alpha1.FsStats); ok {
+	ret1, _ := ret[1].(*v1alpha1.NetworkStats)
-		r0 = rf()
+	ret2, _ := ret[2].(error)
-	} else {
+	return ret0, ret1, ret2
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*v1alpha1.FsStats)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
 }
 
-// ListPodStats provides a mock function with given fields:
+// GetCgroupStats indicates an expected call of GetCgroupStats
-func (_m *StatsProvider) ListPodStats() ([]v1alpha1.PodStats, error) {
+func (mr *MockProviderMockRecorder) GetCgroupStats(cgroupName, updateStats interface{}) *gomock.Call {
-	ret := _m.Called()
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCgroupStats", reflect.TypeOf((*MockProvider)(nil).GetCgroupStats), cgroupName, updateStats)
-	var r0 []v1alpha1.PodStats
-	if rf, ok := ret.Get(0).(func() []v1alpha1.PodStats); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]v1alpha1.PodStats)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
 }
 
-// ListPodStatsAndUpdateCPUNanoCoreUsage provides a mock function with given fields:
+// GetCgroupCPUAndMemoryStats mocks base method
-func (_m *StatsProvider) ListPodStatsAndUpdateCPUNanoCoreUsage() ([]v1alpha1.PodStats, error) {
+func (m *MockProvider) GetCgroupCPUAndMemoryStats(cgroupName string, updateStats bool) (*v1alpha1.ContainerStats, error) {
-	ret := _m.Called()
+	m.ctrl.T.Helper()
-
+	ret := m.ctrl.Call(m, "GetCgroupCPUAndMemoryStats", cgroupName, updateStats)
-	var r0 []v1alpha1.PodStats
+	ret0, _ := ret[0].(*v1alpha1.ContainerStats)
-	if rf, ok := ret.Get(0).(func() []v1alpha1.PodStats); ok {
+	ret1, _ := ret[1].(error)
-		r0 = rf()
+	return ret0, ret1
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]v1alpha1.PodStats)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
 }
 
-// ListPodCPUAndMemoryStats provides a mock function with given fields:
+// GetCgroupCPUAndMemoryStats indicates an expected call of GetCgroupCPUAndMemoryStats
-func (_m *StatsProvider) ListPodCPUAndMemoryStats() ([]v1alpha1.PodStats, error) {
+func (mr *MockProviderMockRecorder) GetCgroupCPUAndMemoryStats(cgroupName, updateStats interface{}) *gomock.Call {
-	ret := _m.Called()
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCgroupCPUAndMemoryStats", reflect.TypeOf((*MockProvider)(nil).GetCgroupCPUAndMemoryStats), cgroupName, updateStats)
-	var r0 []v1alpha1.PodStats
-	if rf, ok := ret.Get(0).(func() []v1alpha1.PodStats); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]v1alpha1.PodStats)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
 }
 
-// ListVolumesForPod provides a mock function with given fields: podUID
+// RootFsStats mocks base method
-func (_m *StatsProvider) ListVolumesForPod(podUID types.UID) (map[string]volume.Volume, bool) {
+func (m *MockProvider) RootFsStats() (*v1alpha1.FsStats, error) {
-	ret := _m.Called(podUID)
+	m.ctrl.T.Helper()
-
+	ret := m.ctrl.Call(m, "RootFsStats")
-	var r0 map[string]volume.Volume
+	ret0, _ := ret[0].(*v1alpha1.FsStats)
-	if rf, ok := ret.Get(0).(func(types.UID) map[string]volume.Volume); ok {
+	ret1, _ := ret[1].(error)
-		r0 = rf(podUID)
+	return ret0, ret1
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(map[string]volume.Volume)
-		}
-	}
-
-	var r1 bool
-	if rf, ok := ret.Get(1).(func(types.UID) bool); ok {
-		r1 = rf(podUID)
-	} else {
-		r1 = ret.Get(1).(bool)
-	}
-
-	return r0, r1
 }
 
-// ListBlockVolumesForPod provides a mock function with given fields: podUID
+// RootFsStats indicates an expected call of RootFsStats
-func (_m *StatsProvider) ListBlockVolumesForPod(podUID types.UID) (map[string]volume.BlockVolume, bool) {
+func (mr *MockProviderMockRecorder) RootFsStats() *gomock.Call {
-	ret := _m.Called(podUID)
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RootFsStats", reflect.TypeOf((*MockProvider)(nil).RootFsStats))
-	var r0 map[string]volume.BlockVolume
-	if rf, ok := ret.Get(0).(func(types.UID) map[string]volume.BlockVolume); ok {
-		r0 = rf(podUID)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(map[string]volume.BlockVolume)
-		}
-	}
-
-	var r1 bool
-	if rf, ok := ret.Get(1).(func(types.UID) bool); ok {
-		r1 = rf(podUID)
-	} else {
-		r1 = ret.Get(1).(bool)
-	}
-
-	return r0, r1
 }
 
-// RootFsStats provides a mock function with given fields:
+// GetContainerInfo mocks base method
-func (_m *StatsProvider) RootFsStats() (*v1alpha1.FsStats, error) {
+func (m *MockProvider) GetContainerInfo(podFullName string, uid types.UID, containerName string, req *v1.ContainerInfoRequest) (*v1.ContainerInfo, error) {
-	ret := _m.Called()
+	m.ctrl.T.Helper()
-
+	ret := m.ctrl.Call(m, "GetContainerInfo", podFullName, uid, containerName, req)
-	var r0 *v1alpha1.FsStats
+	ret0, _ := ret[0].(*v1.ContainerInfo)
-	if rf, ok := ret.Get(0).(func() *v1alpha1.FsStats); ok {
+	ret1, _ := ret[1].(error)
-		r0 = rf()
+	return ret0, ret1
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*v1alpha1.FsStats)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
 }
 
-// RlimitStats provides a mock function with given fields:
+// GetContainerInfo indicates an expected call of GetContainerInfo
-func (_m *StatsProvider) RlimitStats() (*v1alpha1.RlimitStats, error) {
+func (mr *MockProviderMockRecorder) GetContainerInfo(podFullName, uid, containerName, req interface{}) *gomock.Call {
-	ret := _m.Called()
+	mr.mock.ctrl.T.Helper()
-
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerInfo", reflect.TypeOf((*MockProvider)(nil).GetContainerInfo), podFullName, uid, containerName, req)
-	var r0 *v1alpha1.RlimitStats
+}
-	if rf, ok := ret.Get(0).(func() *v1alpha1.RlimitStats); ok {
+
-		r0 = rf()
+// GetRawContainerInfo mocks base method
-	} else {
+func (m *MockProvider) GetRawContainerInfo(containerName string, req *v1.ContainerInfoRequest, subcontainers bool) (map[string]*v1.ContainerInfo, error) {
-		if ret.Get(0) != nil {
+	m.ctrl.T.Helper()
-			r0 = ret.Get(0).(*v1alpha1.RlimitStats)
+	ret := m.ctrl.Call(m, "GetRawContainerInfo", containerName, req, subcontainers)
-		}
+	ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
-	}
+	ret1, _ := ret[1].(error)
-
+	return ret0, ret1
-	var r1 error
+}
-	if rf, ok := ret.Get(1).(func() error); ok {
+
-		r1 = rf()
+// GetRawContainerInfo indicates an expected call of GetRawContainerInfo
-	} else {
+func (mr *MockProviderMockRecorder) GetRawContainerInfo(containerName, req, subcontainers interface{}) *gomock.Call {
-		r1 = ret.Error(1)
+	mr.mock.ctrl.T.Helper()
-	}
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawContainerInfo", reflect.TypeOf((*MockProvider)(nil).GetRawContainerInfo), containerName, req, subcontainers)
-
+}
-	return r0, r1
+
+// GetRequestedContainersInfo mocks base method
+func (m *MockProvider) GetRequestedContainersInfo(containerName string, options v2.RequestOptions) (map[string]*v1.ContainerInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRequestedContainersInfo", containerName, options)
+	ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRequestedContainersInfo indicates an expected call of GetRequestedContainersInfo
+func (mr *MockProviderMockRecorder) GetRequestedContainersInfo(containerName, options interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRequestedContainersInfo", reflect.TypeOf((*MockProvider)(nil).GetRequestedContainersInfo), containerName, options)
+}
+
+// GetPodByName mocks base method
+func (m *MockProvider) GetPodByName(namespace, name string) (*v10.Pod, bool) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPodByName", namespace, name)
+	ret0, _ := ret[0].(*v10.Pod)
+	ret1, _ := ret[1].(bool)
+	return ret0, ret1
+}
+
+// GetPodByName indicates an expected call of GetPodByName
+func (mr *MockProviderMockRecorder) GetPodByName(namespace, name interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByName", reflect.TypeOf((*MockProvider)(nil).GetPodByName), namespace, name)
+}
+
+// GetNode mocks base method
+func (m *MockProvider) GetNode() (*v10.Node, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetNode")
+	ret0, _ := ret[0].(*v10.Node)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetNode indicates an expected call of GetNode
+func (mr *MockProviderMockRecorder) GetNode() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNode", reflect.TypeOf((*MockProvider)(nil).GetNode))
+}
+
+// GetNodeConfig mocks base method
+func (m *MockProvider) GetNodeConfig() cm.NodeConfig {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetNodeConfig")
+	ret0, _ := ret[0].(cm.NodeConfig)
+	return ret0
+}
+
+// GetNodeConfig indicates an expected call of GetNodeConfig
+func (mr *MockProviderMockRecorder) GetNodeConfig() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeConfig", reflect.TypeOf((*MockProvider)(nil).GetNodeConfig))
+}
+
+// ListVolumesForPod mocks base method
+func (m *MockProvider) ListVolumesForPod(podUID types.UID) (map[string]volume.Volume, bool) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListVolumesForPod", podUID)
+	ret0, _ := ret[0].(map[string]volume.Volume)
+	ret1, _ := ret[1].(bool)
+	return ret0, ret1
+}
+
+// ListVolumesForPod indicates an expected call of ListVolumesForPod
+func (mr *MockProviderMockRecorder) ListVolumesForPod(podUID interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVolumesForPod", reflect.TypeOf((*MockProvider)(nil).ListVolumesForPod), podUID)
+}
+
+// ListBlockVolumesForPod mocks base method
+func (m *MockProvider) ListBlockVolumesForPod(podUID types.UID) (map[string]volume.BlockVolume, bool) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListBlockVolumesForPod", podUID)
+	ret0, _ := ret[0].(map[string]volume.BlockVolume)
+	ret1, _ := ret[1].(bool)
+	return ret0, ret1
+}
+
+// ListBlockVolumesForPod indicates an expected call of ListBlockVolumesForPod
+func (mr *MockProviderMockRecorder) ListBlockVolumesForPod(podUID interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBlockVolumesForPod", reflect.TypeOf((*MockProvider)(nil).ListBlockVolumesForPod), podUID)
+}
+
+// GetPods mocks base method
+func (m *MockProvider) GetPods() []*v10.Pod {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPods")
+	ret0, _ := ret[0].([]*v10.Pod)
+	return ret0
+}
+
+// GetPods indicates an expected call of GetPods
+func (mr *MockProviderMockRecorder) GetPods() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockProvider)(nil).GetPods))
+}
+
+// RlimitStats mocks base method
+func (m *MockProvider) RlimitStats() (*v1alpha1.RlimitStats, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RlimitStats")
+	ret0, _ := ret[0].(*v1alpha1.RlimitStats)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RlimitStats indicates an expected call of RlimitStats
+func (mr *MockProviderMockRecorder) RlimitStats() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RlimitStats", reflect.TypeOf((*MockProvider)(nil).RlimitStats))
+}
+
+// GetPodCgroupRoot mocks base method
+func (m *MockProvider) GetPodCgroupRoot() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPodCgroupRoot")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// GetPodCgroupRoot indicates an expected call of GetPodCgroupRoot
+func (mr *MockProviderMockRecorder) GetPodCgroupRoot() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodCgroupRoot", reflect.TypeOf((*MockProvider)(nil).GetPodCgroupRoot))
+}
+
+// GetPodByCgroupfs mocks base method
+func (m *MockProvider) GetPodByCgroupfs(cgroupfs string) (*v10.Pod, bool) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPodByCgroupfs", cgroupfs)
+	ret0, _ := ret[0].(*v10.Pod)
+	ret1, _ := ret[1].(bool)
+	return ret0, ret1
+}
+
+// GetPodByCgroupfs indicates an expected call of GetPodByCgroupfs
+func (mr *MockProviderMockRecorder) GetPodByCgroupfs(cgroupfs interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByCgroupfs", reflect.TypeOf((*MockProvider)(nil).GetPodByCgroupfs), cgroupfs)
 }

pkg/kubelet/server/stats/testing/mock_summary_provider.go

@@ -0,0 +1,80 @@
+/*
+Copyright 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 MockGen. DO NOT EDIT.
+// Source: summary.go
+
+// Package testing is a generated GoMock package.
+package testing
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	v1alpha1 "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
+	reflect "reflect"
+)
+
+// MockSummaryProvider is a mock of SummaryProvider interface
+type MockSummaryProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockSummaryProviderMockRecorder
+}
+
+// MockSummaryProviderMockRecorder is the mock recorder for MockSummaryProvider
+type MockSummaryProviderMockRecorder struct {
+	mock *MockSummaryProvider
+}
+
+// NewMockSummaryProvider creates a new mock instance
+func NewMockSummaryProvider(ctrl *gomock.Controller) *MockSummaryProvider {
+	mock := &MockSummaryProvider{ctrl: ctrl}
+	mock.recorder = &MockSummaryProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockSummaryProvider) EXPECT() *MockSummaryProviderMockRecorder {
+	return m.recorder
+}
+
+// Get mocks base method
+func (m *MockSummaryProvider) Get(updateStats bool) (*v1alpha1.Summary, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Get", updateStats)
+	ret0, _ := ret[0].(*v1alpha1.Summary)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get
+func (mr *MockSummaryProviderMockRecorder) Get(updateStats interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSummaryProvider)(nil).Get), updateStats)
+}
+
+// GetCPUAndMemoryStats mocks base method
+func (m *MockSummaryProvider) GetCPUAndMemoryStats() (*v1alpha1.Summary, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCPUAndMemoryStats")
+	ret0, _ := ret[0].(*v1alpha1.Summary)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCPUAndMemoryStats indicates an expected call of GetCPUAndMemoryStats
+func (mr *MockSummaryProviderMockRecorder) GetCPUAndMemoryStats() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCPUAndMemoryStats", reflect.TypeOf((*MockSummaryProvider)(nil).GetCPUAndMemoryStats))
+}

pkg/kubelet/server/stats/volume_stat_calculator_test.go

@@ -22,6 +22,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 
 	csipbv1 "github.com/container-storage-interface/spec/lib/go/csi"
@@ -97,12 +98,15 @@ var (
 )
 
 func TestPVCRef(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	// Setup mock stats provider
-	mockStats := new(statstest.StatsProvider)
+	mockStats := statstest.NewMockProvider(mockCtrl)
 	volumes := map[string]volume.Volume{vol0: &fakeVolume{}, vol1: &fakeVolume{}}
-	mockStats.On("ListVolumesForPod", fakePod.UID).Return(volumes, true)
+	mockStats.EXPECT().ListVolumesForPod(fakePod.UID).Return(volumes, true)
 	blockVolumes := map[string]volume.BlockVolume{vol2: &fakeBlockVolume{}}
-	mockStats.On("ListBlockVolumesForPod", fakePod.UID).Return(blockVolumes, true)
+	mockStats.EXPECT().ListBlockVolumesForPod(fakePod.UID).Return(blockVolumes, true)
 
 	eventStore := make(chan string, 1)
 	fakeEventRecorder := record.FakeRecorder{
@@ -141,11 +145,14 @@ func TestPVCRef(t *testing.T) {
 }
 
 func TestNormalVolumeEvent(t *testing.T) {
-	mockStats := new(statstest.StatsProvider)
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	mockStats := statstest.NewMockProvider(mockCtrl)
+
 	volumes := map[string]volume.Volume{vol0: &fakeVolume{}, vol1: &fakeVolume{}}
-	mockStats.On("ListVolumesForPod", fakePod.UID).Return(volumes, true)
+	mockStats.EXPECT().ListVolumesForPod(fakePod.UID).Return(volumes, true)
 	blockVolumes := map[string]volume.BlockVolume{vol2: &fakeBlockVolume{}}
-	mockStats.On("ListBlockVolumesForPod", fakePod.UID).Return(blockVolumes, true)
+	mockStats.EXPECT().ListBlockVolumesForPod(fakePod.UID).Return(blockVolumes, true)
 
 	eventStore := make(chan string, 2)
 	fakeEventRecorder := record.FakeRecorder{
@@ -163,12 +170,15 @@ func TestNormalVolumeEvent(t *testing.T) {
 
 func TestAbnormalVolumeEvent(t *testing.T) {
 	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.CSIVolumeHealth, true)()
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	// Setup mock stats provider
-	mockStats := new(statstest.StatsProvider)
+	mockStats := statstest.NewMockProvider(mockCtrl)
 	volumes := map[string]volume.Volume{vol0: &fakeVolume{}}
-	mockStats.On("ListVolumesForPod", fakePod.UID).Return(volumes, true)
+	mockStats.EXPECT().ListVolumesForPod(fakePod.UID).Return(volumes, true)
 	blockVolumes := map[string]volume.BlockVolume{vol1: &fakeBlockVolume{}}
-	mockStats.On("ListBlockVolumesForPod", fakePod.UID).Return(blockVolumes, true)
+	mockStats.EXPECT().ListBlockVolumesForPod(fakePod.UID).Return(blockVolumes, true)
 
 	eventStore := make(chan string, 2)
 	fakeEventRecorder := record.FakeRecorder{

pkg/kubelet/stats/cadvisor_stats_provider_test.go

@@ -19,6 +19,7 @@ package stats
 import (
 	"testing"
 
+	gomock "github.com/golang/mock/gomock"
 	cadvisorapiv2 "github.com/google/cadvisor/info/v2"
 	"github.com/stretchr/testify/assert"
 
@@ -202,15 +203,16 @@ func TestCadvisorListPodStats(t *testing.T) {
 		Recursive: true,
 	}
 
-	mockCadvisor := new(cadvisortest.Mock)
+	mockCtrl := gomock.NewController(t)
-	mockCadvisor.
+	defer mockCtrl.Finish()
-		On("ContainerInfoV2", "/", options).Return(infos, nil).
-		On("RootFsInfo").Return(rootfs, nil).
-		On("ImagesFsInfo").Return(imagefs, nil)
 
-	mockRuntime := new(containertest.Mock)
+	mockCadvisor := cadvisortest.NewMockInterface(mockCtrl)
-	mockRuntime.
+	mockCadvisor.EXPECT().ContainerInfoV2("/", options).Return(infos, nil)
-		On("ImageStats").Return(&kubecontainer.ImageStats{TotalStorageBytes: 123}, nil)
+	mockCadvisor.EXPECT().RootFsInfo().Return(rootfs, nil)
+	mockCadvisor.EXPECT().ImagesFsInfo().Return(imagefs, nil)
+
+	mockRuntime := containertest.NewMockRuntime(mockCtrl)
+	mockRuntime.EXPECT().ImageStats().Return(&kubecontainer.ImageStats{TotalStorageBytes: 123}, nil).AnyTimes()
 
 	ephemeralVolumes := []statsapi.VolumeStats{getPodVolumeStats(seedEphemeralVolume1, "ephemeralVolume1"),
 		getPodVolumeStats(seedEphemeralVolume2, "ephemeralVolume2")}
@@ -224,11 +226,11 @@ func TestCadvisorListPodStats(t *testing.T) {
 	p1Time := metav1.Now()
 	p2Time := metav1.Now()
 	p3Time := metav1.Now()
-	mockStatus := new(statustest.MockStatusProvider)
+	mockStatus := statustest.NewMockPodStatusProvider(mockCtrl)
-	mockStatus.On("GetPodStatus", types.UID("UID"+pName0)).Return(v1.PodStatus{StartTime: &p0Time}, true)
+	mockStatus.EXPECT().GetPodStatus(types.UID("UID"+pName0)).Return(v1.PodStatus{StartTime: &p0Time}, true)
-	mockStatus.On("GetPodStatus", types.UID("UID"+pName1)).Return(v1.PodStatus{StartTime: &p1Time}, true)
+	mockStatus.EXPECT().GetPodStatus(types.UID("UID"+pName1)).Return(v1.PodStatus{StartTime: &p1Time}, true)
-	mockStatus.On("GetPodStatus", types.UID("UID"+pName2)).Return(v1.PodStatus{StartTime: &p2Time}, true)
+	mockStatus.EXPECT().GetPodStatus(types.UID("UID"+pName2)).Return(v1.PodStatus{StartTime: &p2Time}, true)
-	mockStatus.On("GetPodStatus", types.UID("UID"+pName3)).Return(v1.PodStatus{StartTime: &p3Time}, true)
+	mockStatus.EXPECT().GetPodStatus(types.UID("UID"+pName3)).Return(v1.PodStatus{StartTime: &p3Time}, true)
 
 	resourceAnalyzer := &fakeResourceAnalyzer{podVolumeStats: volumeStats}
 
@@ -385,9 +387,11 @@ func TestCadvisorListPodCPUAndMemoryStats(t *testing.T) {
 		Recursive: true,
 	}
 
-	mockCadvisor := new(cadvisortest.Mock)
+	mockCtrl := gomock.NewController(t)
-	mockCadvisor.
+	defer mockCtrl.Finish()
-		On("ContainerInfoV2", "/", options).Return(infos, nil)
+
+	mockCadvisor := cadvisortest.NewMockInterface(mockCtrl)
+	mockCadvisor.EXPECT().ContainerInfoV2("/", options).Return(infos, nil)
 
 	ephemeralVolumes := []statsapi.VolumeStats{getPodVolumeStats(seedEphemeralVolume1, "ephemeralVolume1"),
 		getPodVolumeStats(seedEphemeralVolume2, "ephemeralVolume2")}
@@ -473,18 +477,20 @@ func TestCadvisorListPodCPUAndMemoryStats(t *testing.T) {
 }
 
 func TestCadvisorImagesFsStats(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
 	var (
 		assert       = assert.New(t)
-		mockCadvisor = new(cadvisortest.Mock)
+		mockCadvisor = cadvisortest.NewMockInterface(mockCtrl)
-		mockRuntime  = new(containertest.Mock)
+		mockRuntime  = containertest.NewMockRuntime(mockCtrl)
 
 		seed        = 1000
 		imageFsInfo = getTestFsInfo(seed)
 		imageStats  = &kubecontainer.ImageStats{TotalStorageBytes: 100}
 	)
 
-	mockCadvisor.On("ImagesFsInfo").Return(imageFsInfo, nil)
+	mockCadvisor.EXPECT().ImagesFsInfo().Return(imageFsInfo, nil)
-	mockRuntime.On("ImageStats").Return(imageStats, nil)
+	mockRuntime.EXPECT().ImageStats().Return(imageStats, nil)
 
 	provider := newCadvisorStatsProvider(mockCadvisor, &fakeResourceAnalyzer{}, mockRuntime, nil, NewFakeHostStatsProvider())
 	stats, err := provider.ImageFsStats()
@@ -497,6 +503,4 @@ func TestCadvisorImagesFsStats(t *testing.T) {
 	assert.Equal(imageFsInfo.InodesFree, stats.InodesFree)
 	assert.Equal(imageFsInfo.Inodes, stats.Inodes)
 	assert.Equal(*imageFsInfo.Inodes-*imageFsInfo.InodesFree, *stats.InodesUsed)
-
-	mockCadvisor.AssertExpectations(t)
 }

pkg/kubelet/stats/cri_stats_provider_test.go

@@ -139,8 +139,11 @@ func TestCRIListPodStats(t *testing.T) {
 		podLogStats1 = makeFakeLogStats(6000)
 	)
 
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	var (
-		mockCadvisor       = new(cadvisortest.Mock)
+		mockCadvisor       = cadvisortest.NewMockInterface(mockCtrl)
 		mockRuntimeCache   = new(kubecontainertest.MockRuntimeCache)
 		mockPodManager     = new(kubepodtest.MockManager)
 		resourceAnalyzer   = new(fakeResourceAnalyzer)
@@ -171,11 +174,11 @@ func TestCRIListPodStats(t *testing.T) {
 		Recursive: true,
 	}
 
-	mockCadvisor.
+	mockCadvisor.EXPECT().ContainerInfoV2("/", options).Return(infos, nil)
-		On("ContainerInfoV2", "/", options).Return(infos, nil).
+	mockCadvisor.EXPECT().RootFsInfo().Return(rootFsInfo, nil)
-		On("RootFsInfo").Return(rootFsInfo, nil).
+	mockCadvisor.EXPECT().GetDirFsInfo(imageFsMountpoint).Return(imageFsInfo, nil)
-		On("GetDirFsInfo", imageFsMountpoint).Return(imageFsInfo, nil).
+	mockCadvisor.EXPECT().GetDirFsInfo(unknownMountpoint).Return(cadvisorapiv2.FsInfo{}, cadvisorfs.ErrNoSuchDevice)
-		On("GetDirFsInfo", unknownMountpoint).Return(cadvisorapiv2.FsInfo{}, cadvisorfs.ErrNoSuchDevice)
+
 	fakeRuntimeService.SetFakeSandboxes([]*critest.FakePodSandbox{
 		sandbox0, sandbox1, sandbox2, sandbox3, sandbox4, sandbox5,
 	})
@@ -317,8 +320,6 @@ func TestCRIListPodStats(t *testing.T) {
 	assert.NotNil(c8.CPU.Time)
 	assert.NotNil(c8.Memory.Time)
 	checkCRIPodCPUAndMemoryStats(assert, p3, infos[sandbox3Cgroup].Stats[0])
-
-	mockCadvisor.AssertExpectations(t)
 }
 
 func TestAcceleratorUsageStatsCanBeDisabled(t *testing.T) {
@@ -336,8 +337,11 @@ func TestAcceleratorUsageStatsCanBeDisabled(t *testing.T) {
 		containerStats1 = makeFakeContainerStats(container1, unknownMountpoint)
 	)
 
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	var (
-		mockCadvisor       = new(cadvisortest.Mock)
+		mockCadvisor       = cadvisortest.NewMockInterface(mockCtrl)
 		mockRuntimeCache   = new(kubecontainertest.MockRuntimeCache)
 		mockPodManager     = new(kubepodtest.MockManager)
 		resourceAnalyzer   = new(fakeResourceAnalyzer)
@@ -361,11 +365,11 @@ func TestAcceleratorUsageStatsCanBeDisabled(t *testing.T) {
 		Recursive: true,
 	}
 
-	mockCadvisor.
+	mockCadvisor.EXPECT().ContainerInfoV2("/", options).Return(infos, nil)
-		On("ContainerInfoV2", "/", options).Return(infos, nil).
+	mockCadvisor.EXPECT().RootFsInfo().Return(rootFsInfo, nil)
-		On("RootFsInfo").Return(rootFsInfo, nil).
+	mockCadvisor.EXPECT().GetDirFsInfo(imageFsMountpoint).Return(imageFsInfo, nil)
-		On("GetDirFsInfo", imageFsMountpoint).Return(imageFsInfo, nil).
+	mockCadvisor.EXPECT().GetDirFsInfo(unknownMountpoint).Return(cadvisorapiv2.FsInfo{}, cadvisorfs.ErrNoSuchDevice)
-		On("GetDirFsInfo", unknownMountpoint).Return(cadvisorapiv2.FsInfo{}, cadvisorfs.ErrNoSuchDevice)
+
 	fakeRuntimeService.SetFakeSandboxes([]*critest.FakePodSandbox{
 		sandbox0,
 	})
@@ -424,8 +428,6 @@ func TestAcceleratorUsageStatsCanBeDisabled(t *testing.T) {
 	assert.Nil(c1.Accelerators)
 
 	checkCRIPodCPUAndMemoryStats(assert, p0, infos[sandbox0Cgroup].Stats[0])
-
-	mockCadvisor.AssertExpectations(t)
 }
 
 func TestCRIListPodCPUAndMemoryStats(t *testing.T) {
@@ -477,8 +479,11 @@ func TestCRIListPodCPUAndMemoryStats(t *testing.T) {
 		containerStats9 = makeFakeContainerStats(container9, imageFsMountpoint)
 	)
 
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	var (
-		mockCadvisor       = new(cadvisortest.Mock)
+		mockCadvisor       = cadvisortest.NewMockInterface(mockCtrl)
 		mockRuntimeCache   = new(kubecontainertest.MockRuntimeCache)
 		mockPodManager     = new(kubepodtest.MockManager)
 		resourceAnalyzer   = new(fakeResourceAnalyzer)
@@ -508,8 +513,8 @@ func TestCRIListPodCPUAndMemoryStats(t *testing.T) {
 		Recursive: true,
 	}
 
-	mockCadvisor.
+	mockCadvisor.EXPECT().ContainerInfoV2("/", options).Return(infos, nil)
-		On("ContainerInfoV2", "/", options).Return(infos, nil)
+
 	fakeRuntimeService.SetFakeSandboxes([]*critest.FakePodSandbox{
 		sandbox0, sandbox1, sandbox2, sandbox3, sandbox4, sandbox5, sandbox6,
 	})
@@ -632,8 +637,6 @@ func TestCRIListPodCPUAndMemoryStats(t *testing.T) {
 	assert.Equal(containerStats9.Cpu.Timestamp, p6.CPU.Time.UnixNano())
 	assert.NotNil(c9.Memory.Time)
 	assert.Equal(containerStats9.Memory.Timestamp, p6.Memory.Time.UnixNano())
-
-	mockCadvisor.AssertExpectations(t)
 }
 
 func TestCRIImagesFsStats(t *testing.T) {
@@ -642,16 +645,19 @@ func TestCRIImagesFsStats(t *testing.T) {
 		imageFsInfo       = getTestFsInfo(2000)
 		imageFsUsage      = makeFakeImageFsUsage(imageFsMountpoint)
 	)
+
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	var (
-		mockCadvisor       = new(cadvisortest.Mock)
+		mockCadvisor       = cadvisortest.NewMockInterface(mockCtrl)
 		mockRuntimeCache   = new(kubecontainertest.MockRuntimeCache)
 		mockPodManager     = new(kubepodtest.MockManager)
 		resourceAnalyzer   = new(fakeResourceAnalyzer)
 		fakeRuntimeService = critest.NewFakeRuntimeService()
 		fakeImageService   = critest.NewFakeImageService()
 	)
-
+	mockCadvisor.EXPECT().GetDirFsInfo(imageFsMountpoint).Return(imageFsInfo, nil)
-	mockCadvisor.On("GetDirFsInfo", imageFsMountpoint).Return(imageFsInfo, nil)
 	fakeImageService.SetFakeFilesystemUsage([]*runtimeapi.FilesystemUsage{
 		imageFsUsage,
 	})
@@ -678,8 +684,6 @@ func TestCRIImagesFsStats(t *testing.T) {
 	assert.Equal(imageFsInfo.Inodes, stats.Inodes)
 	assert.Equal(imageFsUsage.UsedBytes.Value, *stats.UsedBytes)
 	assert.Equal(imageFsUsage.InodesUsed.Value, *stats.InodesUsed)
-
-	mockCadvisor.AssertExpectations(t)
 }
 
 func makeFakePodSandbox(name, uid, namespace string, terminated bool) *critest.FakePodSandbox {

pkg/kubelet/stats/provider_test.go

@@ -21,6 +21,7 @@ import (
 	"testing"
 	"time"
 
+	gomock "github.com/golang/mock/gomock"
 	cadvisorapiv1 "github.com/google/cadvisor/info/v1"
 	cadvisorapiv2 "github.com/google/cadvisor/info/v2"
 	fuzz "github.com/google/gofuzz"
@@ -73,8 +74,12 @@ func TestGetCgroupStats(t *testing.T) {
 		containerInfoSeed = 1000
 		updateStats       = false
 	)
+
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	var (
-		mockCadvisor     = new(cadvisortest.Mock)
+		mockCadvisor     = cadvisortest.NewMockInterface(mockCtrl)
 		mockPodManager   = new(kubepodtest.MockManager)
 		mockRuntimeCache = new(kubecontainertest.MockRuntimeCache)
 
@@ -85,7 +90,7 @@ func TestGetCgroupStats(t *testing.T) {
 		containerInfoMap = map[string]cadvisorapiv2.ContainerInfo{cgroupName: containerInfo}
 	)
 
-	mockCadvisor.On("ContainerInfoV2", cgroupName, options).Return(containerInfoMap, nil)
+	mockCadvisor.EXPECT().ContainerInfoV2(cgroupName, options).Return(containerInfoMap, nil)
 
 	provider := newStatsProvider(mockCadvisor, mockPodManager, mockRuntimeCache, fakeContainerStatsProvider{})
 	cs, ns, err := provider.GetCgroupStats(cgroupName, updateStats)
@@ -97,8 +102,6 @@ func TestGetCgroupStats(t *testing.T) {
 
 	assert.Equal(cgroupName, cs.Name)
 	assert.Equal(metav1.NewTime(containerInfo.Spec.CreationTime), cs.StartTime)
-
-	mockCadvisor.AssertExpectations(t)
 }
 
 func TestGetCgroupCPUAndMemoryStats(t *testing.T) {
@@ -107,8 +110,12 @@ func TestGetCgroupCPUAndMemoryStats(t *testing.T) {
 		containerInfoSeed = 1000
 		updateStats       = false
 	)
+
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	var (
-		mockCadvisor     = new(cadvisortest.Mock)
+		mockCadvisor     = cadvisortest.NewMockInterface(mockCtrl)
 		mockPodManager   = new(kubepodtest.MockManager)
 		mockRuntimeCache = new(kubecontainertest.MockRuntimeCache)
 
@@ -119,7 +126,7 @@ func TestGetCgroupCPUAndMemoryStats(t *testing.T) {
 		containerInfoMap = map[string]cadvisorapiv2.ContainerInfo{cgroupName: containerInfo}
 	)
 
-	mockCadvisor.On("ContainerInfoV2", cgroupName, options).Return(containerInfoMap, nil)
+	mockCadvisor.EXPECT().ContainerInfoV2(cgroupName, options).Return(containerInfoMap, nil)
 
 	provider := newStatsProvider(mockCadvisor, mockPodManager, mockRuntimeCache, fakeContainerStatsProvider{})
 	cs, err := provider.GetCgroupCPUAndMemoryStats(cgroupName, updateStats)
@@ -130,8 +137,6 @@ func TestGetCgroupCPUAndMemoryStats(t *testing.T) {
 
 	assert.Equal(cgroupName, cs.Name)
 	assert.Equal(metav1.NewTime(containerInfo.Spec.CreationTime), cs.StartTime)
-
-	mockCadvisor.AssertExpectations(t)
 }
 
 func TestRootFsStats(t *testing.T) {
@@ -139,8 +144,12 @@ func TestRootFsStats(t *testing.T) {
 		rootFsInfoSeed    = 1000
 		containerInfoSeed = 2000
 	)
+
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	var (
-		mockCadvisor     = new(cadvisortest.Mock)
+		mockCadvisor     = cadvisortest.NewMockInterface(mockCtrl)
 		mockPodManager   = new(kubepodtest.MockManager)
 		mockRuntimeCache = new(kubecontainertest.MockRuntimeCache)
 
@@ -152,9 +161,8 @@ func TestRootFsStats(t *testing.T) {
 		containerInfoMap = map[string]cadvisorapiv2.ContainerInfo{"/": containerInfo}
 	)
 
-	mockCadvisor.
+	mockCadvisor.EXPECT().RootFsInfo().Return(rootFsInfo, nil)
-		On("RootFsInfo").Return(rootFsInfo, nil).
+	mockCadvisor.EXPECT().ContainerInfoV2("/", options).Return(containerInfoMap, nil)
-		On("ContainerInfoV2", "/", options).Return(containerInfoMap, nil)
 
 	provider := newStatsProvider(mockCadvisor, mockPodManager, mockRuntimeCache, fakeContainerStatsProvider{})
 	stats, err := provider.RootFsStats()
@@ -165,8 +173,6 @@ func TestRootFsStats(t *testing.T) {
 	assert.Equal(metav1.NewTime(containerInfo.Stats[0].Timestamp), stats.Time)
 	assert.Equal(rootFsInfo.Usage, *stats.UsedBytes)
 	assert.Equal(*rootFsInfo.Inodes-*rootFsInfo.InodesFree, *stats.InodesUsed)
-
-	mockCadvisor.AssertExpectations(t)
 }
 
 func TestGetContainerInfo(t *testing.T) {
@@ -316,19 +322,22 @@ func TestGetContainerInfo(t *testing.T) {
 		},
 	}
 
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	for _, tc := range tests {
 		var (
-			mockCadvisor     = new(cadvisortest.Mock)
+			mockCadvisor     = cadvisortest.NewMockInterface(mockCtrl)
-			mockPodManager   = new(kubepodtest.MockManager)
+			mockPodManager   = kubepodtest.NewMockManager(mockCtrl)
-			mockRuntimeCache = new(kubecontainertest.MockRuntimeCache)
+			mockRuntimeCache = kubecontainertest.NewMockRuntimeCache(mockCtrl)
 
 			cadvisorReq = &cadvisorapiv1.ContainerInfoRequest{}
 		)
 
-		mockPodManager.On("TranslatePodUID", tc.requestedPodUID).Return(kubetypes.ResolvedPodUID(tc.requestedPodUID))
+		mockPodManager.EXPECT().TranslatePodUID(tc.requestedPodUID).Return(kubetypes.ResolvedPodUID(tc.requestedPodUID))
-		mockRuntimeCache.On("GetPods").Return(tc.podList, tc.runtimeError)
+		mockRuntimeCache.EXPECT().GetPods().Return(tc.podList, tc.runtimeError)
 		if tc.expectDockerContainerCall {
-			mockCadvisor.On("DockerContainer", tc.containerID, cadvisorReq).Return(tc.cadvisorContainerInfo, tc.mockError)
+			mockCadvisor.EXPECT().DockerContainer(tc.containerID, cadvisorReq).Return(tc.cadvisorContainerInfo, tc.mockError)
 		}
 
 		provider := newStatsProvider(mockCadvisor, mockPodManager, mockRuntimeCache, fakeContainerStatsProvider{})
@@ -338,13 +347,15 @@ func TestGetContainerInfo(t *testing.T) {
 		if tc.expectStats {
 			require.NotNil(t, stats)
 		}
-		mockCadvisor.AssertExpectations(t)
 	}
 }
 
 func TestGetRawContainerInfoRoot(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	var (
-		mockCadvisor     = new(cadvisortest.Mock)
+		mockCadvisor     = cadvisortest.NewMockInterface(mockCtrl)
 		mockPodManager   = new(kubepodtest.MockManager)
 		mockRuntimeCache = new(kubecontainertest.MockRuntimeCache)
 
@@ -357,17 +368,19 @@ func TestGetRawContainerInfoRoot(t *testing.T) {
 		}
 	)
 
-	mockCadvisor.On("ContainerInfo", containerPath, cadvisorReq).Return(containerInfo, nil)
+	mockCadvisor.EXPECT().ContainerInfo(containerPath, cadvisorReq).Return(containerInfo, nil)
 
 	provider := newStatsProvider(mockCadvisor, mockPodManager, mockRuntimeCache, fakeContainerStatsProvider{})
 	_, err := provider.GetRawContainerInfo(containerPath, cadvisorReq, false)
 	assert.NoError(t, err)
-	mockCadvisor.AssertExpectations(t)
 }
 
 func TestGetRawContainerInfoSubcontainers(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	var (
-		mockCadvisor     = new(cadvisortest.Mock)
+		mockCadvisor     = cadvisortest.NewMockInterface(mockCtrl)
 		mockPodManager   = new(kubepodtest.MockManager)
 		mockRuntimeCache = new(kubecontainertest.MockRuntimeCache)
 
@@ -387,16 +400,18 @@ func TestGetRawContainerInfoSubcontainers(t *testing.T) {
 		}
 	)
 
-	mockCadvisor.On("SubcontainerInfo", containerPath, cadvisorReq).Return(containerInfo, nil)
+	mockCadvisor.EXPECT().SubcontainerInfo(containerPath, cadvisorReq).Return(containerInfo, nil)
 
 	provider := newStatsProvider(mockCadvisor, mockPodManager, mockRuntimeCache, fakeContainerStatsProvider{})
 	result, err := provider.GetRawContainerInfo(containerPath, cadvisorReq, true)
 	assert.NoError(t, err)
 	assert.Len(t, result, 2)
-	mockCadvisor.AssertExpectations(t)
 }
 
 func TestHasDedicatedImageFs(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	for desc, test := range map[string]struct {
 		rootfsDevice  string
 		imagefsDevice string
@@ -415,11 +430,11 @@ func TestHasDedicatedImageFs(t *testing.T) {
 	} {
 		t.Logf("TestCase %q", desc)
 		var (
-			mockCadvisor     = new(cadvisortest.Mock)
+			mockCadvisor     = cadvisortest.NewMockInterface(mockCtrl)
 			mockPodManager   = new(kubepodtest.MockManager)
 			mockRuntimeCache = new(kubecontainertest.MockRuntimeCache)
 		)
-		mockCadvisor.On("RootFsInfo").Return(cadvisorapiv2.FsInfo{Device: test.rootfsDevice}, nil)
+		mockCadvisor.EXPECT().RootFsInfo().Return(cadvisorapiv2.FsInfo{Device: test.rootfsDevice}, nil)
 
 		provider := newStatsProvider(mockCadvisor, mockPodManager, mockRuntimeCache, fakeContainerStatsProvider{
 			device: test.imagefsDevice,
@@ -427,7 +442,6 @@ func TestHasDedicatedImageFs(t *testing.T) {
 		dedicated, err := provider.HasDedicatedImageFs()
 		assert.NoError(t, err)
 		assert.Equal(t, test.dedicated, dedicated)
-		mockCadvisor.AssertExpectations(t)
 	}
 }
 

pkg/kubelet/status/status_manager.go

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+//go:generate mockgen -source=status_manager.go -destination=testing/mock_pod_status_provider.go -package=testing PodStatusProvider
 package status
 
 import (

pkg/kubelet/status/testing/mock_pod_status_provider.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2018 The Kubernetes Authors.
+Copyright 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.
@@ -14,22 +14,201 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+// Code generated by MockGen. DO NOT EDIT.
+// Source: status_manager.go
+
+// Package testing is a generated GoMock package.
 package testing
 
 import (
-	"github.com/stretchr/testify/mock"
+	gomock "github.com/golang/mock/gomock"
-
+	v1 "k8s.io/api/core/v1"
-	"k8s.io/api/core/v1"
+	types "k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/types"
+	container "k8s.io/kubernetes/pkg/kubelet/container"
+	reflect "reflect"
 )
 
-// MockStatusProvider mocks a PodStatusProvider.
+// MockPodStatusProvider is a mock of PodStatusProvider interface
-type MockStatusProvider struct {
+type MockPodStatusProvider struct {
-	mock.Mock
+	ctrl     *gomock.Controller
+	recorder *MockPodStatusProviderMockRecorder
 }
 
-// GetPodStatus implements PodStatusProvider.
+// MockPodStatusProviderMockRecorder is the mock recorder for MockPodStatusProvider
-func (m *MockStatusProvider) GetPodStatus(uid types.UID) (v1.PodStatus, bool) {
+type MockPodStatusProviderMockRecorder struct {
-	args := m.Called(uid)
+	mock *MockPodStatusProvider
-	return args.Get(0).(v1.PodStatus), args.Bool(1)
+}
+
+// NewMockPodStatusProvider creates a new mock instance
+func NewMockPodStatusProvider(ctrl *gomock.Controller) *MockPodStatusProvider {
+	mock := &MockPodStatusProvider{ctrl: ctrl}
+	mock.recorder = &MockPodStatusProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockPodStatusProvider) EXPECT() *MockPodStatusProviderMockRecorder {
+	return m.recorder
+}
+
+// GetPodStatus mocks base method
+func (m *MockPodStatusProvider) GetPodStatus(uid types.UID) (v1.PodStatus, bool) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPodStatus", uid)
+	ret0, _ := ret[0].(v1.PodStatus)
+	ret1, _ := ret[1].(bool)
+	return ret0, ret1
+}
+
+// GetPodStatus indicates an expected call of GetPodStatus
+func (mr *MockPodStatusProviderMockRecorder) GetPodStatus(uid interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodStatus", reflect.TypeOf((*MockPodStatusProvider)(nil).GetPodStatus), uid)
+}
+
+// MockPodDeletionSafetyProvider is a mock of PodDeletionSafetyProvider interface
+type MockPodDeletionSafetyProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockPodDeletionSafetyProviderMockRecorder
+}
+
+// MockPodDeletionSafetyProviderMockRecorder is the mock recorder for MockPodDeletionSafetyProvider
+type MockPodDeletionSafetyProviderMockRecorder struct {
+	mock *MockPodDeletionSafetyProvider
+}
+
+// NewMockPodDeletionSafetyProvider creates a new mock instance
+func NewMockPodDeletionSafetyProvider(ctrl *gomock.Controller) *MockPodDeletionSafetyProvider {
+	mock := &MockPodDeletionSafetyProvider{ctrl: ctrl}
+	mock.recorder = &MockPodDeletionSafetyProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockPodDeletionSafetyProvider) EXPECT() *MockPodDeletionSafetyProviderMockRecorder {
+	return m.recorder
+}
+
+// PodResourcesAreReclaimed mocks base method
+func (m *MockPodDeletionSafetyProvider) PodResourcesAreReclaimed(pod *v1.Pod, status v1.PodStatus) bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PodResourcesAreReclaimed", pod, status)
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// PodResourcesAreReclaimed indicates an expected call of PodResourcesAreReclaimed
+func (mr *MockPodDeletionSafetyProviderMockRecorder) PodResourcesAreReclaimed(pod, status interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PodResourcesAreReclaimed", reflect.TypeOf((*MockPodDeletionSafetyProvider)(nil).PodResourcesAreReclaimed), pod, status)
+}
+
+// MockManager is a mock of Manager interface
+type MockManager struct {
+	ctrl     *gomock.Controller
+	recorder *MockManagerMockRecorder
+}
+
+// MockManagerMockRecorder is the mock recorder for MockManager
+type MockManagerMockRecorder struct {
+	mock *MockManager
+}
+
+// NewMockManager creates a new mock instance
+func NewMockManager(ctrl *gomock.Controller) *MockManager {
+	mock := &MockManager{ctrl: ctrl}
+	mock.recorder = &MockManagerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockManager) EXPECT() *MockManagerMockRecorder {
+	return m.recorder
+}
+
+// GetPodStatus mocks base method
+func (m *MockManager) GetPodStatus(uid types.UID) (v1.PodStatus, bool) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPodStatus", uid)
+	ret0, _ := ret[0].(v1.PodStatus)
+	ret1, _ := ret[1].(bool)
+	return ret0, ret1
+}
+
+// GetPodStatus indicates an expected call of GetPodStatus
+func (mr *MockManagerMockRecorder) GetPodStatus(uid interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodStatus", reflect.TypeOf((*MockManager)(nil).GetPodStatus), uid)
+}
+
+// Start mocks base method
+func (m *MockManager) Start() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Start")
+}
+
+// Start indicates an expected call of Start
+func (mr *MockManagerMockRecorder) Start() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockManager)(nil).Start))
+}
+
+// SetPodStatus mocks base method
+func (m *MockManager) SetPodStatus(pod *v1.Pod, status v1.PodStatus) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "SetPodStatus", pod, status)
+}
+
+// SetPodStatus indicates an expected call of SetPodStatus
+func (mr *MockManagerMockRecorder) SetPodStatus(pod, status interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPodStatus", reflect.TypeOf((*MockManager)(nil).SetPodStatus), pod, status)
+}
+
+// SetContainerReadiness mocks base method
+func (m *MockManager) SetContainerReadiness(podUID types.UID, containerID container.ContainerID, ready bool) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "SetContainerReadiness", podUID, containerID, ready)
+}
+
+// SetContainerReadiness indicates an expected call of SetContainerReadiness
+func (mr *MockManagerMockRecorder) SetContainerReadiness(podUID, containerID, ready interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetContainerReadiness", reflect.TypeOf((*MockManager)(nil).SetContainerReadiness), podUID, containerID, ready)
+}
+
+// SetContainerStartup mocks base method
+func (m *MockManager) SetContainerStartup(podUID types.UID, containerID container.ContainerID, started bool) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "SetContainerStartup", podUID, containerID, started)
+}
+
+// SetContainerStartup indicates an expected call of SetContainerStartup
+func (mr *MockManagerMockRecorder) SetContainerStartup(podUID, containerID, started interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetContainerStartup", reflect.TypeOf((*MockManager)(nil).SetContainerStartup), podUID, containerID, started)
+}
+
+// TerminatePod mocks base method
+func (m *MockManager) TerminatePod(pod *v1.Pod) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "TerminatePod", pod)
+}
+
+// TerminatePod indicates an expected call of TerminatePod
+func (mr *MockManagerMockRecorder) TerminatePod(pod interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminatePod", reflect.TypeOf((*MockManager)(nil).TerminatePod), pod)
+}
+
+// RemoveOrphanedStatuses mocks base method
+func (m *MockManager) RemoveOrphanedStatuses(podUIDs map[types.UID]bool) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RemoveOrphanedStatuses", podUIDs)
+}
+
+// RemoveOrphanedStatuses indicates an expected call of RemoveOrphanedStatuses
+func (mr *MockManagerMockRecorder) RemoveOrphanedStatuses(podUIDs interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveOrphanedStatuses", reflect.TypeOf((*MockManager)(nil).RemoveOrphanedStatuses), podUIDs)
 }

pkg/volume/testing/mock_volume.go

@@ -1,65 +0,0 @@
-/*
-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 (
-	"github.com/stretchr/testify/mock"
-	. "k8s.io/kubernetes/pkg/volume"
-)
-
-// ORIGINALLY GENERATED BY mockery with hand edits
-
-type MockVolume struct {
-	mock.Mock
-}
-
-// GetPath provides a mock function with given fields:
-func (_m *MockVolume) GetPath() string {
-	ret := _m.Called()
-
-	var r0 string
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-
-	return r0
-}
-
-// GetMetrics provides a mock function with given fields:
-func (_m *MockVolume) GetMetrics() (*Metrics, error) {
-	ret := _m.Called()
-
-	var r0 *Metrics
-	if rf, ok := ret.Get(0).(func() *Metrics); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*Metrics)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}