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

Merge pull request #108902 from kolyshkin/bump-golangci-lint

Browse Source 
Fix verify:* after go 1.18 upgrade
This commit is contained in:
Kubernetes Prow Robot 2022-03-24 02:59:06 -07:00 committed by GitHub
commit 190f974dd8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
34 changed files with 2606 additions and 2240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
hack/lib/golang.sh
View File

@ -496,9 +496,6 @@ EOF
# ${PATH}. It will also check that the Go version is good enough for the
# Kubernetes build.
#
# Inputs:
# KUBE_EXTRA_GOPATH - If set, this is included in created GOPATH
#
# Outputs:
# env-var GOPATH points to our local output dir
# env-var GOBIN is unset (we want binaries in a predictable place)
@ -512,11 +509,6 @@ kube::golang::setup_env() {
export GOPATH="${KUBE_GOPATH}"
export GOCACHE="${KUBE_GOPATH}/cache"
# Append KUBE_EXTRA_GOPATH to the GOPATH if it is defined.
if [[ -n ${KUBE_EXTRA_GOPATH:-} ]]; then
GOPATH="${GOPATH}:${KUBE_EXTRA_GOPATH}"
fi
# Make sure our own Go binaries are in PATH.
export PATH="${KUBE_GOPATH}/bin:${PATH}"

1
hack/make-rules/verify.sh
View File

@ -35,7 +35,6 @@ EXCLUDED_PATTERNS=(
"verify-linkcheck.sh" # runs in separate Jenkins job once per day due to high network usage
"verify-*-dockerized.sh" # Don't run any scripts that intended to be run dockerized
"verify-govet-levee.sh" # Do not run levee analysis by default while KEP-1933 implementation is in alpha.
"verify-golangci-lint.sh" # TODO(dims) Need to get this running with golang 1.18
"verify-structured-logging.sh" # TODO(dims) Need to get this running with golang 1.18
)

6
hack/tools/go.mod
View File

@ -6,11 +6,11 @@ require (
github.com/aojea/sloppy-netparser v0.0.0-20210819225411-1b3bd8b3b975
github.com/cespare/prettybench v0.0.0-20150116022406-03b8cfe5406c
github.com/client9/misspell v0.3.4
github.com/golang/mock v1.4.4
github.com/golangci/golangci-lint v1.41.1
github.com/golang/mock v1.6.0
github.com/golangci/golangci-lint v1.45.0
github.com/google/go-flow-levee v0.1.5
gotest.tools/gotestsum v1.6.4
honnef.co/go/tools v0.2.0
honnef.co/go/tools v0.2.2
k8s.io/klog/hack/tools v0.0.0-20210917071902-331d2323a192
sigs.k8s.io/zeitgeist v0.2.0
)

676
hack/tools/go.sum
View File

File diff suppressed because it is too large Load Diff

159
pkg/kubelet/apis/podresources/testing/provider_mock.go
View File

@ -21,62 +21,37 @@ limitations under the License.
package testing
import (
reflect "reflect"
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
// MockDevicesProvider is a mock of DevicesProvider interface.
type MockDevicesProvider struct {
ctrl *gomock.Controller
recorder *MockDevicesProviderMockRecorder
}
// MockDevicesProviderMockRecorder is the mock recorder for MockDevicesProvider
// MockDevicesProviderMockRecorder is the mock recorder for MockDevicesProvider.
type MockDevicesProviderMockRecorder struct {
mock *MockDevicesProvider
}
// NewMockDevicesProvider creates a new mock instance
// 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
// 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
// GetAllocatableDevices mocks base method.
func (m *MockDevicesProvider) GetAllocatableDevices() []*v10.ContainerDevices {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetAllocatableDevices")
@ -84,36 +59,62 @@ func (m *MockDevicesProvider) GetAllocatableDevices() []*v10.ContainerDevices {
return ret0
}
// GetAllocatableDevices indicates an expected call of GetAllocatableDevices
// 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
// 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)
}
// 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))
}
// MockPodsProvider is a mock of PodsProvider interface.
type MockPodsProvider struct {
ctrl *gomock.Controller
recorder *MockPodsProviderMockRecorder
}
// MockPodsProviderMockRecorder is the mock recorder for MockPodsProvider
// MockPodsProviderMockRecorder is the mock recorder for MockPodsProvider.
type MockPodsProviderMockRecorder struct {
mock *MockPodsProvider
}
// NewMockPodsProvider creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPodsProvider) EXPECT() *MockPodsProviderMockRecorder {
return m.recorder
}
// GetPods mocks base method
// GetPods mocks base method.
func (m *MockPodsProvider) GetPods() []*v1.Pod {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPods")
@ -121,50 +122,36 @@ func (m *MockPodsProvider) GetPods() []*v1.Pod {
return ret0
}
// GetPods indicates an expected call of GetPods
// 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
// MockCPUsProvider is a mock of CPUsProvider interface.
type MockCPUsProvider struct {
ctrl *gomock.Controller
recorder *MockCPUsProviderMockRecorder
}
// MockCPUsProviderMockRecorder is the mock recorder for MockCPUsProvider
// MockCPUsProviderMockRecorder is the mock recorder for MockCPUsProvider.
type MockCPUsProviderMockRecorder struct {
mock *MockCPUsProvider
}
// NewMockCPUsProvider creates a new mock instance
// 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
// 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
// GetAllocatableCPUs mocks base method.
func (m *MockCPUsProvider) GetAllocatableCPUs() []int64 {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetAllocatableCPUs")
@ -172,50 +159,50 @@ func (m *MockCPUsProvider) GetAllocatableCPUs() []int64 {
return ret0
}
// GetAllocatableCPUs indicates an expected call of GetAllocatableCPUs
// 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
// 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)
}
// MockMemoryProvider is a mock of MemoryProvider interface.
type MockMemoryProvider struct {
ctrl *gomock.Controller
recorder *MockMemoryProviderMockRecorder
}
// MockMemoryProviderMockRecorder is the mock recorder for MockMemoryProvider
// MockMemoryProviderMockRecorder is the mock recorder for MockMemoryProvider.
type MockMemoryProviderMockRecorder struct {
mock *MockMemoryProvider
}
// NewMockMemoryProvider creates a new mock instance
// 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
// 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
// GetAllocatableMemory mocks base method.
func (m *MockMemoryProvider) GetAllocatableMemory() []*v10.ContainerMemory {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetAllocatableMemory")
@ -223,8 +210,22 @@ func (m *MockMemoryProvider) GetAllocatableMemory() []*v10.ContainerMemory {
return ret0
}
// GetAllocatableMemory indicates an expected call of GetAllocatableMemory
// 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))
}
// 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)
}

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

@ -21,66 +21,38 @@ limitations under the License.
package testing
import (
reflect "reflect"
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"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// 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
}
// 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 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
}
// 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)
}
// ContainerInfo mocks base method
// 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)
@ -89,13 +61,13 @@ func (m *MockInterface) ContainerInfo(name string, req *v1.ContainerInfoRequest)
return ret0, ret1
}
// ContainerInfo indicates an expected call of ContainerInfo
// 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)
}
// ContainerInfoV2 mocks base method
// 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)
@ -104,118 +76,28 @@ func (m *MockInterface) ContainerInfoV2(name string, options v2.RequestOptions)
return ret0, ret1
}
// ContainerInfoV2 indicates an expected call of ContainerInfoV2
// 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)
}
// GetRequestedContainersInfo mocks base method
func (m *MockInterface) GetRequestedContainersInfo(containerName string, options v2.RequestOptions) (map[string]*v1.ContainerInfo, error) {
// 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, "GetRequestedContainersInfo", containerName, options)
ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
ret := m.ctrl.Call(m, "DockerContainer", name, req)
ret0, _ := ret[0].(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 {
// 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, "GetRequestedContainersInfo", reflect.TypeOf((*MockInterface)(nil).GetRequestedContainersInfo), containerName, options)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DockerContainer", reflect.TypeOf((*MockInterface)(nil).DockerContainer), name, req)
}
// 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
// GetDirFsInfo mocks base method.
func (m *MockInterface) GetDirFsInfo(path string) (v2.FsInfo, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetDirFsInfo", path)
@ -224,36 +106,155 @@ func (m *MockInterface) GetDirFsInfo(path string) (v2.FsInfo, error) {
return ret0, ret1
}
// GetDirFsInfo indicates an expected call of GetDirFsInfo
// 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
// 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)
}
// 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))
}
// 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))
}
// 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))
}
// 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
}
// 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))
}
// 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)
}
// 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))
}
// 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)
}
// MockImageFsInfoProvider is a mock of ImageFsInfoProvider interface.
type MockImageFsInfoProvider struct {
ctrl *gomock.Controller
recorder *MockImageFsInfoProviderMockRecorder
}
// MockImageFsInfoProviderMockRecorder is the mock recorder for MockImageFsInfoProvider
// MockImageFsInfoProviderMockRecorder is the mock recorder for MockImageFsInfoProvider.
type MockImageFsInfoProviderMockRecorder struct {
mock *MockImageFsInfoProvider
}
// NewMockImageFsInfoProvider creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockImageFsInfoProvider) EXPECT() *MockImageFsInfoProviderMockRecorder {
return m.recorder
}
// ImageFsInfoLabel mocks base method
// ImageFsInfoLabel mocks base method.
func (m *MockImageFsInfoProvider) ImageFsInfoLabel() (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ImageFsInfoLabel")
@ -262,7 +263,7 @@ func (m *MockImageFsInfoProvider) ImageFsInfoLabel() (string, error) {
return ret0, ret1
}
// ImageFsInfoLabel indicates an expected call of ImageFsInfoLabel
// 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))

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

@ -21,36 +21,51 @@ limitations under the License.
package testing
import (
gomock "github.com/golang/mock/gomock"
container "k8s.io/kubernetes/pkg/kubelet/container"
reflect "reflect"
time "time"
gomock "github.com/golang/mock/gomock"
container "k8s.io/kubernetes/pkg/kubelet/container"
)
// MockRuntimeCache is a mock of RuntimeCache interface
// MockRuntimeCache is a mock of RuntimeCache interface.
type MockRuntimeCache struct {
ctrl *gomock.Controller
recorder *MockRuntimeCacheMockRecorder
}
// MockRuntimeCacheMockRecorder is the mock recorder for MockRuntimeCache
// MockRuntimeCacheMockRecorder is the mock recorder for MockRuntimeCache.
type MockRuntimeCacheMockRecorder struct {
mock *MockRuntimeCache
}
// NewMockRuntimeCache creates a new mock instance
// NewMockRuntimeCache creates a new mock instance.
func NewMockRuntimeCache(ctrl *gomock.Controller) *MockRuntimeCache {
mock := &MockRuntimeCache{ctrl: ctrl}
mock.recorder = &MockRuntimeCacheMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRuntimeCache) EXPECT() *MockRuntimeCacheMockRecorder {
return m.recorder
}
// GetPods mocks base method
// 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)
}
// GetPods mocks base method.
func (m *MockRuntimeCache) GetPods() ([]*container.Pod, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPods")
@ -59,50 +74,36 @@ func (m *MockRuntimeCache) GetPods() ([]*container.Pod, error) {
return ret0, ret1
}
// GetPods indicates an expected call of GetPods
// 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
// MockpodsGetter is a mock of podsGetter interface.
type MockpodsGetter struct {
ctrl *gomock.Controller
recorder *MockpodsGetterMockRecorder
}
// MockpodsGetterMockRecorder is the mock recorder for MockpodsGetter
// MockpodsGetterMockRecorder is the mock recorder for MockpodsGetter.
type MockpodsGetterMockRecorder struct {
mock *MockpodsGetter
}
// NewMockpodsGetter creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockpodsGetter) EXPECT() *MockpodsGetterMockRecorder {
return m.recorder
}
// GetPods mocks base method
// GetPods mocks base method.
func (m *MockpodsGetter) GetPods(arg0 bool) ([]*container.Pod, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPods", arg0)
@ -111,7 +112,7 @@ func (m *MockpodsGetter) GetPods(arg0 bool) ([]*container.Pod, error) {
return ret0, ret1
}
// GetPods indicates an expected call of GetPods
// 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)

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

@ -22,43 +22,44 @@ package testing
import (
context "context"
gomock "github.com/golang/mock/gomock"
io "io"
url "net/url"
reflect "reflect"
time "time"
gomock "github.com/golang/mock/gomock"
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"
v10 "k8s.io/cri-api/pkg/apis/runtime/v1"
container "k8s.io/kubernetes/pkg/kubelet/container"
url "net/url"
reflect "reflect"
time "time"
)
// MockVersion is a mock of Version interface
// MockVersion is a mock of Version interface.
type MockVersion struct {
ctrl *gomock.Controller
recorder *MockVersionMockRecorder
}
// MockVersionMockRecorder is the mock recorder for MockVersion
// MockVersionMockRecorder is the mock recorder for MockVersion.
type MockVersionMockRecorder struct {
mock *MockVersion
}
// NewMockVersion creates a new mock instance
// NewMockVersion creates a new mock instance.
func NewMockVersion(ctrl *gomock.Controller) *MockVersion {
mock := &MockVersion{ctrl: ctrl}
mock.recorder = &MockVersionMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVersion) EXPECT() *MockVersionMockRecorder {
return m.recorder
}
// Compare mocks base method
// Compare mocks base method.
func (m *MockVersion) Compare(other string) (int, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Compare", other)
@ -67,13 +68,13 @@ func (m *MockVersion) Compare(other string) (int, error) {
return ret0, ret1
}
// Compare indicates an expected call of Compare
// 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)
}
// String mocks base method
// String mocks base method.
func (m *MockVersion) String() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "String")
@ -81,65 +82,36 @@ func (m *MockVersion) String() string {
return ret0
}
// String indicates an expected call of String
// 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))
}
// MockRuntime is a mock of Runtime interface
// MockRuntime is a mock of Runtime interface.
type MockRuntime struct {
ctrl *gomock.Controller
recorder *MockRuntimeMockRecorder
}
// MockRuntimeMockRecorder is the mock recorder for MockRuntime
// MockRuntimeMockRecorder is the mock recorder for MockRuntime.
type MockRuntimeMockRecorder struct {
mock *MockRuntime
}
// NewMockRuntime creates a new mock instance
// NewMockRuntime creates a new mock instance.
func NewMockRuntime(ctrl *gomock.Controller) *MockRuntime {
mock := &MockRuntime{ctrl: ctrl}
mock.recorder = &MockRuntimeMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRuntime) EXPECT() *MockRuntimeMockRecorder {
return m.recorder
}
// 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
}
// 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))
}
// 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
}
// 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))
}
// APIVersion mocks base method
// APIVersion mocks base method.
func (m *MockRuntime) APIVersion() (container.Version, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "APIVersion")
@ -148,114 +120,13 @@ func (m *MockRuntime) APIVersion() (container.Version, error) {
return ret0, ret1
}
// APIVersion indicates an expected call of APIVersion
// 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))
}
// 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
}
// 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))
}
// 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
}
// 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)
}
// 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
// DeleteContainer mocks base method.
func (m *MockRuntime) DeleteContainer(containerID container.ContainerID) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteContainer", containerID)
@ -263,28 +134,41 @@ func (m *MockRuntime) DeleteContainer(containerID container.ContainerID) error {
return ret0
}
// DeleteContainer indicates an expected call of DeleteContainer
// 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 *v10.PodSandboxConfig) (string, error) {
// GarbageCollect mocks base method.
func (m *MockRuntime) GarbageCollect(gcPolicy container.GCPolicy, allSourcesReady, evictNonDeletedPods bool) 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
ret := m.ctrl.Call(m, "GarbageCollect", gcPolicy, allSourcesReady, evictNonDeletedPods)
ret0, _ := ret[0].(error)
return ret0
}
// PullImage indicates an expected call of PullImage
func (mr *MockRuntimeMockRecorder) PullImage(image, pullSecrets, podSandboxConfig interface{}) *gomock.Call {
// 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, "PullImage", reflect.TypeOf((*MockRuntime)(nil).PullImage), image, pullSecrets, podSandboxConfig)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GarbageCollect", reflect.TypeOf((*MockRuntime)(nil).GarbageCollect), gcPolicy, allSourcesReady, evictNonDeletedPods)
}
// GetImageRef mocks base method
// 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)
}
// GetImageRef mocks base method.
func (m *MockRuntime) GetImageRef(image container.ImageSpec) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetImageRef", image)
@ -293,42 +177,43 @@ func (m *MockRuntime) GetImageRef(image container.ImageSpec) (string, error) {
return ret0, ret1
}
// GetImageRef indicates an expected call of GetImageRef
// 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) {
// 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, "ListImages")
ret0, _ := ret[0].([]container.Image)
ret := m.ctrl.Call(m, "GetPodStatus", uid, name, namespace)
ret0, _ := ret[0].(*container.PodStatus)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListImages indicates an expected call of ListImages
func (mr *MockRuntimeMockRecorder) ListImages() *gomock.Call {
// 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, "ListImages", reflect.TypeOf((*MockRuntime)(nil).ListImages))
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodStatus", reflect.TypeOf((*MockRuntime)(nil).GetPodStatus), uid, name, namespace)
}
// RemoveImage mocks base method
func (m *MockRuntime) RemoveImage(image container.ImageSpec) error {
// GetPods mocks base method.
func (m *MockRuntime) GetPods(all bool) ([]*container.Pod, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RemoveImage", image)
ret0, _ := ret[0].(error)
return ret0
ret := m.ctrl.Call(m, "GetPods", all)
ret0, _ := ret[0].([]*container.Pod)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// RemoveImage indicates an expected call of RemoveImage
func (mr *MockRuntimeMockRecorder) RemoveImage(image interface{}) *gomock.Call {
// 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, "RemoveImage", reflect.TypeOf((*MockRuntime)(nil).RemoveImage), image)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockRuntime)(nil).GetPods), all)
}
// ImageStats mocks base method
// ImageStats mocks base method.
func (m *MockRuntime) ImageStats() (*container.ImageStats, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ImageStats")
@ -337,13 +222,114 @@ func (m *MockRuntime) ImageStats() (*container.ImageStats, error) {
return ret0, ret1
}
// ImageStats indicates an expected call of ImageStats
// 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
// 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)
}
// 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))
}
// PullImage mocks base method.
func (m *MockRuntime) PullImage(image container.ImageSpec, pullSecrets []v1.Secret, podSandboxConfig *v10.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)
}
// 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)
}
// 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
}
// 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))
}
// 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)
}
// 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
}
// 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))
}
// UpdatePodCIDR mocks base method.
func (m *MockRuntime) UpdatePodCIDR(podCIDR string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UpdatePodCIDR", podCIDR)
@ -351,51 +337,51 @@ func (m *MockRuntime) UpdatePodCIDR(podCIDR string) error {
return ret0
}
// UpdatePodCIDR indicates an expected call of UpdatePodCIDR
// 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
// 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
}
// 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))
}
// MockStreamingRuntime is a mock of StreamingRuntime interface.
type MockStreamingRuntime struct {
ctrl *gomock.Controller
recorder *MockStreamingRuntimeMockRecorder
}
// MockStreamingRuntimeMockRecorder is the mock recorder for MockStreamingRuntime
// MockStreamingRuntimeMockRecorder is the mock recorder for MockStreamingRuntime.
type MockStreamingRuntimeMockRecorder struct {
mock *MockStreamingRuntime
}
// NewMockStreamingRuntime creates a new mock instance
// 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
// 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
// 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)
@ -404,13 +390,28 @@ func (m *MockStreamingRuntime) GetAttach(id container.ContainerID, stdin, stdout
return ret0, ret1
}
// GetAttach indicates an expected call of GetAttach
// 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
// 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)
}
// 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)
@ -419,51 +420,36 @@ func (m *MockStreamingRuntime) GetPortForward(podName, podNamespace string, podU
return ret0, ret1
}
// GetPortForward indicates an expected call of GetPortForward
// 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
// MockImageService is a mock of ImageService interface.
type MockImageService struct {
ctrl *gomock.Controller
recorder *MockImageServiceMockRecorder
}
// MockImageServiceMockRecorder is the mock recorder for MockImageService
// MockImageServiceMockRecorder is the mock recorder for MockImageService.
type MockImageServiceMockRecorder struct {
mock *MockImageService
}
// NewMockImageService creates a new mock instance
// 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
// 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 *v10.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
// GetImageRef mocks base method.
func (m *MockImageService) GetImageRef(image container.ImageSpec) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetImageRef", image)
@ -472,42 +458,13 @@ func (m *MockImageService) GetImageRef(image container.ImageSpec) (string, error
return ret0, ret1
}
// GetImageRef indicates an expected call of GetImageRef
// 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
// ImageStats mocks base method.
func (m *MockImageService) ImageStats() (*container.ImageStats, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ImageStats")
@ -516,36 +473,80 @@ func (m *MockImageService) ImageStats() (*container.ImageStats, error) {
return ret0, ret1
}
// ImageStats indicates an expected call of ImageStats
// 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
// 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))
}
// PullImage mocks base method.
func (m *MockImageService) PullImage(image container.ImageSpec, pullSecrets []v1.Secret, podSandboxConfig *v10.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)
}
// 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)
}
// MockAttacher is a mock of Attacher interface.
type MockAttacher struct {
ctrl *gomock.Controller
recorder *MockAttacherMockRecorder
}
// MockAttacherMockRecorder is the mock recorder for MockAttacher
// MockAttacherMockRecorder is the mock recorder for MockAttacher.
type MockAttacherMockRecorder struct {
mock *MockAttacher
}
// NewMockAttacher creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAttacher) EXPECT() *MockAttacherMockRecorder {
return m.recorder
}
// AttachContainer mocks base method
// 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)
@ -553,36 +554,36 @@ func (m *MockAttacher) AttachContainer(id container.ContainerID, stdin io.Reader
return ret0
}
// AttachContainer indicates an expected call of AttachContainer
// 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
// MockCommandRunner is a mock of CommandRunner interface.
type MockCommandRunner struct {
ctrl *gomock.Controller
recorder *MockCommandRunnerMockRecorder
}
// MockCommandRunnerMockRecorder is the mock recorder for MockCommandRunner
// MockCommandRunnerMockRecorder is the mock recorder for MockCommandRunner.
type MockCommandRunnerMockRecorder struct {
mock *MockCommandRunner
}
// NewMockCommandRunner creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCommandRunner) EXPECT() *MockCommandRunnerMockRecorder {
return m.recorder
}
// RunInContainer mocks base method
// 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)
@ -591,7 +592,7 @@ func (m *MockCommandRunner) RunInContainer(id container.ContainerID, cmd []strin
return ret0, ret1
}
// RunInContainer indicates an expected call of RunInContainer
// 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)

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

