github/kubernetes
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #104933 from vikramcse/automate_mockery

Browse Source 
conversion of tests from mockery to mockgen
This commit is contained in:
Kubernetes Prow Robot 2021-09-30 18:33:21 -07:00 committed by GitHub
commit cab54856f1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
34 changed files with 2594 additions and 1244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
pkg/kubelet/apis/podresources/server_v1_test.go
View File

@ -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 {

65
pkg/kubelet/apis/podresources/server_v1alpha1_test.go
View File

@ -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)

230
pkg/kubelet/apis/podresources/testing/provider_mock.go Normal file
View File

@ -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))
}

3
pkg/kubelet/apis/podresources/types.go
View File

@ -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"
)

283
pkg/kubelet/cadvisor/testing/cadvisor_mock.go
View File

@ -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))
}

1
pkg/kubelet/cadvisor/types.go
View File

@ -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 (

1
pkg/kubelet/container/runtime.go
View File

@ -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 (

1
pkg/kubelet/container/runtime_cache.go
View File

@ -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 (

122
pkg/kubelet/container/testing/mock_runtime_cache.go
View File

@ -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)
// MockRuntimeCacheMockRecorder is the mock recorder for MockRuntimeCache
type MockRuntimeCacheMockRecorder struct {
mock *MockRuntimeCache
}
return r0
// NewMockRuntimeCache creates a new mock instance
func NewMockRuntimeCache(ctrl *gomock.Controller) *MockRuntimeCache {
mock := &MockRuntimeCache{ctrl: ctrl}
mock.recorder = &MockRuntimeCacheMockRecorder{mock}
return mock
}
// 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)
}
// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockRuntimeCache) EXPECT() *MockRuntimeCacheMockRecorder {
return m.recorder
}
var r1 error
if rf, ok := ret.Get(1).(func() error); ok {
r1 = rf()
} else {
r1 = ret.Error(1)
// 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
}
return r0, r1
// GetPods indicates an expected call of GetPods
func (mr *MockRuntimeCacheMockRecorder) GetPods() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockRuntimeCache)(nil).GetPods))
}
// ForceUpdateIfOlder mocks base method
func (m *MockRuntimeCache) ForceUpdateIfOlder(arg0 time.Time) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ForceUpdateIfOlder", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// ForceUpdateIfOlder indicates an expected call of ForceUpdateIfOlder
func (mr *MockRuntimeCacheMockRecorder) ForceUpdateIfOlder(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceUpdateIfOlder", reflect.TypeOf((*MockRuntimeCache)(nil).ForceUpdateIfOlder), arg0)
}
// MockpodsGetter is a mock of podsGetter interface
type MockpodsGetter struct {
ctrl *gomock.Controller
recorder *MockpodsGetterMockRecorder
}
// MockpodsGetterMockRecorder is the mock recorder for MockpodsGetter
type MockpodsGetterMockRecorder struct {
mock *MockpodsGetter
}
// NewMockpodsGetter creates a new mock instance
func NewMockpodsGetter(ctrl *gomock.Controller) *MockpodsGetter {
mock := &MockpodsGetter{ctrl: ctrl}
mock.recorder = &MockpodsGetterMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockpodsGetter) EXPECT() *MockpodsGetterMockRecorder {
return m.recorder
}
// GetPods mocks base method
func (m *MockpodsGetter) GetPods(arg0 bool) ([]*container.Pod, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPods", arg0)
ret0, _ := ret[0].([]*container.Pod)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPods indicates an expected call of GetPods
func (mr *MockpodsGetterMockRecorder) GetPods(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockpodsGetter)(nil).GetPods), arg0)
}

632
pkg/kubelet/container/testing/runtime_mock.go
View File

@ -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)
}

31
pkg/kubelet/eviction/eviction_manager_test.go
View File

@ -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)
}

30
pkg/kubelet/eviction/memory_threshold_notifier_test.go
View File

@ -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()

375
pkg/kubelet/eviction/mock_threshold_notifier_test.go
View File

