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

Fix verify:* after go 1.18 upgrade

hack/lib/golang.sh

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

hack/make-rules/verify.sh

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

hack/tools/go.mod

@@ -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/golang/mock v1.6.0
-	github.com/golangci/golangci-lint v1.41.1
+	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
 )

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

@@ -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
+// GetAllocatableDevices mocks base method.
-func (m *MockDevicesProvider) UpdateAllocatedDevices() {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "UpdateAllocatedDevices")
-}
-
-// UpdateAllocatedDevices indicates an expected call of UpdateAllocatedDevices
-func (mr *MockDevicesProviderMockRecorder) UpdateAllocatedDevices() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAllocatedDevices", reflect.TypeOf((*MockDevicesProvider)(nil).UpdateAllocatedDevices))
-}
-
-// GetDevices mocks base method
-func (m *MockDevicesProvider) GetDevices(podUID, containerName string) []*v10.ContainerDevices {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetDevices", podUID, containerName)
-	ret0, _ := ret[0].([]*v10.ContainerDevices)
-	return ret0
-}
-
-// GetDevices indicates an expected call of GetDevices
-func (mr *MockDevicesProviderMockRecorder) GetDevices(podUID, containerName interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDevices", reflect.TypeOf((*MockDevicesProvider)(nil).GetDevices), podUID, containerName)
-}
-
-// GetAllocatableDevices mocks base method
 func (m *MockDevicesProvider) GetAllocatableDevices() []*v10.ContainerDevices {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetAllocatableDevices")
@@ -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
+// GetAllocatableCPUs mocks base method.
-func (m *MockCPUsProvider) GetCPUs(podUID, containerName string) []int64 {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetCPUs", podUID, containerName)
-	ret0, _ := ret[0].([]int64)
-	return ret0
-}
-
-// GetCPUs indicates an expected call of GetCPUs
-func (mr *MockCPUsProviderMockRecorder) GetCPUs(podUID, containerName interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCPUs", reflect.TypeOf((*MockCPUsProvider)(nil).GetCPUs), podUID, containerName)
-}
-
-// GetAllocatableCPUs mocks base method
 func (m *MockCPUsProvider) GetAllocatableCPUs() []int64 {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetAllocatableCPUs")
@@ -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
+// GetAllocatableMemory mocks base method.
-func (m *MockMemoryProvider) GetMemory(podUID, containerName string) []*v10.ContainerMemory {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetMemory", podUID, containerName)
-	ret0, _ := ret[0].([]*v10.ContainerMemory)
-	return ret0
-}
-
-// GetMemory indicates an expected call of GetMemory
-func (mr *MockMemoryProviderMockRecorder) GetMemory(podUID, containerName interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMemory", reflect.TypeOf((*MockMemoryProvider)(nil).GetMemory), podUID, containerName)
-}
-
-// GetAllocatableMemory mocks base method
 func (m *MockMemoryProvider) GetAllocatableMemory() []*v10.ContainerMemory {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetAllocatableMemory")
@@ -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)
+}

pkg/kubelet/cadvisor/testing/cadvisor_mock.go

@@ -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
+// ContainerInfo 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
 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
+// DockerContainer mocks base method.
-func (m *MockInterface) GetRequestedContainersInfo(containerName string, options v2.RequestOptions) (map[string]*v1.ContainerInfo, error) {
+func (m *MockInterface) DockerContainer(name string, req *v1.ContainerInfoRequest) (v1.ContainerInfo, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetRequestedContainersInfo", containerName, options)
+	ret := m.ctrl.Call(m, "DockerContainer", name, req)
-	ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
+	ret0, _ := ret[0].(v1.ContainerInfo)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// GetRequestedContainersInfo indicates an expected call of GetRequestedContainersInfo
+// DockerContainer indicates an expected call of DockerContainer.
-func (mr *MockInterfaceMockRecorder) GetRequestedContainersInfo(containerName, options interface{}) *gomock.Call {
+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
+// GetDirFsInfo mocks base method.
-func (m *MockInterface) SubcontainerInfo(name string, req *v1.ContainerInfoRequest) (map[string]*v1.ContainerInfo, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SubcontainerInfo", name, req)
-	ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SubcontainerInfo indicates an expected call of SubcontainerInfo
-func (mr *MockInterfaceMockRecorder) SubcontainerInfo(name, req interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubcontainerInfo", reflect.TypeOf((*MockInterface)(nil).SubcontainerInfo), name, req)
-}
-
-// MachineInfo mocks base method
-func (m *MockInterface) MachineInfo() (*v1.MachineInfo, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "MachineInfo")
-	ret0, _ := ret[0].(*v1.MachineInfo)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// MachineInfo indicates an expected call of MachineInfo
-func (mr *MockInterfaceMockRecorder) MachineInfo() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MachineInfo", reflect.TypeOf((*MockInterface)(nil).MachineInfo))
-}
-
-// VersionInfo mocks base method
-func (m *MockInterface) VersionInfo() (*v1.VersionInfo, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "VersionInfo")
-	ret0, _ := ret[0].(*v1.VersionInfo)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// VersionInfo indicates an expected call of VersionInfo
-func (mr *MockInterfaceMockRecorder) VersionInfo() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VersionInfo", reflect.TypeOf((*MockInterface)(nil).VersionInfo))
-}
-
-// ImagesFsInfo mocks base method
-func (m *MockInterface) ImagesFsInfo() (v2.FsInfo, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ImagesFsInfo")
-	ret0, _ := ret[0].(v2.FsInfo)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ImagesFsInfo indicates an expected call of ImagesFsInfo
-func (mr *MockInterfaceMockRecorder) ImagesFsInfo() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImagesFsInfo", reflect.TypeOf((*MockInterface)(nil).ImagesFsInfo))
-}
-
-// RootFsInfo mocks base method
-func (m *MockInterface) RootFsInfo() (v2.FsInfo, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RootFsInfo")
-	ret0, _ := ret[0].(v2.FsInfo)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RootFsInfo indicates an expected call of RootFsInfo
-func (mr *MockInterfaceMockRecorder) RootFsInfo() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RootFsInfo", reflect.TypeOf((*MockInterface)(nil).RootFsInfo))
-}
-
-// WatchEvents mocks base method
-func (m *MockInterface) WatchEvents(request *events.Request) (*events.EventChannel, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WatchEvents", request)
-	ret0, _ := ret[0].(*events.EventChannel)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// WatchEvents indicates an expected call of WatchEvents
-func (mr *MockInterfaceMockRecorder) WatchEvents(request interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchEvents", reflect.TypeOf((*MockInterface)(nil).WatchEvents), request)
-}
-
-// GetDirFsInfo mocks base method
 func (m *MockInterface) GetDirFsInfo(path string) (v2.FsInfo, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetDirFsInfo", path)
@@ -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))

pkg/kubelet/container/testing/mock_runtime_cache.go

@@ -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
+// MockpodsGetter is a mock of podsGetter interface.
-func (m *MockRuntimeCache) ForceUpdateIfOlder(arg0 time.Time) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ForceUpdateIfOlder", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ForceUpdateIfOlder indicates an expected call of ForceUpdateIfOlder
-func (mr *MockRuntimeCacheMockRecorder) ForceUpdateIfOlder(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceUpdateIfOlder", reflect.TypeOf((*MockRuntimeCache)(nil).ForceUpdateIfOlder), arg0)
-}
-
-// MockpodsGetter is a mock of podsGetter interface
 type MockpodsGetter struct {
 	ctrl     *gomock.Controller
 	recorder *MockpodsGetterMockRecorder
 }
 
-// MockpodsGetterMockRecorder is the mock recorder for MockpodsGetter
+// 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)

pkg/kubelet/container/testing/runtime_mock.go

@@ -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
+// APIVersion 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
 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
+// DeleteContainer 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
 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
+// GarbageCollect mocks base method.
-func (m *MockRuntime) PullImage(image container.ImageSpec, pullSecrets []v1.Secret, podSandboxConfig *v10.PodSandboxConfig) (string, error) {
+func (m *MockRuntime) GarbageCollect(gcPolicy container.GCPolicy, allSourcesReady, evictNonDeletedPods bool) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PullImage", image, pullSecrets, podSandboxConfig)
+	ret := m.ctrl.Call(m, "GarbageCollect", gcPolicy, allSourcesReady, evictNonDeletedPods)
-	ret0, _ := ret[0].(string)
+	ret0, _ := ret[0].(error)
-	ret1, _ := ret[1].(error)
+	return ret0
-	return ret0, ret1
 }
 
-// PullImage indicates an expected call of PullImage
+// GarbageCollect indicates an expected call of GarbageCollect.
-func (mr *MockRuntimeMockRecorder) PullImage(image, pullSecrets, podSandboxConfig interface{}) *gomock.Call {
+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
+// GetPodStatus mocks base method.
-func (m *MockRuntime) ListImages() ([]container.Image, error) {
+func (m *MockRuntime) GetPodStatus(uid types.UID, name, namespace string) (*container.PodStatus, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListImages")
+	ret := m.ctrl.Call(m, "GetPodStatus", uid, name, namespace)
-	ret0, _ := ret[0].([]container.Image)
+	ret0, _ := ret[0].(*container.PodStatus)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// ListImages indicates an expected call of ListImages
+// GetPodStatus indicates an expected call of GetPodStatus.
-func (mr *MockRuntimeMockRecorder) ListImages() *gomock.Call {
+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
+// GetPods mocks base method.
-func (m *MockRuntime) RemoveImage(image container.ImageSpec) error {
+func (m *MockRuntime) GetPods(all bool) ([]*container.Pod, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveImage", image)
+	ret := m.ctrl.Call(m, "GetPods", all)
-	ret0, _ := ret[0].(error)
+	ret0, _ := ret[0].([]*container.Pod)
-	return ret0
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
 }
 
-// RemoveImage indicates an expected call of RemoveImage
+// GetPods indicates an expected call of GetPods.
-func (mr *MockRuntimeMockRecorder) RemoveImage(image interface{}) *gomock.Call {
+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
+// GetAttach mocks base method.
-func (m *MockStreamingRuntime) GetExec(id container.ContainerID, cmd []string, stdin, stdout, stderr, tty bool) (*url.URL, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetExec", id, cmd, stdin, stdout, stderr, tty)
-	ret0, _ := ret[0].(*url.URL)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetExec indicates an expected call of GetExec
-func (mr *MockStreamingRuntimeMockRecorder) GetExec(id, cmd, stdin, stdout, stderr, tty interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExec", reflect.TypeOf((*MockStreamingRuntime)(nil).GetExec), id, cmd, stdin, stdout, stderr, tty)
-}
-
-// GetAttach mocks base method
 func (m *MockStreamingRuntime) GetAttach(id container.ContainerID, stdin, stdout, stderr, tty bool) (*url.URL, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetAttach", id, stdin, stdout, stderr, tty)
@@ -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
+// GetImageRef 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
 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
+// ImageStats mocks base method.
-func (m *MockImageService) ListImages() ([]container.Image, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListImages")
-	ret0, _ := ret[0].([]container.Image)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListImages indicates an expected call of ListImages
-func (mr *MockImageServiceMockRecorder) ListImages() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImages", reflect.TypeOf((*MockImageService)(nil).ListImages))
-}
-
-// RemoveImage mocks base method
-func (m *MockImageService) RemoveImage(image container.ImageSpec) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveImage", image)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// RemoveImage indicates an expected call of RemoveImage
-func (mr *MockImageServiceMockRecorder) RemoveImage(image interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveImage", reflect.TypeOf((*MockImageService)(nil).RemoveImage), image)
-}
-
-// ImageStats mocks base method
 func (m *MockImageService) ImageStats() (*container.ImageStats, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ImageStats")
@@ -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)

pkg/kubelet/eviction/mock_threshold_notifier_test.go

@@ -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
+// IsUnderDiskPressure mocks base method.
-func (m *MockManager) Start(diskInfoProvider DiskInfoProvider, podFunc ActivePodsFunc, podCleanedUpFunc PodCleanedUpFunc, monitoringInterval time.Duration) {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "Start", diskInfoProvider, podFunc, podCleanedUpFunc, monitoringInterval)
-}
-
-// Start indicates an expected call of Start
-func (mr *MockManagerMockRecorder) Start(diskInfoProvider, podFunc, podCleanedUpFunc, monitoringInterval interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockManager)(nil).Start), diskInfoProvider, podFunc, podCleanedUpFunc, monitoringInterval)
-}
-
-// IsUnderMemoryPressure mocks base method
-func (m *MockManager) IsUnderMemoryPressure() bool {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "IsUnderMemoryPressure")
-	ret0, _ := ret[0].(bool)
-	return ret0
-}
-
-// IsUnderMemoryPressure indicates an expected call of IsUnderMemoryPressure
-func (mr *MockManagerMockRecorder) IsUnderMemoryPressure() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUnderMemoryPressure", reflect.TypeOf((*MockManager)(nil).IsUnderMemoryPressure))
-}
-
-// IsUnderDiskPressure mocks base method
 func (m *MockManager) IsUnderDiskPressure() bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "IsUnderDiskPressure")
@@ -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
+// Description 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
 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)
+}

pkg/kubelet/pod/testing/mock_manager.go

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

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

@@ -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
+// GetCgroupCPUAndMemoryStats mocks base method.
-func (m *MockProvider) ListPodStats() ([]v1alpha1.PodStats, error) {
+func (m *MockProvider) GetCgroupCPUAndMemoryStats(cgroupName string, updateStats bool) (*v1alpha1.ContainerStats, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListPodStats")
+	ret := m.ctrl.Call(m, "GetCgroupCPUAndMemoryStats", cgroupName, updateStats)
-	ret0, _ := ret[0].([]v1alpha1.PodStats)
+	ret0, _ := ret[0].(*v1alpha1.ContainerStats)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// ListPodStats indicates an expected call of ListPodStats
+// GetCgroupCPUAndMemoryStats indicates an expected call of GetCgroupCPUAndMemoryStats.
-func (mr *MockProviderMockRecorder) ListPodStats() *gomock.Call {
+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
+// GetCgroupStats 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
 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
+// GetContainerInfo 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
 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
+// GetNode mocks base method.
-func (m *MockProvider) GetRawContainerInfo(containerName string, req *v1.ContainerInfoRequest, subcontainers bool) (map[string]*v1.ContainerInfo, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetRawContainerInfo", containerName, req, subcontainers)
-	ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetRawContainerInfo indicates an expected call of GetRawContainerInfo
-func (mr *MockProviderMockRecorder) GetRawContainerInfo(containerName, req, subcontainers interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawContainerInfo", reflect.TypeOf((*MockProvider)(nil).GetRawContainerInfo), containerName, req, subcontainers)
-}
-
-// GetRequestedContainersInfo mocks base method
-func (m *MockProvider) GetRequestedContainersInfo(containerName string, options v2.RequestOptions) (map[string]*v1.ContainerInfo, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetRequestedContainersInfo", containerName, options)
-	ret0, _ := ret[0].(map[string]*v1.ContainerInfo)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetRequestedContainersInfo indicates an expected call of GetRequestedContainersInfo
-func (mr *MockProviderMockRecorder) GetRequestedContainersInfo(containerName, options interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRequestedContainersInfo", reflect.TypeOf((*MockProvider)(nil).GetRequestedContainersInfo), containerName, options)
-}
-
-// GetPodByName mocks base method
-func (m *MockProvider) GetPodByName(namespace, name string) (*v10.Pod, bool) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetPodByName", namespace, name)
-	ret0, _ := ret[0].(*v10.Pod)
-	ret1, _ := ret[1].(bool)
-	return ret0, ret1
-}
-
-// GetPodByName indicates an expected call of GetPodByName
-func (mr *MockProviderMockRecorder) GetPodByName(namespace, name interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByName", reflect.TypeOf((*MockProvider)(nil).GetPodByName), namespace, name)
-}
-
-// GetNode mocks base method
 func (m *MockProvider) GetNode() (*v10.Node, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetNode")
@@ -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
+// GetPodByCgroupfs mocks base method.
-func (m *MockProvider) ListVolumesForPod(podUID types.UID) (map[string]volume.Volume, bool) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListVolumesForPod", podUID)
-	ret0, _ := ret[0].(map[string]volume.Volume)
-	ret1, _ := ret[1].(bool)
-	return ret0, ret1
-}
-
-// ListVolumesForPod indicates an expected call of ListVolumesForPod
-func (mr *MockProviderMockRecorder) ListVolumesForPod(podUID interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVolumesForPod", reflect.TypeOf((*MockProvider)(nil).ListVolumesForPod), podUID)
-}
-
-// ListBlockVolumesForPod mocks base method
-func (m *MockProvider) ListBlockVolumesForPod(podUID types.UID) (map[string]volume.BlockVolume, bool) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListBlockVolumesForPod", podUID)
-	ret0, _ := ret[0].(map[string]volume.BlockVolume)
-	ret1, _ := ret[1].(bool)
-	return ret0, ret1
-}
-
-// ListBlockVolumesForPod indicates an expected call of ListBlockVolumesForPod
-func (mr *MockProviderMockRecorder) ListBlockVolumesForPod(podUID interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBlockVolumesForPod", reflect.TypeOf((*MockProvider)(nil).ListBlockVolumesForPod), podUID)
-}
-
-// GetPods mocks base method
-func (m *MockProvider) GetPods() []*v10.Pod {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetPods")
-	ret0, _ := ret[0].([]*v10.Pod)
-	return ret0
-}
-
-// GetPods indicates an expected call of GetPods
-func (mr *MockProviderMockRecorder) GetPods() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockProvider)(nil).GetPods))
-}
-
-// RlimitStats mocks base method
-func (m *MockProvider) RlimitStats() (*v1alpha1.RlimitStats, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RlimitStats")
-	ret0, _ := ret[0].(*v1alpha1.RlimitStats)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RlimitStats indicates an expected call of RlimitStats
-func (mr *MockProviderMockRecorder) RlimitStats() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RlimitStats", reflect.TypeOf((*MockProvider)(nil).RlimitStats))
-}
-
-// GetPodCgroupRoot mocks base method
-func (m *MockProvider) GetPodCgroupRoot() string {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetPodCgroupRoot")
-	ret0, _ := ret[0].(string)
-	return ret0
-}
-
-// GetPodCgroupRoot indicates an expected call of GetPodCgroupRoot
-func (mr *MockProviderMockRecorder) GetPodCgroupRoot() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodCgroupRoot", reflect.TypeOf((*MockProvider)(nil).GetPodCgroupRoot))
-}
-
-// GetPodByCgroupfs mocks base method
 func (m *MockProvider) GetPodByCgroupfs(cgroupfs string) (*v10.Pod, bool) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetPodByCgroupfs", cgroupfs)