@ -21,62 +21,37 @@ limitations under the License.
package eviction
import (
gomock "github.com/golang/mock/gomock"
v1alpha1 "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
reflect "reflect"
time "time"
gomock "github.com/golang/mock/gomock"
v1alpha1 "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
)
// MockManager is a mock of Manager interface
// MockManager is a mock of Manager interface.
type MockManager struct {
ctrl *gomock.Controller
recorder *MockManagerMockRecorder
}
// MockManagerMockRecorder is the mock recorder for MockManager
// MockManagerMockRecorder is the mock recorder for MockManager.
type MockManagerMockRecorder struct {
mock *MockManager
}
// NewMockManager creates a new mock instance
// 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
// 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
// IsUnderDiskPressure mocks base method.
func (m *MockManager) IsUnderDiskPressure() bool {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsUnderDiskPressure")
@ -84,13 +59,27 @@ func (m *MockManager) IsUnderDiskPressure() bool {
return ret0
}
// IsUnderDiskPressure indicates an expected call of IsUnderDiskPressure
// 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
// 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))
}
// IsUnderPIDPressure mocks base method.
func (m *MockManager) IsUnderPIDPressure() bool {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsUnderPIDPressure")
@ -98,36 +87,48 @@ func (m *MockManager) IsUnderPIDPressure() bool {
return ret0
}
// IsUnderPIDPressure indicates an expected call of IsUnderPIDPressure
// 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
// 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)
}
// MockDiskInfoProvider is a mock of DiskInfoProvider interface.
type MockDiskInfoProvider struct {
ctrl *gomock.Controller
recorder *MockDiskInfoProviderMockRecorder
}
// MockDiskInfoProviderMockRecorder is the mock recorder for MockDiskInfoProvider
// MockDiskInfoProviderMockRecorder is the mock recorder for MockDiskInfoProvider.
type MockDiskInfoProviderMockRecorder struct {
mock *MockDiskInfoProvider
}
// NewMockDiskInfoProvider creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDiskInfoProvider) EXPECT() *MockDiskInfoProviderMockRecorder {
return m.recorder
}
// HasDedicatedImageFs mocks base method
// HasDedicatedImageFs mocks base method.
func (m *MockDiskInfoProvider) HasDedicatedImageFs() (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HasDedicatedImageFs")
@ -136,36 +137,36 @@ func (m *MockDiskInfoProvider) HasDedicatedImageFs() (bool, error) {
return ret0, ret1
}
// HasDedicatedImageFs indicates an expected call of HasDedicatedImageFs
// 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
// MockImageGC is a mock of ImageGC interface.
type MockImageGC struct {
ctrl *gomock.Controller
recorder *MockImageGCMockRecorder
}
// MockImageGCMockRecorder is the mock recorder for MockImageGC
// MockImageGCMockRecorder is the mock recorder for MockImageGC.
type MockImageGCMockRecorder struct {
mock *MockImageGC
}
// NewMockImageGC creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockImageGC) EXPECT() *MockImageGCMockRecorder {
return m.recorder
}
// DeleteUnusedImages mocks base method
// DeleteUnusedImages mocks base method.
func (m *MockImageGC) DeleteUnusedImages() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteUnusedImages")
@ -173,36 +174,36 @@ func (m *MockImageGC) DeleteUnusedImages() error {
return ret0
}
// DeleteUnusedImages indicates an expected call of DeleteUnusedImages
// 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
// MockContainerGC is a mock of ContainerGC interface.
type MockContainerGC struct {
ctrl *gomock.Controller
recorder *MockContainerGCMockRecorder
}
// MockContainerGCMockRecorder is the mock recorder for MockContainerGC
// MockContainerGCMockRecorder is the mock recorder for MockContainerGC.
type MockContainerGCMockRecorder struct {
mock *MockContainerGC
}
// NewMockContainerGC creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockContainerGC) EXPECT() *MockContainerGCMockRecorder {
return m.recorder
}
// DeleteAllUnusedContainers mocks base method
// DeleteAllUnusedContainers mocks base method.
func (m *MockContainerGC) DeleteAllUnusedContainers() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteAllUnusedContainers")
@ -210,83 +211,83 @@ func (m *MockContainerGC) DeleteAllUnusedContainers() error {
return ret0
}
// DeleteAllUnusedContainers indicates an expected call of DeleteAllUnusedContainers
// 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
// MockCgroupNotifier is a mock of CgroupNotifier interface.
type MockCgroupNotifier struct {
ctrl *gomock.Controller
recorder *MockCgroupNotifierMockRecorder
}
// MockCgroupNotifierMockRecorder is the mock recorder for MockCgroupNotifier
// MockCgroupNotifierMockRecorder is the mock recorder for MockCgroupNotifier.
type MockCgroupNotifierMockRecorder struct {
mock *MockCgroupNotifier
}
// NewMockCgroupNotifier creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCgroupNotifier) EXPECT() *MockCgroupNotifierMockRecorder {
return m.recorder
}
// Start mocks base method
// 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
// 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
// Stop mocks base method.
func (m *MockCgroupNotifier) Stop() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Stop")
}
// Stop indicates an expected call of Stop
// 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
// MockNotifierFactory is a mock of NotifierFactory interface.
type MockNotifierFactory struct {
ctrl *gomock.Controller
recorder *MockNotifierFactoryMockRecorder
}
// MockNotifierFactoryMockRecorder is the mock recorder for MockNotifierFactory
// MockNotifierFactoryMockRecorder is the mock recorder for MockNotifierFactory.
type MockNotifierFactoryMockRecorder struct {
mock *MockNotifierFactory
}
// NewMockNotifierFactory creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockNotifierFactory) EXPECT() *MockNotifierFactoryMockRecorder {
return m.recorder
}
// NewCgroupNotifier mocks base method
// 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)
@ -295,62 +296,36 @@ func (m *MockNotifierFactory) NewCgroupNotifier(path, attribute string, threshol
return ret0, ret1
}
// NewCgroupNotifier indicates an expected call of NewCgroupNotifier
// 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
// MockThresholdNotifier is a mock of ThresholdNotifier interface.
type MockThresholdNotifier struct {
ctrl *gomock.Controller
recorder *MockThresholdNotifierMockRecorder
}
// MockThresholdNotifierMockRecorder is the mock recorder for MockThresholdNotifier
// MockThresholdNotifierMockRecorder is the mock recorder for MockThresholdNotifier.
type MockThresholdNotifierMockRecorder struct {
mock *MockThresholdNotifier
}
// NewMockThresholdNotifier creates a new mock instance
// 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
// 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.ctrl.T.Helper()
m.ctrl.Call(m, "Start")
}
// 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))
}
// 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
// Description mocks base method.
func (m *MockThresholdNotifier) Description() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Description")
@ -358,8 +333,34 @@ func (m *MockThresholdNotifier) Description() string {
return ret0
}
// Description indicates an expected call of Description
// 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))
}
// Start mocks base method.
func (m *MockThresholdNotifier) Start() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Start")
}
// 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))
}
// 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)
}

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

@ -21,49 +21,50 @@ limitations under the License.
package testing
import (
reflect "reflect"
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 a mock of Manager interface
// MockManager is a mock of Manager interface.
type MockManager struct {
ctrl *gomock.Controller
recorder *MockManagerMockRecorder
}
// MockManagerMockRecorder is the mock recorder for MockManager
// MockManagerMockRecorder is the mock recorder for MockManager.
type MockManagerMockRecorder struct {
mock *MockManager
}
// NewMockManager creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockManager) EXPECT() *MockManagerMockRecorder {
return m.recorder
}
// AddPod mocks base method
// AddPod mocks base method.
func (m *MockManager) AddPod(arg0 *v1.Pod) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "AddPod", arg0)
}
// AddPod indicates an expected call of AddPod
// 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)
}
// CreateMirrorPod mocks base method
// CreateMirrorPod mocks base method.
func (m *MockManager) CreateMirrorPod(arg0 *v1.Pod) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateMirrorPod", arg0)
@ -71,13 +72,13 @@ func (m *MockManager) CreateMirrorPod(arg0 *v1.Pod) error {
return ret0
}
// CreateMirrorPod indicates an expected call of CreateMirrorPod
// 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)
}
// DeleteMirrorPod mocks base method
// 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)
@ -86,25 +87,25 @@ func (m *MockManager) DeleteMirrorPod(arg0 string, arg1 *types.UID) (bool, error
return ret0, ret1
}
// DeleteMirrorPod indicates an expected call of DeleteMirrorPod
// 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)
}
// DeletePod mocks base method
// DeletePod mocks base method.
func (m *MockManager) DeletePod(arg0 *v1.Pod) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "DeletePod", arg0)
}
// DeletePod indicates an expected call of DeletePod
// 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)
}
// GetMirrorPodByPod mocks base method
// 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)
@ -113,13 +114,13 @@ func (m *MockManager) GetMirrorPodByPod(arg0 *v1.Pod) (*v1.Pod, bool) {
return ret0, ret1
}
// GetMirrorPodByPod indicates an expected call of GetMirrorPodByPod
// 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)
}
// GetOrphanedMirrorPodNames mocks base method
// GetOrphanedMirrorPodNames mocks base method.
func (m *MockManager) GetOrphanedMirrorPodNames() []string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetOrphanedMirrorPodNames")
@ -127,13 +128,13 @@ func (m *MockManager) GetOrphanedMirrorPodNames() []string {
return ret0
}
// GetOrphanedMirrorPodNames indicates an expected call of GetOrphanedMirrorPodNames
// 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))
}
// GetPodByFullName mocks base method
// GetPodByFullName mocks base method.
func (m *MockManager) GetPodByFullName(arg0 string) (*v1.Pod, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPodByFullName", arg0)
@ -142,13 +143,13 @@ func (m *MockManager) GetPodByFullName(arg0 string) (*v1.Pod, bool) {
return ret0, ret1
}
// GetPodByFullName indicates an expected call of GetPodByFullName
// 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)
}
// GetPodByMirrorPod mocks base method
// 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)
@ -157,13 +158,13 @@ func (m *MockManager) GetPodByMirrorPod(arg0 *v1.Pod) (*v1.Pod, bool) {
return ret0, ret1
}
// GetPodByMirrorPod indicates an expected call of GetPodByMirrorPod
// GetPodByMirrorPod indicates an expected call of GetPodByMirrorPod.
func (mr *MockManagerMockRecorder) GetPodByMirrorPod(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByMirrorPod", reflect.TypeOf((*MockManager)(nil).GetPodByMirrorPod), arg0)
}
// GetPodByName mocks base method
// 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)
@ -172,13 +173,13 @@ func (m *MockManager) GetPodByName(arg0, arg1 string) (*v1.Pod, bool) {
return ret0, ret1
}
// GetPodByName indicates an expected call of GetPodByName
// GetPodByName indicates an expected call of GetPodByName.
func (mr *MockManagerMockRecorder) GetPodByName(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByName", reflect.TypeOf((*MockManager)(nil).GetPodByName), arg0, arg1)
}
// GetPodByUID mocks base method
// 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)
@ -187,13 +188,13 @@ func (m *MockManager) GetPodByUID(arg0 types.UID) (*v1.Pod, bool) {
return ret0, ret1
}
// GetPodByUID indicates an expected call of GetPodByUID
// GetPodByUID indicates an expected call of GetPodByUID.
func (mr *MockManagerMockRecorder) GetPodByUID(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByUID", reflect.TypeOf((*MockManager)(nil).GetPodByUID), arg0)
}
// GetPods mocks base method
// GetPods mocks base method.
func (m *MockManager) GetPods() []*v1.Pod {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPods")
@ -201,13 +202,13 @@ func (m *MockManager) GetPods() []*v1.Pod {
return ret0
}
// GetPods indicates an expected call of GetPods
// GetPods indicates an expected call of GetPods.
func (mr *MockManagerMockRecorder) GetPods() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockManager)(nil).GetPods))
}
// GetPodsAndMirrorPods mocks base method
// GetPodsAndMirrorPods mocks base method.
func (m *MockManager) GetPodsAndMirrorPods() ([]*v1.Pod, []*v1.Pod) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPodsAndMirrorPods")
@ -216,13 +217,13 @@ func (m *MockManager) GetPodsAndMirrorPods() ([]*v1.Pod, []*v1.Pod) {
return ret0, ret1
}
// GetPodsAndMirrorPods indicates an expected call of GetPodsAndMirrorPods
// GetPodsAndMirrorPods indicates an expected call of GetPodsAndMirrorPods.
func (mr *MockManagerMockRecorder) GetPodsAndMirrorPods() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodsAndMirrorPods", reflect.TypeOf((*MockManager)(nil).GetPodsAndMirrorPods))
}
// GetUIDTranslations mocks base method
// 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")
@ -231,13 +232,13 @@ func (m *MockManager) GetUIDTranslations() (map[types0.ResolvedPodUID]types0.Mir
return ret0, ret1
}
// GetUIDTranslations indicates an expected call of GetUIDTranslations
// GetUIDTranslations indicates an expected call of GetUIDTranslations.
func (mr *MockManagerMockRecorder) GetUIDTranslations() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUIDTranslations", reflect.TypeOf((*MockManager)(nil).GetUIDTranslations))
}
// IsMirrorPodOf mocks base method
// 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)
@ -245,25 +246,25 @@ func (m *MockManager) IsMirrorPodOf(arg0, arg1 *v1.Pod) bool {
return ret0
}
// IsMirrorPodOf indicates an expected call of IsMirrorPodOf
// IsMirrorPodOf indicates an expected call of IsMirrorPodOf.
func (mr *MockManagerMockRecorder) IsMirrorPodOf(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsMirrorPodOf", reflect.TypeOf((*MockManager)(nil).IsMirrorPodOf), arg0, arg1)
}
// SetPods mocks base method
// SetPods mocks base method.
func (m *MockManager) SetPods(arg0 []*v1.Pod) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetPods", arg0)
}
// SetPods indicates an expected call of SetPods
// SetPods indicates an expected call of SetPods.
func (mr *MockManagerMockRecorder) SetPods(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPods", reflect.TypeOf((*MockManager)(nil).SetPods), arg0)
}
// TranslatePodUID mocks base method
// TranslatePodUID mocks base method.
func (m *MockManager) TranslatePodUID(arg0 types.UID) types0.ResolvedPodUID {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TranslatePodUID", arg0)
@ -271,19 +272,19 @@ func (m *MockManager) TranslatePodUID(arg0 types.UID) types0.ResolvedPodUID {
return ret0
}
// TranslatePodUID indicates an expected call of TranslatePodUID
// TranslatePodUID indicates an expected call of TranslatePodUID.
func (mr *MockManagerMockRecorder) TranslatePodUID(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TranslatePodUID", reflect.TypeOf((*MockManager)(nil).TranslatePodUID), arg0)
}
// UpdatePod mocks base method
// UpdatePod mocks base method.
func (m *MockManager) UpdatePod(arg0 *v1.Pod) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "UpdatePod", arg0)
}
// UpdatePod indicates an expected call of UpdatePod
// 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)

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

