From 34a59f2b093cf7518a263073951fd85457ecfb48 Mon Sep 17 00:00:00 2001 From: Travis Rhoden Date: Fri, 22 Jun 2018 12:19:46 -0600 Subject: [PATCH] Update generated mock code Update driver/driver.mock.go, by using `mockgen` that is built from the project's current version of golang/mock, which is v1.1.1. This generates vastly updated code. --- driver/driver.mock.go | 845 +++++++++--------------------------------- 1 file changed, 175 insertions(+), 670 deletions(-) diff --git a/driver/driver.mock.go b/driver/driver.mock.go index abd7d610..f6d2b135 100644 --- a/driver/driver.mock.go +++ b/driver/driver.mock.go @@ -1,849 +1,354 @@ -// Automatically generated by MockGen. DO NOT EDIT! -// Source: ../vendor/github.com/container-storage-interface/spec/lib/go/csi/v0/csi.pb.go +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/container-storage-interface/spec/lib/go/csi/v0 (interfaces: IdentityServer,ControllerServer,NodeServer) +// Package driver is a generated GoMock package. package driver import ( + context "context" v0 "github.com/container-storage-interface/spec/lib/go/csi/v0" gomock "github.com/golang/mock/gomock" - context "golang.org/x/net/context" - grpc "google.golang.org/grpc" + reflect "reflect" ) -// Mock of isPluginCapability_Type interface -type MockisPluginCapability_Type struct { - ctrl *gomock.Controller - recorder *_MockisPluginCapability_TypeRecorder -} - -// Recorder for MockisPluginCapability_Type (not exported) -type _MockisPluginCapability_TypeRecorder struct { - mock *MockisPluginCapability_Type -} - -func NewMockisPluginCapability_Type(ctrl *gomock.Controller) *MockisPluginCapability_Type { - mock := &MockisPluginCapability_Type{ctrl: ctrl} - mock.recorder = &_MockisPluginCapability_TypeRecorder{mock} - return mock -} - -func (_m *MockisPluginCapability_Type) EXPECT() *_MockisPluginCapability_TypeRecorder { - return _m.recorder -} - -func (_m *MockisPluginCapability_Type) isPluginCapability_Type() { - _m.ctrl.Call(_m, "isPluginCapability_Type") -} - -func (_mr *_MockisPluginCapability_TypeRecorder) isPluginCapability_Type() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "isPluginCapability_Type") -} - -// Mock of isVolumeContentSource_Type interface -type MockisVolumeContentSource_Type struct { - ctrl *gomock.Controller - recorder *_MockisVolumeContentSource_TypeRecorder -} - -// Recorder for MockisVolumeContentSource_Type (not exported) -type _MockisVolumeContentSource_TypeRecorder struct { - mock *MockisVolumeContentSource_Type -} - -func NewMockisVolumeContentSource_Type(ctrl *gomock.Controller) *MockisVolumeContentSource_Type { - mock := &MockisVolumeContentSource_Type{ctrl: ctrl} - mock.recorder = &_MockisVolumeContentSource_TypeRecorder{mock} - return mock -} - -func (_m *MockisVolumeContentSource_Type) EXPECT() *_MockisVolumeContentSource_TypeRecorder { - return _m.recorder -} - -func (_m *MockisVolumeContentSource_Type) isVolumeContentSource_Type() { - _m.ctrl.Call(_m, "isVolumeContentSource_Type") -} - -func (_mr *_MockisVolumeContentSource_TypeRecorder) isVolumeContentSource_Type() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "isVolumeContentSource_Type") -} - -// Mock of isVolumeCapability_AccessType interface -type MockisVolumeCapability_AccessType struct { - ctrl *gomock.Controller - recorder *_MockisVolumeCapability_AccessTypeRecorder -} - -// Recorder for MockisVolumeCapability_AccessType (not exported) -type _MockisVolumeCapability_AccessTypeRecorder struct { - mock *MockisVolumeCapability_AccessType -} - -func NewMockisVolumeCapability_AccessType(ctrl *gomock.Controller) *MockisVolumeCapability_AccessType { - mock := &MockisVolumeCapability_AccessType{ctrl: ctrl} - mock.recorder = &_MockisVolumeCapability_AccessTypeRecorder{mock} - return mock -} - -func (_m *MockisVolumeCapability_AccessType) EXPECT() *_MockisVolumeCapability_AccessTypeRecorder { - return _m.recorder -} - -func (_m *MockisVolumeCapability_AccessType) isVolumeCapability_AccessType() { - _m.ctrl.Call(_m, "isVolumeCapability_AccessType") -} - -func (_mr *_MockisVolumeCapability_AccessTypeRecorder) isVolumeCapability_AccessType() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "isVolumeCapability_AccessType") -} - -// Mock of isControllerServiceCapability_Type interface -type MockisControllerServiceCapability_Type struct { - ctrl *gomock.Controller - recorder *_MockisControllerServiceCapability_TypeRecorder -} - -// Recorder for MockisControllerServiceCapability_Type (not exported) -type _MockisControllerServiceCapability_TypeRecorder struct { - mock *MockisControllerServiceCapability_Type -} - -func NewMockisControllerServiceCapability_Type(ctrl *gomock.Controller) *MockisControllerServiceCapability_Type { - mock := &MockisControllerServiceCapability_Type{ctrl: ctrl} - mock.recorder = &_MockisControllerServiceCapability_TypeRecorder{mock} - return mock -} - -func (_m *MockisControllerServiceCapability_Type) EXPECT() *_MockisControllerServiceCapability_TypeRecorder { - return _m.recorder -} - -func (_m *MockisControllerServiceCapability_Type) isControllerServiceCapability_Type() { - _m.ctrl.Call(_m, "isControllerServiceCapability_Type") -} - -func (_mr *_MockisControllerServiceCapability_TypeRecorder) isControllerServiceCapability_Type() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "isControllerServiceCapability_Type") -} - -// Mock of isNodeServiceCapability_Type interface -type MockisNodeServiceCapability_Type struct { - ctrl *gomock.Controller - recorder *_MockisNodeServiceCapability_TypeRecorder -} - -// Recorder for MockisNodeServiceCapability_Type (not exported) -type _MockisNodeServiceCapability_TypeRecorder struct { - mock *MockisNodeServiceCapability_Type -} - -func NewMockisNodeServiceCapability_Type(ctrl *gomock.Controller) *MockisNodeServiceCapability_Type { - mock := &MockisNodeServiceCapability_Type{ctrl: ctrl} - mock.recorder = &_MockisNodeServiceCapability_TypeRecorder{mock} - return mock -} - -func (_m *MockisNodeServiceCapability_Type) EXPECT() *_MockisNodeServiceCapability_TypeRecorder { - return _m.recorder -} - -func (_m *MockisNodeServiceCapability_Type) isNodeServiceCapability_Type() { - _m.ctrl.Call(_m, "isNodeServiceCapability_Type") -} - -func (_mr *_MockisNodeServiceCapability_TypeRecorder) isNodeServiceCapability_Type() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "isNodeServiceCapability_Type") -} - -// Mock of IdentityClient interface -type MockIdentityClient struct { - ctrl *gomock.Controller - recorder *_MockIdentityClientRecorder -} - -// Recorder for MockIdentityClient (not exported) -type _MockIdentityClientRecorder struct { - mock *MockIdentityClient -} - -func NewMockIdentityClient(ctrl *gomock.Controller) *MockIdentityClient { - mock := &MockIdentityClient{ctrl: ctrl} - mock.recorder = &_MockIdentityClientRecorder{mock} - return mock -} - -func (_m *MockIdentityClient) EXPECT() *_MockIdentityClientRecorder { - return _m.recorder -} - -func (_m *MockIdentityClient) GetPluginInfo(ctx context.Context, in *v0.GetPluginInfoRequest, opts ...grpc.CallOption) (*v0.GetPluginInfoResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "GetPluginInfo", _s...) - ret0, _ := ret[0].(*v0.GetPluginInfoResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockIdentityClientRecorder) GetPluginInfo(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPluginInfo", _s...) -} - -func (_m *MockIdentityClient) GetPluginCapabilities(ctx context.Context, in *v0.GetPluginCapabilitiesRequest, opts ...grpc.CallOption) (*v0.GetPluginCapabilitiesResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "GetPluginCapabilities", _s...) - ret0, _ := ret[0].(*v0.GetPluginCapabilitiesResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockIdentityClientRecorder) GetPluginCapabilities(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPluginCapabilities", _s...) -} - -func (_m *MockIdentityClient) Probe(ctx context.Context, in *v0.ProbeRequest, opts ...grpc.CallOption) (*v0.ProbeResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "Probe", _s...) - ret0, _ := ret[0].(*v0.ProbeResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockIdentityClientRecorder) Probe(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "Probe", _s...) -} - -// Mock of IdentityServer interface +// MockIdentityServer is a mock of IdentityServer interface type MockIdentityServer struct { ctrl *gomock.Controller - recorder *_MockIdentityServerRecorder + recorder *MockIdentityServerMockRecorder } -// Recorder for MockIdentityServer (not exported) -type _MockIdentityServerRecorder struct { +// MockIdentityServerMockRecorder is the mock recorder for MockIdentityServer +type MockIdentityServerMockRecorder struct { mock *MockIdentityServer } +// NewMockIdentityServer creates a new mock instance func NewMockIdentityServer(ctrl *gomock.Controller) *MockIdentityServer { mock := &MockIdentityServer{ctrl: ctrl} - mock.recorder = &_MockIdentityServerRecorder{mock} + mock.recorder = &MockIdentityServerMockRecorder{mock} return mock } -func (_m *MockIdentityServer) EXPECT() *_MockIdentityServerRecorder { - return _m.recorder -} - -func (_m *MockIdentityServer) GetPluginInfo(_param0 context.Context, _param1 *v0.GetPluginInfoRequest) (*v0.GetPluginInfoResponse, error) { - ret := _m.ctrl.Call(_m, "GetPluginInfo", _param0, _param1) - ret0, _ := ret[0].(*v0.GetPluginInfoResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockIdentityServerRecorder) GetPluginInfo(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPluginInfo", arg0, arg1) +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockIdentityServer) EXPECT() *MockIdentityServerMockRecorder { + return m.recorder } -func (_m *MockIdentityServer) GetPluginCapabilities(_param0 context.Context, _param1 *v0.GetPluginCapabilitiesRequest) (*v0.GetPluginCapabilitiesResponse, error) { - ret := _m.ctrl.Call(_m, "GetPluginCapabilities", _param0, _param1) +// GetPluginCapabilities mocks base method +func (m *MockIdentityServer) GetPluginCapabilities(arg0 context.Context, arg1 *v0.GetPluginCapabilitiesRequest) (*v0.GetPluginCapabilitiesResponse, error) { + ret := m.ctrl.Call(m, "GetPluginCapabilities", arg0, arg1) ret0, _ := ret[0].(*v0.GetPluginCapabilitiesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockIdentityServerRecorder) GetPluginCapabilities(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPluginCapabilities", arg0, arg1) -} - -func (_m *MockIdentityServer) Probe(_param0 context.Context, _param1 *v0.ProbeRequest) (*v0.ProbeResponse, error) { - ret := _m.ctrl.Call(_m, "Probe", _param0, _param1) - ret0, _ := ret[0].(*v0.ProbeResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockIdentityServerRecorder) Probe(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Probe", arg0, arg1) +// GetPluginCapabilities indicates an expected call of GetPluginCapabilities +func (mr *MockIdentityServerMockRecorder) GetPluginCapabilities(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPluginCapabilities", reflect.TypeOf((*MockIdentityServer)(nil).GetPluginCapabilities), arg0, arg1) } -// Mock of ControllerClient interface -type MockControllerClient struct { - ctrl *gomock.Controller - recorder *_MockControllerClientRecorder -} - -// Recorder for MockControllerClient (not exported) -type _MockControllerClientRecorder struct { - mock *MockControllerClient -} - -func NewMockControllerClient(ctrl *gomock.Controller) *MockControllerClient { - mock := &MockControllerClient{ctrl: ctrl} - mock.recorder = &_MockControllerClientRecorder{mock} - return mock -} - -func (_m *MockControllerClient) EXPECT() *_MockControllerClientRecorder { - return _m.recorder -} - -func (_m *MockControllerClient) CreateVolume(ctx context.Context, in *v0.CreateVolumeRequest, opts ...grpc.CallOption) (*v0.CreateVolumeResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "CreateVolume", _s...) - ret0, _ := ret[0].(*v0.CreateVolumeResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerClientRecorder) CreateVolume(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateVolume", _s...) -} - -func (_m *MockControllerClient) DeleteVolume(ctx context.Context, in *v0.DeleteVolumeRequest, opts ...grpc.CallOption) (*v0.DeleteVolumeResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "DeleteVolume", _s...) - ret0, _ := ret[0].(*v0.DeleteVolumeResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerClientRecorder) DeleteVolume(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteVolume", _s...) -} - -func (_m *MockControllerClient) ControllerPublishVolume(ctx context.Context, in *v0.ControllerPublishVolumeRequest, opts ...grpc.CallOption) (*v0.ControllerPublishVolumeResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "ControllerPublishVolume", _s...) - ret0, _ := ret[0].(*v0.ControllerPublishVolumeResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerClientRecorder) ControllerPublishVolume(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ControllerPublishVolume", _s...) -} - -func (_m *MockControllerClient) ControllerUnpublishVolume(ctx context.Context, in *v0.ControllerUnpublishVolumeRequest, opts ...grpc.CallOption) (*v0.ControllerUnpublishVolumeResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "ControllerUnpublishVolume", _s...) - ret0, _ := ret[0].(*v0.ControllerUnpublishVolumeResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerClientRecorder) ControllerUnpublishVolume(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ControllerUnpublishVolume", _s...) -} - -func (_m *MockControllerClient) ValidateVolumeCapabilities(ctx context.Context, in *v0.ValidateVolumeCapabilitiesRequest, opts ...grpc.CallOption) (*v0.ValidateVolumeCapabilitiesResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "ValidateVolumeCapabilities", _s...) - ret0, _ := ret[0].(*v0.ValidateVolumeCapabilitiesResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerClientRecorder) ValidateVolumeCapabilities(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ValidateVolumeCapabilities", _s...) -} - -func (_m *MockControllerClient) ListVolumes(ctx context.Context, in *v0.ListVolumesRequest, opts ...grpc.CallOption) (*v0.ListVolumesResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "ListVolumes", _s...) - ret0, _ := ret[0].(*v0.ListVolumesResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerClientRecorder) ListVolumes(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListVolumes", _s...) -} - -func (_m *MockControllerClient) GetCapacity(ctx context.Context, in *v0.GetCapacityRequest, opts ...grpc.CallOption) (*v0.GetCapacityResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "GetCapacity", _s...) - ret0, _ := ret[0].(*v0.GetCapacityResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerClientRecorder) GetCapacity(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetCapacity", _s...) -} - -func (_m *MockControllerClient) ControllerGetCapabilities(ctx context.Context, in *v0.ControllerGetCapabilitiesRequest, opts ...grpc.CallOption) (*v0.ControllerGetCapabilitiesResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "ControllerGetCapabilities", _s...) - ret0, _ := ret[0].(*v0.ControllerGetCapabilitiesResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerClientRecorder) ControllerGetCapabilities(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ControllerGetCapabilities", _s...) -} - -func (_m *MockControllerClient) CreateSnapshot(ctx context.Context, in *v0.CreateSnapshotRequest, opts ...grpc.CallOption) (*v0.CreateSnapshotResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "CreateSnapshot", _s...) - ret0, _ := ret[0].(*v0.CreateSnapshotResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerClientRecorder) CreateSnapshot(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateSnapshot", _s...) -} - -func (_m *MockControllerClient) DeleteSnapshot(ctx context.Context, in *v0.DeleteSnapshotRequest, opts ...grpc.CallOption) (*v0.DeleteSnapshotResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "DeleteSnapshot", _s...) - ret0, _ := ret[0].(*v0.DeleteSnapshotResponse) +// GetPluginInfo mocks base method +func (m *MockIdentityServer) GetPluginInfo(arg0 context.Context, arg1 *v0.GetPluginInfoRequest) (*v0.GetPluginInfoResponse, error) { + ret := m.ctrl.Call(m, "GetPluginInfo", arg0, arg1) + ret0, _ := ret[0].(*v0.GetPluginInfoResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockControllerClientRecorder) DeleteSnapshot(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteSnapshot", _s...) +// GetPluginInfo indicates an expected call of GetPluginInfo +func (mr *MockIdentityServerMockRecorder) GetPluginInfo(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPluginInfo", reflect.TypeOf((*MockIdentityServer)(nil).GetPluginInfo), arg0, arg1) } -func (_m *MockControllerClient) ListSnapshots(ctx context.Context, in *v0.ListSnapshotsRequest, opts ...grpc.CallOption) (*v0.ListSnapshotsResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "ListSnapshots", _s...) - ret0, _ := ret[0].(*v0.ListSnapshotsResponse) +// Probe mocks base method +func (m *MockIdentityServer) Probe(arg0 context.Context, arg1 *v0.ProbeRequest) (*v0.ProbeResponse, error) { + ret := m.ctrl.Call(m, "Probe", arg0, arg1) + ret0, _ := ret[0].(*v0.ProbeResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockControllerClientRecorder) ListSnapshots(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListSnapshots", _s...) +// Probe indicates an expected call of Probe +func (mr *MockIdentityServerMockRecorder) Probe(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Probe", reflect.TypeOf((*MockIdentityServer)(nil).Probe), arg0, arg1) } -// Mock of ControllerServer interface +// MockControllerServer is a mock of ControllerServer interface type MockControllerServer struct { ctrl *gomock.Controller - recorder *_MockControllerServerRecorder + recorder *MockControllerServerMockRecorder } -// Recorder for MockControllerServer (not exported) -type _MockControllerServerRecorder struct { +// MockControllerServerMockRecorder is the mock recorder for MockControllerServer +type MockControllerServerMockRecorder struct { mock *MockControllerServer } +// NewMockControllerServer creates a new mock instance func NewMockControllerServer(ctrl *gomock.Controller) *MockControllerServer { mock := &MockControllerServer{ctrl: ctrl} - mock.recorder = &_MockControllerServerRecorder{mock} + mock.recorder = &MockControllerServerMockRecorder{mock} return mock } -func (_m *MockControllerServer) EXPECT() *_MockControllerServerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockControllerServer) EXPECT() *MockControllerServerMockRecorder { + return m.recorder } -func (_m *MockControllerServer) CreateVolume(_param0 context.Context, _param1 *v0.CreateVolumeRequest) (*v0.CreateVolumeResponse, error) { - ret := _m.ctrl.Call(_m, "CreateVolume", _param0, _param1) - ret0, _ := ret[0].(*v0.CreateVolumeResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerServerRecorder) CreateVolume(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateVolume", arg0, arg1) -} - -func (_m *MockControllerServer) DeleteVolume(_param0 context.Context, _param1 *v0.DeleteVolumeRequest) (*v0.DeleteVolumeResponse, error) { - ret := _m.ctrl.Call(_m, "DeleteVolume", _param0, _param1) - ret0, _ := ret[0].(*v0.DeleteVolumeResponse) +// ControllerGetCapabilities mocks base method +func (m *MockControllerServer) ControllerGetCapabilities(arg0 context.Context, arg1 *v0.ControllerGetCapabilitiesRequest) (*v0.ControllerGetCapabilitiesResponse, error) { + ret := m.ctrl.Call(m, "ControllerGetCapabilities", arg0, arg1) + ret0, _ := ret[0].(*v0.ControllerGetCapabilitiesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockControllerServerRecorder) DeleteVolume(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteVolume", arg0, arg1) +// ControllerGetCapabilities indicates an expected call of ControllerGetCapabilities +func (mr *MockControllerServerMockRecorder) ControllerGetCapabilities(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerGetCapabilities", reflect.TypeOf((*MockControllerServer)(nil).ControllerGetCapabilities), arg0, arg1) } -func (_m *MockControllerServer) ControllerPublishVolume(_param0 context.Context, _param1 *v0.ControllerPublishVolumeRequest) (*v0.ControllerPublishVolumeResponse, error) { - ret := _m.ctrl.Call(_m, "ControllerPublishVolume", _param0, _param1) +// ControllerPublishVolume mocks base method +func (m *MockControllerServer) ControllerPublishVolume(arg0 context.Context, arg1 *v0.ControllerPublishVolumeRequest) (*v0.ControllerPublishVolumeResponse, error) { + ret := m.ctrl.Call(m, "ControllerPublishVolume", arg0, arg1) ret0, _ := ret[0].(*v0.ControllerPublishVolumeResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockControllerServerRecorder) ControllerPublishVolume(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ControllerPublishVolume", arg0, arg1) +// ControllerPublishVolume indicates an expected call of ControllerPublishVolume +func (mr *MockControllerServerMockRecorder) ControllerPublishVolume(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerPublishVolume", reflect.TypeOf((*MockControllerServer)(nil).ControllerPublishVolume), arg0, arg1) } -func (_m *MockControllerServer) ControllerUnpublishVolume(_param0 context.Context, _param1 *v0.ControllerUnpublishVolumeRequest) (*v0.ControllerUnpublishVolumeResponse, error) { - ret := _m.ctrl.Call(_m, "ControllerUnpublishVolume", _param0, _param1) +// ControllerUnpublishVolume mocks base method +func (m *MockControllerServer) ControllerUnpublishVolume(arg0 context.Context, arg1 *v0.ControllerUnpublishVolumeRequest) (*v0.ControllerUnpublishVolumeResponse, error) { + ret := m.ctrl.Call(m, "ControllerUnpublishVolume", arg0, arg1) ret0, _ := ret[0].(*v0.ControllerUnpublishVolumeResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockControllerServerRecorder) ControllerUnpublishVolume(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ControllerUnpublishVolume", arg0, arg1) -} - -func (_m *MockControllerServer) ValidateVolumeCapabilities(_param0 context.Context, _param1 *v0.ValidateVolumeCapabilitiesRequest) (*v0.ValidateVolumeCapabilitiesResponse, error) { - ret := _m.ctrl.Call(_m, "ValidateVolumeCapabilities", _param0, _param1) - ret0, _ := ret[0].(*v0.ValidateVolumeCapabilitiesResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerServerRecorder) ValidateVolumeCapabilities(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ValidateVolumeCapabilities", arg0, arg1) -} - -func (_m *MockControllerServer) ListVolumes(_param0 context.Context, _param1 *v0.ListVolumesRequest) (*v0.ListVolumesResponse, error) { - ret := _m.ctrl.Call(_m, "ListVolumes", _param0, _param1) - ret0, _ := ret[0].(*v0.ListVolumesResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerServerRecorder) ListVolumes(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListVolumes", arg0, arg1) -} - -func (_m *MockControllerServer) GetCapacity(_param0 context.Context, _param1 *v0.GetCapacityRequest) (*v0.GetCapacityResponse, error) { - ret := _m.ctrl.Call(_m, "GetCapacity", _param0, _param1) - ret0, _ := ret[0].(*v0.GetCapacityResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerServerRecorder) GetCapacity(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetCapacity", arg0, arg1) -} - -func (_m *MockControllerServer) ControllerGetCapabilities(_param0 context.Context, _param1 *v0.ControllerGetCapabilitiesRequest) (*v0.ControllerGetCapabilitiesResponse, error) { - ret := _m.ctrl.Call(_m, "ControllerGetCapabilities", _param0, _param1) - ret0, _ := ret[0].(*v0.ControllerGetCapabilitiesResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerServerRecorder) ControllerGetCapabilities(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ControllerGetCapabilities", arg0, arg1) +// ControllerUnpublishVolume indicates an expected call of ControllerUnpublishVolume +func (mr *MockControllerServerMockRecorder) ControllerUnpublishVolume(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerUnpublishVolume", reflect.TypeOf((*MockControllerServer)(nil).ControllerUnpublishVolume), arg0, arg1) } -func (_m *MockControllerServer) CreateSnapshot(_param0 context.Context, _param1 *v0.CreateSnapshotRequest) (*v0.CreateSnapshotResponse, error) { - ret := _m.ctrl.Call(_m, "CreateSnapshot", _param0, _param1) +// CreateSnapshot mocks base method +func (m *MockControllerServer) CreateSnapshot(arg0 context.Context, arg1 *v0.CreateSnapshotRequest) (*v0.CreateSnapshotResponse, error) { + ret := m.ctrl.Call(m, "CreateSnapshot", arg0, arg1) ret0, _ := ret[0].(*v0.CreateSnapshotResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockControllerServerRecorder) CreateSnapshot(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateSnapshot", arg0, arg1) -} - -func (_m *MockControllerServer) DeleteSnapshot(_param0 context.Context, _param1 *v0.DeleteSnapshotRequest) (*v0.DeleteSnapshotResponse, error) { - ret := _m.ctrl.Call(_m, "DeleteSnapshot", _param0, _param1) - ret0, _ := ret[0].(*v0.DeleteSnapshotResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerServerRecorder) DeleteSnapshot(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteSnapshot", arg0, arg1) -} - -func (_m *MockControllerServer) ListSnapshots(_param0 context.Context, _param1 *v0.ListSnapshotsRequest) (*v0.ListSnapshotsResponse, error) { - ret := _m.ctrl.Call(_m, "ListSnapshots", _param0, _param1) - ret0, _ := ret[0].(*v0.ListSnapshotsResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -func (_mr *_MockControllerServerRecorder) ListSnapshots(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListSnapshots", arg0, arg1) -} - -// Mock of NodeClient interface -type MockNodeClient struct { - ctrl *gomock.Controller - recorder *_MockNodeClientRecorder -} - -// Recorder for MockNodeClient (not exported) -type _MockNodeClientRecorder struct { - mock *MockNodeClient -} - -func NewMockNodeClient(ctrl *gomock.Controller) *MockNodeClient { - mock := &MockNodeClient{ctrl: ctrl} - mock.recorder = &_MockNodeClientRecorder{mock} - return mock +// CreateSnapshot indicates an expected call of CreateSnapshot +func (mr *MockControllerServerMockRecorder) CreateSnapshot(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockControllerServer)(nil).CreateSnapshot), arg0, arg1) } -func (_m *MockNodeClient) EXPECT() *_MockNodeClientRecorder { - return _m.recorder -} - -func (_m *MockNodeClient) NodeStageVolume(ctx context.Context, in *v0.NodeStageVolumeRequest, opts ...grpc.CallOption) (*v0.NodeStageVolumeResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "NodeStageVolume", _s...) - ret0, _ := ret[0].(*v0.NodeStageVolumeResponse) +// CreateVolume mocks base method +func (m *MockControllerServer) CreateVolume(arg0 context.Context, arg1 *v0.CreateVolumeRequest) (*v0.CreateVolumeResponse, error) { + ret := m.ctrl.Call(m, "CreateVolume", arg0, arg1) + ret0, _ := ret[0].(*v0.CreateVolumeResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeClientRecorder) NodeStageVolume(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeStageVolume", _s...) +// CreateVolume indicates an expected call of CreateVolume +func (mr *MockControllerServerMockRecorder) CreateVolume(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolume", reflect.TypeOf((*MockControllerServer)(nil).CreateVolume), arg0, arg1) } -func (_m *MockNodeClient) NodeUnstageVolume(ctx context.Context, in *v0.NodeUnstageVolumeRequest, opts ...grpc.CallOption) (*v0.NodeUnstageVolumeResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "NodeUnstageVolume", _s...) - ret0, _ := ret[0].(*v0.NodeUnstageVolumeResponse) +// DeleteSnapshot mocks base method +func (m *MockControllerServer) DeleteSnapshot(arg0 context.Context, arg1 *v0.DeleteSnapshotRequest) (*v0.DeleteSnapshotResponse, error) { + ret := m.ctrl.Call(m, "DeleteSnapshot", arg0, arg1) + ret0, _ := ret[0].(*v0.DeleteSnapshotResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeClientRecorder) NodeUnstageVolume(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeUnstageVolume", _s...) +// DeleteSnapshot indicates an expected call of DeleteSnapshot +func (mr *MockControllerServerMockRecorder) DeleteSnapshot(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockControllerServer)(nil).DeleteSnapshot), arg0, arg1) } -func (_m *MockNodeClient) NodePublishVolume(ctx context.Context, in *v0.NodePublishVolumeRequest, opts ...grpc.CallOption) (*v0.NodePublishVolumeResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "NodePublishVolume", _s...) - ret0, _ := ret[0].(*v0.NodePublishVolumeResponse) +// DeleteVolume mocks base method +func (m *MockControllerServer) DeleteVolume(arg0 context.Context, arg1 *v0.DeleteVolumeRequest) (*v0.DeleteVolumeResponse, error) { + ret := m.ctrl.Call(m, "DeleteVolume", arg0, arg1) + ret0, _ := ret[0].(*v0.DeleteVolumeResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeClientRecorder) NodePublishVolume(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodePublishVolume", _s...) +// DeleteVolume indicates an expected call of DeleteVolume +func (mr *MockControllerServerMockRecorder) DeleteVolume(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolume", reflect.TypeOf((*MockControllerServer)(nil).DeleteVolume), arg0, arg1) } -func (_m *MockNodeClient) NodeUnpublishVolume(ctx context.Context, in *v0.NodeUnpublishVolumeRequest, opts ...grpc.CallOption) (*v0.NodeUnpublishVolumeResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "NodeUnpublishVolume", _s...) - ret0, _ := ret[0].(*v0.NodeUnpublishVolumeResponse) +// GetCapacity mocks base method +func (m *MockControllerServer) GetCapacity(arg0 context.Context, arg1 *v0.GetCapacityRequest) (*v0.GetCapacityResponse, error) { + ret := m.ctrl.Call(m, "GetCapacity", arg0, arg1) + ret0, _ := ret[0].(*v0.GetCapacityResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeClientRecorder) NodeUnpublishVolume(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeUnpublishVolume", _s...) +// GetCapacity indicates an expected call of GetCapacity +func (mr *MockControllerServerMockRecorder) GetCapacity(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacity", reflect.TypeOf((*MockControllerServer)(nil).GetCapacity), arg0, arg1) } -func (_m *MockNodeClient) NodeGetId(ctx context.Context, in *v0.NodeGetIdRequest, opts ...grpc.CallOption) (*v0.NodeGetIdResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "NodeGetId", _s...) - ret0, _ := ret[0].(*v0.NodeGetIdResponse) +// ListSnapshots mocks base method +func (m *MockControllerServer) ListSnapshots(arg0 context.Context, arg1 *v0.ListSnapshotsRequest) (*v0.ListSnapshotsResponse, error) { + ret := m.ctrl.Call(m, "ListSnapshots", arg0, arg1) + ret0, _ := ret[0].(*v0.ListSnapshotsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeClientRecorder) NodeGetId(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeGetId", _s...) +// ListSnapshots indicates an expected call of ListSnapshots +func (mr *MockControllerServerMockRecorder) ListSnapshots(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshots", reflect.TypeOf((*MockControllerServer)(nil).ListSnapshots), arg0, arg1) } -func (_m *MockNodeClient) NodeGetCapabilities(ctx context.Context, in *v0.NodeGetCapabilitiesRequest, opts ...grpc.CallOption) (*v0.NodeGetCapabilitiesResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "NodeGetCapabilities", _s...) - ret0, _ := ret[0].(*v0.NodeGetCapabilitiesResponse) +// ListVolumes mocks base method +func (m *MockControllerServer) ListVolumes(arg0 context.Context, arg1 *v0.ListVolumesRequest) (*v0.ListVolumesResponse, error) { + ret := m.ctrl.Call(m, "ListVolumes", arg0, arg1) + ret0, _ := ret[0].(*v0.ListVolumesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeClientRecorder) NodeGetCapabilities(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeGetCapabilities", _s...) +// ListVolumes indicates an expected call of ListVolumes +func (mr *MockControllerServerMockRecorder) ListVolumes(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVolumes", reflect.TypeOf((*MockControllerServer)(nil).ListVolumes), arg0, arg1) } -func (_m *MockNodeClient) NodeGetInfo(ctx context.Context, in *v0.NodeGetInfoRequest, opts ...grpc.CallOption) (*v0.NodeGetInfoResponse, error) { - _s := []interface{}{ctx, in} - for _, _x := range opts { - _s = append(_s, _x) - } - ret := _m.ctrl.Call(_m, "NodeGetInfo", _s...) - ret0, _ := ret[0].(*v0.NodeGetInfoResponse) +// ValidateVolumeCapabilities mocks base method +func (m *MockControllerServer) ValidateVolumeCapabilities(arg0 context.Context, arg1 *v0.ValidateVolumeCapabilitiesRequest) (*v0.ValidateVolumeCapabilitiesResponse, error) { + ret := m.ctrl.Call(m, "ValidateVolumeCapabilities", arg0, arg1) + ret0, _ := ret[0].(*v0.ValidateVolumeCapabilitiesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeClientRecorder) NodeGetInfo(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0, arg1}, arg2...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeGetInfo", _s...) +// ValidateVolumeCapabilities indicates an expected call of ValidateVolumeCapabilities +func (mr *MockControllerServerMockRecorder) ValidateVolumeCapabilities(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateVolumeCapabilities", reflect.TypeOf((*MockControllerServer)(nil).ValidateVolumeCapabilities), arg0, arg1) } -// Mock of NodeServer interface +// MockNodeServer is a mock of NodeServer interface type MockNodeServer struct { ctrl *gomock.Controller - recorder *_MockNodeServerRecorder + recorder *MockNodeServerMockRecorder } -// Recorder for MockNodeServer (not exported) -type _MockNodeServerRecorder struct { +// MockNodeServerMockRecorder is the mock recorder for MockNodeServer +type MockNodeServerMockRecorder struct { mock *MockNodeServer } +// NewMockNodeServer creates a new mock instance func NewMockNodeServer(ctrl *gomock.Controller) *MockNodeServer { mock := &MockNodeServer{ctrl: ctrl} - mock.recorder = &_MockNodeServerRecorder{mock} + mock.recorder = &MockNodeServerMockRecorder{mock} return mock } -func (_m *MockNodeServer) EXPECT() *_MockNodeServerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockNodeServer) EXPECT() *MockNodeServerMockRecorder { + return m.recorder } -func (_m *MockNodeServer) NodeStageVolume(_param0 context.Context, _param1 *v0.NodeStageVolumeRequest) (*v0.NodeStageVolumeResponse, error) { - ret := _m.ctrl.Call(_m, "NodeStageVolume", _param0, _param1) - ret0, _ := ret[0].(*v0.NodeStageVolumeResponse) +// NodeGetCapabilities mocks base method +func (m *MockNodeServer) NodeGetCapabilities(arg0 context.Context, arg1 *v0.NodeGetCapabilitiesRequest) (*v0.NodeGetCapabilitiesResponse, error) { + ret := m.ctrl.Call(m, "NodeGetCapabilities", arg0, arg1) + ret0, _ := ret[0].(*v0.NodeGetCapabilitiesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeServerRecorder) NodeStageVolume(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeStageVolume", arg0, arg1) +// NodeGetCapabilities indicates an expected call of NodeGetCapabilities +func (mr *MockNodeServerMockRecorder) NodeGetCapabilities(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeGetCapabilities", reflect.TypeOf((*MockNodeServer)(nil).NodeGetCapabilities), arg0, arg1) } -func (_m *MockNodeServer) NodeUnstageVolume(_param0 context.Context, _param1 *v0.NodeUnstageVolumeRequest) (*v0.NodeUnstageVolumeResponse, error) { - ret := _m.ctrl.Call(_m, "NodeUnstageVolume", _param0, _param1) - ret0, _ := ret[0].(*v0.NodeUnstageVolumeResponse) +// NodeGetId mocks base method +func (m *MockNodeServer) NodeGetId(arg0 context.Context, arg1 *v0.NodeGetIdRequest) (*v0.NodeGetIdResponse, error) { + ret := m.ctrl.Call(m, "NodeGetId", arg0, arg1) + ret0, _ := ret[0].(*v0.NodeGetIdResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeServerRecorder) NodeUnstageVolume(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeUnstageVolume", arg0, arg1) +// NodeGetId indicates an expected call of NodeGetId +func (mr *MockNodeServerMockRecorder) NodeGetId(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeGetId", reflect.TypeOf((*MockNodeServer)(nil).NodeGetId), arg0, arg1) } -func (_m *MockNodeServer) NodePublishVolume(_param0 context.Context, _param1 *v0.NodePublishVolumeRequest) (*v0.NodePublishVolumeResponse, error) { - ret := _m.ctrl.Call(_m, "NodePublishVolume", _param0, _param1) - ret0, _ := ret[0].(*v0.NodePublishVolumeResponse) +// NodeGetInfo mocks base method +func (m *MockNodeServer) NodeGetInfo(arg0 context.Context, arg1 *v0.NodeGetInfoRequest) (*v0.NodeGetInfoResponse, error) { + ret := m.ctrl.Call(m, "NodeGetInfo", arg0, arg1) + ret0, _ := ret[0].(*v0.NodeGetInfoResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeServerRecorder) NodePublishVolume(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodePublishVolume", arg0, arg1) +// NodeGetInfo indicates an expected call of NodeGetInfo +func (mr *MockNodeServerMockRecorder) NodeGetInfo(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeGetInfo", reflect.TypeOf((*MockNodeServer)(nil).NodeGetInfo), arg0, arg1) } -func (_m *MockNodeServer) NodeUnpublishVolume(_param0 context.Context, _param1 *v0.NodeUnpublishVolumeRequest) (*v0.NodeUnpublishVolumeResponse, error) { - ret := _m.ctrl.Call(_m, "NodeUnpublishVolume", _param0, _param1) - ret0, _ := ret[0].(*v0.NodeUnpublishVolumeResponse) +// NodePublishVolume mocks base method +func (m *MockNodeServer) NodePublishVolume(arg0 context.Context, arg1 *v0.NodePublishVolumeRequest) (*v0.NodePublishVolumeResponse, error) { + ret := m.ctrl.Call(m, "NodePublishVolume", arg0, arg1) + ret0, _ := ret[0].(*v0.NodePublishVolumeResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeServerRecorder) NodeUnpublishVolume(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeUnpublishVolume", arg0, arg1) +// NodePublishVolume indicates an expected call of NodePublishVolume +func (mr *MockNodeServerMockRecorder) NodePublishVolume(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodePublishVolume", reflect.TypeOf((*MockNodeServer)(nil).NodePublishVolume), arg0, arg1) } -func (_m *MockNodeServer) NodeGetId(_param0 context.Context, _param1 *v0.NodeGetIdRequest) (*v0.NodeGetIdResponse, error) { - ret := _m.ctrl.Call(_m, "NodeGetId", _param0, _param1) - ret0, _ := ret[0].(*v0.NodeGetIdResponse) +// NodeStageVolume mocks base method +func (m *MockNodeServer) NodeStageVolume(arg0 context.Context, arg1 *v0.NodeStageVolumeRequest) (*v0.NodeStageVolumeResponse, error) { + ret := m.ctrl.Call(m, "NodeStageVolume", arg0, arg1) + ret0, _ := ret[0].(*v0.NodeStageVolumeResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeServerRecorder) NodeGetId(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeGetId", arg0, arg1) +// NodeStageVolume indicates an expected call of NodeStageVolume +func (mr *MockNodeServerMockRecorder) NodeStageVolume(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeStageVolume", reflect.TypeOf((*MockNodeServer)(nil).NodeStageVolume), arg0, arg1) } -func (_m *MockNodeServer) NodeGetCapabilities(_param0 context.Context, _param1 *v0.NodeGetCapabilitiesRequest) (*v0.NodeGetCapabilitiesResponse, error) { - ret := _m.ctrl.Call(_m, "NodeGetCapabilities", _param0, _param1) - ret0, _ := ret[0].(*v0.NodeGetCapabilitiesResponse) +// NodeUnpublishVolume mocks base method +func (m *MockNodeServer) NodeUnpublishVolume(arg0 context.Context, arg1 *v0.NodeUnpublishVolumeRequest) (*v0.NodeUnpublishVolumeResponse, error) { + ret := m.ctrl.Call(m, "NodeUnpublishVolume", arg0, arg1) + ret0, _ := ret[0].(*v0.NodeUnpublishVolumeResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeServerRecorder) NodeGetCapabilities(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeGetCapabilities", arg0, arg1) +// NodeUnpublishVolume indicates an expected call of NodeUnpublishVolume +func (mr *MockNodeServerMockRecorder) NodeUnpublishVolume(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeUnpublishVolume", reflect.TypeOf((*MockNodeServer)(nil).NodeUnpublishVolume), arg0, arg1) } -func (_m *MockNodeServer) NodeGetInfo(_param0 context.Context, _param1 *v0.NodeGetInfoRequest) (*v0.NodeGetInfoResponse, error) { - ret := _m.ctrl.Call(_m, "NodeGetInfo", _param0, _param1) - ret0, _ := ret[0].(*v0.NodeGetInfoResponse) +// NodeUnstageVolume mocks base method +func (m *MockNodeServer) NodeUnstageVolume(arg0 context.Context, arg1 *v0.NodeUnstageVolumeRequest) (*v0.NodeUnstageVolumeResponse, error) { + ret := m.ctrl.Call(m, "NodeUnstageVolume", arg0, arg1) + ret0, _ := ret[0].(*v0.NodeUnstageVolumeResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNodeServerRecorder) NodeGetInfo(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeGetInfo", arg0, arg1) +// NodeUnstageVolume indicates an expected call of NodeUnstageVolume +func (mr *MockNodeServerMockRecorder) NodeUnstageVolume(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeUnstageVolume", reflect.TypeOf((*MockNodeServer)(nil).NodeUnstageVolume), arg0, arg1) }