@@ -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))
+}

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

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

pkg/kubelet/status/testing/mock_pod_status_provider.go

@@ -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
+// PodCouldHaveRunningContainers 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
 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
+// RemoveOrphanedStatuses mocks base method.
-func (m *MockManager) Start() {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "Start")
-}
-
-// Start indicates an expected call of Start
-func (mr *MockManagerMockRecorder) Start() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockManager)(nil).Start))
-}
-
-// SetPodStatus mocks base method
-func (m *MockManager) SetPodStatus(pod *v1.Pod, status v1.PodStatus) {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "SetPodStatus", pod, status)
-}
-
-// SetPodStatus indicates an expected call of SetPodStatus
-func (mr *MockManagerMockRecorder) SetPodStatus(pod, status interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPodStatus", reflect.TypeOf((*MockManager)(nil).SetPodStatus), pod, status)
-}
-
-// SetContainerReadiness mocks base method
-func (m *MockManager) SetContainerReadiness(podUID types.UID, containerID container.ContainerID, ready bool) {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "SetContainerReadiness", podUID, containerID, ready)
-}
-
-// SetContainerReadiness indicates an expected call of SetContainerReadiness
-func (mr *MockManagerMockRecorder) SetContainerReadiness(podUID, containerID, ready interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetContainerReadiness", reflect.TypeOf((*MockManager)(nil).SetContainerReadiness), podUID, containerID, ready)
-}
-
-// SetContainerStartup mocks base method
-func (m *MockManager) SetContainerStartup(podUID types.UID, containerID container.ContainerID, started bool) {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "SetContainerStartup", podUID, containerID, started)
-}
-
-// SetContainerStartup indicates an expected call of SetContainerStartup
-func (mr *MockManagerMockRecorder) SetContainerStartup(podUID, containerID, started interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetContainerStartup", reflect.TypeOf((*MockManager)(nil).SetContainerStartup), podUID, containerID, started)
-}
-
-// TerminatePod mocks base method
-func (m *MockManager) TerminatePod(pod *v1.Pod) {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "TerminatePod", pod)
-}
-
-// TerminatePod indicates an expected call of TerminatePod
-func (mr *MockManagerMockRecorder) TerminatePod(pod interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminatePod", reflect.TypeOf((*MockManager)(nil).TerminatePod), pod)
-}
-
-// RemoveOrphanedStatuses mocks base method
 func (m *MockManager) RemoveOrphanedStatuses(podUIDs map[types.UID]bool) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "RemoveOrphanedStatuses", podUIDs)
 }
 