@ -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)
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Description")
ret0, _ := ret[0].(string)
return ret0
}
return r0
// 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))
}

1
pkg/kubelet/eviction/types.go
View File

@ -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 (

94
pkg/kubelet/images/image_gc_manager_test.go
View File

@ -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,

24
pkg/kubelet/metrics/collectors/resource_metrics_test.go
View File

@ -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 {

10
pkg/kubelet/metrics/collectors/volume_stats_test.go
View File

@ -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)
}

66
pkg/kubelet/pleg/generic_test.go
View File

@ -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)

1
pkg/kubelet/pod/pod_manager.go
View File

@ -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 (

414
pkg/kubelet/pod/testing/mock_manager.go
View File

@ -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)
// NewMockManager creates a new mock instance
func NewMockManager(ctrl *gomock.Controller) *MockManager {
mock := &MockManager{ctrl: ctrl}
mock.recorder = &MockManagerMockRecorder{mock}
return mock
}
return r0
// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockManager) EXPECT() *MockManagerMockRecorder {
return m.recorder
}
// 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)
// AddPod mocks base method
func (m *MockManager) AddPod(arg0 *v1.Pod) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "AddPod", arg0)
}
return false, 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)
}
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
// 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
}
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
// 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)
}
// DeletePod provides a mock function with given fields: _a0
func (_m *MockManager) DeletePod(_a0 *v1.Pod) {
_m.Called(_a0)
// 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
}
// 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)
}
// 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)
}
var r1 bool
if rf, ok := ret.Get(1).(func(*v1.Pod) bool); ok {
r1 = rf(_a0)
} else {
r1 = ret.Get(1).(bool)
// DeletePod mocks base method
func (m *MockManager) DeletePod(arg0 *v1.Pod) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "DeletePod", arg0)
}
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)
}
// 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)
}
// 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
}
var r1 bool
if rf, ok := ret.Get(1).(func(string) bool); ok {
r1 = rf(podFullName)
} else {
r1 = ret.Get(1).(bool)
// 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)
}
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
}
// 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)
}
// 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))
}
var r1 bool
if rf, ok := ret.Get(1).(func(*v1.Pod) bool); ok {
r1 = rf(_a0)
} else {
r1 = ret.Get(1).(bool)
// 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
}
return r0, r1
// 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)
}
// 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)
}
// 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
}
var r1 bool
if rf, ok := ret.Get(1).(func(string, string) bool); ok {
r1 = rf(namespace, name)
} else {
r1 = ret.Get(1).(bool)
// 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)
}
return r0, r1
// 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
}
// 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)
}
// 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)
}
var r1 bool
if rf, ok := ret.Get(1).(func(types.UID) bool); ok {
r1 = rf(_a0)
} else {
r1 = ret.Get(1).(bool)
// 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
}
return r0, r1
// 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 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)
}
// 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
}
return r0
// 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 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)
}
// 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
}
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)
}
// 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))
}
return r0, r1
// 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 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)
}
// 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))
}
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)
}
// 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
}
return r0, r1
// 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)
}
// 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)
// SetPods mocks base method
func (m *MockManager) SetPods(arg0 []*v1.Pod) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetPods", arg0)
}
return r0
// 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)
}
// SetPods provides a mock function with given fields: pods
func (_m *MockManager) SetPods(pods []*v1.Pod) {
_m.Called(pods)
// 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 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)
// 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)
}
return r0
// UpdatePod mocks base method
func (m *MockManager) UpdatePod(arg0 *v1.Pod) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "UpdatePod", arg0)
}
// UpdatePod provides a mock function with given fields: _a0
func (_m *MockManager) UpdatePod(_a0 *v1.Pod) {
_m.Called(_a0)
// 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)
}

16
pkg/kubelet/runonce_test.go
View File