@ -21,6 +21,8 @@ limitations under the License.
package testing
import (
reflect "reflect"
gomock "github.com/golang/mock/gomock"
v1 "github.com/google/cadvisor/info/v1"
v2 "github.com/google/cadvisor/info/v2"
@ -29,93 +31,47 @@ import (
v1alpha1 "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
cm "k8s.io/kubernetes/pkg/kubelet/cm"
volume "k8s.io/kubernetes/pkg/volume"
reflect "reflect"
)
// MockProvider is a mock of Provider interface
// MockProvider is a mock of Provider interface.
type MockProvider struct {
ctrl *gomock.Controller
recorder *MockProviderMockRecorder
}
// MockProviderMockRecorder is the mock recorder for MockProvider
// MockProviderMockRecorder is the mock recorder for MockProvider.
type MockProviderMockRecorder struct {
mock *MockProvider
}
// NewMockProvider creates a new mock instance
// NewMockProvider creates a new mock instance.
func NewMockProvider(ctrl *gomock.Controller) *MockProvider {
mock := &MockProvider{ctrl: ctrl}
mock.recorder = &MockProviderMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockProvider) EXPECT() *MockProviderMockRecorder {
return m.recorder
}
// ListPodStats mocks base method
func (m *MockProvider) ListPodStats() ([]v1alpha1.PodStats, error) {
// GetCgroupCPUAndMemoryStats mocks base method.
func (m *MockProvider) GetCgroupCPUAndMemoryStats(cgroupName string, updateStats bool) (*v1alpha1.ContainerStats, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListPodStats")
ret0, _ := ret[0].([]v1alpha1.PodStats)
ret := m.ctrl.Call(m, "GetCgroupCPUAndMemoryStats", cgroupName, updateStats)
ret0, _ := ret[0].(*v1alpha1.ContainerStats)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListPodStats indicates an expected call of ListPodStats
func (mr *MockProviderMockRecorder) ListPodStats() *gomock.Call {
// 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, "ListPodStats", reflect.TypeOf((*MockProvider)(nil).ListPodStats))
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCgroupCPUAndMemoryStats", reflect.TypeOf((*MockProvider)(nil).GetCgroupCPUAndMemoryStats), cgroupName, updateStats)
}
// 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
}
// 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))
}
// 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
}
// 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))
}
// 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
}
// 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))
}
// GetCgroupStats mocks base method
// 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)
@ -125,43 +81,13 @@ func (m *MockProvider) GetCgroupStats(cgroupName string, updateStats bool) (*v1a
return ret0, ret1, ret2
}
// GetCgroupStats indicates an expected call of GetCgroupStats
// 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)
}
// 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
}
// 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)
}
// 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
}
// 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))
}
// GetContainerInfo mocks base method
// 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)
@ -170,58 +96,13 @@ func (m *MockProvider) GetContainerInfo(podFullName string, uid types.UID, conta
return ret0, ret1
}
// GetContainerInfo indicates an expected call of GetContainerInfo
// GetContainerInfo indicates an expected call of GetContainerInfo.
func (mr *MockProviderMockRecorder) GetContainerInfo(podFullName, uid, containerName, req interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerInfo", reflect.TypeOf((*MockProvider)(nil).GetContainerInfo), podFullName, uid, containerName, req)
}
// GetRawContainerInfo mocks base method
func (m *MockProvider) GetRawContainerInfo(containerName string, req *v1.ContainerInfoRequest, subcontainers bool) (map[string]*v1.ContainerInfo, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetRawContainerInfo", containerName, req, subcontainers)
ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetRawContainerInfo indicates an expected call of GetRawContainerInfo
func (mr *MockProviderMockRecorder) GetRawContainerInfo(containerName, req, subcontainers interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawContainerInfo", reflect.TypeOf((*MockProvider)(nil).GetRawContainerInfo), containerName, req, subcontainers)
}
// GetRequestedContainersInfo mocks base method
func (m *MockProvider) GetRequestedContainersInfo(containerName string, options v2.RequestOptions) (map[string]*v1.ContainerInfo, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetRequestedContainersInfo", containerName, options)
ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetRequestedContainersInfo indicates an expected call of GetRequestedContainersInfo
func (mr *MockProviderMockRecorder) GetRequestedContainersInfo(containerName, options interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRequestedContainersInfo", reflect.TypeOf((*MockProvider)(nil).GetRequestedContainersInfo), containerName, options)
}
// GetPodByName mocks base method
func (m *MockProvider) GetPodByName(namespace, name string) (*v10.Pod, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPodByName", namespace, name)
ret0, _ := ret[0].(*v10.Pod)
ret1, _ := ret[1].(bool)
return ret0, ret1
}
// GetPodByName indicates an expected call of GetPodByName
func (mr *MockProviderMockRecorder) GetPodByName(namespace, name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByName", reflect.TypeOf((*MockProvider)(nil).GetPodByName), namespace, name)
}
// GetNode mocks base method
// GetNode mocks base method.
func (m *MockProvider) GetNode() (*v10.Node, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetNode")
@ -230,13 +111,13 @@ func (m *MockProvider) GetNode() (*v10.Node, error) {
return ret0, ret1
}
// GetNode indicates an expected call of GetNode
// GetNode indicates an expected call of GetNode.
func (mr *MockProviderMockRecorder) GetNode() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNode", reflect.TypeOf((*MockProvider)(nil).GetNode))
}
// GetNodeConfig mocks base method
// GetNodeConfig mocks base method.
func (m *MockProvider) GetNodeConfig() cm.NodeConfig {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetNodeConfig")
@ -244,86 +125,13 @@ func (m *MockProvider) GetNodeConfig() cm.NodeConfig {
return ret0
}
// GetNodeConfig indicates an expected call of GetNodeConfig
// GetNodeConfig indicates an expected call of GetNodeConfig.
func (mr *MockProviderMockRecorder) GetNodeConfig() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeConfig", reflect.TypeOf((*MockProvider)(nil).GetNodeConfig))
}
// ListVolumesForPod mocks base method
func (m *MockProvider) ListVolumesForPod(podUID types.UID) (map[string]volume.Volume, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListVolumesForPod", podUID)
ret0, _ := ret[0].(map[string]volume.Volume)
ret1, _ := ret[1].(bool)
return ret0, ret1
}
// ListVolumesForPod indicates an expected call of ListVolumesForPod
func (mr *MockProviderMockRecorder) ListVolumesForPod(podUID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVolumesForPod", reflect.TypeOf((*MockProvider)(nil).ListVolumesForPod), podUID)
}
// ListBlockVolumesForPod mocks base method
func (m *MockProvider) ListBlockVolumesForPod(podUID types.UID) (map[string]volume.BlockVolume, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListBlockVolumesForPod", podUID)
ret0, _ := ret[0].(map[string]volume.BlockVolume)
ret1, _ := ret[1].(bool)
return ret0, ret1
}
// ListBlockVolumesForPod indicates an expected call of ListBlockVolumesForPod
func (mr *MockProviderMockRecorder) ListBlockVolumesForPod(podUID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBlockVolumesForPod", reflect.TypeOf((*MockProvider)(nil).ListBlockVolumesForPod), podUID)
}
// GetPods mocks base method
func (m *MockProvider) GetPods() []*v10.Pod {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPods")
ret0, _ := ret[0].([]*v10.Pod)
return ret0
}
// GetPods indicates an expected call of GetPods
func (mr *MockProviderMockRecorder) GetPods() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockProvider)(nil).GetPods))
}
// RlimitStats mocks base method
func (m *MockProvider) RlimitStats() (*v1alpha1.RlimitStats, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RlimitStats")
ret0, _ := ret[0].(*v1alpha1.RlimitStats)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// RlimitStats indicates an expected call of RlimitStats
func (mr *MockProviderMockRecorder) RlimitStats() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RlimitStats", reflect.TypeOf((*MockProvider)(nil).RlimitStats))
}
// GetPodCgroupRoot mocks base method
func (m *MockProvider) GetPodCgroupRoot() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPodCgroupRoot")
ret0, _ := ret[0].(string)
return ret0
}
// GetPodCgroupRoot indicates an expected call of GetPodCgroupRoot
func (mr *MockProviderMockRecorder) GetPodCgroupRoot() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodCgroupRoot", reflect.TypeOf((*MockProvider)(nil).GetPodCgroupRoot))
}
// GetPodByCgroupfs mocks base method
// GetPodByCgroupfs mocks base method.
func (m *MockProvider) GetPodByCgroupfs(cgroupfs string) (*v10.Pod, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPodByCgroupfs", cgroupfs)
@ -332,8 +140,201 @@ func (m *MockProvider) GetPodByCgroupfs(cgroupfs string) (*v10.Pod, bool) {
return ret0, ret1
}
// GetPodByCgroupfs indicates an expected call of GetPodByCgroupfs
// 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)
}
// GetPodByName mocks base method.
func (m *MockProvider) GetPodByName(namespace, name string) (*v10.Pod, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPodByName", namespace, name)
ret0, _ := ret[0].(*v10.Pod)
ret1, _ := ret[1].(bool)
return ret0, ret1
}
// GetPodByName indicates an expected call of GetPodByName.
func (mr *MockProviderMockRecorder) GetPodByName(namespace, name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByName", reflect.TypeOf((*MockProvider)(nil).GetPodByName), namespace, name)
}
// GetPodCgroupRoot mocks base method.
func (m *MockProvider) GetPodCgroupRoot() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPodCgroupRoot")
ret0, _ := ret[0].(string)
return ret0
}
// GetPodCgroupRoot indicates an expected call of GetPodCgroupRoot.
func (mr *MockProviderMockRecorder) GetPodCgroupRoot() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodCgroupRoot", reflect.TypeOf((*MockProvider)(nil).GetPodCgroupRoot))
}
// GetPods mocks base method.
func (m *MockProvider) GetPods() []*v10.Pod {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPods")
ret0, _ := ret[0].([]*v10.Pod)
return ret0
}
// GetPods indicates an expected call of GetPods.
func (mr *MockProviderMockRecorder) GetPods() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockProvider)(nil).GetPods))
}
// GetRawContainerInfo mocks base method.
func (m *MockProvider) GetRawContainerInfo(containerName string, req *v1.ContainerInfoRequest, subcontainers bool) (map[string]*v1.ContainerInfo, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetRawContainerInfo", containerName, req, subcontainers)
ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetRawContainerInfo indicates an expected call of GetRawContainerInfo.
func (mr *MockProviderMockRecorder) GetRawContainerInfo(containerName, req, subcontainers interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawContainerInfo", reflect.TypeOf((*MockProvider)(nil).GetRawContainerInfo), containerName, req, subcontainers)
}
// GetRequestedContainersInfo mocks base method.
func (m *MockProvider) GetRequestedContainersInfo(containerName string, options v2.RequestOptions) (map[string]*v1.ContainerInfo, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetRequestedContainersInfo", containerName, options)
ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetRequestedContainersInfo indicates an expected call of GetRequestedContainersInfo.
func (mr *MockProviderMockRecorder) GetRequestedContainersInfo(containerName, options interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRequestedContainersInfo", reflect.TypeOf((*MockProvider)(nil).GetRequestedContainersInfo), containerName, options)
}
// 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
}
// 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))
}
// ListBlockVolumesForPod mocks base method.
func (m *MockProvider) ListBlockVolumesForPod(podUID types.UID) (map[string]volume.BlockVolume, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListBlockVolumesForPod", podUID)
ret0, _ := ret[0].(map[string]volume.BlockVolume)
ret1, _ := ret[1].(bool)
return ret0, ret1
}
// ListBlockVolumesForPod indicates an expected call of ListBlockVolumesForPod.
func (mr *MockProviderMockRecorder) ListBlockVolumesForPod(podUID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBlockVolumesForPod", reflect.TypeOf((*MockProvider)(nil).ListBlockVolumesForPod), podUID)
}
// 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
}
// 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))
}
// 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
}
// 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))
}
// 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
}
// 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))
}
// ListVolumesForPod mocks base method.
func (m *MockProvider) ListVolumesForPod(podUID types.UID) (map[string]volume.Volume, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListVolumesForPod", podUID)
ret0, _ := ret[0].(map[string]volume.Volume)
ret1, _ := ret[1].(bool)
return ret0, ret1
}
// ListVolumesForPod indicates an expected call of ListVolumesForPod.
func (mr *MockProviderMockRecorder) ListVolumesForPod(podUID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVolumesForPod", reflect.TypeOf((*MockProvider)(nil).ListVolumesForPod), podUID)
}
// RlimitStats mocks base method.
func (m *MockProvider) RlimitStats() (*v1alpha1.RlimitStats, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RlimitStats")
ret0, _ := ret[0].(*v1alpha1.RlimitStats)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// RlimitStats indicates an expected call of RlimitStats.
func (mr *MockProviderMockRecorder) RlimitStats() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RlimitStats", reflect.TypeOf((*MockProvider)(nil).RlimitStats))
}
// 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
}
// 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))
}

19
pkg/kubelet/server/stats/testing/mock_summary_provider.go
View File

@ -21,35 +21,36 @@ limitations under the License.
package testing
import (
reflect "reflect"
gomock "github.com/golang/mock/gomock"
v1alpha1 "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
reflect "reflect"
)
// MockSummaryProvider is a mock of SummaryProvider interface
// MockSummaryProvider is a mock of SummaryProvider interface.
type MockSummaryProvider struct {
ctrl *gomock.Controller
recorder *MockSummaryProviderMockRecorder
}
// MockSummaryProviderMockRecorder is the mock recorder for MockSummaryProvider
// MockSummaryProviderMockRecorder is the mock recorder for MockSummaryProvider.
type MockSummaryProviderMockRecorder struct {
mock *MockSummaryProvider
}
// NewMockSummaryProvider creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSummaryProvider) EXPECT() *MockSummaryProviderMockRecorder {
return m.recorder
}
// Get mocks base method
// Get mocks base method.
func (m *MockSummaryProvider) Get(updateStats bool) (*v1alpha1.Summary, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", updateStats)
@ -58,13 +59,13 @@ func (m *MockSummaryProvider) Get(updateStats bool) (*v1alpha1.Summary, error) {
return ret0, ret1
}
// Get indicates an expected call of Get
// 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
// GetCPUAndMemoryStats mocks base method.
func (m *MockSummaryProvider) GetCPUAndMemoryStats() (*v1alpha1.Summary, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetCPUAndMemoryStats")
@ -73,7 +74,7 @@ func (m *MockSummaryProvider) GetCPUAndMemoryStats() (*v1alpha1.Summary, error)
return ret0, ret1
}
// GetCPUAndMemoryStats indicates an expected call of GetCPUAndMemoryStats
// 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))

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

@ -21,37 +21,38 @@ limitations under the License.
package testing
import (
reflect "reflect"
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"
)
// MockPodStatusProvider is a mock of PodStatusProvider interface
// MockPodStatusProvider is a mock of PodStatusProvider interface.
type MockPodStatusProvider struct {
ctrl *gomock.Controller
recorder *MockPodStatusProviderMockRecorder
}
// MockPodStatusProviderMockRecorder is the mock recorder for MockPodStatusProvider
// MockPodStatusProviderMockRecorder is the mock recorder for MockPodStatusProvider.
type MockPodStatusProviderMockRecorder struct {
mock *MockPodStatusProvider
}
// NewMockPodStatusProvider creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPodStatusProvider) EXPECT() *MockPodStatusProviderMockRecorder {
return m.recorder
}
// GetPodStatus mocks base method
// 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)
@ -60,50 +61,36 @@ func (m *MockPodStatusProvider) GetPodStatus(uid types.UID) (v1.PodStatus, bool)
return ret0, ret1
}
// GetPodStatus indicates an expected call of GetPodStatus
// 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
// MockPodDeletionSafetyProvider is a mock of PodDeletionSafetyProvider interface.
type MockPodDeletionSafetyProvider struct {
ctrl *gomock.Controller
recorder *MockPodDeletionSafetyProviderMockRecorder
}
// MockPodDeletionSafetyProviderMockRecorder is the mock recorder for MockPodDeletionSafetyProvider
// MockPodDeletionSafetyProviderMockRecorder is the mock recorder for MockPodDeletionSafetyProvider.
type MockPodDeletionSafetyProviderMockRecorder struct {
mock *MockPodDeletionSafetyProvider
}
// NewMockPodDeletionSafetyProvider creates a new mock instance
// 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
// 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)
}
// PodCouldHaveRunningContainers mocks base method
// PodCouldHaveRunningContainers mocks base method.
func (m *MockPodDeletionSafetyProvider) PodCouldHaveRunningContainers(pod *v1.Pod) bool {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PodCouldHaveRunningContainers", pod)
@ -111,36 +98,50 @@ func (m *MockPodDeletionSafetyProvider) PodCouldHaveRunningContainers(pod *v1.Po
return ret0
}
// PodCouldHaveRunningContainers indicates an expected call of PodCouldHaveRunningContainers
// PodCouldHaveRunningContainers indicates an expected call of PodCouldHaveRunningContainers.
func (mr *MockPodDeletionSafetyProviderMockRecorder) PodCouldHaveRunningContainers(pod interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PodCouldHaveRunningContainers", reflect.TypeOf((*MockPodDeletionSafetyProvider)(nil).PodCouldHaveRunningContainers), pod)
}
// MockManager is a mock of Manager interface
// 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
// MockManagerMockRecorder is the mock recorder for MockManager.
type MockManagerMockRecorder struct {
mock *MockManager
}
// NewMockManager creates a new mock instance
// 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
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockManager) EXPECT() *MockManagerMockRecorder {
return m.recorder
}
// GetPodStatus mocks base method
// 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)
@ -149,80 +150,80 @@ func (m *MockManager) GetPodStatus(uid types.UID) (v1.PodStatus, bool) {
return ret0, ret1
}
// GetPodStatus indicates an expected call of GetPodStatus
// 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
// 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
// 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)
}
// 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)
}
// 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)
}
// 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))
}
// 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)
}

477
staging/src/k8s.io/legacy-cloud-providers/azure/clients/armclient/mockarmclient/interface.go
View File