-// RemoveOrphanedStatuses indicates an expected call of RemoveOrphanedStatuses
+// 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)
+}

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

@@ -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
+// CloseResponse mocks base method.
-func (m *MockInterface) Send(ctx context.Context, request *http.Request) (*http.Response, *retry.Error) {
+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
+// GetResource indicates an expected call of GetResource.
-func (mr *MockInterfaceMockRecorder) Send(ctx, request interface{}) *gomock.Call {
+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
+// GetResourceWithDecorators mocks base method.
-func (m *MockInterface) PreparePutRequest(ctx context.Context, decorators ...autorest.PrepareDecorator) (*http.Request, error) {
+func (m *MockInterface) GetResourceWithDecorators(ctx context.Context, resourceID string, decorators []autorest.PrepareDecorator) (*http.Response, *retry.Error) {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{ctx}
+	ret := m.ctrl.Call(m, "GetResourceWithDecorators", ctx, resourceID, decorators)
-	for _, a := range decorators {
+	ret0, _ := ret[0].(*http.Response)
-		varargs = append(varargs, a)
+	ret1, _ := ret[1].(*retry.Error)
-	}
-	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
+// GetResourceWithDecorators indicates an expected call of GetResourceWithDecorators.
-func (mr *MockInterfaceMockRecorder) PreparePutRequest(ctx interface{}, decorators ...interface{}) *gomock.Call {
+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, "GetResourceWithDecorators", reflect.TypeOf((*MockInterface)(nil).GetResourceWithDecorators), ctx, resourceID, decorators)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreparePutRequest", reflect.TypeOf((*MockInterface)(nil).PreparePutRequest), varargs...)
 }
 
-// PreparePostRequest mocks base method
+// HeadResource mocks base method.
-func (m *MockInterface) PreparePostRequest(ctx context.Context, decorators ...autorest.PrepareDecorator) (*http.Request, error) {
+func (m *MockInterface) HeadResource(ctx context.Context, resourceID string) (*http.Response, *retry.Error) {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{ctx}
+	ret := m.ctrl.Call(m, "HeadResource", ctx, resourceID)
-	for _, a := range decorators {
+	ret0, _ := ret[0].(*http.Response)
-		varargs = append(varargs, a)
+	ret1, _ := ret[1].(*retry.Error)
-	}
-	ret := m.ctrl.Call(m, "PreparePostRequest", varargs...)
-	ret0, _ := ret[0].(*http.Request)
-	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// PreparePostRequest indicates an expected call of PreparePostRequest
+// HeadResource indicates an expected call of HeadResource.
-func (mr *MockInterfaceMockRecorder) PreparePostRequest(ctx interface{}, decorators ...interface{}) *gomock.Call {
+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, "HeadResource", reflect.TypeOf((*MockInterface)(nil).HeadResource), ctx, resourceID)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreparePostRequest", reflect.TypeOf((*MockInterface)(nil).PreparePostRequest), varargs...)
 }
 
-// PrepareGetRequest mocks base method
+// PatchResource mocks base method.
-func (m *MockInterface) PrepareGetRequest(ctx context.Context, decorators ...autorest.PrepareDecorator) (*http.Request, error) {
+func (m *MockInterface) PatchResource(ctx context.Context, resourceID string, parameters interface{}) (*http.Response, *retry.Error) {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{ctx}
+	ret := m.ctrl.Call(m, "PatchResource", ctx, resourceID, parameters)
-	for _, a := range decorators {
+	ret0, _ := ret[0].(*http.Response)
-		varargs = append(varargs, a)
+	ret1, _ := ret[1].(*retry.Error)
-	}
-	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
+// PatchResource indicates an expected call of PatchResource.
-func (mr *MockInterfaceMockRecorder) PrepareGetRequest(ctx interface{}, decorators ...interface{}) *gomock.Call {
+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, "PatchResource", reflect.TypeOf((*MockInterface)(nil).PatchResource), ctx, resourceID, parameters)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareGetRequest", reflect.TypeOf((*MockInterface)(nil).PrepareGetRequest), varargs...)
 }
 
-// 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
+// PreparePostRequest mocks base method.
-func (m *MockInterface) WaitForAsyncOperationCompletion(ctx context.Context, future *azure.Future, asyncOperationName string) error {
+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)
+	varargs := []interface{}{ctx}
-	ret0, _ := ret[0].(error)
+	for _, a := range decorators {
-	return ret0
+		varargs = append(varargs, a)
-}
+	}
-
+	ret := m.ctrl.Call(m, "PreparePostRequest", varargs...)
-// WaitForAsyncOperationCompletion indicates an expected call of WaitForAsyncOperationCompletion
+	ret0, _ := ret[0].(*http.Request)
-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)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// WaitForAsyncOperationResult indicates an expected call of WaitForAsyncOperationResult
+// PreparePostRequest indicates an expected call of PreparePostRequest.
-func (mr *MockInterfaceMockRecorder) WaitForAsyncOperationResult(ctx, future, asyncOperationName interface{}) *gomock.Call {
+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
+// WaitForAsyncOperationCompletion mocks base method.
-func (m *MockInterface) PutResource(ctx context.Context, resourceID string, parameters interface{}) (*http.Response, *retry.Error) {
+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)
+	ret := m.ctrl.Call(m, "WaitForAsyncOperationCompletion", ctx, future, asyncOperationName)
-	ret0, _ := ret[0].(*http.Response)
+	ret0, _ := ret[0].(error)
-	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)
 	return ret0
 }
 
-// PutResources indicates an expected call of PutResources
+// WaitForAsyncOperationCompletion indicates an expected call of WaitForAsyncOperationCompletion.
-func (mr *MockInterfaceMockRecorder) PutResources(ctx, resources interface{}) *gomock.Call {
+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
+// WaitForAsyncOperationResult mocks base method.
-func (m *MockInterface) PutResourceWithDecorators(ctx context.Context, resourceID string, parameters interface{}, decorators []autorest.PrepareDecorator) (*http.Response, *retry.Error) {
+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
+// WaitForAsyncOperationResult indicates an expected call of WaitForAsyncOperationResult.
-func (mr *MockInterfaceMockRecorder) PutResourceWithDecorators(ctx, resourceID, parameters, decorators interface{}) *gomock.Call {
+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)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForAsyncOperationResult", reflect.TypeOf((*MockInterface)(nil).WaitForAsyncOperationResult), ctx, future, asyncOperationName)
-}
-
-// 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)
 }

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

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

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

@@ -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
+// CreateOrUpdate mocks base method.
-func (m *MockInterface) Get(ctx context.Context, resourceGroupName, deploymentName string) (resources.DeploymentExtended, *retry.Error) {
+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)
+	ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, resourceGroupName, managedClusterName, parameters, etag)
-	ret0, _ := ret[0].(resources.DeploymentExtended)
+	ret0, _ := ret[0].(*retry.Error)
-	ret1, _ := ret[1].(*retry.Error)
+	return ret0
-	return ret0, ret1
 }
 