@ -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(

1
pkg/kubelet/server/stats/handler.go
View File

@ -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 (

1
pkg/kubelet/server/stats/summary.go
View File

@ -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 (

59
pkg/kubelet/server/stats/summary_test.go
View File

@ -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()

25
pkg/kubelet/server/stats/summary_windows_test.go
View File

@ -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)

558
pkg/kubelet/server/stats/testing/mock_stats_provider.go
View File

@ -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)
}
// MockProviderMockRecorder is the mock recorder for MockProvider
type MockProviderMockRecorder struct {
mock *MockProvider
}
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)
}
// NewMockProvider creates a new mock instance
func NewMockProvider(ctrl *gomock.Controller) *MockProvider {
mock := &MockProvider{ctrl: ctrl}
mock.recorder = &MockProviderMockRecorder{mock}
return mock
}
var r2 error
if rf, ok := ret.Get(2).(func(string, bool) error); ok {
r2 = rf(cgroupName, updateStats)
} else {
r2 = ret.Error(2)
// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockProvider) EXPECT() *MockProviderMockRecorder {
return m.recorder
}
return r0, r1, r2
// 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
}
// 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)
}
// 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))
}
var r1 error
if rf, ok := ret.Get(1).(func(string, bool) error); ok {
r1 = rf(cgroupName, updateStats)
} else {
r1 = ret.Error(1)
// 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
}
return r0, r1
// 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))
}
// 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
// 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
}
// 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)
// 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))
}
// 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)
}
// 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
}
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)
// 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))
}
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
}
// 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)
}
// 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)
}
var r1 error
if rf, ok := ret.Get(1).(func() error); ok {
r1 = rf()
} else {
r1 = ret.Error(1)
// 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
}
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)
}
// 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)
// 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
}
return r0
// 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))
}
// 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)
// 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
}
return r0
// 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)
}
// 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)
}
// 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
}
var r1 bool
if rf, ok := ret.Get(1).(func(string, string) bool); ok {
r1 = rf(namespace, name)
} else {
r1 = ret.Get(1).(bool)
// 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)
}
return r0, r1
// GetRequestedContainersInfo mocks base method
func (m *MockProvider) GetRequestedContainersInfo(containerName string, options v2.RequestOptions) (map[string]*v1.ContainerInfo, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetRequestedContainersInfo", containerName, options)
ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// 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)
}
// 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)
}
return r0
// 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
}
// 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)
}
// 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)
}
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)
// 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
}
return r0, r1
// 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))
}
// 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)
}
// 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
}
var r1 error
if rf, ok := ret.Get(1).(func() error); ok {
r1 = rf()
} else {
r1 = ret.Error(1)
// 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))
}
return r0, r1
// 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
}
// 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)
}
// 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)
}
var r1 error
if rf, ok := ret.Get(1).(func() error); ok {
r1 = rf()
} else {
r1 = ret.Error(1)
// 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
}
return r0, r1
// 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)
}
// 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)
}
// 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
}
var r1 error
if rf, ok := ret.Get(1).(func() error); ok {
r1 = rf()
} else {
r1 = ret.Error(1)
// 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))
}
return r0, r1
// 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
}
// 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)
}
// 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))
}
var r1 error
if rf, ok := ret.Get(1).(func() error); ok {
r1 = rf()
} else {
r1 = ret.Error(1)
// 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
}
return r0, r1
}
// 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
}
// 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 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
}
// 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)
}
// 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))
}
var r1 error
if rf, ok := ret.Get(1).(func() error); ok {
r1 = rf()
} else {
r1 = ret.Error(1)
// 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
}
return r0, r1
// 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)
}

80
pkg/kubelet/server/stats/testing/mock_summary_provider.go Normal file
View File

@ -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))
}

28
pkg/kubelet/server/stats/volume_stat_calculator_test.go
View File

@ -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{

48
pkg/kubelet/stats/cadvisor_stats_provider_test.go
View File

@ -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)
}

56
pkg/kubelet/stats/cri_stats_provider_test.go
View File

@ -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 {

74
pkg/kubelet/stats/provider_test.go
View File

@ -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)
}
}

1
pkg/kubelet/status/status_manager.go
View File

@ -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 (

203
pkg/kubelet/status/testing/mock_pod_status_provider.go
View File

@ -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)
}

65
pkg/volume/testing/mock_volume.go
View File

@ -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
}