@ -25,114 +25,156 @@ package mockarmclient
import (
context "context"
http "net/http"
reflect "reflect"
autorest "github.com/Azure/go-autorest/autorest"
azure "github.com/Azure/go-autorest/autorest/azure"
gomock "github.com/golang/mock/gomock"
armclient "k8s.io/legacy-cloud-providers/azure/clients/armclient"
retry "k8s.io/legacy-cloud-providers/azure/retry"
http "net/http"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Send mocks base method
func (m *MockInterface) Send(ctx context.Context, request *http.Request) (*http.Response, *retry.Error) {
// CloseResponse mocks base method.
func (m *MockInterface) CloseResponse(ctx context.Context, response *http.Response) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Send", ctx, request)
m.ctrl.Call(m, "CloseResponse", ctx, response)
}
// CloseResponse indicates an expected call of CloseResponse.
func (mr *MockInterfaceMockRecorder) CloseResponse(ctx, response interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseResponse", reflect.TypeOf((*MockInterface)(nil).CloseResponse), ctx, response)
}
// DeleteResource mocks base method.
func (m *MockInterface) DeleteResource(ctx context.Context, resourceID, ifMatch string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteResource", ctx, resourceID, ifMatch)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// DeleteResource indicates an expected call of DeleteResource.
func (mr *MockInterfaceMockRecorder) DeleteResource(ctx, resourceID, ifMatch interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResource", reflect.TypeOf((*MockInterface)(nil).DeleteResource), ctx, resourceID, ifMatch)
}
// DeleteResourceAsync mocks base method.
func (m *MockInterface) DeleteResourceAsync(ctx context.Context, resourceID, ifMatch string) (*azure.Future, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteResourceAsync", ctx, resourceID, ifMatch)
ret0, _ := ret[0].(*azure.Future)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// DeleteResourceAsync indicates an expected call of DeleteResourceAsync.
func (mr *MockInterfaceMockRecorder) DeleteResourceAsync(ctx, resourceID, ifMatch interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourceAsync", reflect.TypeOf((*MockInterface)(nil).DeleteResourceAsync), ctx, resourceID, ifMatch)
}
// GetResource mocks base method.
func (m *MockInterface) GetResource(ctx context.Context, resourceID, expand string) (*http.Response, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetResource", ctx, resourceID, expand)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// Send indicates an expected call of Send
func (mr *MockInterfaceMockRecorder) Send(ctx, request interface{}) *gomock.Call {
// GetResource indicates an expected call of GetResource.
func (mr *MockInterfaceMockRecorder) GetResource(ctx, resourceID, expand interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockInterface)(nil).Send), ctx, request)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResource", reflect.TypeOf((*MockInterface)(nil).GetResource), ctx, resourceID, expand)
}
// PreparePutRequest mocks base method
func (m *MockInterface) PreparePutRequest(ctx context.Context, decorators ...autorest.PrepareDecorator) (*http.Request, error) {
// GetResourceWithDecorators mocks base method.
func (m *MockInterface) GetResourceWithDecorators(ctx context.Context, resourceID string, decorators []autorest.PrepareDecorator) (*http.Response, *retry.Error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx}
for _, a := range decorators {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "PreparePutRequest", varargs...)
ret0, _ := ret[0].(*http.Request)
ret1, _ := ret[1].(error)
ret := m.ctrl.Call(m, "GetResourceWithDecorators", ctx, resourceID, decorators)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// PreparePutRequest indicates an expected call of PreparePutRequest
func (mr *MockInterfaceMockRecorder) PreparePutRequest(ctx interface{}, decorators ...interface{}) *gomock.Call {
// GetResourceWithDecorators indicates an expected call of GetResourceWithDecorators.
func (mr *MockInterfaceMockRecorder) GetResourceWithDecorators(ctx, resourceID, decorators interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx}, decorators...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreparePutRequest", reflect.TypeOf((*MockInterface)(nil).PreparePutRequest), varargs...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceWithDecorators", reflect.TypeOf((*MockInterface)(nil).GetResourceWithDecorators), ctx, resourceID, decorators)
}
// PreparePostRequest mocks base method
func (m *MockInterface) PreparePostRequest(ctx context.Context, decorators ...autorest.PrepareDecorator) (*http.Request, error) {
// HeadResource mocks base method.
func (m *MockInterface) HeadResource(ctx context.Context, resourceID string) (*http.Response, *retry.Error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx}
for _, a := range decorators {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "PreparePostRequest", varargs...)
ret0, _ := ret[0].(*http.Request)
ret1, _ := ret[1].(error)
ret := m.ctrl.Call(m, "HeadResource", ctx, resourceID)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// PreparePostRequest indicates an expected call of PreparePostRequest
func (mr *MockInterfaceMockRecorder) PreparePostRequest(ctx interface{}, decorators ...interface{}) *gomock.Call {
// HeadResource indicates an expected call of HeadResource.
func (mr *MockInterfaceMockRecorder) HeadResource(ctx, resourceID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx}, decorators...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreparePostRequest", reflect.TypeOf((*MockInterface)(nil).PreparePostRequest), varargs...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadResource", reflect.TypeOf((*MockInterface)(nil).HeadResource), ctx, resourceID)
}
// PrepareGetRequest mocks base method
func (m *MockInterface) PrepareGetRequest(ctx context.Context, decorators ...autorest.PrepareDecorator) (*http.Request, error) {
// PatchResource mocks base method.
func (m *MockInterface) PatchResource(ctx context.Context, resourceID string, parameters interface{}) (*http.Response, *retry.Error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx}
for _, a := range decorators {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "PrepareGetRequest", varargs...)
ret0, _ := ret[0].(*http.Request)
ret1, _ := ret[1].(error)
ret := m.ctrl.Call(m, "PatchResource", ctx, resourceID, parameters)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// PrepareGetRequest indicates an expected call of PrepareGetRequest
func (mr *MockInterfaceMockRecorder) PrepareGetRequest(ctx interface{}, decorators ...interface{}) *gomock.Call {
// PatchResource indicates an expected call of PatchResource.
func (mr *MockInterfaceMockRecorder) PatchResource(ctx, resourceID, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx}, decorators...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareGetRequest", reflect.TypeOf((*MockInterface)(nil).PrepareGetRequest), varargs...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchResource", reflect.TypeOf((*MockInterface)(nil).PatchResource), ctx, resourceID, parameters)
}
// PrepareDeleteRequest mocks base method
// PostResource mocks base method.
func (m *MockInterface) PostResource(ctx context.Context, resourceID, action string, parameters interface{}) (*http.Response, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PostResource", ctx, resourceID, action, parameters)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// PostResource indicates an expected call of PostResource.
func (mr *MockInterfaceMockRecorder) PostResource(ctx, resourceID, action, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostResource", reflect.TypeOf((*MockInterface)(nil).PostResource), ctx, resourceID, action, parameters)
}
// PrepareDeleteRequest mocks base method.
func (m *MockInterface) PrepareDeleteRequest(ctx context.Context, decorators ...autorest.PrepareDecorator) (*http.Request, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx}
@ -145,14 +187,34 @@ func (m *MockInterface) PrepareDeleteRequest(ctx context.Context, decorators ...
return ret0, ret1
}
// PrepareDeleteRequest indicates an expected call of PrepareDeleteRequest
// PrepareDeleteRequest indicates an expected call of PrepareDeleteRequest.
func (mr *MockInterfaceMockRecorder) PrepareDeleteRequest(ctx interface{}, decorators ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx}, decorators...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareDeleteRequest", reflect.TypeOf((*MockInterface)(nil).PrepareDeleteRequest), varargs...)
}
// PrepareHeadRequest mocks base method
// PrepareGetRequest mocks base method.
func (m *MockInterface) PrepareGetRequest(ctx context.Context, decorators ...autorest.PrepareDecorator) (*http.Request, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx}
for _, a := range decorators {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "PrepareGetRequest", varargs...)
ret0, _ := ret[0].(*http.Request)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// PrepareGetRequest indicates an expected call of PrepareGetRequest.
func (mr *MockInterfaceMockRecorder) PrepareGetRequest(ctx interface{}, decorators ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx}, decorators...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareGetRequest", reflect.TypeOf((*MockInterface)(nil).PrepareGetRequest), varargs...)
}
// PrepareHeadRequest mocks base method.
func (m *MockInterface) PrepareHeadRequest(ctx context.Context, decorators ...autorest.PrepareDecorator) (*http.Request, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx}
@ -165,43 +227,128 @@ func (m *MockInterface) PrepareHeadRequest(ctx context.Context, decorators ...au
return ret0, ret1
}
// PrepareHeadRequest indicates an expected call of PrepareHeadRequest
// PrepareHeadRequest indicates an expected call of PrepareHeadRequest.
func (mr *MockInterfaceMockRecorder) PrepareHeadRequest(ctx interface{}, decorators ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx}, decorators...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareHeadRequest", reflect.TypeOf((*MockInterface)(nil).PrepareHeadRequest), varargs...)
}
// WaitForAsyncOperationCompletion mocks base method
func (m *MockInterface) WaitForAsyncOperationCompletion(ctx context.Context, future *azure.Future, asyncOperationName string) error {
// PreparePostRequest mocks base method.
func (m *MockInterface) PreparePostRequest(ctx context.Context, decorators ...autorest.PrepareDecorator) (*http.Request, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WaitForAsyncOperationCompletion", ctx, future, asyncOperationName)
ret0, _ := ret[0].(error)
return ret0
}
// WaitForAsyncOperationCompletion indicates an expected call of WaitForAsyncOperationCompletion
func (mr *MockInterfaceMockRecorder) WaitForAsyncOperationCompletion(ctx, future, asyncOperationName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForAsyncOperationCompletion", reflect.TypeOf((*MockInterface)(nil).WaitForAsyncOperationCompletion), ctx, future, asyncOperationName)
}
// WaitForAsyncOperationResult mocks base method
func (m *MockInterface) WaitForAsyncOperationResult(ctx context.Context, future *azure.Future, asyncOperationName string) (*http.Response, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WaitForAsyncOperationResult", ctx, future, asyncOperationName)
ret0, _ := ret[0].(*http.Response)
varargs := []interface{}{ctx}
for _, a := range decorators {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "PreparePostRequest", varargs...)
ret0, _ := ret[0].(*http.Request)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// WaitForAsyncOperationResult indicates an expected call of WaitForAsyncOperationResult
func (mr *MockInterfaceMockRecorder) WaitForAsyncOperationResult(ctx, future, asyncOperationName interface{}) *gomock.Call {
// PreparePostRequest indicates an expected call of PreparePostRequest.
func (mr *MockInterfaceMockRecorder) PreparePostRequest(ctx interface{}, decorators ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForAsyncOperationResult", reflect.TypeOf((*MockInterface)(nil).WaitForAsyncOperationResult), ctx, future, asyncOperationName)
varargs := append([]interface{}{ctx}, decorators...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreparePostRequest", reflect.TypeOf((*MockInterface)(nil).PreparePostRequest), varargs...)
}
// SendAsync mocks base method
// PreparePutRequest mocks base method.
func (m *MockInterface) PreparePutRequest(ctx context.Context, decorators ...autorest.PrepareDecorator) (*http.Request, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx}
for _, a := range decorators {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "PreparePutRequest", varargs...)
ret0, _ := ret[0].(*http.Request)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// PreparePutRequest indicates an expected call of PreparePutRequest.
func (mr *MockInterfaceMockRecorder) PreparePutRequest(ctx interface{}, decorators ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx}, decorators...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreparePutRequest", reflect.TypeOf((*MockInterface)(nil).PreparePutRequest), varargs...)
}
// PutResource mocks base method.
func (m *MockInterface) PutResource(ctx context.Context, resourceID string, parameters interface{}) (*http.Response, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PutResource", ctx, resourceID, parameters)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// PutResource indicates an expected call of PutResource.
func (mr *MockInterfaceMockRecorder) PutResource(ctx, resourceID, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResource", reflect.TypeOf((*MockInterface)(nil).PutResource), ctx, resourceID, parameters)
}
// PutResourceAsync mocks base method.
func (m *MockInterface) PutResourceAsync(ctx context.Context, resourceID string, parameters interface{}) (*azure.Future, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PutResourceAsync", ctx, resourceID, parameters)
ret0, _ := ret[0].(*azure.Future)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// PutResourceAsync indicates an expected call of PutResourceAsync.
func (mr *MockInterfaceMockRecorder) PutResourceAsync(ctx, resourceID, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourceAsync", reflect.TypeOf((*MockInterface)(nil).PutResourceAsync), ctx, resourceID, parameters)
}
// PutResourceWithDecorators mocks base method.
func (m *MockInterface) PutResourceWithDecorators(ctx context.Context, resourceID string, parameters interface{}, decorators []autorest.PrepareDecorator) (*http.Response, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PutResourceWithDecorators", ctx, resourceID, parameters, decorators)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// PutResourceWithDecorators indicates an expected call of PutResourceWithDecorators.
func (mr *MockInterfaceMockRecorder) PutResourceWithDecorators(ctx, resourceID, parameters, decorators interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourceWithDecorators", reflect.TypeOf((*MockInterface)(nil).PutResourceWithDecorators), ctx, resourceID, parameters, decorators)
}
// PutResources mocks base method.
func (m *MockInterface) PutResources(ctx context.Context, resources map[string]interface{}) map[string]*armclient.PutResourcesResponse {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PutResources", ctx, resources)
ret0, _ := ret[0].(map[string]*armclient.PutResourcesResponse)
return ret0
}
// PutResources indicates an expected call of PutResources.
func (mr *MockInterfaceMockRecorder) PutResources(ctx, resources interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResources", reflect.TypeOf((*MockInterface)(nil).PutResources), ctx, resources)
}
// Send mocks base method.
func (m *MockInterface) Send(ctx context.Context, request *http.Request) (*http.Response, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Send", ctx, request)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// Send indicates an expected call of Send.
func (mr *MockInterfaceMockRecorder) Send(ctx, request interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockInterface)(nil).Send), ctx, request)
}
// SendAsync mocks base method.
func (m *MockInterface) SendAsync(ctx context.Context, request *http.Request) (*azure.Future, *http.Response, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendAsync", ctx, request)
@ -211,183 +358,37 @@ func (m *MockInterface) SendAsync(ctx context.Context, request *http.Request) (*
return ret0, ret1, ret2
}
// SendAsync indicates an expected call of SendAsync
// SendAsync indicates an expected call of SendAsync.
func (mr *MockInterfaceMockRecorder) SendAsync(ctx, request interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAsync", reflect.TypeOf((*MockInterface)(nil).SendAsync), ctx, request)
}
// PutResource mocks base method
func (m *MockInterface) PutResource(ctx context.Context, resourceID string, parameters interface{}) (*http.Response, *retry.Error) {
// WaitForAsyncOperationCompletion mocks base method.
func (m *MockInterface) WaitForAsyncOperationCompletion(ctx context.Context, future *azure.Future, asyncOperationName string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PutResource", ctx, resourceID, parameters)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// PutResource indicates an expected call of PutResource
func (mr *MockInterfaceMockRecorder) PutResource(ctx, resourceID, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResource", reflect.TypeOf((*MockInterface)(nil).PutResource), ctx, resourceID, parameters)
}
// PutResources mocks base method
func (m *MockInterface) PutResources(ctx context.Context, resources map[string]interface{}) map[string]*armclient.PutResourcesResponse {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PutResources", ctx, resources)
ret0, _ := ret[0].(map[string]*armclient.PutResourcesResponse)
ret := m.ctrl.Call(m, "WaitForAsyncOperationCompletion", ctx, future, asyncOperationName)
ret0, _ := ret[0].(error)
return ret0
}
// PutResources indicates an expected call of PutResources
func (mr *MockInterfaceMockRecorder) PutResources(ctx, resources interface{}) *gomock.Call {
// WaitForAsyncOperationCompletion indicates an expected call of WaitForAsyncOperationCompletion.
func (mr *MockInterfaceMockRecorder) WaitForAsyncOperationCompletion(ctx, future, asyncOperationName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResources", reflect.TypeOf((*MockInterface)(nil).PutResources), ctx, resources)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForAsyncOperationCompletion", reflect.TypeOf((*MockInterface)(nil).WaitForAsyncOperationCompletion), ctx, future, asyncOperationName)
}
// PutResourceWithDecorators mocks base method
func (m *MockInterface) PutResourceWithDecorators(ctx context.Context, resourceID string, parameters interface{}, decorators []autorest.PrepareDecorator) (*http.Response, *retry.Error) {
// WaitForAsyncOperationResult mocks base method.
func (m *MockInterface) WaitForAsyncOperationResult(ctx context.Context, future *azure.Future, asyncOperationName string) (*http.Response, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PutResourceWithDecorators", ctx, resourceID, parameters, decorators)
ret := m.ctrl.Call(m, "WaitForAsyncOperationResult", ctx, future, asyncOperationName)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// PutResourceWithDecorators indicates an expected call of PutResourceWithDecorators
func (mr *MockInterfaceMockRecorder) PutResourceWithDecorators(ctx, resourceID, parameters, decorators interface{}) *gomock.Call {
// WaitForAsyncOperationResult indicates an expected call of WaitForAsyncOperationResult.
func (mr *MockInterfaceMockRecorder) WaitForAsyncOperationResult(ctx, future, asyncOperationName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourceWithDecorators", reflect.TypeOf((*MockInterface)(nil).PutResourceWithDecorators), ctx, resourceID, parameters, decorators)
}
// PatchResource mocks base method
func (m *MockInterface) PatchResource(ctx context.Context, resourceID string, parameters interface{}) (*http.Response, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PatchResource", ctx, resourceID, parameters)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// PatchResource indicates an expected call of PatchResource
func (mr *MockInterfaceMockRecorder) PatchResource(ctx, resourceID, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchResource", reflect.TypeOf((*MockInterface)(nil).PatchResource), ctx, resourceID, parameters)
}
// PutResourceAsync mocks base method
func (m *MockInterface) PutResourceAsync(ctx context.Context, resourceID string, parameters interface{}) (*azure.Future, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PutResourceAsync", ctx, resourceID, parameters)
ret0, _ := ret[0].(*azure.Future)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// PutResourceAsync indicates an expected call of PutResourceAsync
func (mr *MockInterfaceMockRecorder) PutResourceAsync(ctx, resourceID, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourceAsync", reflect.TypeOf((*MockInterface)(nil).PutResourceAsync), ctx, resourceID, parameters)
}
// HeadResource mocks base method
func (m *MockInterface) HeadResource(ctx context.Context, resourceID string) (*http.Response, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HeadResource", ctx, resourceID)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// HeadResource indicates an expected call of HeadResource
func (mr *MockInterfaceMockRecorder) HeadResource(ctx, resourceID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadResource", reflect.TypeOf((*MockInterface)(nil).HeadResource), ctx, resourceID)
}
// GetResource mocks base method
func (m *MockInterface) GetResource(ctx context.Context, resourceID, expand string) (*http.Response, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetResource", ctx, resourceID, expand)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// GetResource indicates an expected call of GetResource
func (mr *MockInterfaceMockRecorder) GetResource(ctx, resourceID, expand interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResource", reflect.TypeOf((*MockInterface)(nil).GetResource), ctx, resourceID, expand)
}
// GetResourceWithDecorators mocks base method
func (m *MockInterface) GetResourceWithDecorators(ctx context.Context, resourceID string, decorators []autorest.PrepareDecorator) (*http.Response, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetResourceWithDecorators", ctx, resourceID, decorators)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// GetResourceWithDecorators indicates an expected call of GetResourceWithDecorators
func (mr *MockInterfaceMockRecorder) GetResourceWithDecorators(ctx, resourceID, decorators interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceWithDecorators", reflect.TypeOf((*MockInterface)(nil).GetResourceWithDecorators), ctx, resourceID, decorators)
}
// PostResource mocks base method
func (m *MockInterface) PostResource(ctx context.Context, resourceID, action string, parameters interface{}) (*http.Response, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PostResource", ctx, resourceID, action, parameters)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// PostResource indicates an expected call of PostResource
func (mr *MockInterfaceMockRecorder) PostResource(ctx, resourceID, action, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostResource", reflect.TypeOf((*MockInterface)(nil).PostResource), ctx, resourceID, action, parameters)
}
// DeleteResource mocks base method
func (m *MockInterface) DeleteResource(ctx context.Context, resourceID, ifMatch string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteResource", ctx, resourceID, ifMatch)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// DeleteResource indicates an expected call of DeleteResource
func (mr *MockInterfaceMockRecorder) DeleteResource(ctx, resourceID, ifMatch interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResource", reflect.TypeOf((*MockInterface)(nil).DeleteResource), ctx, resourceID, ifMatch)
}
// DeleteResourceAsync mocks base method
func (m *MockInterface) DeleteResourceAsync(ctx context.Context, resourceID, ifMatch string) (*azure.Future, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteResourceAsync", ctx, resourceID, ifMatch)
ret0, _ := ret[0].(*azure.Future)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// DeleteResourceAsync indicates an expected call of DeleteResourceAsync
func (mr *MockInterfaceMockRecorder) DeleteResourceAsync(ctx, resourceID, ifMatch interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourceAsync", reflect.TypeOf((*MockInterface)(nil).DeleteResourceAsync), ctx, resourceID, ifMatch)
}
// CloseResponse mocks base method
func (m *MockInterface) CloseResponse(ctx context.Context, response *http.Response) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "CloseResponse", ctx, response)
}
// CloseResponse indicates an expected call of CloseResponse
func (mr *MockInterfaceMockRecorder) CloseResponse(ctx, response interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseResponse", reflect.TypeOf((*MockInterface)(nil).CloseResponse), ctx, response)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForAsyncOperationResult", reflect.TypeOf((*MockInterface)(nil).WaitForAsyncOperationResult), ctx, future, asyncOperationName)
}

27
staging/src/k8s.io/legacy-cloud-providers/azure/clients/containerserviceclient/mockcontainerserviceclient/interface.go
View File

@ -25,36 +25,37 @@ package mockcontainerserviceclient
import (
context "context"
reflect "reflect"
containerservice "github.com/Azure/azure-sdk-for-go/services/containerservice/mgmt/2020-04-01/containerservice"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// CreateOrUpdate mocks base method
// CreateOrUpdate mocks base method.
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, managedClusterName string, parameters containerservice.ManagedCluster, etag string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, managedClusterName, parameters, etag)
@ -62,13 +63,13 @@ func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, m
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate
// CreateOrUpdate indicates an expected call of CreateOrUpdate.
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, managedClusterName, parameters, etag interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, managedClusterName, parameters, etag)
}
// Delete mocks base method
// Delete mocks base method.
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, managedClusterName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, managedClusterName)
@ -76,13 +77,13 @@ func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, managedCl
return ret0
}
// Delete indicates an expected call of Delete
// Delete indicates an expected call of Delete.
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, managedClusterName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, managedClusterName)
}
// Get mocks base method
// Get mocks base method.
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, managedClusterName string) (containerservice.ManagedCluster, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, managedClusterName)
@ -91,13 +92,13 @@ func (m *MockInterface) Get(ctx context.Context, resourceGroupName, managedClust
return ret0, ret1
}
// Get indicates an expected call of Get
// Get indicates an expected call of Get.
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, managedClusterName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, managedClusterName)
}
// List mocks base method
// List mocks base method.
func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]containerservice.ManagedCluster, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "List", ctx, resourceGroupName)
@ -106,7 +107,7 @@ func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]c
return ret0, ret1
}
// List indicates an expected call of List
// List indicates an expected call of List.
func (mr *MockInterfaceMockRecorder) List(ctx, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInterface)(nil).List), ctx, resourceGroupName)

83
staging/src/k8s.io/legacy-cloud-providers/azure/clients/deploymentclient/mockdeploymentclient/interface.go
View File

@ -25,66 +25,65 @@ package mockdeploymentclient
import (
context "context"
reflect "reflect"
resources "github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2017-05-10/resources"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Get mocks base method
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, deploymentName string) (resources.DeploymentExtended, *retry.Error) {
// CreateOrUpdate mocks base method.
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, managedClusterName string, parameters resources.Deployment, etag string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, deploymentName)
ret0, _ := ret[0].(resources.DeploymentExtended)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, managedClusterName, parameters, etag)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Get indicates an expected call of Get
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, deploymentName interface{}) *gomock.Call {
// CreateOrUpdate indicates an expected call of CreateOrUpdate.
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, managedClusterName, parameters, etag interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, deploymentName)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, managedClusterName, parameters, etag)
}
// List mocks base method
func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]resources.DeploymentExtended, *retry.Error) {
// Delete mocks base method.
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, deploymentName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "List", ctx, resourceGroupName)
ret0, _ := ret[0].([]resources.DeploymentExtended)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, deploymentName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// List indicates an expected call of List
func (mr *MockInterfaceMockRecorder) List(ctx, resourceGroupName interface{}) *gomock.Call {
// Delete indicates an expected call of Delete.
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, deploymentName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInterface)(nil).List), ctx, resourceGroupName)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, deploymentName)
}
// ExportTemplate mocks base method
// ExportTemplate mocks base method.
func (m *MockInterface) ExportTemplate(ctx context.Context, resourceGroupName, deploymentName string) (resources.DeploymentExportResult, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ExportTemplate", ctx, resourceGroupName, deploymentName)
@ -93,36 +92,38 @@ func (m *MockInterface) ExportTemplate(ctx context.Context, resourceGroupName, d
return ret0, ret1
}
// ExportTemplate indicates an expected call of ExportTemplate
// ExportTemplate indicates an expected call of ExportTemplate.
func (mr *MockInterfaceMockRecorder) ExportTemplate(ctx, resourceGroupName, deploymentName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTemplate", reflect.TypeOf((*MockInterface)(nil).ExportTemplate), ctx, resourceGroupName, deploymentName)
}
// CreateOrUpdate mocks base method
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, managedClusterName string, parameters resources.Deployment, etag string) *retry.Error {
// Get mocks base method.
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, deploymentName string) (resources.DeploymentExtended, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, managedClusterName, parameters, etag)
ret0, _ := ret[0].(*retry.Error)
return ret0
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, deploymentName)
ret0, _ := ret[0].(resources.DeploymentExtended)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, managedClusterName, parameters, etag interface{}) *gomock.Call {
// Get indicates an expected call of Get.
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, deploymentName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, managedClusterName, parameters, etag)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, deploymentName)
}
// Delete mocks base method
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, deploymentName string) *retry.Error {
// List mocks base method.
func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]resources.DeploymentExtended, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, deploymentName)
ret0, _ := ret[0].(*retry.Error)
return ret0
ret := m.ctrl.Call(m, "List", ctx, resourceGroupName)
ret0, _ := ret[0].([]resources.DeploymentExtended)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// Delete indicates an expected call of Delete
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, deploymentName interface{}) *gomock.Call {
// List indicates an expected call of List.
func (mr *MockInterfaceMockRecorder) List(ctx, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, deploymentName)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInterface)(nil).List), ctx, resourceGroupName)
}

103
staging/src/k8s.io/legacy-cloud-providers/azure/clients/diskclient/mockdiskclient/interface.go
View File