-// Get indicates an expected call of Get
+// CreateOrUpdate indicates an expected call of CreateOrUpdate.
-func (mr *MockInterfaceMockRecorder) Get(ctx, resourceGroupName, deploymentName interface{}) *gomock.Call {
+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
+// Delete mocks base method.
-func (m *MockInterface) List(ctx context.Context, resourceGroupName string) ([]resources.DeploymentExtended, *retry.Error) {
+func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, deploymentName string) *retry.Error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "List", ctx, resourceGroupName)
+	ret := m.ctrl.Call(m, "Delete", ctx, resourceGroupName, deploymentName)
-	ret0, _ := ret[0].([]resources.DeploymentExtended)
+	ret0, _ := ret[0].(*retry.Error)
-	ret1, _ := ret[1].(*retry.Error)
+	return ret0
-	return ret0, ret1
 }
 
-// List indicates an expected call of List
+// Delete indicates an expected call of Delete.
-func (mr *MockInterfaceMockRecorder) List(ctx, resourceGroupName interface{}) *gomock.Call {
+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
+// Get mocks base method.
-func (m *MockInterface) CreateOrUpdate(ctx context.Context, resourceGroupName, managedClusterName string, parameters resources.Deployment, etag string) *retry.Error {
+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)
+	ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, deploymentName)
-	ret0, _ := ret[0].(*retry.Error)
+	ret0, _ := ret[0].(resources.DeploymentExtended)
-	return ret0
+	ret1, _ := ret[1].(*retry.Error)
+	return ret0, ret1
 }
 
