diff --git a/pkg/kubelet/apis/podresources/server_v1_test.go b/pkg/kubelet/apis/podresources/server_v1_test.go index e5f8280a996..1c09bbe5607 100644 --- a/pkg/kubelet/apis/podresources/server_v1_test.go +++ b/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" - "k8s.io/kubernetes/pkg/kubelet/cm/devicemanager" - "k8s.io/kubernetes/pkg/kubelet/cm/memorymanager/state" + podresourcetest "k8s.io/kubernetes/pkg/kubelet/apis/podresources/testing" ) 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) - m.On("GetPods").Return(tc.pods) - m.On("GetDevices", string(podUID), containerName).Return(tc.devices) - m.On("GetCPUs", string(podUID), containerName).Return(tc.cpus) - m.On("GetMemory", string(podUID), containerName).Return(tc.memory) - m.On("UpdateAllocatedDevices").Return() - m.On("GetAllocatableCPUs").Return(cpuset.CPUSet{}) - m.On("GetAllocatableDevices").Return(devicemanager.NewResourceDeviceInstances()) - m.On("GetAllocatableMemory").Return([]state.Block{}) - server := NewV1PodResourcesServer(m, m, m, m) + mockDevicesProvider := podresourcetest.NewMockDevicesProvider(mockCtrl) + mockPodsProvider := podresourcetest.NewMockPodsProvider(mockCtrl) + mockCPUsProvider := podresourcetest.NewMockCPUsProvider(mockCtrl) + mockMemoryProvider := podresourcetest.NewMockMemoryProvider(mockCtrl) + + mockPodsProvider.EXPECT().GetPods().Return(tc.pods).AnyTimes().AnyTimes() + mockDevicesProvider.EXPECT().GetDevices(string(podUID), containerName).Return(tc.devices).AnyTimes() + mockCPUsProvider.EXPECT().GetCPUs(string(podUID), containerName).Return(tc.cpus).AnyTimes() + mockMemoryProvider.EXPECT().GetMemory(string(podUID), containerName).Return(tc.memory).AnyTimes() + 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) - m.On("GetDevices", "", "").Return([]*podresourcesapi.ContainerDevices{}) - m.On("GetCPUs", "", "").Return([]int64{}) - m.On("GetMemory", "", "").Return([]*podresourcesapi.ContainerMemory{}) - m.On("UpdateAllocatedDevices").Return() - m.On("GetAllocatableDevices").Return(tc.allDevices) - m.On("GetAllocatableCPUs").Return(tc.allCPUs) - m.On("GetAllocatableMemory").Return(tc.allMemory) - server := NewV1PodResourcesServer(m, m, m, m) + mockDevicesProvider := podresourcetest.NewMockDevicesProvider(mockCtrl) + mockPodsProvider := podresourcetest.NewMockPodsProvider(mockCtrl) + mockCPUsProvider := podresourcetest.NewMockCPUsProvider(mockCtrl) + mockMemoryProvider := podresourcetest.NewMockMemoryProvider(mockCtrl) + + mockDevicesProvider.EXPECT().GetDevices("", "").Return([]*podresourcesapi.ContainerDevices{}).AnyTimes() + mockCPUsProvider.EXPECT().GetCPUs("", "").Return([]int64{}).AnyTimes() + mockMemoryProvider.EXPECT().GetMemory("", "").Return([]*podresourcesapi.ContainerMemory{}).AnyTimes() + 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 { diff --git a/pkg/kubelet/apis/podresources/server_v1alpha1_test.go b/pkg/kubelet/apis/podresources/server_v1alpha1_test.go index 8c4cf440575..45399ba7c8b 100644 --- a/pkg/kubelet/apis/podresources/server_v1alpha1_test.go +++ b/pkg/kubelet/apis/podresources/server_v1alpha1_test.go @@ -20,58 +20,15 @@ import ( "context" "testing" - "github.com/stretchr/testify/mock" - - "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" 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) - m.On("GetPods").Return(tc.pods) - m.On("GetDevices", string(podUID), containerName).Return(tc.devices) - m.On("UpdateAllocatedDevices").Return() - server := NewV1alpha1PodResourcesServer(m, m) + mockDevicesProvider := podresourcetest.NewMockDevicesProvider(mockCtrl) + mockPodsProvider := podresourcetest.NewMockPodsProvider(mockCtrl) + + mockPodsProvider.EXPECT().GetPods().Return(tc.pods).AnyTimes() + 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) diff --git a/pkg/kubelet/apis/podresources/testing/provider_mock.go b/pkg/kubelet/apis/podresources/testing/provider_mock.go new file mode 100644 index 00000000000..dcd585938da --- /dev/null +++ b/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)) +} diff --git a/pkg/kubelet/apis/podresources/types.go b/pkg/kubelet/apis/podresources/types.go index 74db3d74223..b6011d12976 100644 --- a/pkg/kubelet/apis/podresources/types.go +++ b/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" ) diff --git a/pkg/kubelet/cadvisor/testing/cadvisor_mock.go b/pkg/kubelet/cadvisor/testing/cadvisor_mock.go index 0112db5ca22..ee9f314187b 100644 --- a/pkg/kubelet/cadvisor/testing/cadvisor_mock.go +++ b/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" - cadvisorapi "github.com/google/cadvisor/info/v1" - cadvisorapiv2 "github.com/google/cadvisor/info/v2" - "github.com/stretchr/testify/mock" - "k8s.io/kubernetes/pkg/kubelet/cadvisor" + gomock "github.com/golang/mock/gomock" + events "github.com/google/cadvisor/events" + v1 "github.com/google/cadvisor/info/v1" + v2 "github.com/google/cadvisor/info/v2" + reflect "reflect" ) -// Mock cadvisor.Interface implementation. -type Mock struct { - mock.Mock +// MockInterface is a mock of Interface interface +type MockInterface struct { + ctrl *gomock.Controller + recorder *MockInterfaceMockRecorder } -var _ cadvisor.Interface = new(Mock) - -// Start is a mock implementation of Interface.Start. -func (c *Mock) Start() error { - args := c.Called() - return args.Error(0) +// MockInterfaceMockRecorder is the mock recorder for MockInterface +type MockInterfaceMockRecorder struct { + mock *MockInterface } -// ContainerInfo is a mock implementation of Interface.ContainerInfo. -func (c *Mock) ContainerInfo(name string, req *cadvisorapi.ContainerInfoRequest) (*cadvisorapi.ContainerInfo, error) { - args := c.Called(name, req) - return args.Get(0).(*cadvisorapi.ContainerInfo), args.Error(1) +// NewMockInterface creates a new mock instance +func NewMockInterface(ctrl *gomock.Controller) *MockInterface { + mock := &MockInterface{ctrl: ctrl} + mock.recorder = &MockInterfaceMockRecorder{mock} + return mock } -// ContainerInfoV2 is a mock implementation of Interface.ContainerInfoV2. -func (c *Mock) ContainerInfoV2(name string, options cadvisorapiv2.RequestOptions) (map[string]cadvisorapiv2.ContainerInfo, error) { - args := c.Called(name, options) - return args.Get(0).(map[string]cadvisorapiv2.ContainerInfo), args.Error(1) +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder { + return m.recorder } -// GetRequestedContainersInfo is a fake implementation if Interface.GetRequestedContainersInfo -func (c *Mock) GetRequestedContainersInfo(containerName string, options cadvisorapiv2.RequestOptions) (map[string]*cadvisorapi.ContainerInfo, error) { - args := c.Called(containerName, options) - return args.Get(0).(map[string]*cadvisorapi.ContainerInfo), args.Error(1) +// Start mocks base method +func (m *MockInterface) Start() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Start") + ret0, _ := ret[0].(error) + return ret0 } -// SubcontainerInfo is a mock implementation of Interface.SubcontainerInfo. -func (c *Mock) SubcontainerInfo(name string, req *cadvisorapi.ContainerInfoRequest) (map[string]*cadvisorapi.ContainerInfo, error) { - args := c.Called(name, req) - return args.Get(0).(map[string]*cadvisorapi.ContainerInfo), args.Error(1) +// Start indicates an expected call of Start +func (mr *MockInterfaceMockRecorder) Start() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockInterface)(nil).Start)) } -// DockerContainer is a mock implementation of Interface.DockerContainer. -func (c *Mock) DockerContainer(name string, req *cadvisorapi.ContainerInfoRequest) (cadvisorapi.ContainerInfo, error) { - args := c.Called(name, req) - return args.Get(0).(cadvisorapi.ContainerInfo), args.Error(1) +// DockerContainer mocks base method +func (m *MockInterface) DockerContainer(name string, req *v1.ContainerInfoRequest) (v1.ContainerInfo, error) { + m.ctrl.T.Helper() + 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. -func (c *Mock) MachineInfo() (*cadvisorapi.MachineInfo, error) { - args := c.Called() - return args.Get(0).(*cadvisorapi.MachineInfo), args.Error(1) +// DockerContainer indicates an expected call of DockerContainer +func (mr *MockInterfaceMockRecorder) DockerContainer(name, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DockerContainer", reflect.TypeOf((*MockInterface)(nil).DockerContainer), name, req) } -// VersionInfo is a mock implementation of Interface.VersionInfo. -func (c *Mock) VersionInfo() (*cadvisorapi.VersionInfo, error) { - args := c.Called() - return args.Get(0).(*cadvisorapi.VersionInfo), args.Error(1) +// ContainerInfo mocks base method +func (m *MockInterface) ContainerInfo(name string, req *v1.ContainerInfoRequest) (*v1.ContainerInfo, error) { + m.ctrl.T.Helper() + 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. -func (c *Mock) ImagesFsInfo() (cadvisorapiv2.FsInfo, error) { - args := c.Called() - return args.Get(0).(cadvisorapiv2.FsInfo), args.Error(1) +// ContainerInfo indicates an expected call of ContainerInfo +func (mr *MockInterfaceMockRecorder) ContainerInfo(name, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerInfo", reflect.TypeOf((*MockInterface)(nil).ContainerInfo), name, req) } -// RootFsInfo is a mock implementation of Interface.RootFsInfo. -func (c *Mock) RootFsInfo() (cadvisorapiv2.FsInfo, error) { - args := c.Called() - return args.Get(0).(cadvisorapiv2.FsInfo), args.Error(1) +// ContainerInfoV2 mocks base method +func (m *MockInterface) ContainerInfoV2(name string, options v2.RequestOptions) (map[string]v2.ContainerInfo, error) { + m.ctrl.T.Helper() + 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. -func (c *Mock) WatchEvents(request *events.Request) (*events.EventChannel, error) { - args := c.Called() - return args.Get(0).(*events.EventChannel), args.Error(1) +// ContainerInfoV2 indicates an expected call of ContainerInfoV2 +func (mr *MockInterfaceMockRecorder) ContainerInfoV2(name, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerInfoV2", reflect.TypeOf((*MockInterface)(nil).ContainerInfoV2), name, options) } -// GetDirFsInfo is a mock implementation of Interface.GetDirFsInfo. -func (c *Mock) GetDirFsInfo(path string) (cadvisorapiv2.FsInfo, error) { - args := c.Called(path) - return args.Get(0).(cadvisorapiv2.FsInfo), args.Error(1) +// GetRequestedContainersInfo mocks base method +func (m *MockInterface) 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 *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)) } diff --git a/pkg/kubelet/cadvisor/types.go b/pkg/kubelet/cadvisor/types.go index be1f478a4c7..6c1d0d39ac4 100644 --- a/pkg/kubelet/cadvisor/types.go +++ b/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 ( diff --git a/pkg/kubelet/container/runtime.go b/pkg/kubelet/container/runtime.go index 45ed19063bd..43d180ec6d3 100644 --- a/pkg/kubelet/container/runtime.go +++ b/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 ( diff --git a/pkg/kubelet/container/runtime_cache.go b/pkg/kubelet/container/runtime_cache.go index 0d7a1d399c8..587a3521153 100644 --- a/pkg/kubelet/container/runtime_cache.go +++ b/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 ( diff --git a/pkg/kubelet/container/testing/mock_runtime_cache.go b/pkg/kubelet/container/testing/mock_runtime_cache.go index 0267764c90b..d281146b80a 100644 --- a/pkg/kubelet/container/testing/mock_runtime_cache.go +++ b/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 mock "github.com/stretchr/testify/mock" -import time "time" +import ( + gomock "github.com/golang/mock/gomock" + 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 -func (_m *MockRuntimeCache) ForceUpdateIfOlder(_a0 time.Time) error { - ret := _m.Called(_a0) - - var r0 error - if rf, ok := ret.Get(0).(func(time.Time) error); ok { - r0 = rf(_a0) - } else { - r0 = ret.Error(0) - } - - return r0 +// MockRuntimeCacheMockRecorder is the mock recorder for MockRuntimeCache +type MockRuntimeCacheMockRecorder struct { + mock *MockRuntimeCache } -// GetPods provides a mock function with given fields: -func (_m *MockRuntimeCache) GetPods() ([]*container.Pod, error) { - ret := _m.Called() - - var r0 []*container.Pod - if rf, ok := ret.Get(0).(func() []*container.Pod); ok { - r0 = rf() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]*container.Pod) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func() error); ok { - r1 = rf() - } else { - r1 = ret.Error(1) - } - - return r0, r1 +// NewMockRuntimeCache creates a new mock instance +func NewMockRuntimeCache(ctrl *gomock.Controller) *MockRuntimeCache { + mock := &MockRuntimeCache{ctrl: ctrl} + mock.recorder = &MockRuntimeCacheMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockRuntimeCache) EXPECT() *MockRuntimeCacheMockRecorder { + return m.recorder +} + +// GetPods mocks base method +func (m *MockRuntimeCache) GetPods() ([]*container.Pod, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPods") + ret0, _ := ret[0].([]*container.Pod) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// 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) } diff --git a/pkg/kubelet/container/testing/runtime_mock.go b/pkg/kubelet/container/testing/runtime_mock.go index d9e4b57c954..999d3bda506 100644 --- a/pkg/kubelet/container/testing/runtime_mock.go +++ b/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" - "io" - "time" - - "github.com/stretchr/testify/mock" - "k8s.io/api/core/v1" - "k8s.io/apimachinery/pkg/types" - "k8s.io/client-go/tools/remotecommand" - "k8s.io/client-go/util/flowcontrol" - runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1alpha2" - kubecontainer "k8s.io/kubernetes/pkg/kubelet/container" - "k8s.io/kubernetes/pkg/volume" + context "context" + gomock "github.com/golang/mock/gomock" + io "io" + v1 "k8s.io/api/core/v1" + types "k8s.io/apimachinery/pkg/types" + remotecommand "k8s.io/client-go/tools/remotecommand" + flowcontrol "k8s.io/client-go/util/flowcontrol" + v1alpha2 "k8s.io/cri-api/pkg/apis/runtime/v1alpha2" + container "k8s.io/kubernetes/pkg/kubelet/container" + url "net/url" + reflect "reflect" + time "time" ) -type Mock struct { - mock.Mock +// MockVersion is a mock of Version interface +type MockVersion struct { + ctrl *gomock.Controller + recorder *MockVersionMockRecorder } -var _ kubecontainer.Runtime = new(Mock) - -func (r *Mock) Start() error { - args := r.Called() - return args.Error(0) +// MockVersionMockRecorder is the mock recorder for MockVersion +type MockVersionMockRecorder struct { + mock *MockVersion } -func (r *Mock) Type() string { - args := r.Called() - return args.Get(0).(string) +// NewMockVersion creates a new mock instance +func NewMockVersion(ctrl *gomock.Controller) *MockVersion { + mock := &MockVersion{ctrl: ctrl} + mock.recorder = &MockVersionMockRecorder{mock} + return mock } -func (r *Mock) SupportsSingleFileMapping() bool { - args := r.Called() - return args.Get(0).(bool) +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockVersion) EXPECT() *MockVersionMockRecorder { + return m.recorder } -func (r *Mock) Version() (kubecontainer.Version, error) { - args := r.Called() - return args.Get(0).(kubecontainer.Version), args.Error(1) +// Compare mocks base method +func (m *MockVersion) Compare(other string) (int, error) { + 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) { - args := r.Called() - return args.Get(0).(kubecontainer.Version), args.Error(1) +// Compare indicates an expected call of Compare +func (mr *MockVersionMockRecorder) Compare(other interface{}) *gomock.Call { + 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) { - args := r.Called() - return args.Get(0).(*kubecontainer.RuntimeStatus), args.Error(0) +// String mocks base method +func (m *MockVersion) String() string { + 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) { - args := r.Called(all) - return args.Get(0).([]*kubecontainer.Pod), args.Error(1) +// String indicates an expected call of String +func (mr *MockVersionMockRecorder) String() *gomock.Call { + 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 { - args := r.Called(pod, status, secrets, backOff) - return args.Get(0).(kubecontainer.PodSyncResult) +// MockRuntime is a mock of Runtime interface +type MockRuntime struct { + ctrl *gomock.Controller + recorder *MockRuntimeMockRecorder } -func (r *Mock) KillPod(pod *v1.Pod, runningPod kubecontainer.Pod, gracePeriodOverride *int64) error { - args := r.Called(pod, runningPod, gracePeriodOverride) - return args.Error(0) +// MockRuntimeMockRecorder is the mock recorder for MockRuntime +type MockRuntimeMockRecorder struct { + mock *MockRuntime } -func (r *Mock) RunContainerInPod(container v1.Container, pod *v1.Pod, volumeMap map[string]volume.VolumePlugin) error { - args := r.Called(pod, pod, volumeMap) - return args.Error(0) +// NewMockRuntime creates a new mock instance +func NewMockRuntime(ctrl *gomock.Controller) *MockRuntime { + mock := &MockRuntime{ctrl: ctrl} + mock.recorder = &MockRuntimeMockRecorder{mock} + return mock } -func (r *Mock) KillContainerInPod(container v1.Container, pod *v1.Pod) error { - args := r.Called(pod, pod) - return args.Error(0) +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockRuntime) EXPECT() *MockRuntimeMockRecorder { + return m.recorder } -func (r *Mock) GetPodStatus(uid types.UID, name, namespace string) (*kubecontainer.PodStatus, error) { - args := r.Called(uid, name, namespace) - return args.Get(0).(*kubecontainer.PodStatus), args.Error(1) +// Type mocks base method +func (m *MockRuntime) Type() string { + 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 { - args := r.Called(containerID, cmd, stdin, stdout, stderr, tty) - return args.Error(0) +// Type indicates an expected call of Type +func (mr *MockRuntimeMockRecorder) Type() *gomock.Call { + 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 { - args := r.Called(containerID, stdin, stdout, stderr, tty) - return args.Error(0) +// SupportsSingleFileMapping mocks base method +func (m *MockRuntime) SupportsSingleFileMapping() bool { + 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) { - args := r.Called(pod, containerID, logOptions, stdout, stderr) - return args.Error(0) +// SupportsSingleFileMapping indicates an expected call of SupportsSingleFileMapping +func (mr *MockRuntimeMockRecorder) SupportsSingleFileMapping() *gomock.Call { + 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) { - args := r.Called(image, pullSecrets) - return image.Image, args.Error(0) +// Version mocks base method +func (m *MockRuntime) Version() (container.Version, error) { + 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) { - args := r.Called(image) - return args.Get(0).(string), args.Error(1) +// Version indicates an expected call of Version +func (mr *MockRuntimeMockRecorder) Version() *gomock.Call { + 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) { - args := r.Called() - return args.Get(0).([]kubecontainer.Image), args.Error(1) +// APIVersion mocks base method +func (m *MockRuntime) APIVersion() (container.Version, error) { + 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 { - args := r.Called(image) - return args.Error(0) +// APIVersion indicates an expected call of APIVersion +func (mr *MockRuntimeMockRecorder) APIVersion() *gomock.Call { + 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 { - args := r.Called(pod, port, stream) - return args.Error(0) +// Status mocks base method +func (m *MockRuntime) Status() (*container.RuntimeStatus, error) { + 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 { - args := r.Called(gcPolicy, ready, evictNonDeletedPods) - return args.Error(0) +// Status indicates an expected call of Status +func (mr *MockRuntimeMockRecorder) Status() *gomock.Call { + 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 { - args := r.Called(containerID) - return args.Error(0) +// GetPods mocks base method +func (m *MockRuntime) GetPods(all bool) ([]*container.Pod, error) { + 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) { - args := r.Called() - return args.Get(0).(*kubecontainer.ImageStats), args.Error(1) +// GetPods indicates an expected call of GetPods +func (mr *MockRuntimeMockRecorder) GetPods(all interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockRuntime)(nil).GetPods), all) } -// UpdatePodCIDR fulfills the cri interface. -func (r *Mock) UpdatePodCIDR(c string) error { - return nil +// GarbageCollect mocks base method +func (m *MockRuntime) GarbageCollect(gcPolicy container.GCPolicy, allSourcesReady, evictNonDeletedPods bool) error { + 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) } diff --git a/pkg/kubelet/eviction/eviction_manager_test.go b/pkg/kubelet/eviction/eviction_manager_test.go index 92b3916eb59..6bb54e0ab61 100644 --- a/pkg/kubelet/eviction/eviction_manager_test.go +++ b/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{} - thresholdNotifier.On("UpdateThreshold", summaryProvider.result).Return(nil).Twice() + mockCtrl := gomock.NewController(t) + 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.On("UpdateThreshold", summaryProvider.result).Return(fmt.Errorf("error updating threshold")) - thresholdNotifier.On("Description").Return("mock thresholdNotifier").Once() + thresholdNotifier = NewMockThresholdNotifier(mockCtrl) + thresholdNotifier.EXPECT().UpdateThreshold(summaryProvider.result).Return(fmt.Errorf("error updating threshold")).Times(1) + 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) - thresholdNotifier.AssertNumberOfCalls(t, "Description", 1) + fakeClock.Step(2 * notifierRefreshInterval) + manager.synchronize(diskInfoProvider, activePodsFunc) } diff --git a/pkg/kubelet/eviction/memory_threshold_notifier_test.go b/pkg/kubelet/eviction/memory_threshold_notifier_test.go index 3800aadf664..41063cace44 100644 --- a/pkg/kubelet/eviction/memory_threshold_notifier_test.go +++ b/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{} - notifier := &MockCgroupNotifier{} + notifierFactory := NewMockNotifierFactory(mockCtrl) + 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{} - notifierFactory := &MockNotifierFactory{} + mockCtrl := gomock.NewController(t) + 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.On("Stop").Return() + notifier.EXPECT().Start(events).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() diff --git a/pkg/kubelet/eviction/mock_threshold_notifier_test.go b/pkg/kubelet/eviction/mock_threshold_notifier_test.go index 7fec82cadd0..1a8f72f254d 100644 --- a/pkg/kubelet/eviction/mock_threshold_notifier_test.go +++ b/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" - statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1" + gomock "github.com/golang/mock/gomock" + 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 -func (m *MockCgroupNotifier) Start(a0 chan<- struct{}) { - m.Called(a0) +// MockCgroupNotifierMockRecorder is the mock recorder for MockCgroupNotifier +type MockCgroupNotifierMockRecorder struct { + 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 -func (m *MockNotifierFactory) NewCgroupNotifier(a0, a1 string, a2 int64) (CgroupNotifier, error) { - ret := m.Called(a0, a1, a2) - - 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 +// MockNotifierFactoryMockRecorder is the mock recorder for MockNotifierFactory +type MockNotifierFactoryMockRecorder struct { + mock *MockNotifierFactory } -// 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 -func (m *MockThresholdNotifier) UpdateThreshold(a0 *statsapi.Summary) error { - ret := m.Called(a0) - - var r0 error - if rf, ok := ret.Get(0).(func(*statsapi.Summary) error); ok { - r0 = rf(a0) - } else { - r0 = ret.Error(0) - } - return r0 +// Start indicates an expected call of Start +func (mr *MockThresholdNotifierMockRecorder) Start() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockThresholdNotifier)(nil).Start)) } -// 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() - var r0 string - if rf, ok := ret.Get(0).(func() string); ok { - r0 = rf() - } else { - r0 = ret.String(0) - } - return r0 + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Description") + ret0, _ := ret[0].(string) + return ret0 +} + +// Description indicates an expected call of Description +func (mr *MockThresholdNotifierMockRecorder) Description() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Description", reflect.TypeOf((*MockThresholdNotifier)(nil).Description)) } diff --git a/pkg/kubelet/eviction/types.go b/pkg/kubelet/eviction/types.go index 95214d84540..4cfb4e1d95d 100644 --- a/pkg/kubelet/eviction/types.go +++ b/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 ( diff --git a/pkg/kubelet/images/image_gc_manager_test.go b/pkg/kubelet/images/image_gc_manager_test.go index 129e45adf6f..e7c2ef24f47 100644 --- a/pkg/kubelet/images/image_gc_manager_test.go +++ b/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" @@ -28,6 +29,7 @@ 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" testingclock "k8s.io/utils/clock/testing" ) @@ -35,9 +37,8 @@ import ( 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, diff --git a/pkg/kubelet/metrics/collectors/resource_metrics_test.go b/pkg/kubelet/metrics/collectors/resource_metrics_test.go index 6f87fd7c638..5d2077815aa 100644 --- a/pkg/kubelet/metrics/collectors/resource_metrics_test.go +++ b/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.On("GetCPUAndMemoryStats").Return(tc.summary, tc.summaryErr) + provider := summaryprovidertest.NewMockSummaryProvider(mockCtrl) + provider.EXPECT().GetCPUAndMemoryStats().Return(tc.summary, tc.summaryErr).AnyTimes() collector := NewResourceMetricsCollector(provider) if err := testutil.CustomCollectAndCompare(collector, strings.NewReader(tc.expectedMetrics), interestedMetrics...); err != nil { diff --git a/pkg/kubelet/metrics/collectors/volume_stats_test.go b/pkg/kubelet/metrics/collectors/volume_stats_test.go index d7184a8b8c5..54f07178c6d 100644 --- a/pkg/kubelet/metrics/collectors/volume_stats_test.go +++ b/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) - mockStatsProvider.On("ListPodStats").Return(podStats, nil) - mockStatsProvider.On("ListPodStatsAndUpdateCPUNanoCoreUsage").Return(podStats, nil) + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + 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) } diff --git a/pkg/kubelet/pleg/generic_test.go b/pkg/kubelet/pleg/generic_test.go index 41c7db70255..53f45c9ee1f 100644 --- a/pkg/kubelet/pleg/generic_test.go +++ b/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" @@ -311,8 +312,7 @@ func testReportMissingPods(t *testing.T, numRelists int) { verifyEvents(t, expected, actual) } -func newTestGenericPLEGWithRuntimeMock() (*GenericPLEG, *containertest.Mock) { - runtimeMock := &containertest.Mock{} +func newTestGenericPLEGWithRuntimeMock(runtimeMock kubecontainer.Runtime) *GenericPLEG { pleg := &GenericPLEG{ relistPeriod: time.Hour, runtime: runtimeMock, @@ -321,7 +321,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) { @@ -350,15 +350,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.On("GetPodStatus", pods[0].ID, "", "").Return(statuses[0], nil).Once() + runtimeMock.EXPECT().GetPods(true).Return(pods, nil).AnyTimes() + 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) @@ -380,7 +384,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 { @@ -402,15 +406,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.On("GetPodStatus", pods[0].ID, "", "").Return(statuses[0], nil).Once() + runtimeMock.EXPECT().GetPods(true).Return(pods, nil).Times(1) + 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) @@ -445,7 +453,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) @@ -455,13 +467,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} @@ -480,13 +492,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) @@ -497,8 +509,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.On("GetPodStatus", podID, "", "").Return(goodStatus, nil).Once() + runtimeMock.EXPECT().GetPods(true).Return(pods, nil).Times(1) + runtimeMock.EXPECT().GetPodStatus(podID, "", "").Return(goodStatus, nil).Times(1) pleg.relist() actualEvents = getEventsFromChannel(ch) @@ -595,8 +607,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) @@ -613,8 +631,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.On("GetPodStatus", pod.ID, "", "").Return(status, nil).Once() + runtimeMock.EXPECT().GetPods(true).Return([]*kubecontainer.Pod{pod}, nil).Times(1) + runtimeMock.EXPECT().GetPodStatus(pod.ID, "", "").Return(status, nil).Times(1) pleg.relist() actualEvents := getEventsFromChannel(ch) @@ -634,8 +652,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.On("GetPodStatus", pod.ID, "", "").Return(status, nil).Once() + runtimeMock.EXPECT().GetPods(true).Return([]*kubecontainer.Pod{pod}, nil).Times(1) + runtimeMock.EXPECT().GetPodStatus(pod.ID, "", "").Return(status, nil).Times(1) pleg.relist() actualEvents = getEventsFromChannel(ch) diff --git a/pkg/kubelet/pod/pod_manager.go b/pkg/kubelet/pod/pod_manager.go index 044be68b220..c94e563620c 100644 --- a/pkg/kubelet/pod/pod_manager.go +++ b/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 ( diff --git a/pkg/kubelet/pod/testing/mock_manager.go b/pkg/kubelet/pod/testing/mock_manager.go index b3781c8a0cf..842495d9d89 100644 --- a/pkg/kubelet/pod/testing/mock_manager.go +++ b/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" - - mock "github.com/stretchr/testify/mock" - - types "k8s.io/apimachinery/pkg/types" - + gomock "github.com/golang/mock/gomock" 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 -func (_m *MockManager) AddPod(_a0 *v1.Pod) { - _m.Called(_a0) +// MockManagerMockRecorder is the mock recorder for MockManager +type MockManagerMockRecorder struct { + mock *MockManager } -// CreateMirrorPod provides a mock function with given fields: _a0 -func (_m *MockManager) CreateMirrorPod(_a0 *v1.Pod) error { - ret := _m.Called(_a0) - - var r0 error - if rf, ok := ret.Get(0).(func(*v1.Pod) error); ok { - r0 = rf(_a0) - } else { - r0 = ret.Error(0) - } - - return r0 +// NewMockManager creates a new mock instance +func NewMockManager(ctrl *gomock.Controller) *MockManager { + mock := &MockManager{ctrl: ctrl} + mock.recorder = &MockManagerMockRecorder{mock} + return mock } -// DeleteMirrorPod provides a mock function with given fields: podFullName -func (_m *MockManager) DeleteMirrorPod(podFullName string, _ *types.UID) (bool, error) { - ret := _m.Called(podFullName) - - 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 +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockManager) EXPECT() *MockManagerMockRecorder { + return m.recorder } -func (_m *MockManager) GetOrphanedMirrorPodNames() []string { - ret := _m.Called() - - var r0 []string - if rf, ok := ret.Get(0).(func() []string); ok { - r0 = rf() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]string) - } - } - return r0 +// AddPod mocks base method +func (m *MockManager) AddPod(arg0 *v1.Pod) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "AddPod", arg0) } -func (_m *MockManager) GetOrphanedMirrorPodNamesAndUIDs() map[string]kubelettypes.ResolvedPodUID { - ret := _m.Called() - - var r0 map[string]kubelettypes.ResolvedPodUID - 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 +// AddPod indicates an expected call of AddPod +func (mr *MockManagerMockRecorder) AddPod(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPod", reflect.TypeOf((*MockManager)(nil).AddPod), arg0) } -// DeletePod provides a mock function with given fields: _a0 -func (_m *MockManager) DeletePod(_a0 *v1.Pod) { - _m.Called(_a0) +// CreateMirrorPod mocks base method +func (m *MockManager) CreateMirrorPod(arg0 *v1.Pod) error { + 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 -func (_m *MockManager) GetMirrorPodByPod(_a0 *v1.Pod) (*v1.Pod, bool) { - ret := _m.Called(_a0) - - 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 +// CreateMirrorPod indicates an expected call of CreateMirrorPod +func (mr *MockManagerMockRecorder) CreateMirrorPod(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMirrorPod", reflect.TypeOf((*MockManager)(nil).CreateMirrorPod), arg0) } -// GetPodByFullName provides a mock function with given fields: podFullName -func (_m *MockManager) GetPodByFullName(podFullName string) (*v1.Pod, bool) { - ret := _m.Called(podFullName) - - var r0 *v1.Pod - if rf, ok := ret.Get(0).(func(string) *v1.Pod); ok { - r0 = rf(podFullName) - } 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 +// DeleteMirrorPod mocks base method +func (m *MockManager) DeleteMirrorPod(arg0 string, arg1 *types.UID) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteMirrorPod", arg0, arg1) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// GetPodByMirrorPod provides a mock function with given fields: _a0 -func (_m *MockManager) GetPodByMirrorPod(_a0 *v1.Pod) (*v1.Pod, bool) { - ret := _m.Called(_a0) - - 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 +// DeleteMirrorPod indicates an expected call of DeleteMirrorPod +func (mr *MockManagerMockRecorder) DeleteMirrorPod(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMirrorPod", reflect.TypeOf((*MockManager)(nil).DeleteMirrorPod), arg0, arg1) } -// GetPodByName provides a mock function with given fields: namespace, name -func (_m *MockManager) GetPodByName(namespace string, name string) (*v1.Pod, bool) { - ret := _m.Called(namespace, name) - - 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 +// DeletePod mocks base method +func (m *MockManager) DeletePod(arg0 *v1.Pod) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "DeletePod", arg0) } -// GetPodByUID provides a mock function with given fields: _a0 -func (_m *MockManager) GetPodByUID(_a0 types.UID) (*v1.Pod, bool) { - ret := _m.Called(_a0) - - 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 +// DeletePod indicates an expected call of DeletePod +func (mr *MockManagerMockRecorder) DeletePod(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePod", reflect.TypeOf((*MockManager)(nil).DeletePod), arg0) } -// GetPods provides a mock function with given fields: -func (_m *MockManager) GetPods() []*v1.Pod { - ret := _m.Called() - - 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) - } - } - - return r0 +// GetMirrorPodByPod mocks base method +func (m *MockManager) GetMirrorPodByPod(arg0 *v1.Pod) (*v1.Pod, bool) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetMirrorPodByPod", arg0) + ret0, _ := ret[0].(*v1.Pod) + ret1, _ := ret[1].(bool) + return ret0, ret1 } -// GetPodsAndMirrorPods provides a mock function with given fields: -func (_m *MockManager) GetPodsAndMirrorPods() ([]*v1.Pod, []*v1.Pod) { - ret := _m.Called() - - 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 +// GetMirrorPodByPod indicates an expected call of GetMirrorPodByPod +func (mr *MockManagerMockRecorder) GetMirrorPodByPod(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMirrorPodByPod", reflect.TypeOf((*MockManager)(nil).GetMirrorPodByPod), arg0) } -// GetUIDTranslations provides a mock function with given fields: -func (_m *MockManager) GetUIDTranslations() (map[kubelettypes.ResolvedPodUID]kubelettypes.MirrorPodUID, map[kubelettypes.MirrorPodUID]kubelettypes.ResolvedPodUID) { - ret := _m.Called() - - var r0 map[kubelettypes.ResolvedPodUID]kubelettypes.MirrorPodUID - if rf, ok := ret.Get(0).(func() map[kubelettypes.ResolvedPodUID]kubelettypes.MirrorPodUID); ok { - 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 +// GetOrphanedMirrorPodNames mocks base method +func (m *MockManager) GetOrphanedMirrorPodNames() []string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOrphanedMirrorPodNames") + ret0, _ := ret[0].([]string) + return ret0 } -// IsMirrorPodOf provides a mock function with given fields: mirrorPod, _a1 -func (_m *MockManager) IsMirrorPodOf(mirrorPod *v1.Pod, _a1 *v1.Pod) bool { - ret := _m.Called(mirrorPod, _a1) - - 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 +// GetOrphanedMirrorPodNames indicates an expected call of GetOrphanedMirrorPodNames +func (mr *MockManagerMockRecorder) GetOrphanedMirrorPodNames() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrphanedMirrorPodNames", reflect.TypeOf((*MockManager)(nil).GetOrphanedMirrorPodNames)) } -// SetPods provides a mock function with given fields: pods -func (_m *MockManager) SetPods(pods []*v1.Pod) { - _m.Called(pods) +// GetPodByFullName mocks base method +func (m *MockManager) GetPodByFullName(arg0 string) (*v1.Pod, bool) { + 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 -func (_m *MockManager) TranslatePodUID(uid types.UID) kubelettypes.ResolvedPodUID { - ret := _m.Called(uid) - - 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 +// GetPodByFullName indicates an expected call of GetPodByFullName +func (mr *MockManagerMockRecorder) GetPodByFullName(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByFullName", reflect.TypeOf((*MockManager)(nil).GetPodByFullName), arg0) } -// UpdatePod provides a mock function with given fields: _a0 -func (_m *MockManager) UpdatePod(_a0 *v1.Pod) { - _m.Called(_a0) +// GetPodByMirrorPod mocks base method +func (m *MockManager) GetPodByMirrorPod(arg0 *v1.Pod) (*v1.Pod, bool) { + 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) } diff --git a/pkg/kubelet/runonce_test.go b/pkg/kubelet/runonce_test.go index 61ea87e3f9e..9f402d99418 100644 --- a/pkg/kubelet/runonce_test.go +++ b/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{} - cadvisor.On("MachineInfo").Return(&cadvisorapi.MachineInfo{}, nil) - cadvisor.On("ImagesFsInfo").Return(cadvisorapiv2.FsInfo{ + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + 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) - cadvisor.On("RootFsInfo").Return(cadvisorapiv2.FsInfo{ + }, nil).AnyTimes() + cadvisor.EXPECT().RootFsInfo().Return(cadvisorapiv2.FsInfo{ Usage: 9, Capacity: 10, - }, nil) + }, nil).AnyTimes() fakeSecretManager := secret.NewFakeManager() fakeConfigMapManager := configmap.NewFakeManager() podManager := kubepod.NewBasicPodManager( diff --git a/pkg/kubelet/server/stats/handler.go b/pkg/kubelet/server/stats/handler.go index 0e6d90f4150..de1ec55bfa0 100644 --- a/pkg/kubelet/server/stats/handler.go +++ b/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 ( diff --git a/pkg/kubelet/server/stats/summary.go b/pkg/kubelet/server/stats/summary.go index 0bc1154f782..297b2bf27fa 100644 --- a/pkg/kubelet/server/stats/summary.go +++ b/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 ( diff --git a/pkg/kubelet/server/stats/summary_test.go b/pkg/kubelet/server/stats/summary_test.go index bdc5ceb5a02..dae4638f241 100644 --- a/pkg/kubelet/server/stats/summary_test.go +++ b/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) - mockStatsProvider. - On("GetNode").Return(node, nil). - On("GetNodeConfig").Return(nodeConfig). - On("GetPodCgroupRoot").Return(cgroupRoot). - On("ListPodStats").Return(podStats, nil). - On("ListPodStatsAndUpdateCPUNanoCoreUsage").Return(podStats, nil). - On("ImageFsStats").Return(imageFsStats, nil). - On("RootFsStats").Return(rootFsStats, nil). - On("RlimitStats").Return(rlimitStats, nil). - On("GetCgroupStats", "/", true).Return(cgroupStatsMap["/"].cs, cgroupStatsMap["/"].ns, nil). - On("GetCgroupStats", "/runtime", false).Return(cgroupStatsMap["/runtime"].cs, cgroupStatsMap["/runtime"].ns, nil). - On("GetCgroupStats", "/misc", false).Return(cgroupStatsMap["/misc"].cs, cgroupStatsMap["/misc"].ns, nil). - On("GetCgroupStats", "/kubelet", false).Return(cgroupStatsMap["/kubelet"].cs, cgroupStatsMap["/kubelet"].ns, nil). - On("GetCgroupStats", "/kubepods", true).Return(cgroupStatsMap["/pods"].cs, cgroupStatsMap["/pods"].ns, nil) + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockStatsProvider := statstest.NewMockProvider(mockCtrl) + + mockStatsProvider.EXPECT().GetNode().Return(node, nil) + mockStatsProvider.EXPECT().GetNodeConfig().Return(nodeConfig) + mockStatsProvider.EXPECT().GetPodCgroupRoot().Return(cgroupRoot) + mockStatsProvider.EXPECT().ListPodStats().Return(podStats, nil).AnyTimes() + mockStatsProvider.EXPECT().ListPodStatsAndUpdateCPUNanoCoreUsage().Return(podStats, nil) + mockStatsProvider.EXPECT().ImageFsStats().Return(imageFsStats, nil) + mockStatsProvider.EXPECT().RootFsStats().Return(rootFsStats, nil) + mockStatsProvider.EXPECT().RlimitStats().Return(rlimitStats, nil) + mockStatsProvider.EXPECT().GetCgroupStats("/", true).Return(cgroupStatsMap["/"].cs, cgroupStatsMap["/"].ns, nil) + mockStatsProvider.EXPECT().GetCgroupStats("/runtime", false).Return(cgroupStatsMap["/runtime"].cs, cgroupStatsMap["/runtime"].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) - mockStatsProvider. - On("GetNode").Return(node, nil). - On("GetNodeConfig").Return(nodeConfig). - On("GetPodCgroupRoot").Return(cgroupRoot). - On("ListPodCPUAndMemoryStats").Return(podStats, nil). - On("GetCgroupCPUAndMemoryStats", "/", false).Return(cgroupStatsMap["/"].cs, nil). - On("GetCgroupCPUAndMemoryStats", "/runtime", false).Return(cgroupStatsMap["/runtime"].cs, nil). - On("GetCgroupCPUAndMemoryStats", "/misc", false).Return(cgroupStatsMap["/misc"].cs, nil). - On("GetCgroupCPUAndMemoryStats", "/kubelet", false).Return(cgroupStatsMap["/kubelet"].cs, nil). - On("GetCgroupCPUAndMemoryStats", "/kubepods", false).Return(cgroupStatsMap["/pods"].cs, nil) + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockStatsProvider := statstest.NewMockProvider(mockCtrl) + + mockStatsProvider.EXPECT().GetNode().Return(node, nil) + mockStatsProvider.EXPECT().GetNodeConfig().Return(nodeConfig) + mockStatsProvider.EXPECT().GetPodCgroupRoot().Return(cgroupRoot) + mockStatsProvider.EXPECT().ListPodCPUAndMemoryStats().Return(podStats, nil) + mockStatsProvider.EXPECT().GetCgroupCPUAndMemoryStats("/", false).Return(cgroupStatsMap["/"].cs, nil) + mockStatsProvider.EXPECT().GetCgroupCPUAndMemoryStats("/runtime", false).Return(cgroupStatsMap["/runtime"].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() diff --git a/pkg/kubelet/server/stats/summary_windows_test.go b/pkg/kubelet/server/stats/summary_windows_test.go index 335c233fbb9..ddedee3bcef 100644 --- a/pkg/kubelet/server/stats/summary_windows_test.go +++ b/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) - mockStatsProvider. - On("GetNode").Return(node, nil). - On("GetNodeConfig").Return(nodeConfig). - On("GetPodCgroupRoot").Return(cgroupRoot). - On("ListPodStats").Return(podStats, nil). - On("ListPodStatsAndUpdateCPUNanoCoreUsage").Return(podStats, nil). - On("ImageFsStats").Return(imageFsStats, nil). - On("RootFsStats").Return(rootFsStats, nil). - On("RlimitStats").Return(nil, nil). - On("GetCgroupStats", "/", true).Return(cgroupStatsMap["/"].cs, cgroupStatsMap["/"].ns, nil) + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockStatsProvider := statstest.NewMockProvider(mockCtrl) + mockStatsProvider.EXPECT().GetNode().Return(node, nil).AnyTimes() + mockStatsProvider.EXPECT().GetNodeConfig().Return(nodeConfig).AnyTimes() + mockStatsProvider.EXPECT().GetPodCgroupRoot().Return(cgroupRoot).AnyTimes() + mockStatsProvider.EXPECT().ListPodStats().Return(podStats, nil).AnyTimes() + mockStatsProvider.EXPECT().ListPodStatsAndUpdateCPUNanoCoreUsage().Return(podStats, nil).AnyTimes() + mockStatsProvider.EXPECT().ImageFsStats().Return(imageFsStats, nil).AnyTimes() + 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) diff --git a/pkg/kubelet/server/stats/testing/mock_stats_provider.go b/pkg/kubelet/server/stats/testing/mock_stats_provider.go index a5649928218..2671dc10233 100644 --- a/pkg/kubelet/server/stats/testing/mock_stats_provider.go +++ b/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 corev1 "k8s.io/api/core/v1" -import mock "github.com/stretchr/testify/mock" +import ( + gomock "github.com/golang/mock/gomock" + 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" -import v1 "github.com/google/cadvisor/info/v1" -import v2 "github.com/google/cadvisor/info/v2" -import v1alpha1 "k8s.io/kubelet/pkg/apis/stats/v1alpha1" -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 +// MockProvider is a mock of Provider interface +type MockProvider struct { + ctrl *gomock.Controller + recorder *MockProviderMockRecorder } -// GetCgroupStats provides a mock function with given fields: cgroupName, updateStats -func (_m *StatsProvider) GetCgroupStats(cgroupName string, updateStats bool) (*v1alpha1.ContainerStats, *v1alpha1.NetworkStats, error) { - ret := _m.Called(cgroupName, updateStats) - - 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 +// MockProviderMockRecorder is the mock recorder for MockProvider +type MockProviderMockRecorder struct { + mock *MockProvider } -// GetCgroupCPUAndMemoryStats provides a mock function with given fields: cgroupName, updateStats -func (_m *StatsProvider) GetCgroupCPUAndMemoryStats(cgroupName string, updateStats bool) (*v1alpha1.ContainerStats, error) { - ret := _m.Called(cgroupName, updateStats) - - 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 error - if rf, ok := ret.Get(1).(func(string, bool) error); ok { - r1 = rf(cgroupName, updateStats) - } else { - r1 = ret.Error(1) - } - - return r0, r1 +// NewMockProvider creates a new mock instance +func NewMockProvider(ctrl *gomock.Controller) *MockProvider { + mock := &MockProvider{ctrl: ctrl} + mock.recorder = &MockProviderMockRecorder{mock} + return mock } -// GetPodByCgroupfs provides the pod that maps to the specified cgroup, as well -// as whether the pod was found. -func (_m *StatsProvider) GetPodByCgroupfs(cgroupfs string) (*corev1.Pod, bool) { - return nil, false +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockProvider) EXPECT() *MockProviderMockRecorder { + return m.recorder } -// GetRequestedContainersInfo provides a mock function with given fields: containerName, options -func (_m *StatsProvider) GetRequestedContainersInfo(containerName string, options v2.RequestOptions) (map[string]*v1.ContainerInfo, error) { - ret := _m.Called(containerName, options) - return ret.Get(0).(map[string]*v1.ContainerInfo), ret.Error(1) +// ListPodStats mocks base method +func (m *MockProvider) ListPodStats() ([]v1alpha1.PodStats, error) { + m.ctrl.T.Helper() + 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 -func (_m *StatsProvider) GetContainerInfo(podFullName string, uid types.UID, containerName string, req *v1.ContainerInfoRequest) (*v1.ContainerInfo, error) { - ret := _m.Called(podFullName, uid, containerName, req) - - 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 +// ListPodStats indicates an expected call of ListPodStats +func (mr *MockProviderMockRecorder) ListPodStats() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPodStats", reflect.TypeOf((*MockProvider)(nil).ListPodStats)) } -// GetNode provides a mock function with given fields: -func (_m *StatsProvider) GetNode() (*corev1.Node, error) { - ret := _m.Called() - - var r0 *corev1.Node - if rf, ok := ret.Get(0).(func() *corev1.Node); ok { - r0 = rf() - } 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 +// ListPodCPUAndMemoryStats mocks base method +func (m *MockProvider) ListPodCPUAndMemoryStats() ([]v1alpha1.PodStats, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPodCPUAndMemoryStats") + ret0, _ := ret[0].([]v1alpha1.PodStats) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// GetNodeConfig provides a mock function with given fields: -func (_m *StatsProvider) GetNodeConfig() cm.NodeConfig { - ret := _m.Called() - - 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 +// ListPodCPUAndMemoryStats indicates an expected call of ListPodCPUAndMemoryStats +func (mr *MockProviderMockRecorder) ListPodCPUAndMemoryStats() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPodCPUAndMemoryStats", reflect.TypeOf((*MockProvider)(nil).ListPodCPUAndMemoryStats)) } -// GetPodCgroupRoot provides a mock function with given fields: -func (_m *StatsProvider) GetPodCgroupRoot() 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 +// ListPodStatsAndUpdateCPUNanoCoreUsage mocks base method +func (m *MockProvider) ListPodStatsAndUpdateCPUNanoCoreUsage() ([]v1alpha1.PodStats, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPodStatsAndUpdateCPUNanoCoreUsage") + ret0, _ := ret[0].([]v1alpha1.PodStats) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// GetPodByName provides a mock function with given fields: namespace, name -func (_m *StatsProvider) GetPodByName(namespace string, name string) (*corev1.Pod, bool) { - ret := _m.Called(namespace, name) - - 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 +// ListPodStatsAndUpdateCPUNanoCoreUsage indicates an expected call of ListPodStatsAndUpdateCPUNanoCoreUsage +func (mr *MockProviderMockRecorder) ListPodStatsAndUpdateCPUNanoCoreUsage() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPodStatsAndUpdateCPUNanoCoreUsage", reflect.TypeOf((*MockProvider)(nil).ListPodStatsAndUpdateCPUNanoCoreUsage)) } -// GetPods provides a mock function with given fields: -func (_m *StatsProvider) GetPods() []*corev1.Pod { - ret := _m.Called() - - var r0 []*corev1.Pod - if rf, ok := ret.Get(0).(func() []*corev1.Pod); ok { - r0 = rf() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]*corev1.Pod) - } - } - - return r0 +// ImageFsStats mocks base method +func (m *MockProvider) ImageFsStats() (*v1alpha1.FsStats, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImageFsStats") + ret0, _ := ret[0].(*v1alpha1.FsStats) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// GetRawContainerInfo provides a mock function with given fields: containerName, req, subcontainers -func (_m *StatsProvider) GetRawContainerInfo(containerName string, req *v1.ContainerInfoRequest, subcontainers bool) (map[string]*v1.ContainerInfo, error) { - ret := _m.Called(containerName, req, subcontainers) - - 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 indicates an expected call of ImageFsStats +func (mr *MockProviderMockRecorder) ImageFsStats() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageFsStats", reflect.TypeOf((*MockProvider)(nil).ImageFsStats)) } -// ImageFsStats provides a mock function with given fields: -func (_m *StatsProvider) ImageFsStats() (*v1alpha1.FsStats, error) { - ret := _m.Called() - - var r0 *v1alpha1.FsStats - if rf, ok := ret.Get(0).(func() *v1alpha1.FsStats); ok { - r0 = rf() - } 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 +// GetCgroupStats mocks base method +func (m *MockProvider) GetCgroupStats(cgroupName string, updateStats bool) (*v1alpha1.ContainerStats, *v1alpha1.NetworkStats, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCgroupStats", cgroupName, updateStats) + ret0, _ := ret[0].(*v1alpha1.ContainerStats) + ret1, _ := ret[1].(*v1alpha1.NetworkStats) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 } -// ListPodStats provides a mock function with given fields: -func (_m *StatsProvider) ListPodStats() ([]v1alpha1.PodStats, error) { - ret := _m.Called() - - 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 +// GetCgroupStats indicates an expected call of GetCgroupStats +func (mr *MockProviderMockRecorder) GetCgroupStats(cgroupName, updateStats interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCgroupStats", reflect.TypeOf((*MockProvider)(nil).GetCgroupStats), cgroupName, updateStats) } -// ListPodStatsAndUpdateCPUNanoCoreUsage provides a mock function with given fields: -func (_m *StatsProvider) ListPodStatsAndUpdateCPUNanoCoreUsage() ([]v1alpha1.PodStats, error) { - ret := _m.Called() - - 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 +// GetCgroupCPUAndMemoryStats mocks base method +func (m *MockProvider) GetCgroupCPUAndMemoryStats(cgroupName string, updateStats bool) (*v1alpha1.ContainerStats, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCgroupCPUAndMemoryStats", cgroupName, updateStats) + ret0, _ := ret[0].(*v1alpha1.ContainerStats) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// ListPodCPUAndMemoryStats provides a mock function with given fields: -func (_m *StatsProvider) ListPodCPUAndMemoryStats() ([]v1alpha1.PodStats, error) { - ret := _m.Called() - - 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 +// GetCgroupCPUAndMemoryStats indicates an expected call of GetCgroupCPUAndMemoryStats +func (mr *MockProviderMockRecorder) GetCgroupCPUAndMemoryStats(cgroupName, updateStats interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCgroupCPUAndMemoryStats", reflect.TypeOf((*MockProvider)(nil).GetCgroupCPUAndMemoryStats), cgroupName, updateStats) } -// ListVolumesForPod provides a mock function with given fields: podUID -func (_m *StatsProvider) ListVolumesForPod(podUID types.UID) (map[string]volume.Volume, bool) { - ret := _m.Called(podUID) - - var r0 map[string]volume.Volume - if rf, ok := ret.Get(0).(func(types.UID) map[string]volume.Volume); ok { - r0 = rf(podUID) - } 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 +// RootFsStats mocks base method +func (m *MockProvider) RootFsStats() (*v1alpha1.FsStats, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RootFsStats") + ret0, _ := ret[0].(*v1alpha1.FsStats) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// ListBlockVolumesForPod provides a mock function with given fields: podUID -func (_m *StatsProvider) ListBlockVolumesForPod(podUID types.UID) (map[string]volume.BlockVolume, bool) { - ret := _m.Called(podUID) - - 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 indicates an expected call of RootFsStats +func (mr *MockProviderMockRecorder) RootFsStats() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RootFsStats", reflect.TypeOf((*MockProvider)(nil).RootFsStats)) } -// RootFsStats provides a mock function with given fields: -func (_m *StatsProvider) RootFsStats() (*v1alpha1.FsStats, error) { - ret := _m.Called() - - var r0 *v1alpha1.FsStats - if rf, ok := ret.Get(0).(func() *v1alpha1.FsStats); ok { - r0 = rf() - } 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 +// GetContainerInfo mocks base method +func (m *MockProvider) GetContainerInfo(podFullName string, uid types.UID, containerName string, req *v1.ContainerInfoRequest) (*v1.ContainerInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetContainerInfo", podFullName, uid, containerName, req) + ret0, _ := ret[0].(*v1.ContainerInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// RlimitStats provides a mock function with given fields: -func (_m *StatsProvider) RlimitStats() (*v1alpha1.RlimitStats, error) { - ret := _m.Called() - - var r0 *v1alpha1.RlimitStats - if rf, ok := ret.Get(0).(func() *v1alpha1.RlimitStats); ok { - r0 = rf() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.RlimitStats) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func() error); ok { - r1 = rf() - } else { - r1 = ret.Error(1) - } - - return r0, r1 +// GetContainerInfo indicates an expected call of GetContainerInfo +func (mr *MockProviderMockRecorder) GetContainerInfo(podFullName, uid, containerName, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerInfo", reflect.TypeOf((*MockProvider)(nil).GetContainerInfo), podFullName, uid, containerName, req) +} + +// GetRawContainerInfo mocks base method +func (m *MockProvider) GetRawContainerInfo(containerName string, req *v1.ContainerInfoRequest, subcontainers bool) (map[string]*v1.ContainerInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRawContainerInfo", containerName, req, subcontainers) + ret0, _ := ret[0].(map[string]*v1.ContainerInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRawContainerInfo indicates an expected call of GetRawContainerInfo +func (mr *MockProviderMockRecorder) GetRawContainerInfo(containerName, req, subcontainers interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawContainerInfo", reflect.TypeOf((*MockProvider)(nil).GetRawContainerInfo), containerName, req, subcontainers) +} + +// 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) } diff --git a/pkg/kubelet/server/stats/testing/mock_summary_provider.go b/pkg/kubelet/server/stats/testing/mock_summary_provider.go new file mode 100644 index 00000000000..2f1949a7cd4 --- /dev/null +++ b/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)) +} diff --git a/pkg/kubelet/server/stats/volume_stat_calculator_test.go b/pkg/kubelet/server/stats/volume_stat_calculator_test.go index db3620289f3..fbf779c8cb1 100644 --- a/pkg/kubelet/server/stats/volume_stat_calculator_test.go +++ b/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{ diff --git a/pkg/kubelet/stats/cadvisor_stats_provider_test.go b/pkg/kubelet/stats/cadvisor_stats_provider_test.go index 8e18376e29f..303d62526ba 100644 --- a/pkg/kubelet/stats/cadvisor_stats_provider_test.go +++ b/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" @@ -208,15 +209,16 @@ func TestCadvisorListPodStats(t *testing.T) { Recursive: true, } - mockCadvisor := new(cadvisortest.Mock) - mockCadvisor. - On("ContainerInfoV2", "/", options).Return(infos, nil). - On("RootFsInfo").Return(rootfs, nil). - On("ImagesFsInfo").Return(imagefs, nil) + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() - mockRuntime := new(containertest.Mock) - mockRuntime. - On("ImageStats").Return(&kubecontainer.ImageStats{TotalStorageBytes: 123}, nil) + mockCadvisor := cadvisortest.NewMockInterface(mockCtrl) + mockCadvisor.EXPECT().ContainerInfoV2("/", options).Return(infos, 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")} @@ -230,11 +232,11 @@ func TestCadvisorListPodStats(t *testing.T) { p1Time := metav1.Now() p2Time := metav1.Now() p3Time := metav1.Now() - mockStatus := new(statustest.MockStatusProvider) - mockStatus.On("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.On("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 := statustest.NewMockPodStatusProvider(mockCtrl) + mockStatus.EXPECT().GetPodStatus(types.UID("UID"+pName0)).Return(v1.PodStatus{StartTime: &p0Time}, true) + mockStatus.EXPECT().GetPodStatus(types.UID("UID"+pName1)).Return(v1.PodStatus{StartTime: &p1Time}, true) + mockStatus.EXPECT().GetPodStatus(types.UID("UID"+pName2)).Return(v1.PodStatus{StartTime: &p2Time}, true) + mockStatus.EXPECT().GetPodStatus(types.UID("UID"+pName3)).Return(v1.PodStatus{StartTime: &p3Time}, true) resourceAnalyzer := &fakeResourceAnalyzer{podVolumeStats: volumeStats} @@ -391,9 +393,11 @@ func TestCadvisorListPodCPUAndMemoryStats(t *testing.T) { Recursive: true, } - mockCadvisor := new(cadvisortest.Mock) - mockCadvisor. - On("ContainerInfoV2", "/", options).Return(infos, nil) + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockCadvisor := cadvisortest.NewMockInterface(mockCtrl) + mockCadvisor.EXPECT().ContainerInfoV2("/", options).Return(infos, nil) ephemeralVolumes := []statsapi.VolumeStats{getPodVolumeStats(seedEphemeralVolume1, "ephemeralVolume1"), getPodVolumeStats(seedEphemeralVolume2, "ephemeralVolume2")} @@ -479,18 +483,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) - mockRuntime = new(containertest.Mock) + mockCadvisor = cadvisortest.NewMockInterface(mockCtrl) + mockRuntime = containertest.NewMockRuntime(mockCtrl) seed = 1000 imageFsInfo = getTestFsInfo(seed) imageStats = &kubecontainer.ImageStats{TotalStorageBytes: 100} ) - mockCadvisor.On("ImagesFsInfo").Return(imageFsInfo, nil) - mockRuntime.On("ImageStats").Return(imageStats, nil) + mockCadvisor.EXPECT().ImagesFsInfo().Return(imageFsInfo, nil) + mockRuntime.EXPECT().ImageStats().Return(imageStats, nil) provider := newCadvisorStatsProvider(mockCadvisor, &fakeResourceAnalyzer{}, mockRuntime, nil, NewFakeHostStatsProvider()) stats, err := provider.ImageFsStats() @@ -503,6 +509,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) } diff --git a/pkg/kubelet/stats/cri_stats_provider_test.go b/pkg/kubelet/stats/cri_stats_provider_test.go index 3320c8ab3fa..a5857c1a0a9 100644 --- a/pkg/kubelet/stats/cri_stats_provider_test.go +++ b/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. - On("ContainerInfoV2", "/", options).Return(infos, nil). - On("RootFsInfo").Return(rootFsInfo, nil). - On("GetDirFsInfo", imageFsMountpoint).Return(imageFsInfo, nil). - On("GetDirFsInfo", unknownMountpoint).Return(cadvisorapiv2.FsInfo{}, cadvisorfs.ErrNoSuchDevice) + mockCadvisor.EXPECT().ContainerInfoV2("/", options).Return(infos, nil) + mockCadvisor.EXPECT().RootFsInfo().Return(rootFsInfo, nil) + mockCadvisor.EXPECT().GetDirFsInfo(imageFsMountpoint).Return(imageFsInfo, nil) + mockCadvisor.EXPECT().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. - On("ContainerInfoV2", "/", options).Return(infos, nil). - On("RootFsInfo").Return(rootFsInfo, nil). - On("GetDirFsInfo", imageFsMountpoint).Return(imageFsInfo, nil). - On("GetDirFsInfo", unknownMountpoint).Return(cadvisorapiv2.FsInfo{}, cadvisorfs.ErrNoSuchDevice) + mockCadvisor.EXPECT().ContainerInfoV2("/", options).Return(infos, nil) + mockCadvisor.EXPECT().RootFsInfo().Return(rootFsInfo, nil) + mockCadvisor.EXPECT().GetDirFsInfo(imageFsMountpoint).Return(imageFsInfo, nil) + mockCadvisor.EXPECT().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. - On("ContainerInfoV2", "/", options).Return(infos, nil) + mockCadvisor.EXPECT().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.On("GetDirFsInfo", imageFsMountpoint).Return(imageFsInfo, nil) + mockCadvisor.EXPECT().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 { diff --git a/pkg/kubelet/stats/provider_test.go b/pkg/kubelet/stats/provider_test.go index d92aa537e33..3bbc8334ba0 100644 --- a/pkg/kubelet/stats/provider_test.go +++ b/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. - On("RootFsInfo").Return(rootFsInfo, nil). - On("ContainerInfoV2", "/", options).Return(containerInfoMap, nil) + mockCadvisor.EXPECT().RootFsInfo().Return(rootFsInfo, nil) + mockCadvisor.EXPECT().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) - mockPodManager = new(kubepodtest.MockManager) - mockRuntimeCache = new(kubecontainertest.MockRuntimeCache) + mockCadvisor = cadvisortest.NewMockInterface(mockCtrl) + mockPodManager = kubepodtest.NewMockManager(mockCtrl) + mockRuntimeCache = kubecontainertest.NewMockRuntimeCache(mockCtrl) cadvisorReq = &cadvisorapiv1.ContainerInfoRequest{} ) - mockPodManager.On("TranslatePodUID", tc.requestedPodUID).Return(kubetypes.ResolvedPodUID(tc.requestedPodUID)) - mockRuntimeCache.On("GetPods").Return(tc.podList, tc.runtimeError) + mockPodManager.EXPECT().TranslatePodUID(tc.requestedPodUID).Return(kubetypes.ResolvedPodUID(tc.requestedPodUID)) + 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) } } diff --git a/pkg/kubelet/status/status_manager.go b/pkg/kubelet/status/status_manager.go index f61fd526293..70381df836a 100644 --- a/pkg/kubelet/status/status_manager.go +++ b/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 ( diff --git a/pkg/kubelet/status/testing/mock_pod_status_provider.go b/pkg/kubelet/status/testing/mock_pod_status_provider.go index fb07925f7cc..82618b28785 100644 --- a/pkg/kubelet/status/testing/mock_pod_status_provider.go +++ b/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" - - "k8s.io/api/core/v1" - "k8s.io/apimachinery/pkg/types" + gomock "github.com/golang/mock/gomock" + v1 "k8s.io/api/core/v1" + types "k8s.io/apimachinery/pkg/types" + container "k8s.io/kubernetes/pkg/kubelet/container" + reflect "reflect" ) -// MockStatusProvider mocks a PodStatusProvider. -type MockStatusProvider struct { - mock.Mock +// MockPodStatusProvider is a mock of PodStatusProvider interface +type MockPodStatusProvider struct { + ctrl *gomock.Controller + recorder *MockPodStatusProviderMockRecorder } -// GetPodStatus implements PodStatusProvider. -func (m *MockStatusProvider) GetPodStatus(uid types.UID) (v1.PodStatus, bool) { - args := m.Called(uid) - return args.Get(0).(v1.PodStatus), args.Bool(1) +// MockPodStatusProviderMockRecorder is the mock recorder for MockPodStatusProvider +type MockPodStatusProviderMockRecorder struct { + mock *MockPodStatusProvider +} + +// 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) } diff --git a/pkg/volume/testing/mock_volume.go b/pkg/volume/testing/mock_volume.go deleted file mode 100644 index 0304e951ec4..00000000000 --- a/pkg/volume/testing/mock_volume.go +++ /dev/null @@ -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 -}