@ -25,36 +25,65 @@ package mockdiskclient
import (
context "context"
reflect "reflect"
compute "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-12-01/compute"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Get mocks base method
// CreateOrUpdate mocks base method.
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, diskName string, diskParameter compute.Disk) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, diskName, diskParameter)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate.
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, diskName, diskParameter interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, diskName, diskParameter)
}
// Delete mocks base method.
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, diskName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, diskName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete.
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, diskName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, diskName)
}
// Get mocks base method.
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, diskName string) (compute.Disk, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, diskName)
@ -63,55 +92,13 @@ func (m *MockInterface) Get(ctx context.Context, resourceGroupName, diskName str
return ret0, ret1
}
// Get indicates an expected call of Get
// Get indicates an expected call of Get.
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, diskName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, diskName)
}
// CreateOrUpdate mocks base method
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, diskName string, diskParameter compute.Disk) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, diskName, diskParameter)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, diskName, diskParameter interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, diskName, diskParameter)
}
// Update mocks base method
func (m *MockInterface) Update(ctx context.Context, resourceGroupName, diskName string, diskParameter compute.DiskUpdate) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Update", ctx, resourceGroupName, diskName, diskParameter)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Update indicates an expected call of Update
func (mr *MockInterfaceMockRecorder) Update(ctx, resourceGroupName, diskName, diskParameter interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockInterface)(nil).Update), ctx, resourceGroupName, diskName, diskParameter)
}
// Delete mocks base method
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, diskName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, diskName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, diskName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, diskName)
}
// ListByResourceGroup mocks base method
// ListByResourceGroup mocks base method.
func (m *MockInterface) ListByResourceGroup(ctx context.Context, resourceGroupName string) ([]compute.Disk, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListByResourceGroup", ctx, resourceGroupName)
@ -120,8 +107,22 @@ func (m *MockInterface) ListByResourceGroup(ctx context.Context, resourceGroupNa
return ret0, ret1
}
// ListByResourceGroup indicates an expected call of ListByResourceGroup
// ListByResourceGroup indicates an expected call of ListByResourceGroup.
func (mr *MockInterfaceMockRecorder) ListByResourceGroup(ctx, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByResourceGroup", reflect.TypeOf((*MockInterface)(nil).ListByResourceGroup), ctx, resourceGroupName)
}
// Update mocks base method.
func (m *MockInterface) Update(ctx context.Context, resourceGroupName, diskName string, diskParameter compute.DiskUpdate) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Update", ctx, resourceGroupName, diskName, diskParameter)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Update indicates an expected call of Update.
func (mr *MockInterfaceMockRecorder) Update(ctx, resourceGroupName, diskName, diskParameter interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockInterface)(nil).Update), ctx, resourceGroupName, diskName, diskParameter)
}

75
staging/src/k8s.io/legacy-cloud-providers/azure/clients/interfaceclient/mockinterfaceclient/interface.go
View File

@ -25,36 +25,65 @@ package mockinterfaceclient
import (
context "context"
reflect "reflect"
network "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2019-06-01/network"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Get mocks base method
// CreateOrUpdate mocks base method.
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, networkInterfaceName string, parameters network.Interface) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, networkInterfaceName, parameters)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate.
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, networkInterfaceName, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, networkInterfaceName, parameters)
}
// Delete mocks base method.
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, networkInterfaceName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, networkInterfaceName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete.
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, networkInterfaceName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, networkInterfaceName)
}
// Get mocks base method.
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, networkInterfaceName, expand string) (network.Interface, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, networkInterfaceName, expand)
@ -63,13 +92,13 @@ func (m *MockInterface) Get(ctx context.Context, resourceGroupName, networkInter
return ret0, ret1
}
// Get indicates an expected call of Get
// Get indicates an expected call of Get.
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, networkInterfaceName, expand interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, networkInterfaceName, expand)
}
// GetVirtualMachineScaleSetNetworkInterface mocks base method
// GetVirtualMachineScaleSetNetworkInterface mocks base method.
func (m *MockInterface) GetVirtualMachineScaleSetNetworkInterface(ctx context.Context, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, expand string) (network.Interface, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetVirtualMachineScaleSetNetworkInterface", ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, expand)
@ -78,36 +107,8 @@ func (m *MockInterface) GetVirtualMachineScaleSetNetworkInterface(ctx context.Co
return ret0, ret1
}
// GetVirtualMachineScaleSetNetworkInterface indicates an expected call of GetVirtualMachineScaleSetNetworkInterface
// GetVirtualMachineScaleSetNetworkInterface indicates an expected call of GetVirtualMachineScaleSetNetworkInterface.
func (mr *MockInterfaceMockRecorder) GetVirtualMachineScaleSetNetworkInterface(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, expand interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineScaleSetNetworkInterface", reflect.TypeOf((*MockInterface)(nil).GetVirtualMachineScaleSetNetworkInterface), ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, expand)
}
// CreateOrUpdate mocks base method
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, networkInterfaceName string, parameters network.Interface) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, networkInterfaceName, parameters)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, networkInterfaceName, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, networkInterfaceName, parameters)
}
// Delete mocks base method
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, networkInterfaceName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, networkInterfaceName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, networkInterfaceName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, networkInterfaceName)
}

75
staging/src/k8s.io/legacy-cloud-providers/azure/clients/loadbalancerclient/mockloadbalancerclient/interface.go
View File

@ -25,36 +25,65 @@ package mockloadbalancerclient
import (
context "context"
reflect "reflect"
network "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2019-06-01/network"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Get mocks base method
// CreateOrUpdate mocks base method.
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, loadBalancerName string, parameters network.LoadBalancer, etag string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, loadBalancerName, parameters, etag)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate.
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, loadBalancerName, parameters, etag interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, loadBalancerName, parameters, etag)
}
// Delete mocks base method.
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, loadBalancerName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, loadBalancerName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete.
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, loadBalancerName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, loadBalancerName)
}
// Get mocks base method.
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, loadBalancerName, expand string) (network.LoadBalancer, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, loadBalancerName, expand)
@ -63,13 +92,13 @@ func (m *MockInterface) Get(ctx context.Context, resourceGroupName, loadBalancer
return ret0, ret1
}
// Get indicates an expected call of Get
// Get indicates an expected call of Get.
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, loadBalancerName, expand interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, loadBalancerName, expand)
}
// List mocks base method
// List mocks base method.
func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]network.LoadBalancer, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "List", ctx, resourceGroupName)
@ -78,36 +107,8 @@ func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]n
return ret0, ret1
}
// List indicates an expected call of List
// List indicates an expected call of List.
func (mr *MockInterfaceMockRecorder) List(ctx, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInterface)(nil).List), ctx, resourceGroupName)
}
// CreateOrUpdate mocks base method
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, loadBalancerName string, parameters network.LoadBalancer, etag string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, loadBalancerName, parameters, etag)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, loadBalancerName, parameters, etag interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, loadBalancerName, parameters, etag)
}
// Delete mocks base method
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, loadBalancerName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, loadBalancerName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, loadBalancerName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, loadBalancerName)
}

79
staging/src/k8s.io/legacy-cloud-providers/azure/clients/publicipclient/mockpublicipclient/interface.go
View File

@ -25,36 +25,65 @@ package mockpublicipclient
import (
context "context"
reflect "reflect"
network "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2019-06-01/network"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Get mocks base method
// CreateOrUpdate mocks base method.
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, publicIPAddressName string, parameters network.PublicIPAddress) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, publicIPAddressName, parameters)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate.
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, publicIPAddressName, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, publicIPAddressName, parameters)
}
// Delete mocks base method.
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, publicIPAddressName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, publicIPAddressName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete.
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, publicIPAddressName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, publicIPAddressName)
}
// Get mocks base method.
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, publicIPAddressName, expand string) (network.PublicIPAddress, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, publicIPAddressName, expand)
@ -63,13 +92,13 @@ func (m *MockInterface) Get(ctx context.Context, resourceGroupName, publicIPAddr
return ret0, ret1
}
// Get indicates an expected call of Get
// Get indicates an expected call of Get.
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, publicIPAddressName, expand interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, publicIPAddressName, expand)
}
// GetVirtualMachineScaleSetPublicIPAddress mocks base method
// GetVirtualMachineScaleSetPublicIPAddress mocks base method.
func (m *MockInterface) GetVirtualMachineScaleSetPublicIPAddress(ctx context.Context, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, IPConfigurationName, publicIPAddressName, expand string) (network.PublicIPAddress, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetVirtualMachineScaleSetPublicIPAddress", ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, IPConfigurationName, publicIPAddressName, expand)
@ -78,13 +107,13 @@ func (m *MockInterface) GetVirtualMachineScaleSetPublicIPAddress(ctx context.Con
return ret0, ret1
}
// GetVirtualMachineScaleSetPublicIPAddress indicates an expected call of GetVirtualMachineScaleSetPublicIPAddress
// GetVirtualMachineScaleSetPublicIPAddress indicates an expected call of GetVirtualMachineScaleSetPublicIPAddress.
func (mr *MockInterfaceMockRecorder) GetVirtualMachineScaleSetPublicIPAddress(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, IPConfigurationName, publicIPAddressName, expand interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineScaleSetPublicIPAddress", reflect.TypeOf((*MockInterface)(nil).GetVirtualMachineScaleSetPublicIPAddress), ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, IPConfigurationName, publicIPAddressName, expand)
}
// List mocks base method
// List mocks base method.
func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]network.PublicIPAddress, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "List", ctx, resourceGroupName)
@ -93,36 +122,8 @@ func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]n
return ret0, ret1
}
// List indicates an expected call of List
// List indicates an expected call of List.
func (mr *MockInterfaceMockRecorder) List(ctx, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInterface)(nil).List), ctx, resourceGroupName)
}
// CreateOrUpdate mocks base method
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, publicIPAddressName string, parameters network.PublicIPAddress) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, publicIPAddressName, parameters)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, publicIPAddressName, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, publicIPAddressName, parameters)
}
// Delete mocks base method
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, publicIPAddressName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, publicIPAddressName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, publicIPAddressName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, publicIPAddressName)
}

19
staging/src/k8s.io/legacy-cloud-providers/azure/clients/routeclient/mockrouteclient/interface.go
View File

@ -25,36 +25,37 @@ package mockrouteclient
import (
context "context"
reflect "reflect"
network "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2019-06-01/network"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// CreateOrUpdate mocks base method
// CreateOrUpdate mocks base method.
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, routeTableName, routeName string, routeParameters network.Route, etag string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, routeTableName, routeName, routeParameters, etag)
@ -62,13 +63,13 @@ func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, r
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate
// CreateOrUpdate indicates an expected call of CreateOrUpdate.
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, routeTableName, routeName, routeParameters, etag interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, routeTableName, routeName, routeParameters, etag)
}
// Delete mocks base method
// Delete mocks base method.
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, routeTableName, routeName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, routeTableName, routeName)
@ -76,7 +77,7 @@ func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, routeTabl
return ret0
}
// Delete indicates an expected call of Delete
// Delete indicates an expected call of Delete.
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, routeTableName, routeName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, routeTableName, routeName)

43
staging/src/k8s.io/legacy-cloud-providers/azure/clients/routetableclient/mockroutetableclient/interface.go
View File

@ -25,36 +25,51 @@ package mockroutetableclient
import (
context "context"
reflect "reflect"
network "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2019-06-01/network"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Get mocks base method
// CreateOrUpdate mocks base method.
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, routeTableName string, parameters network.RouteTable, etag string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, routeTableName, parameters, etag)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate.
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, routeTableName, parameters, etag interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, routeTableName, parameters, etag)
}
// Get mocks base method.
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, routeTableName, expand string) (network.RouteTable, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, routeTableName, expand)
@ -63,22 +78,8 @@ func (m *MockInterface) Get(ctx context.Context, resourceGroupName, routeTableNa
return ret0, ret1
}
// Get indicates an expected call of Get
// Get indicates an expected call of Get.
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, routeTableName, expand interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, routeTableName, expand)
}
// CreateOrUpdate mocks base method
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, routeTableName string, parameters network.RouteTable, etag string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, routeTableName, parameters, etag)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, routeTableName, parameters, etag interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, routeTableName, parameters, etag)
}

75
staging/src/k8s.io/legacy-cloud-providers/azure/clients/securitygroupclient/mocksecuritygroupclient/interface.go
View File

@ -25,36 +25,65 @@ package mocksecuritygroupclient
import (
context "context"
reflect "reflect"
network "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2019-06-01/network"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Get mocks base method
// CreateOrUpdate mocks base method.
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, networkSecurityGroupName string, parameters network.SecurityGroup, etag string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, networkSecurityGroupName, parameters, etag)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate.
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, networkSecurityGroupName, parameters, etag interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, networkSecurityGroupName, parameters, etag)
}
// Delete mocks base method.
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, networkSecurityGroupName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, networkSecurityGroupName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete.
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, networkSecurityGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, networkSecurityGroupName)
}
// Get mocks base method.
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, networkSecurityGroupName, expand string) (network.SecurityGroup, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, networkSecurityGroupName, expand)
@ -63,13 +92,13 @@ func (m *MockInterface) Get(ctx context.Context, resourceGroupName, networkSecur
return ret0, ret1
}
// Get indicates an expected call of Get
// Get indicates an expected call of Get.
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, networkSecurityGroupName, expand interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, networkSecurityGroupName, expand)
}
// List mocks base method
// List mocks base method.
func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]network.SecurityGroup, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "List", ctx, resourceGroupName)
@ -78,36 +107,8 @@ func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]n
return ret0, ret1
}
// List indicates an expected call of List
// List indicates an expected call of List.
func (mr *MockInterfaceMockRecorder) List(ctx, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInterface)(nil).List), ctx, resourceGroupName)
}
// CreateOrUpdate mocks base method
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, networkSecurityGroupName string, parameters network.SecurityGroup, etag string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, networkSecurityGroupName, parameters, etag)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, networkSecurityGroupName, parameters, etag interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, networkSecurityGroupName, parameters, etag)
}
// Delete mocks base method
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, networkSecurityGroupName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, networkSecurityGroupName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, networkSecurityGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, networkSecurityGroupName)
}

75
staging/src/k8s.io/legacy-cloud-providers/azure/clients/snapshotclient/mocksnapshotclient/interface.go
View File

@ -25,36 +25,65 @@ package mocksnapshotclient
import (
context "context"
reflect "reflect"
compute "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-12-01/compute"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Get mocks base method
// CreateOrUpdate mocks base method.
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, snapshotName string, snapshot compute.Snapshot) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, snapshotName, snapshot)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate.
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, snapshotName, snapshot interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, snapshotName, snapshot)
}
// Delete mocks base method.
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, snapshotName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, snapshotName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete.
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, snapshotName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, snapshotName)
}
// Get mocks base method.
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, snapshotName string) (compute.Snapshot, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, snapshotName)
@ -63,27 +92,13 @@ func (m *MockInterface) Get(ctx context.Context, resourceGroupName, snapshotName
return ret0, ret1
}
// Get indicates an expected call of Get
// Get indicates an expected call of Get.
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, snapshotName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, snapshotName)
}
// Delete mocks base method
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, snapshotName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, snapshotName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, snapshotName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, snapshotName)
}
// ListByResourceGroup mocks base method
// ListByResourceGroup mocks base method.
func (m *MockInterface) ListByResourceGroup(ctx context.Context, resourceGroupName string) ([]compute.Snapshot, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListByResourceGroup", ctx, resourceGroupName)
@ -92,22 +107,8 @@ func (m *MockInterface) ListByResourceGroup(ctx context.Context, resourceGroupNa
return ret0, ret1
}
// ListByResourceGroup indicates an expected call of ListByResourceGroup
// ListByResourceGroup indicates an expected call of ListByResourceGroup.
func (mr *MockInterfaceMockRecorder) ListByResourceGroup(ctx, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByResourceGroup", reflect.TypeOf((*MockInterface)(nil).ListByResourceGroup), ctx, resourceGroupName)
}
// CreateOrUpdate mocks base method
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, snapshotName string, snapshot compute.Snapshot) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, snapshotName, snapshot)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, snapshotName, snapshot interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, snapshotName, snapshot)
}

83
staging/src/k8s.io/legacy-cloud-providers/azure/clients/storageaccountclient/mockstorageaccountclient/interface.go
View File

@ -25,36 +25,37 @@ package mockstorageaccountclient
import (
context "context"
reflect "reflect"
storage "github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2019-06-01/storage"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Create mocks base method
// Create mocks base method.
func (m *MockInterface) Create(ctx context.Context, resourceGroupName, accountName string, parameters storage.AccountCreateParameters) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Create", ctx, resourceGroupName, accountName, parameters)
@ -62,13 +63,13 @@ func (m *MockInterface) Create(ctx context.Context, resourceGroupName, accountNa
return ret0
}
// Create indicates an expected call of Create
// Create indicates an expected call of Create.
func (mr *MockInterfaceMockRecorder) Create(ctx, resourceGroupName, accountName, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockInterface)(nil).Create), ctx, resourceGroupName, accountName, parameters)
}
// Delete mocks base method
// Delete mocks base method.
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, accountName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, accountName)
@ -76,43 +77,13 @@ func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, accountNa
return ret0
}
// Delete indicates an expected call of Delete
// Delete indicates an expected call of Delete.
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, accountName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, accountName)
}
// ListKeys mocks base method
func (m *MockInterface) ListKeys(ctx context.Context, resourceGroupName, accountName string) (storage.AccountListKeysResult, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListKeys", ctx, resourceGroupName, accountName)
ret0, _ := ret[0].(storage.AccountListKeysResult)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// ListKeys indicates an expected call of ListKeys
func (mr *MockInterfaceMockRecorder) ListKeys(ctx, resourceGroupName, accountName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeys", reflect.TypeOf((*MockInterface)(nil).ListKeys), ctx, resourceGroupName, accountName)
}
// ListByResourceGroup mocks base method
func (m *MockInterface) ListByResourceGroup(ctx context.Context, resourceGroupName string) ([]storage.Account, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListByResourceGroup", ctx, resourceGroupName)
ret0, _ := ret[0].([]storage.Account)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// ListByResourceGroup indicates an expected call of ListByResourceGroup
func (mr *MockInterfaceMockRecorder) ListByResourceGroup(ctx, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByResourceGroup", reflect.TypeOf((*MockInterface)(nil).ListByResourceGroup), ctx, resourceGroupName)
}
// GetProperties mocks base method
// GetProperties mocks base method.
func (m *MockInterface) GetProperties(ctx context.Context, resourceGroupName, accountName string) (storage.Account, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetProperties", ctx, resourceGroupName, accountName)
@ -121,8 +92,38 @@ func (m *MockInterface) GetProperties(ctx context.Context, resourceGroupName, ac
return ret0, ret1
}
// GetProperties indicates an expected call of GetProperties
// GetProperties indicates an expected call of GetProperties.
func (mr *MockInterfaceMockRecorder) GetProperties(ctx, resourceGroupName, accountName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProperties", reflect.TypeOf((*MockInterface)(nil).GetProperties), ctx, resourceGroupName, accountName)
}
// ListByResourceGroup mocks base method.
func (m *MockInterface) ListByResourceGroup(ctx context.Context, resourceGroupName string) ([]storage.Account, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListByResourceGroup", ctx, resourceGroupName)
ret0, _ := ret[0].([]storage.Account)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// ListByResourceGroup indicates an expected call of ListByResourceGroup.
func (mr *MockInterfaceMockRecorder) ListByResourceGroup(ctx, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByResourceGroup", reflect.TypeOf((*MockInterface)(nil).ListByResourceGroup), ctx, resourceGroupName)
}
// ListKeys mocks base method.
func (m *MockInterface) ListKeys(ctx context.Context, resourceGroupName, accountName string) (storage.AccountListKeysResult, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListKeys", ctx, resourceGroupName, accountName)
ret0, _ := ret[0].(storage.AccountListKeysResult)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// ListKeys indicates an expected call of ListKeys.
func (mr *MockInterfaceMockRecorder) ListKeys(ctx, resourceGroupName, accountName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeys", reflect.TypeOf((*MockInterface)(nil).ListKeys), ctx, resourceGroupName, accountName)
}

75
staging/src/k8s.io/legacy-cloud-providers/azure/clients/subnetclient/mocksubnetclient/interface.go
View File

@ -25,36 +25,65 @@ package mocksubnetclient
import (
context "context"
reflect "reflect"
network "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2019-06-01/network"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Get mocks base method
// CreateOrUpdate mocks base method.
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, virtualNetworkName, subnetName string, subnetParameters network.Subnet) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, virtualNetworkName, subnetName, subnetParameters)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate.
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, virtualNetworkName, subnetName, subnetParameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, virtualNetworkName, subnetName, subnetParameters)
}
// Delete mocks base method.
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, virtualNetworkName, subnetName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, virtualNetworkName, subnetName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete.
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, virtualNetworkName, subnetName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, virtualNetworkName, subnetName)
}
// Get mocks base method.
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, virtualNetworkName, subnetName, expand string) (network.Subnet, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, virtualNetworkName, subnetName, expand)
@ -63,13 +92,13 @@ func (m *MockInterface) Get(ctx context.Context, resourceGroupName, virtualNetwo
return ret0, ret1
}
// Get indicates an expected call of Get
// Get indicates an expected call of Get.
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, virtualNetworkName, subnetName, expand interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, virtualNetworkName, subnetName, expand)
}
// List mocks base method
// List mocks base method.
func (m *MockInterface) List(ctx context.Context, resourceGroupName, virtualNetworkName string) ([]network.Subnet, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "List", ctx, resourceGroupName, virtualNetworkName)
@ -78,36 +107,8 @@ func (m *MockInterface) List(ctx context.Context, resourceGroupName, virtualNetw
return ret0, ret1
}
// List indicates an expected call of List
// List indicates an expected call of List.
func (mr *MockInterfaceMockRecorder) List(ctx, resourceGroupName, virtualNetworkName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInterface)(nil).List), ctx, resourceGroupName, virtualNetworkName)
}
// CreateOrUpdate mocks base method
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, virtualNetworkName, subnetName string, subnetParameters network.Subnet) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, virtualNetworkName, subnetName, subnetParameters)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, virtualNetworkName, subnetName, subnetParameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, virtualNetworkName, subnetName, subnetParameters)
}
// Delete mocks base method
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, virtualNetworkName, subnetName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, virtualNetworkName, subnetName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, virtualNetworkName, subnetName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, virtualNetworkName, subnetName)
}