-// CreateOrUpdate indicates an expected call of CreateOrUpdate
+// Get indicates an expected call of Get.
-func (mr *MockInterfaceMockRecorder) CreateOrUpdate(ctx, resourceGroupName, managedClusterName, parameters, etag interface{}) *gomock.Call {
+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
+// List mocks base method.
-func (m *MockInterface) Delete(ctx context.Context, resourceGroupName, deploymentName string) *retry.Error {
+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)
+	ret := m.ctrl.Call(m, "List", ctx, resourceGroupName)
-	ret0, _ := ret[0].(*retry.Error)
+	ret0, _ := ret[0].([]resources.DeploymentExtended)
-	return ret0
+	ret1, _ := ret[1].(*retry.Error)
+	return ret0, ret1
 }
 
-// Delete indicates an expected call of Delete
+// List indicates an expected call of List.
-func (mr *MockInterfaceMockRecorder) Delete(ctx, resourceGroupName, deploymentName interface{}) *gomock.Call {
+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)
 }

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

@@ -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
+// ListByResourceGroup 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
 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)
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -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
+// ListByResourceGroup 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
 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)
-}

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

@@ -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
+// GetProperties 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
 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)
+}

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

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

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

@@ -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
+// Update 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
 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)
-}

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

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

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

@@ -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
+// CreateOrUpdate 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
 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