79
staging/src/k8s.io/legacy-cloud-providers/azure/clients/vmclient/mockvmclient/interface.go
View File

@ -25,36 +25,65 @@ package mockvmclient
import (
context "context"
reflect "reflect"
compute "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-12-01/compute"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Get mocks base method
// CreateOrUpdate mocks base method.
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, VMName string, parameters compute.VirtualMachine, source string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, VMName, parameters, source)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate.
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, VMName, parameters, source interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, VMName, parameters, source)
}
// Delete mocks base method.
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, VMName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, VMName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete.
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, VMName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, VMName)
}
// Get mocks base method.
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, VMName string, expand compute.InstanceViewTypes) (compute.VirtualMachine, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, VMName, expand)
@ -63,13 +92,13 @@ func (m *MockInterface) Get(ctx context.Context, resourceGroupName, VMName strin
return ret0, ret1
}
// Get indicates an expected call of Get
// Get indicates an expected call of Get.
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, VMName, expand interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, VMName, expand)
}
// List mocks base method
// List mocks base method.
func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]compute.VirtualMachine, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "List", ctx, resourceGroupName)
@ -78,27 +107,13 @@ func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]c
return ret0, ret1
}
// List indicates an expected call of List
// List indicates an expected call of List.
func (mr *MockInterfaceMockRecorder) List(ctx, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInterface)(nil).List), ctx, resourceGroupName)
}
// CreateOrUpdate mocks base method
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, VMName string, parameters compute.VirtualMachine, source string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, VMName, parameters, source)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, VMName, parameters, source interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, VMName, parameters, source)
}
// Update mocks base method
// Update mocks base method.
func (m *MockInterface) Update(ctx context.Context, resourceGroupName, VMName string, parameters compute.VirtualMachineUpdate, source string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Update", ctx, resourceGroupName, VMName, parameters, source)
@ -106,22 +121,8 @@ func (m *MockInterface) Update(ctx context.Context, resourceGroupName, VMName st
return ret0
}
// Update indicates an expected call of Update
// Update indicates an expected call of Update.
func (mr *MockInterfaceMockRecorder) Update(ctx, resourceGroupName, VMName, parameters, source interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockInterface)(nil).Update), ctx, resourceGroupName, VMName, parameters, source)
}
// Delete mocks base method
func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, VMName string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, VMName)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// Delete indicates an expected call of Delete
func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, VMName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInterface)(nil).Delete), ctx, resourceGroupName, VMName)
}

15
staging/src/k8s.io/legacy-cloud-providers/azure/clients/vmsizeclient/mockvmsizeclient/interface.go
View File

@ -25,36 +25,37 @@ package mockvmsizeclient
import (
context "context"
reflect "reflect"
compute "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-12-01/compute"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// List mocks base method
// List mocks base method.
func (m *MockInterface) List(ctx context.Context, location string) (compute.VirtualMachineSizeListResult, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "List", ctx, location)
@ -63,7 +64,7 @@ func (m *MockInterface) List(ctx context.Context, location string) (compute.Virt
return ret0, ret1
}
// List indicates an expected call of List
// List indicates an expected call of List.
func (mr *MockInterfaceMockRecorder) List(ctx, location interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInterface)(nil).List), ctx, location)

257
staging/src/k8s.io/legacy-cloud-providers/azure/clients/vmssclient/mockvmssclient/interface.go
View File