+// DeallocateInstancesAsync 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
 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
+// DeleteInstances mocks base method.
-func (m *MockInterface) WaitForDeallocateInstancesResult(ctx context.Context, future *azure.Future, resourceGroupName string) (*http.Response, error) {
+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)
+	ret := m.ctrl.Call(m, "DeleteInstances", ctx, resourceGroupName, vmScaleSetName, vmInstanceIDs)
-	ret0, _ := ret[0].(*http.Response)
+	ret0, _ := ret[0].(*retry.Error)
-	ret1, _ := ret[1].(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
+// DeleteInstancesAsync indicates an expected call of DeleteInstancesAsync.
-func (mr *MockInterfaceMockRecorder) WaitForDeallocateInstancesResult(ctx, future, resourceGroupName interface{}) *gomock.Call {
+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)

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

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

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

@@ -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
+// AttachDisk mocks base method.
-func (m *MockVMSet) GetInstanceIDByNodeName(name string) (string, error) {
+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)
+	ret := m.ctrl.Call(m, "AttachDisk", isManagedDisk, diskName, diskURI, nodeName, lun, cachingMode, diskEncryptionSetID, writeAcceleratorEnabled)
-	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)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// EnsureHostsInPool indicates an expected call of EnsureHostsInPool
+// AttachDisk indicates an expected call of AttachDisk.
-func (mr *MockVMSetMockRecorder) EnsureHostsInPool(service, nodes, backendPoolID, vmSetName, isInternal interface{}) *gomock.Call {
+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
+// EnsureHostsInPool mocks base method.
-func (m *MockVMSet) EnsureBackendPoolDeleted(service *v1.Service, backendPoolID, vmSetName string, backendAddressPools *[]network.BackendAddressPool, deleteFromVMSet bool) error {
+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
+// EnsureHostsInPool indicates an expected call of EnsureHostsInPool.
-func (mr *MockVMSetMockRecorder) EnsureBackendPoolDeleted(service, backendPoolID, vmSetName, backendAddressPools, deleteFromVMSet interface{}) *gomock.Call {
+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
+// GetDataDisks 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
 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
+// GetIPByNodeName mocks base method.
-func (m *MockVMSet) GetPowerStatusByNodeName(name string) (string, error) {
+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
+// GetInstanceIDByNodeName indicates an expected call of GetInstanceIDByNodeName.
-func (mr *MockVMSetMockRecorder) GetPowerStatusByNodeName(name interface{}) *gomock.Call {
+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
+// GetInstanceTypeByNodeName mocks base method.
-func (m *MockVMSet) GetProvisioningStateByNodeName(name string) (string, error) {
+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
+// GetInstanceTypeByNodeName indicates an expected call of GetInstanceTypeByNodeName.
-func (mr *MockVMSetMockRecorder) GetProvisioningStateByNodeName(name interface{}) *gomock.Call {
+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
+// GetNodeNameByIPConfigurationID 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
 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)
+}

test/e2e/storage/drivers/csi-test/driver/driver.mock.go

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

test/instrumentation/stability-utils.sh

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

test/integration/apimachinery/watch_restart_test.go

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