@ -25,68 +25,39 @@ package mockvmssclient
import (
context "context"
http "net/http"
reflect "reflect"
compute "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-12-01/compute"
azure "github.com/Azure/go-autorest/autorest/azure"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
http "net/http"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Get mocks base method
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, VMScaleSetName string) (compute.VirtualMachineScaleSet, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, VMScaleSetName)
ret0, _ := ret[0].(compute.VirtualMachineScaleSet)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// Get indicates an expected call of Get
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, VMScaleSetName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, VMScaleSetName)
}
// List mocks base method
func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]compute.VirtualMachineScaleSet, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "List", ctx, resourceGroupName)
ret0, _ := ret[0].([]compute.VirtualMachineScaleSet)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// List indicates an expected call of List
func (mr *MockInterfaceMockRecorder) List(ctx, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInterface)(nil).List), ctx, resourceGroupName)
}
// CreateOrUpdate mocks base method
// CreateOrUpdate mocks base method.
func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, VMScaleSetName string, parameters compute.VirtualMachineScaleSet) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, VMScaleSetName, parameters)
@ -94,13 +65,13 @@ func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, V
return ret0
}
// CreateOrUpdate indicates an expected call of CreateOrUpdate
// CreateOrUpdate indicates an expected call of CreateOrUpdate.
func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, VMScaleSetName, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdate), ctx, resourceGroupName, VMScaleSetName, parameters)
}
// CreateOrUpdateAsync mocks base method
// CreateOrUpdateAsync mocks base method.
func (m *MockInterface) CreateOrUpdateAsync(ctx context.Context, resourceGroupName, VMScaleSetName string, parameters compute.VirtualMachineScaleSet) (*azure.Future, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateOrUpdateAsync", ctx, resourceGroupName, VMScaleSetName, parameters)
@ -109,87 +80,13 @@ func (m *MockInterface) CreateOrUpdateAsync(ctx context.Context, resourceGroupNa
return ret0, ret1
}
// CreateOrUpdateAsync indicates an expected call of CreateOrUpdateAsync
// CreateOrUpdateAsync indicates an expected call of CreateOrUpdateAsync.
func (mr *MockInterfaceMockRecorder) CreateOrUpdateAsync(ctx, resourceGroupName, VMScaleSetName, parameters interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateAsync", reflect.TypeOf((*MockInterface)(nil).CreateOrUpdateAsync), ctx, resourceGroupName, VMScaleSetName, parameters)
}
// WaitForAsyncOperationResult mocks base method
func (m *MockInterface) WaitForAsyncOperationResult(ctx context.Context, future *azure.Future) (*http.Response, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WaitForAsyncOperationResult", ctx, future)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// WaitForAsyncOperationResult indicates an expected call of WaitForAsyncOperationResult
func (mr *MockInterfaceMockRecorder) WaitForAsyncOperationResult(ctx, future interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForAsyncOperationResult", reflect.TypeOf((*MockInterface)(nil).WaitForAsyncOperationResult), ctx, future)
}
// DeleteInstances mocks base method
func (m *MockInterface) DeleteInstances(ctx context.Context, resourceGroupName, vmScaleSetName string, vmInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteInstances", ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// DeleteInstances indicates an expected call of DeleteInstances
func (mr *MockInterfaceMockRecorder) DeleteInstances(ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstances", reflect.TypeOf((*MockInterface)(nil).DeleteInstances), ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs)
}
// DeleteInstancesAsync mocks base method
func (m *MockInterface) DeleteInstancesAsync(ctx context.Context, resourceGroupName, vmScaleSetName string, vmInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs) (*azure.Future, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteInstancesAsync", ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs)
ret0, _ := ret[0].(*azure.Future)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// DeleteInstancesAsync indicates an expected call of DeleteInstancesAsync
func (mr *MockInterfaceMockRecorder) DeleteInstancesAsync(ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstancesAsync", reflect.TypeOf((*MockInterface)(nil).DeleteInstancesAsync), ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs)
}
// WaitForCreateOrUpdateResult mocks base method
func (m *MockInterface) WaitForCreateOrUpdateResult(ctx context.Context, future *azure.Future, resourceGroupName string) (*http.Response, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WaitForCreateOrUpdateResult", ctx, future, resourceGroupName)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// WaitForCreateOrUpdateResult indicates an expected call of WaitForCreateOrUpdateResult
func (mr *MockInterfaceMockRecorder) WaitForCreateOrUpdateResult(ctx, future, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForCreateOrUpdateResult", reflect.TypeOf((*MockInterface)(nil).WaitForCreateOrUpdateResult), ctx, future, resourceGroupName)
}
// WaitForDeleteInstancesResult mocks base method
func (m *MockInterface) WaitForDeleteInstancesResult(ctx context.Context, future *azure.Future, resourceGroupName string) (*http.Response, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WaitForDeleteInstancesResult", ctx, future, resourceGroupName)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// WaitForDeleteInstancesResult indicates an expected call of WaitForDeleteInstancesResult
func (mr *MockInterfaceMockRecorder) WaitForDeleteInstancesResult(ctx, future, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForDeleteInstancesResult", reflect.TypeOf((*MockInterface)(nil).WaitForDeleteInstancesResult), ctx, future, resourceGroupName)
}
// DeallocateInstancesAsync mocks base method
// DeallocateInstancesAsync mocks base method.
func (m *MockInterface) DeallocateInstancesAsync(ctx context.Context, resourceGroupName, vmScaleSetName string, vmInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs) (*azure.Future, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeallocateInstancesAsync", ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs)
@ -198,28 +95,72 @@ func (m *MockInterface) DeallocateInstancesAsync(ctx context.Context, resourceGr
return ret0, ret1
}
// DeallocateInstancesAsync indicates an expected call of DeallocateInstancesAsync
// DeallocateInstancesAsync indicates an expected call of DeallocateInstancesAsync.
func (mr *MockInterfaceMockRecorder) DeallocateInstancesAsync(ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeallocateInstancesAsync", reflect.TypeOf((*MockInterface)(nil).DeallocateInstancesAsync), ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs)
}
// WaitForDeallocateInstancesResult mocks base method
func (m *MockInterface) WaitForDeallocateInstancesResult(ctx context.Context, future *azure.Future, resourceGroupName string) (*http.Response, error) {
// DeleteInstances mocks base method.
func (m *MockInterface) DeleteInstances(ctx context.Context, resourceGroupName, vmScaleSetName string, vmInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WaitForDeallocateInstancesResult", ctx, future, resourceGroupName)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(error)
ret := m.ctrl.Call(m, "DeleteInstances", ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs)
ret0, _ := ret[0].(*retry.Error)
return ret0
}
// DeleteInstances indicates an expected call of DeleteInstances.
func (mr *MockInterfaceMockRecorder) DeleteInstances(ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstances", reflect.TypeOf((*MockInterface)(nil).DeleteInstances), ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs)
}
// DeleteInstancesAsync mocks base method.
func (m *MockInterface) DeleteInstancesAsync(ctx context.Context, resourceGroupName, vmScaleSetName string, vmInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs) (*azure.Future, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteInstancesAsync", ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs)
ret0, _ := ret[0].(*azure.Future)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// WaitForDeallocateInstancesResult indicates an expected call of WaitForDeallocateInstancesResult
func (mr *MockInterfaceMockRecorder) WaitForDeallocateInstancesResult(ctx, future, resourceGroupName interface{}) *gomock.Call {
// DeleteInstancesAsync indicates an expected call of DeleteInstancesAsync.
func (mr *MockInterfaceMockRecorder) DeleteInstancesAsync(ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForDeallocateInstancesResult", reflect.TypeOf((*MockInterface)(nil).WaitForDeallocateInstancesResult), ctx, future, resourceGroupName)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstancesAsync", reflect.TypeOf((*MockInterface)(nil).DeleteInstancesAsync), ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs)
}
// StartInstancesAsync mocks base method
// Get mocks base method.
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, VMScaleSetName string) (compute.VirtualMachineScaleSet, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, VMScaleSetName)
ret0, _ := ret[0].(compute.VirtualMachineScaleSet)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// Get indicates an expected call of Get.
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, VMScaleSetName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, VMScaleSetName)
}
// List mocks base method.
func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]compute.VirtualMachineScaleSet, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "List", ctx, resourceGroupName)
ret0, _ := ret[0].([]compute.VirtualMachineScaleSet)
ret1, _ := ret[1].(*retry.Error)
return ret0, ret1
}
// List indicates an expected call of List.
func (mr *MockInterfaceMockRecorder) List(ctx, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInterface)(nil).List), ctx, resourceGroupName)
}
// StartInstancesAsync mocks base method.
func (m *MockInterface) StartInstancesAsync(ctx context.Context, resourceGroupName, vmScaleSetName string, vmInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs) (*azure.Future, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StartInstancesAsync", ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs)
@ -228,13 +169,73 @@ func (m *MockInterface) StartInstancesAsync(ctx context.Context, resourceGroupNa
return ret0, ret1
}
// StartInstancesAsync indicates an expected call of StartInstancesAsync
// StartInstancesAsync indicates an expected call of StartInstancesAsync.
func (mr *MockInterfaceMockRecorder) StartInstancesAsync(ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstancesAsync", reflect.TypeOf((*MockInterface)(nil).StartInstancesAsync), ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs)
}
// WaitForStartInstancesResult mocks base method
// WaitForAsyncOperationResult mocks base method.
func (m *MockInterface) WaitForAsyncOperationResult(ctx context.Context, future *azure.Future) (*http.Response, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WaitForAsyncOperationResult", ctx, future)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// WaitForAsyncOperationResult indicates an expected call of WaitForAsyncOperationResult.
func (mr *MockInterfaceMockRecorder) WaitForAsyncOperationResult(ctx, future interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForAsyncOperationResult", reflect.TypeOf((*MockInterface)(nil).WaitForAsyncOperationResult), ctx, future)
}
// WaitForCreateOrUpdateResult mocks base method.
func (m *MockInterface) WaitForCreateOrUpdateResult(ctx context.Context, future *azure.Future, resourceGroupName string) (*http.Response, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WaitForCreateOrUpdateResult", ctx, future, resourceGroupName)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// WaitForCreateOrUpdateResult indicates an expected call of WaitForCreateOrUpdateResult.
func (mr *MockInterfaceMockRecorder) WaitForCreateOrUpdateResult(ctx, future, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForCreateOrUpdateResult", reflect.TypeOf((*MockInterface)(nil).WaitForCreateOrUpdateResult), ctx, future, resourceGroupName)
}
// WaitForDeallocateInstancesResult mocks base method.
func (m *MockInterface) WaitForDeallocateInstancesResult(ctx context.Context, future *azure.Future, resourceGroupName string) (*http.Response, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WaitForDeallocateInstancesResult", ctx, future, resourceGroupName)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// WaitForDeallocateInstancesResult indicates an expected call of WaitForDeallocateInstancesResult.
func (mr *MockInterfaceMockRecorder) WaitForDeallocateInstancesResult(ctx, future, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForDeallocateInstancesResult", reflect.TypeOf((*MockInterface)(nil).WaitForDeallocateInstancesResult), ctx, future, resourceGroupName)
}
// WaitForDeleteInstancesResult mocks base method.
func (m *MockInterface) WaitForDeleteInstancesResult(ctx context.Context, future *azure.Future, resourceGroupName string) (*http.Response, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WaitForDeleteInstancesResult", ctx, future, resourceGroupName)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// WaitForDeleteInstancesResult indicates an expected call of WaitForDeleteInstancesResult.
func (mr *MockInterfaceMockRecorder) WaitForDeleteInstancesResult(ctx, future, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForDeleteInstancesResult", reflect.TypeOf((*MockInterface)(nil).WaitForDeleteInstancesResult), ctx, future, resourceGroupName)
}
// WaitForStartInstancesResult mocks base method.
func (m *MockInterface) WaitForStartInstancesResult(ctx context.Context, future *azure.Future, resourceGroupName string) (*http.Response, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WaitForStartInstancesResult", ctx, future, resourceGroupName)
@ -243,7 +244,7 @@ func (m *MockInterface) WaitForStartInstancesResult(ctx context.Context, future
return ret0, ret1
}
// WaitForStartInstancesResult indicates an expected call of WaitForStartInstancesResult
// WaitForStartInstancesResult indicates an expected call of WaitForStartInstancesResult.
func (mr *MockInterfaceMockRecorder) WaitForStartInstancesResult(ctx, future, resourceGroupName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForStartInstancesResult", reflect.TypeOf((*MockInterface)(nil).WaitForStartInstancesResult), ctx, future, resourceGroupName)

27
staging/src/k8s.io/legacy-cloud-providers/azure/clients/vmssvmclient/mockvmssvmclient/interface.go
View File

@ -25,36 +25,37 @@ package mockvmssvmclient
import (
context "context"
reflect "reflect"
compute "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-12-01/compute"
gomock "github.com/golang/mock/gomock"
retry "k8s.io/legacy-cloud-providers/azure/retry"
reflect "reflect"
)
// MockInterface is a mock of Interface interface
// MockInterface is a mock of Interface interface.
type MockInterface struct {
ctrl *gomock.Controller
recorder *MockInterfaceMockRecorder
}
// MockInterfaceMockRecorder is the mock recorder for MockInterface
// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
mock *MockInterface
}
// NewMockInterface creates a new mock instance
// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
mock := &MockInterface{ctrl: ctrl}
mock.recorder = &MockInterfaceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
return m.recorder
}
// Get mocks base method
// Get mocks base method.
func (m *MockInterface) Get(ctx context.Context, resourceGroupName, VMScaleSetName, instanceID string, expand compute.InstanceViewTypes) (compute.VirtualMachineScaleSetVM, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, VMScaleSetName, instanceID, expand)
@ -63,13 +64,13 @@ func (m *MockInterface) Get(ctx context.Context, resourceGroupName, VMScaleSetNa
return ret0, ret1
}
// Get indicates an expected call of Get
// Get indicates an expected call of Get.
func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, VMScaleSetName, instanceID, expand interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), ctx, resourceGroupName, VMScaleSetName, instanceID, expand)
}
// List mocks base method
// List mocks base method.
func (m *MockInterface) List(ctx context.Context, resourceGroupName, virtualMachineScaleSetName, expand string) ([]compute.VirtualMachineScaleSetVM, *retry.Error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "List", ctx, resourceGroupName, virtualMachineScaleSetName, expand)
@ -78,13 +79,13 @@ func (m *MockInterface) List(ctx context.Context, resourceGroupName, virtualMach
return ret0, ret1
}
// List indicates an expected call of List
// List indicates an expected call of List.
func (mr *MockInterfaceMockRecorder) List(ctx, resourceGroupName, virtualMachineScaleSetName, expand interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInterface)(nil).List), ctx, resourceGroupName, virtualMachineScaleSetName, expand)
}
// Update mocks base method
// Update mocks base method.
func (m *MockInterface) Update(ctx context.Context, resourceGroupName, VMScaleSetName, instanceID string, parameters compute.VirtualMachineScaleSetVM, source string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Update", ctx, resourceGroupName, VMScaleSetName, instanceID, parameters, source)
@ -92,13 +93,13 @@ func (m *MockInterface) Update(ctx context.Context, resourceGroupName, VMScaleSe
return ret0
}
// Update indicates an expected call of Update
// Update indicates an expected call of Update.
func (mr *MockInterfaceMockRecorder) Update(ctx, resourceGroupName, VMScaleSetName, instanceID, parameters, source interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockInterface)(nil).Update), ctx, resourceGroupName, VMScaleSetName, instanceID, parameters, source)
}
// UpdateVMs mocks base method
// UpdateVMs mocks base method.
func (m *MockInterface) UpdateVMs(ctx context.Context, resourceGroupName, VMScaleSetName string, instances map[string]compute.VirtualMachineScaleSetVM, source string) *retry.Error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UpdateVMs", ctx, resourceGroupName, VMScaleSetName, instances, source)
@ -106,7 +107,7 @@ func (m *MockInterface) UpdateVMs(ctx context.Context, resourceGroupName, VMScal
return ret0
}
// UpdateVMs indicates an expected call of UpdateVMs
// UpdateVMs indicates an expected call of UpdateVMs.
func (mr *MockInterfaceMockRecorder) UpdateVMs(ctx, resourceGroupName, VMScaleSetName, instances, source interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateVMs", reflect.TypeOf((*MockInterface)(nil).UpdateVMs), ctx, resourceGroupName, VMScaleSetName, instances, source)

397
staging/src/k8s.io/legacy-cloud-providers/azure/mockvmsets/azure_mock_vmsets.go
View File

@ -24,6 +24,8 @@ limitations under the License.
package mockvmsets
import (
reflect "reflect"
compute "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-12-01/compute"
network "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2019-06-01/network"
gomock "github.com/golang/mock/gomock"
@ -31,167 +33,74 @@ import (
types "k8s.io/apimachinery/pkg/types"
cloudprovider "k8s.io/cloud-provider"
cache "k8s.io/legacy-cloud-providers/azure/cache"
reflect "reflect"
)
// MockVMSet is a mock of VMSet interface
// MockVMSet is a mock of VMSet interface.
type MockVMSet struct {
ctrl *gomock.Controller
recorder *MockVMSetMockRecorder
}
// MockVMSetMockRecorder is the mock recorder for MockVMSet
// MockVMSetMockRecorder is the mock recorder for MockVMSet.
type MockVMSetMockRecorder struct {
mock *MockVMSet
}
// NewMockVMSet creates a new mock instance
// NewMockVMSet creates a new mock instance.
func NewMockVMSet(ctrl *gomock.Controller) *MockVMSet {
mock := &MockVMSet{ctrl: ctrl}
mock.recorder = &MockVMSetMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVMSet) EXPECT() *MockVMSetMockRecorder {
return m.recorder
}
// GetInstanceIDByNodeName mocks base method
func (m *MockVMSet) GetInstanceIDByNodeName(name string) (string, error) {
// AttachDisk mocks base method.
func (m *MockVMSet) AttachDisk(isManagedDisk bool, diskName, diskURI string, nodeName types.NodeName, lun int32, cachingMode compute.CachingTypes, diskEncryptionSetID string, writeAcceleratorEnabled bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetInstanceIDByNodeName", name)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetInstanceIDByNodeName indicates an expected call of GetInstanceIDByNodeName
func (mr *MockVMSetMockRecorder) GetInstanceIDByNodeName(name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceIDByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetInstanceIDByNodeName), name)
}
// GetInstanceTypeByNodeName mocks base method
func (m *MockVMSet) GetInstanceTypeByNodeName(name string) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetInstanceTypeByNodeName", name)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetInstanceTypeByNodeName indicates an expected call of GetInstanceTypeByNodeName
func (mr *MockVMSetMockRecorder) GetInstanceTypeByNodeName(name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTypeByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetInstanceTypeByNodeName), name)
}
// GetIPByNodeName mocks base method
func (m *MockVMSet) GetIPByNodeName(name string) (string, string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetIPByNodeName", name)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(string)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
}
// GetIPByNodeName indicates an expected call of GetIPByNodeName
func (mr *MockVMSetMockRecorder) GetIPByNodeName(name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIPByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetIPByNodeName), name)
}
// GetPrimaryInterface mocks base method
func (m *MockVMSet) GetPrimaryInterface(nodeName string) (network.Interface, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPrimaryInterface", nodeName)
ret0, _ := ret[0].(network.Interface)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPrimaryInterface indicates an expected call of GetPrimaryInterface
func (mr *MockVMSetMockRecorder) GetPrimaryInterface(nodeName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrimaryInterface", reflect.TypeOf((*MockVMSet)(nil).GetPrimaryInterface), nodeName)
}
// GetNodeNameByProviderID mocks base method
func (m *MockVMSet) GetNodeNameByProviderID(providerID string) (types.NodeName, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetNodeNameByProviderID", providerID)
ret0, _ := ret[0].(types.NodeName)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetNodeNameByProviderID indicates an expected call of GetNodeNameByProviderID
func (mr *MockVMSetMockRecorder) GetNodeNameByProviderID(providerID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeNameByProviderID", reflect.TypeOf((*MockVMSet)(nil).GetNodeNameByProviderID), providerID)
}
// GetZoneByNodeName mocks base method
func (m *MockVMSet) GetZoneByNodeName(name string) (cloudprovider.Zone, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetZoneByNodeName", name)
ret0, _ := ret[0].(cloudprovider.Zone)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetZoneByNodeName indicates an expected call of GetZoneByNodeName
func (mr *MockVMSetMockRecorder) GetZoneByNodeName(name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetZoneByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetZoneByNodeName), name)
}
// GetPrimaryVMSetName mocks base method
func (m *MockVMSet) GetPrimaryVMSetName() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPrimaryVMSetName")
ret0, _ := ret[0].(string)
return ret0
}
// GetPrimaryVMSetName indicates an expected call of GetPrimaryVMSetName
func (mr *MockVMSetMockRecorder) GetPrimaryVMSetName() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrimaryVMSetName", reflect.TypeOf((*MockVMSet)(nil).GetPrimaryVMSetName))
}
// GetVMSetNames mocks base method
func (m *MockVMSet) GetVMSetNames(service *v1.Service, nodes []*v1.Node) (*[]string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetVMSetNames", service, nodes)
ret0, _ := ret[0].(*[]string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetVMSetNames indicates an expected call of GetVMSetNames
func (mr *MockVMSetMockRecorder) GetVMSetNames(service, nodes interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVMSetNames", reflect.TypeOf((*MockVMSet)(nil).GetVMSetNames), service, nodes)
}
// EnsureHostsInPool mocks base method
func (m *MockVMSet) EnsureHostsInPool(service *v1.Service, nodes []*v1.Node, backendPoolID, vmSetName string, isInternal bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "EnsureHostsInPool", service, nodes, backendPoolID, vmSetName, isInternal)
ret := m.ctrl.Call(m, "AttachDisk", isManagedDisk, diskName, diskURI, nodeName, lun, cachingMode, diskEncryptionSetID, writeAcceleratorEnabled)
ret0, _ := ret[0].(error)
return ret0
}
// EnsureHostsInPool indicates an expected call of EnsureHostsInPool
func (mr *MockVMSetMockRecorder) EnsureHostsInPool(service, nodes, backendPoolID, vmSetName, isInternal interface{}) *gomock.Call {
// AttachDisk indicates an expected call of AttachDisk.
func (mr *MockVMSetMockRecorder) AttachDisk(isManagedDisk, diskName, diskURI, nodeName, lun, cachingMode, diskEncryptionSetID, writeAcceleratorEnabled interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureHostsInPool", reflect.TypeOf((*MockVMSet)(nil).EnsureHostsInPool), service, nodes, backendPoolID, vmSetName, isInternal)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachDisk", reflect.TypeOf((*MockVMSet)(nil).AttachDisk), isManagedDisk, diskName, diskURI, nodeName, lun, cachingMode, diskEncryptionSetID, writeAcceleratorEnabled)
}
// EnsureHostInPool mocks base method
// DetachDisk mocks base method.
func (m *MockVMSet) DetachDisk(diskName, diskURI string, nodeName types.NodeName) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DetachDisk", diskName, diskURI, nodeName)
ret0, _ := ret[0].(error)
return ret0
}
// DetachDisk indicates an expected call of DetachDisk.
func (mr *MockVMSetMockRecorder) DetachDisk(diskName, diskURI, nodeName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachDisk", reflect.TypeOf((*MockVMSet)(nil).DetachDisk), diskName, diskURI, nodeName)
}
// EnsureBackendPoolDeleted mocks base method.
func (m *MockVMSet) EnsureBackendPoolDeleted(service *v1.Service, backendPoolID, vmSetName string, backendAddressPools *[]network.BackendAddressPool, deleteFromVMSet bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "EnsureBackendPoolDeleted", service, backendPoolID, vmSetName, backendAddressPools, deleteFromVMSet)
ret0, _ := ret[0].(error)
return ret0
}
// EnsureBackendPoolDeleted indicates an expected call of EnsureBackendPoolDeleted.
func (mr *MockVMSetMockRecorder) EnsureBackendPoolDeleted(service, backendPoolID, vmSetName, backendAddressPools, deleteFromVMSet interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureBackendPoolDeleted", reflect.TypeOf((*MockVMSet)(nil).EnsureBackendPoolDeleted), service, backendPoolID, vmSetName, backendAddressPools, deleteFromVMSet)
}
// EnsureHostInPool mocks base method.
func (m *MockVMSet) EnsureHostInPool(service *v1.Service, nodeName types.NodeName, backendPoolID, vmSetName string, isInternal bool) (string, string, string, *compute.VirtualMachineScaleSetVM, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "EnsureHostInPool", service, nodeName, backendPoolID, vmSetName, isInternal)
@ -203,55 +112,27 @@ func (m *MockVMSet) EnsureHostInPool(service *v1.Service, nodeName types.NodeNam
return ret0, ret1, ret2, ret3, ret4
}
// EnsureHostInPool indicates an expected call of EnsureHostInPool
// EnsureHostInPool indicates an expected call of EnsureHostInPool.
func (mr *MockVMSetMockRecorder) EnsureHostInPool(service, nodeName, backendPoolID, vmSetName, isInternal interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureHostInPool", reflect.TypeOf((*MockVMSet)(nil).EnsureHostInPool), service, nodeName, backendPoolID, vmSetName, isInternal)
}
// EnsureBackendPoolDeleted mocks base method
func (m *MockVMSet) EnsureBackendPoolDeleted(service *v1.Service, backendPoolID, vmSetName string, backendAddressPools *[]network.BackendAddressPool, deleteFromVMSet bool) error {
// EnsureHostsInPool mocks base method.
func (m *MockVMSet) EnsureHostsInPool(service *v1.Service, nodes []*v1.Node, backendPoolID, vmSetName string, isInternal bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "EnsureBackendPoolDeleted", service, backendPoolID, vmSetName, backendAddressPools, deleteFromVMSet)
ret := m.ctrl.Call(m, "EnsureHostsInPool", service, nodes, backendPoolID, vmSetName, isInternal)
ret0, _ := ret[0].(error)
return ret0
}
// EnsureBackendPoolDeleted indicates an expected call of EnsureBackendPoolDeleted
func (mr *MockVMSetMockRecorder) EnsureBackendPoolDeleted(service, backendPoolID, vmSetName, backendAddressPools, deleteFromVMSet interface{}) *gomock.Call {
// EnsureHostsInPool indicates an expected call of EnsureHostsInPool.
func (mr *MockVMSetMockRecorder) EnsureHostsInPool(service, nodes, backendPoolID, vmSetName, isInternal interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureBackendPoolDeleted", reflect.TypeOf((*MockVMSet)(nil).EnsureBackendPoolDeleted), service, backendPoolID, vmSetName, backendAddressPools, deleteFromVMSet)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureHostsInPool", reflect.TypeOf((*MockVMSet)(nil).EnsureHostsInPool), service, nodes, backendPoolID, vmSetName, isInternal)
}
// AttachDisk mocks base method
func (m *MockVMSet) AttachDisk(isManagedDisk bool, diskName, diskURI string, nodeName types.NodeName, lun int32, cachingMode compute.CachingTypes, diskEncryptionSetID string, writeAcceleratorEnabled bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AttachDisk", isManagedDisk, diskName, diskURI, nodeName, lun, cachingMode, diskEncryptionSetID, writeAcceleratorEnabled)
ret0, _ := ret[0].(error)
return ret0
}
// AttachDisk indicates an expected call of AttachDisk
func (mr *MockVMSetMockRecorder) AttachDisk(isManagedDisk, diskName, diskURI, nodeName, lun, cachingMode, diskEncryptionSetID, writeAcceleratorEnabled interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachDisk", reflect.TypeOf((*MockVMSet)(nil).AttachDisk), isManagedDisk, diskName, diskURI, nodeName, lun, cachingMode, diskEncryptionSetID, writeAcceleratorEnabled)
}
// DetachDisk mocks base method
func (m *MockVMSet) DetachDisk(diskName, diskURI string, nodeName types.NodeName) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DetachDisk", diskName, diskURI, nodeName)
ret0, _ := ret[0].(error)
return ret0
}
// DetachDisk indicates an expected call of DetachDisk
func (mr *MockVMSetMockRecorder) DetachDisk(diskName, diskURI, nodeName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachDisk", reflect.TypeOf((*MockVMSet)(nil).DetachDisk), diskName, diskURI, nodeName)
}
// GetDataDisks mocks base method
// GetDataDisks mocks base method.
func (m *MockVMSet) GetDataDisks(nodeName types.NodeName, crt cache.AzureCacheReadType) ([]compute.DataDisk, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetDataDisks", nodeName, crt)
@ -260,58 +141,59 @@ func (m *MockVMSet) GetDataDisks(nodeName types.NodeName, crt cache.AzureCacheRe
return ret0, ret1
}
// GetDataDisks indicates an expected call of GetDataDisks
// GetDataDisks indicates an expected call of GetDataDisks.
func (mr *MockVMSetMockRecorder) GetDataDisks(nodeName, crt interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataDisks", reflect.TypeOf((*MockVMSet)(nil).GetDataDisks), nodeName, crt)
}
// GetPowerStatusByNodeName mocks base method
func (m *MockVMSet) GetPowerStatusByNodeName(name string) (string, error) {
// GetIPByNodeName mocks base method.
func (m *MockVMSet) GetIPByNodeName(name string) (string, string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPowerStatusByNodeName", name)
ret := m.ctrl.Call(m, "GetIPByNodeName", name)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(string)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
}
// GetIPByNodeName indicates an expected call of GetIPByNodeName.
func (mr *MockVMSetMockRecorder) GetIPByNodeName(name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIPByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetIPByNodeName), name)
}
// GetInstanceIDByNodeName mocks base method.
func (m *MockVMSet) GetInstanceIDByNodeName(name string) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetInstanceIDByNodeName", name)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPowerStatusByNodeName indicates an expected call of GetPowerStatusByNodeName
func (mr *MockVMSetMockRecorder) GetPowerStatusByNodeName(name interface{}) *gomock.Call {
// GetInstanceIDByNodeName indicates an expected call of GetInstanceIDByNodeName.
func (mr *MockVMSetMockRecorder) GetInstanceIDByNodeName(name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPowerStatusByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetPowerStatusByNodeName), name)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceIDByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetInstanceIDByNodeName), name)
}
// GetProvisioningStateByNodeName mocks base method
func (m *MockVMSet) GetProvisioningStateByNodeName(name string) (string, error) {
// GetInstanceTypeByNodeName mocks base method.
func (m *MockVMSet) GetInstanceTypeByNodeName(name string) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetProvisioningStateByNodeName", name)
ret := m.ctrl.Call(m, "GetInstanceTypeByNodeName", name)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetProvisioningStateByNodeName indicates an expected call of GetProvisioningStateByNodeName
func (mr *MockVMSetMockRecorder) GetProvisioningStateByNodeName(name interface{}) *gomock.Call {
// GetInstanceTypeByNodeName indicates an expected call of GetInstanceTypeByNodeName.
func (mr *MockVMSetMockRecorder) GetInstanceTypeByNodeName(name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvisioningStateByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetProvisioningStateByNodeName), name)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTypeByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetInstanceTypeByNodeName), name)
}
// GetPrivateIPsByNodeName mocks base method
func (m *MockVMSet) GetPrivateIPsByNodeName(name string) ([]string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPrivateIPsByNodeName", name)
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPrivateIPsByNodeName indicates an expected call of GetPrivateIPsByNodeName
func (mr *MockVMSetMockRecorder) GetPrivateIPsByNodeName(name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateIPsByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetPrivateIPsByNodeName), name)
}
// GetNodeNameByIPConfigurationID mocks base method
// GetNodeNameByIPConfigurationID mocks base method.
func (m *MockVMSet) GetNodeNameByIPConfigurationID(ipConfigurationID string) (string, string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetNodeNameByIPConfigurationID", ipConfigurationID)
@ -321,8 +203,127 @@ func (m *MockVMSet) GetNodeNameByIPConfigurationID(ipConfigurationID string) (st
return ret0, ret1, ret2
}
// GetNodeNameByIPConfigurationID indicates an expected call of GetNodeNameByIPConfigurationID
// GetNodeNameByIPConfigurationID indicates an expected call of GetNodeNameByIPConfigurationID.
func (mr *MockVMSetMockRecorder) GetNodeNameByIPConfigurationID(ipConfigurationID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeNameByIPConfigurationID", reflect.TypeOf((*MockVMSet)(nil).GetNodeNameByIPConfigurationID), ipConfigurationID)
}
// GetNodeNameByProviderID mocks base method.
func (m *MockVMSet) GetNodeNameByProviderID(providerID string) (types.NodeName, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetNodeNameByProviderID", providerID)
ret0, _ := ret[0].(types.NodeName)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetNodeNameByProviderID indicates an expected call of GetNodeNameByProviderID.
func (mr *MockVMSetMockRecorder) GetNodeNameByProviderID(providerID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeNameByProviderID", reflect.TypeOf((*MockVMSet)(nil).GetNodeNameByProviderID), providerID)
}
// GetPowerStatusByNodeName mocks base method.
func (m *MockVMSet) GetPowerStatusByNodeName(name string) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPowerStatusByNodeName", name)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPowerStatusByNodeName indicates an expected call of GetPowerStatusByNodeName.
func (mr *MockVMSetMockRecorder) GetPowerStatusByNodeName(name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPowerStatusByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetPowerStatusByNodeName), name)
}
// GetPrimaryInterface mocks base method.
func (m *MockVMSet) GetPrimaryInterface(nodeName string) (network.Interface, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPrimaryInterface", nodeName)
ret0, _ := ret[0].(network.Interface)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPrimaryInterface indicates an expected call of GetPrimaryInterface.
func (mr *MockVMSetMockRecorder) GetPrimaryInterface(nodeName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrimaryInterface", reflect.TypeOf((*MockVMSet)(nil).GetPrimaryInterface), nodeName)
}
// GetPrimaryVMSetName mocks base method.
func (m *MockVMSet) GetPrimaryVMSetName() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPrimaryVMSetName")
ret0, _ := ret[0].(string)
return ret0
}
// GetPrimaryVMSetName indicates an expected call of GetPrimaryVMSetName.
func (mr *MockVMSetMockRecorder) GetPrimaryVMSetName() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrimaryVMSetName", reflect.TypeOf((*MockVMSet)(nil).GetPrimaryVMSetName))
}
// GetPrivateIPsByNodeName mocks base method.
func (m *MockVMSet) GetPrivateIPsByNodeName(name string) ([]string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPrivateIPsByNodeName", name)
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPrivateIPsByNodeName indicates an expected call of GetPrivateIPsByNodeName.
func (mr *MockVMSetMockRecorder) GetPrivateIPsByNodeName(name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateIPsByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetPrivateIPsByNodeName), name)
}
// GetProvisioningStateByNodeName mocks base method.
func (m *MockVMSet) GetProvisioningStateByNodeName(name string) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetProvisioningStateByNodeName", name)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetProvisioningStateByNodeName indicates an expected call of GetProvisioningStateByNodeName.
func (mr *MockVMSetMockRecorder) GetProvisioningStateByNodeName(name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvisioningStateByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetProvisioningStateByNodeName), name)
}
// GetVMSetNames mocks base method.
func (m *MockVMSet) GetVMSetNames(service *v1.Service, nodes []*v1.Node) (*[]string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetVMSetNames", service, nodes)
ret0, _ := ret[0].(*[]string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetVMSetNames indicates an expected call of GetVMSetNames.
func (mr *MockVMSetMockRecorder) GetVMSetNames(service, nodes interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVMSetNames", reflect.TypeOf((*MockVMSet)(nil).GetVMSetNames), service, nodes)
}
// GetZoneByNodeName mocks base method.
func (m *MockVMSet) GetZoneByNodeName(name string) (cloudprovider.Zone, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetZoneByNodeName", name)
ret0, _ := ret[0].(cloudprovider.Zone)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetZoneByNodeName indicates an expected call of GetZoneByNodeName.
func (mr *MockVMSetMockRecorder) GetZoneByNodeName(name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetZoneByNodeName", reflect.TypeOf((*MockVMSet)(nil).GetZoneByNodeName), name)
}

123
test/e2e/storage/drivers/csi-test/driver/driver.mock.go
View File

@ -22,35 +22,36 @@ package driver
import (
context "context"
reflect "reflect"
csi "github.com/container-storage-interface/spec/lib/go/csi"
gomock "github.com/golang/mock/gomock"
reflect "reflect"
)
// MockIdentityServer is a mock of IdentityServer interface
// MockIdentityServer is a mock of IdentityServer interface.
type MockIdentityServer struct {
ctrl *gomock.Controller
recorder *MockIdentityServerMockRecorder
}
// MockIdentityServerMockRecorder is the mock recorder for MockIdentityServer
// MockIdentityServerMockRecorder is the mock recorder for MockIdentityServer.
type MockIdentityServerMockRecorder struct {
mock *MockIdentityServer
}
// NewMockIdentityServer creates a new mock instance
// NewMockIdentityServer creates a new mock instance.
func NewMockIdentityServer(ctrl *gomock.Controller) *MockIdentityServer {
mock := &MockIdentityServer{ctrl: ctrl}
mock.recorder = &MockIdentityServerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockIdentityServer) EXPECT() *MockIdentityServerMockRecorder {
return m.recorder
}
// GetPluginCapabilities mocks base method
// GetPluginCapabilities mocks base method.
func (m *MockIdentityServer) GetPluginCapabilities(arg0 context.Context, arg1 *csi.GetPluginCapabilitiesRequest) (*csi.GetPluginCapabilitiesResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPluginCapabilities", arg0, arg1)
@ -59,13 +60,13 @@ func (m *MockIdentityServer) GetPluginCapabilities(arg0 context.Context, arg1 *c
return ret0, ret1
}
// GetPluginCapabilities indicates an expected call of GetPluginCapabilities
// GetPluginCapabilities indicates an expected call of GetPluginCapabilities.
func (mr *MockIdentityServerMockRecorder) GetPluginCapabilities(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPluginCapabilities", reflect.TypeOf((*MockIdentityServer)(nil).GetPluginCapabilities), arg0, arg1)
}
// GetPluginInfo mocks base method
// GetPluginInfo mocks base method.
func (m *MockIdentityServer) GetPluginInfo(arg0 context.Context, arg1 *csi.GetPluginInfoRequest) (*csi.GetPluginInfoResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPluginInfo", arg0, arg1)
@ -74,13 +75,13 @@ func (m *MockIdentityServer) GetPluginInfo(arg0 context.Context, arg1 *csi.GetPl
return ret0, ret1
}
// GetPluginInfo indicates an expected call of GetPluginInfo
// GetPluginInfo indicates an expected call of GetPluginInfo.
func (mr *MockIdentityServerMockRecorder) GetPluginInfo(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPluginInfo", reflect.TypeOf((*MockIdentityServer)(nil).GetPluginInfo), arg0, arg1)
}
// Probe mocks base method
// Probe mocks base method.
func (m *MockIdentityServer) Probe(arg0 context.Context, arg1 *csi.ProbeRequest) (*csi.ProbeResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Probe", arg0, arg1)
@ -89,36 +90,36 @@ func (m *MockIdentityServer) Probe(arg0 context.Context, arg1 *csi.ProbeRequest)
return ret0, ret1
}
// Probe indicates an expected call of Probe
// Probe indicates an expected call of Probe.
func (mr *MockIdentityServerMockRecorder) Probe(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Probe", reflect.TypeOf((*MockIdentityServer)(nil).Probe), arg0, arg1)
}
// MockControllerServer is a mock of ControllerServer interface
// MockControllerServer is a mock of ControllerServer interface.
type MockControllerServer struct {
ctrl *gomock.Controller
recorder *MockControllerServerMockRecorder
}
// MockControllerServerMockRecorder is the mock recorder for MockControllerServer
// MockControllerServerMockRecorder is the mock recorder for MockControllerServer.
type MockControllerServerMockRecorder struct {
mock *MockControllerServer
}
// NewMockControllerServer creates a new mock instance
// NewMockControllerServer creates a new mock instance.
func NewMockControllerServer(ctrl *gomock.Controller) *MockControllerServer {
mock := &MockControllerServer{ctrl: ctrl}
mock.recorder = &MockControllerServerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockControllerServer) EXPECT() *MockControllerServerMockRecorder {
return m.recorder
}
// ControllerExpandVolume mocks base method
// ControllerExpandVolume mocks base method.
func (m *MockControllerServer) ControllerExpandVolume(arg0 context.Context, arg1 *csi.ControllerExpandVolumeRequest) (*csi.ControllerExpandVolumeResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ControllerExpandVolume", arg0, arg1)
@ -127,13 +128,13 @@ func (m *MockControllerServer) ControllerExpandVolume(arg0 context.Context, arg1
return ret0, ret1
}
// ControllerExpandVolume indicates an expected call of ControllerExpandVolume
// ControllerExpandVolume indicates an expected call of ControllerExpandVolume.
func (mr *MockControllerServerMockRecorder) ControllerExpandVolume(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerExpandVolume", reflect.TypeOf((*MockControllerServer)(nil).ControllerExpandVolume), arg0, arg1)
}
// ControllerGetCapabilities mocks base method
// ControllerGetCapabilities mocks base method.
func (m *MockControllerServer) ControllerGetCapabilities(arg0 context.Context, arg1 *csi.ControllerGetCapabilitiesRequest) (*csi.ControllerGetCapabilitiesResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ControllerGetCapabilities", arg0, arg1)
@ -142,13 +143,13 @@ func (m *MockControllerServer) ControllerGetCapabilities(arg0 context.Context, a
return ret0, ret1
}
// ControllerGetCapabilities indicates an expected call of ControllerGetCapabilities
// ControllerGetCapabilities indicates an expected call of ControllerGetCapabilities.
func (mr *MockControllerServerMockRecorder) ControllerGetCapabilities(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerGetCapabilities", reflect.TypeOf((*MockControllerServer)(nil).ControllerGetCapabilities), arg0, arg1)
}
// ControllerGetVolume mocks base method
// ControllerGetVolume mocks base method.
func (m *MockControllerServer) ControllerGetVolume(arg0 context.Context, arg1 *csi.ControllerGetVolumeRequest) (*csi.ControllerGetVolumeResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ControllerGetVolume", arg0, arg1)
@ -157,13 +158,13 @@ func (m *MockControllerServer) ControllerGetVolume(arg0 context.Context, arg1 *c
return ret0, ret1
}
// ControllerGetVolume indicates an expected call of ControllerGetVolume
// ControllerGetVolume indicates an expected call of ControllerGetVolume.
func (mr *MockControllerServerMockRecorder) ControllerGetVolume(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerGetVolume", reflect.TypeOf((*MockControllerServer)(nil).ControllerGetVolume), arg0, arg1)
}
// ControllerPublishVolume mocks base method
// ControllerPublishVolume mocks base method.
func (m *MockControllerServer) ControllerPublishVolume(arg0 context.Context, arg1 *csi.ControllerPublishVolumeRequest) (*csi.ControllerPublishVolumeResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ControllerPublishVolume", arg0, arg1)
@ -172,13 +173,13 @@ func (m *MockControllerServer) ControllerPublishVolume(arg0 context.Context, arg
return ret0, ret1
}
// ControllerPublishVolume indicates an expected call of ControllerPublishVolume
// ControllerPublishVolume indicates an expected call of ControllerPublishVolume.
func (mr *MockControllerServerMockRecorder) ControllerPublishVolume(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerPublishVolume", reflect.TypeOf((*MockControllerServer)(nil).ControllerPublishVolume), arg0, arg1)
}
// ControllerUnpublishVolume mocks base method
// ControllerUnpublishVolume mocks base method.
func (m *MockControllerServer) ControllerUnpublishVolume(arg0 context.Context, arg1 *csi.ControllerUnpublishVolumeRequest) (*csi.ControllerUnpublishVolumeResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ControllerUnpublishVolume", arg0, arg1)
@ -187,13 +188,13 @@ func (m *MockControllerServer) ControllerUnpublishVolume(arg0 context.Context, a
return ret0, ret1
}
// ControllerUnpublishVolume indicates an expected call of ControllerUnpublishVolume
// ControllerUnpublishVolume indicates an expected call of ControllerUnpublishVolume.
func (mr *MockControllerServerMockRecorder) ControllerUnpublishVolume(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerUnpublishVolume", reflect.TypeOf((*MockControllerServer)(nil).ControllerUnpublishVolume), arg0, arg1)
}
// CreateSnapshot mocks base method
// CreateSnapshot mocks base method.
func (m *MockControllerServer) CreateSnapshot(arg0 context.Context, arg1 *csi.CreateSnapshotRequest) (*csi.CreateSnapshotResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateSnapshot", arg0, arg1)
@ -202,13 +203,13 @@ func (m *MockControllerServer) CreateSnapshot(arg0 context.Context, arg1 *csi.Cr
return ret0, ret1
}
// CreateSnapshot indicates an expected call of CreateSnapshot
// CreateSnapshot indicates an expected call of CreateSnapshot.
func (mr *MockControllerServerMockRecorder) CreateSnapshot(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockControllerServer)(nil).CreateSnapshot), arg0, arg1)
}
// CreateVolume mocks base method
// CreateVolume mocks base method.
func (m *MockControllerServer) CreateVolume(arg0 context.Context, arg1 *csi.CreateVolumeRequest) (*csi.CreateVolumeResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateVolume", arg0, arg1)
@ -217,13 +218,13 @@ func (m *MockControllerServer) CreateVolume(arg0 context.Context, arg1 *csi.Crea
return ret0, ret1
}
// CreateVolume indicates an expected call of CreateVolume
// CreateVolume indicates an expected call of CreateVolume.
func (mr *MockControllerServerMockRecorder) CreateVolume(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolume", reflect.TypeOf((*MockControllerServer)(nil).CreateVolume), arg0, arg1)
}
// DeleteSnapshot mocks base method
// DeleteSnapshot mocks base method.
func (m *MockControllerServer) DeleteSnapshot(arg0 context.Context, arg1 *csi.DeleteSnapshotRequest) (*csi.DeleteSnapshotResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteSnapshot", arg0, arg1)
@ -232,13 +233,13 @@ func (m *MockControllerServer) DeleteSnapshot(arg0 context.Context, arg1 *csi.De
return ret0, ret1
}
// DeleteSnapshot indicates an expected call of DeleteSnapshot
// DeleteSnapshot indicates an expected call of DeleteSnapshot.
func (mr *MockControllerServerMockRecorder) DeleteSnapshot(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockControllerServer)(nil).DeleteSnapshot), arg0, arg1)
}
// DeleteVolume mocks base method
// DeleteVolume mocks base method.
func (m *MockControllerServer) DeleteVolume(arg0 context.Context, arg1 *csi.DeleteVolumeRequest) (*csi.DeleteVolumeResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteVolume", arg0, arg1)
@ -247,13 +248,13 @@ func (m *MockControllerServer) DeleteVolume(arg0 context.Context, arg1 *csi.Dele
return ret0, ret1
}
// DeleteVolume indicates an expected call of DeleteVolume
// DeleteVolume indicates an expected call of DeleteVolume.
func (mr *MockControllerServerMockRecorder) DeleteVolume(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolume", reflect.TypeOf((*MockControllerServer)(nil).DeleteVolume), arg0, arg1)
}
// GetCapacity mocks base method
// GetCapacity mocks base method.
func (m *MockControllerServer) GetCapacity(arg0 context.Context, arg1 *csi.GetCapacityRequest) (*csi.GetCapacityResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetCapacity", arg0, arg1)
@ -262,13 +263,13 @@ func (m *MockControllerServer) GetCapacity(arg0 context.Context, arg1 *csi.GetCa
return ret0, ret1
}
// GetCapacity indicates an expected call of GetCapacity
// GetCapacity indicates an expected call of GetCapacity.
func (mr *MockControllerServerMockRecorder) GetCapacity(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacity", reflect.TypeOf((*MockControllerServer)(nil).GetCapacity), arg0, arg1)
}
// ListSnapshots mocks base method
// ListSnapshots mocks base method.
func (m *MockControllerServer) ListSnapshots(arg0 context.Context, arg1 *csi.ListSnapshotsRequest) (*csi.ListSnapshotsResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListSnapshots", arg0, arg1)
@ -277,13 +278,13 @@ func (m *MockControllerServer) ListSnapshots(arg0 context.Context, arg1 *csi.Lis
return ret0, ret1
}
// ListSnapshots indicates an expected call of ListSnapshots
// ListSnapshots indicates an expected call of ListSnapshots.
func (mr *MockControllerServerMockRecorder) ListSnapshots(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshots", reflect.TypeOf((*MockControllerServer)(nil).ListSnapshots), arg0, arg1)
}
// ListVolumes mocks base method
// ListVolumes mocks base method.
func (m *MockControllerServer) ListVolumes(arg0 context.Context, arg1 *csi.ListVolumesRequest) (*csi.ListVolumesResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListVolumes", arg0, arg1)
@ -292,13 +293,13 @@ func (m *MockControllerServer) ListVolumes(arg0 context.Context, arg1 *csi.ListV
return ret0, ret1
}
// ListVolumes indicates an expected call of ListVolumes
// ListVolumes indicates an expected call of ListVolumes.
func (mr *MockControllerServerMockRecorder) ListVolumes(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVolumes", reflect.TypeOf((*MockControllerServer)(nil).ListVolumes), arg0, arg1)
}
// ValidateVolumeCapabilities mocks base method
// ValidateVolumeCapabilities mocks base method.
func (m *MockControllerServer) ValidateVolumeCapabilities(arg0 context.Context, arg1 *csi.ValidateVolumeCapabilitiesRequest) (*csi.ValidateVolumeCapabilitiesResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ValidateVolumeCapabilities", arg0, arg1)
@ -307,36 +308,36 @@ func (m *MockControllerServer) ValidateVolumeCapabilities(arg0 context.Context,
return ret0, ret1
}
// ValidateVolumeCapabilities indicates an expected call of ValidateVolumeCapabilities
// ValidateVolumeCapabilities indicates an expected call of ValidateVolumeCapabilities.
func (mr *MockControllerServerMockRecorder) ValidateVolumeCapabilities(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateVolumeCapabilities", reflect.TypeOf((*MockControllerServer)(nil).ValidateVolumeCapabilities), arg0, arg1)
}
// MockNodeServer is a mock of NodeServer interface
// MockNodeServer is a mock of NodeServer interface.
type MockNodeServer struct {
ctrl *gomock.Controller
recorder *MockNodeServerMockRecorder
}
// MockNodeServerMockRecorder is the mock recorder for MockNodeServer
// MockNodeServerMockRecorder is the mock recorder for MockNodeServer.
type MockNodeServerMockRecorder struct {
mock *MockNodeServer
}
// NewMockNodeServer creates a new mock instance
// NewMockNodeServer creates a new mock instance.
func NewMockNodeServer(ctrl *gomock.Controller) *MockNodeServer {
mock := &MockNodeServer{ctrl: ctrl}
mock.recorder = &MockNodeServerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockNodeServer) EXPECT() *MockNodeServerMockRecorder {
return m.recorder
}
// NodeExpandVolume mocks base method
// NodeExpandVolume mocks base method.
func (m *MockNodeServer) NodeExpandVolume(arg0 context.Context, arg1 *csi.NodeExpandVolumeRequest) (*csi.NodeExpandVolumeResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NodeExpandVolume", arg0, arg1)
@ -345,13 +346,13 @@ func (m *MockNodeServer) NodeExpandVolume(arg0 context.Context, arg1 *csi.NodeEx
return ret0, ret1
}
// NodeExpandVolume indicates an expected call of NodeExpandVolume
// NodeExpandVolume indicates an expected call of NodeExpandVolume.
func (mr *MockNodeServerMockRecorder) NodeExpandVolume(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeExpandVolume", reflect.TypeOf((*MockNodeServer)(nil).NodeExpandVolume), arg0, arg1)
}
// NodeGetCapabilities mocks base method
// NodeGetCapabilities mocks base method.
func (m *MockNodeServer) NodeGetCapabilities(arg0 context.Context, arg1 *csi.NodeGetCapabilitiesRequest) (*csi.NodeGetCapabilitiesResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NodeGetCapabilities", arg0, arg1)
@ -360,13 +361,13 @@ func (m *MockNodeServer) NodeGetCapabilities(arg0 context.Context, arg1 *csi.Nod
return ret0, ret1
}
// NodeGetCapabilities indicates an expected call of NodeGetCapabilities
// NodeGetCapabilities indicates an expected call of NodeGetCapabilities.
func (mr *MockNodeServerMockRecorder) NodeGetCapabilities(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeGetCapabilities", reflect.TypeOf((*MockNodeServer)(nil).NodeGetCapabilities), arg0, arg1)
}
// NodeGetInfo mocks base method
// NodeGetInfo mocks base method.
func (m *MockNodeServer) NodeGetInfo(arg0 context.Context, arg1 *csi.NodeGetInfoRequest) (*csi.NodeGetInfoResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NodeGetInfo", arg0, arg1)
@ -375,13 +376,13 @@ func (m *MockNodeServer) NodeGetInfo(arg0 context.Context, arg1 *csi.NodeGetInfo
return ret0, ret1
}
// NodeGetInfo indicates an expected call of NodeGetInfo
// NodeGetInfo indicates an expected call of NodeGetInfo.
func (mr *MockNodeServerMockRecorder) NodeGetInfo(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeGetInfo", reflect.TypeOf((*MockNodeServer)(nil).NodeGetInfo), arg0, arg1)
}
// NodeGetVolumeStats mocks base method
// NodeGetVolumeStats mocks base method.
func (m *MockNodeServer) NodeGetVolumeStats(arg0 context.Context, arg1 *csi.NodeGetVolumeStatsRequest) (*csi.NodeGetVolumeStatsResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NodeGetVolumeStats", arg0, arg1)
@ -390,13 +391,13 @@ func (m *MockNodeServer) NodeGetVolumeStats(arg0 context.Context, arg1 *csi.Node
return ret0, ret1
}
// NodeGetVolumeStats indicates an expected call of NodeGetVolumeStats
// NodeGetVolumeStats indicates an expected call of NodeGetVolumeStats.
func (mr *MockNodeServerMockRecorder) NodeGetVolumeStats(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeGetVolumeStats", reflect.TypeOf((*MockNodeServer)(nil).NodeGetVolumeStats), arg0, arg1)
}
// NodePublishVolume mocks base method
// NodePublishVolume mocks base method.
func (m *MockNodeServer) NodePublishVolume(arg0 context.Context, arg1 *csi.NodePublishVolumeRequest) (*csi.NodePublishVolumeResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NodePublishVolume", arg0, arg1)
@ -405,13 +406,13 @@ func (m *MockNodeServer) NodePublishVolume(arg0 context.Context, arg1 *csi.NodeP
return ret0, ret1
}
// NodePublishVolume indicates an expected call of NodePublishVolume
// NodePublishVolume indicates an expected call of NodePublishVolume.
func (mr *MockNodeServerMockRecorder) NodePublishVolume(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodePublishVolume", reflect.TypeOf((*MockNodeServer)(nil).NodePublishVolume), arg0, arg1)
}
// NodeStageVolume mocks base method
// NodeStageVolume mocks base method.
func (m *MockNodeServer) NodeStageVolume(arg0 context.Context, arg1 *csi.NodeStageVolumeRequest) (*csi.NodeStageVolumeResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NodeStageVolume", arg0, arg1)
@ -420,13 +421,13 @@ func (m *MockNodeServer) NodeStageVolume(arg0 context.Context, arg1 *csi.NodeSta
return ret0, ret1
}
// NodeStageVolume indicates an expected call of NodeStageVolume
// NodeStageVolume indicates an expected call of NodeStageVolume.
func (mr *MockNodeServerMockRecorder) NodeStageVolume(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeStageVolume", reflect.TypeOf((*MockNodeServer)(nil).NodeStageVolume), arg0, arg1)
}
// NodeUnpublishVolume mocks base method
// NodeUnpublishVolume mocks base method.
func (m *MockNodeServer) NodeUnpublishVolume(arg0 context.Context, arg1 *csi.NodeUnpublishVolumeRequest) (*csi.NodeUnpublishVolumeResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NodeUnpublishVolume", arg0, arg1)
@ -435,13 +436,13 @@ func (m *MockNodeServer) NodeUnpublishVolume(arg0 context.Context, arg1 *csi.Nod
return ret0, ret1
}
// NodeUnpublishVolume indicates an expected call of NodeUnpublishVolume
// NodeUnpublishVolume indicates an expected call of NodeUnpublishVolume.
func (mr *MockNodeServerMockRecorder) NodeUnpublishVolume(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeUnpublishVolume", reflect.TypeOf((*MockNodeServer)(nil).NodeUnpublishVolume), arg0, arg1)
}
// NodeUnstageVolume mocks base method
// NodeUnstageVolume mocks base method.
func (m *MockNodeServer) NodeUnstageVolume(arg0 context.Context, arg1 *csi.NodeUnstageVolumeRequest) (*csi.NodeUnstageVolumeResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NodeUnstageVolume", arg0, arg1)
@ -450,7 +451,7 @@ func (m *MockNodeServer) NodeUnstageVolume(arg0 context.Context, arg1 *csi.NodeU
return ret0, ret1
}
// NodeUnstageVolume indicates an expected call of NodeUnstageVolume
// NodeUnstageVolume indicates an expected call of NodeUnstageVolume.
func (mr *MockNodeServerMockRecorder) NodeUnstageVolume(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeUnstageVolume", reflect.TypeOf((*MockNodeServer)(nil).NodeUnstageVolume), arg0, arg1)

6
test/instrumentation/stability-utils.sh
View File

@ -26,13 +26,7 @@ stability_check_setup() {
kube::golang::verify_go_version
kube::util::ensure-temp-dir
cd "${KUBE_ROOT}"
export KUBE_EXTRA_GOPATH=$KUBE_TEMP
kube::golang::setup_env
pushd "${KUBE_EXTRA_GOPATH}" >/dev/null
touch go.mod
GO111MODULE=on go mod edit -module=example.com/mod
GO111MODULE=on go get "gopkg.in/yaml.v2"
popd >/dev/null
}
find_files_to_check() {

3
test/integration/apimachinery/watch_restart_test.go
View File

@ -121,7 +121,8 @@ func TestWatchRestartsIfTimeoutNotReached(t *testing.T) {
patch := fmt.Sprintf(`{"metadata": {"annotations": {"count": "%d"}}}`, counter)
_, err := c.CoreV1().Secrets(secret.Namespace).Patch(context.TODO(), secret.Name, types.StrategicMergePatchType, []byte(patch), metav1.PatchOptions{})
if err != nil {
panic(fmt.Sprintf("Failed to patch secret: %v", err))
t.Errorf("Failed to patch secret: %v", err)
return
}
*referenceOutput = append(*referenceOutput, fmt.Sprintf("%d", counter))