From a3e102e4564477a10a99b50c2313e15d181b79f2 Mon Sep 17 00:00:00 2001 From: Jakub Date: Fri, 11 Jun 2021 13:45:00 +0200 Subject: [PATCH] GODT-1166: Do not expose current auth token in interface --- internal/store/mocks/mocks.go | 96 +++++------ internal/store/mocks/utils_mocks.go | 36 ++-- internal/transfer/mocks/mocks.go | 60 +++---- internal/users/mocks/listener_mocks.go | 36 ++-- internal/users/mocks/mocks.go | 84 ++++----- pkg/message/mocks/mocks.go | 20 +-- pkg/pmapi/client_types.go | 2 - pkg/pmapi/mocks/mocks.go | 230 ++++++++++++------------- test/context/users.go | 11 +- test/liveapi/persistent_clients.go | 22 ++- 10 files changed, 300 insertions(+), 297 deletions(-) diff --git a/internal/store/mocks/mocks.go b/internal/store/mocks/mocks.go index acb846be..7adf0ed3 100644 --- a/internal/store/mocks/mocks.go +++ b/internal/store/mocks/mocks.go @@ -12,89 +12,89 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockPanicHandler is a mock of PanicHandler interface +// MockPanicHandler is a mock of PanicHandler interface. type MockPanicHandler struct { ctrl *gomock.Controller recorder *MockPanicHandlerMockRecorder } -// MockPanicHandlerMockRecorder is the mock recorder for MockPanicHandler +// MockPanicHandlerMockRecorder is the mock recorder for MockPanicHandler. type MockPanicHandlerMockRecorder struct { mock *MockPanicHandler } -// NewMockPanicHandler creates a new mock instance +// NewMockPanicHandler creates a new mock instance. func NewMockPanicHandler(ctrl *gomock.Controller) *MockPanicHandler { mock := &MockPanicHandler{ctrl: ctrl} mock.recorder = &MockPanicHandlerMockRecorder{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 *MockPanicHandler) EXPECT() *MockPanicHandlerMockRecorder { return m.recorder } -// HandlePanic mocks base method +// HandlePanic mocks base method. func (m *MockPanicHandler) HandlePanic() { m.ctrl.T.Helper() m.ctrl.Call(m, "HandlePanic") } -// HandlePanic indicates an expected call of HandlePanic +// HandlePanic indicates an expected call of HandlePanic. func (mr *MockPanicHandlerMockRecorder) HandlePanic() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandlePanic", reflect.TypeOf((*MockPanicHandler)(nil).HandlePanic)) } -// MockBridgeUser is a mock of BridgeUser interface +// MockBridgeUser is a mock of BridgeUser interface. type MockBridgeUser struct { ctrl *gomock.Controller recorder *MockBridgeUserMockRecorder } -// MockBridgeUserMockRecorder is the mock recorder for MockBridgeUser +// MockBridgeUserMockRecorder is the mock recorder for MockBridgeUser. type MockBridgeUserMockRecorder struct { mock *MockBridgeUser } -// NewMockBridgeUser creates a new mock instance +// NewMockBridgeUser creates a new mock instance. func NewMockBridgeUser(ctrl *gomock.Controller) *MockBridgeUser { mock := &MockBridgeUser{ctrl: ctrl} mock.recorder = &MockBridgeUserMockRecorder{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 *MockBridgeUser) EXPECT() *MockBridgeUserMockRecorder { return m.recorder } -// CloseAllConnections mocks base method +// CloseAllConnections mocks base method. func (m *MockBridgeUser) CloseAllConnections() { m.ctrl.T.Helper() m.ctrl.Call(m, "CloseAllConnections") } -// CloseAllConnections indicates an expected call of CloseAllConnections +// CloseAllConnections indicates an expected call of CloseAllConnections. func (mr *MockBridgeUserMockRecorder) CloseAllConnections() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseAllConnections", reflect.TypeOf((*MockBridgeUser)(nil).CloseAllConnections)) } -// CloseConnection mocks base method +// CloseConnection mocks base method. func (m *MockBridgeUser) CloseConnection(arg0 string) { m.ctrl.T.Helper() m.ctrl.Call(m, "CloseConnection", arg0) } -// CloseConnection indicates an expected call of CloseConnection +// CloseConnection indicates an expected call of CloseConnection. func (mr *MockBridgeUserMockRecorder) CloseConnection(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseConnection", reflect.TypeOf((*MockBridgeUser)(nil).CloseConnection), arg0) } -// GetAddressID mocks base method +// GetAddressID mocks base method. func (m *MockBridgeUser) GetAddressID(arg0 string) (string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetAddressID", arg0) @@ -103,13 +103,13 @@ func (m *MockBridgeUser) GetAddressID(arg0 string) (string, error) { return ret0, ret1 } -// GetAddressID indicates an expected call of GetAddressID +// GetAddressID indicates an expected call of GetAddressID. func (mr *MockBridgeUserMockRecorder) GetAddressID(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddressID", reflect.TypeOf((*MockBridgeUser)(nil).GetAddressID), arg0) } -// GetClient mocks base method +// GetClient mocks base method. func (m *MockBridgeUser) GetClient() pmapi.Client { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetClient") @@ -117,13 +117,13 @@ func (m *MockBridgeUser) GetClient() pmapi.Client { return ret0 } -// GetClient indicates an expected call of GetClient +// GetClient indicates an expected call of GetClient. func (mr *MockBridgeUserMockRecorder) GetClient() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockBridgeUser)(nil).GetClient)) } -// GetPrimaryAddress mocks base method +// GetPrimaryAddress mocks base method. func (m *MockBridgeUser) GetPrimaryAddress() string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPrimaryAddress") @@ -131,13 +131,13 @@ func (m *MockBridgeUser) GetPrimaryAddress() string { return ret0 } -// GetPrimaryAddress indicates an expected call of GetPrimaryAddress +// GetPrimaryAddress indicates an expected call of GetPrimaryAddress. func (mr *MockBridgeUserMockRecorder) GetPrimaryAddress() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrimaryAddress", reflect.TypeOf((*MockBridgeUser)(nil).GetPrimaryAddress)) } -// GetStoreAddresses mocks base method +// GetStoreAddresses mocks base method. func (m *MockBridgeUser) GetStoreAddresses() []string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetStoreAddresses") @@ -145,13 +145,13 @@ func (m *MockBridgeUser) GetStoreAddresses() []string { return ret0 } -// GetStoreAddresses indicates an expected call of GetStoreAddresses +// GetStoreAddresses indicates an expected call of GetStoreAddresses. func (mr *MockBridgeUserMockRecorder) GetStoreAddresses() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoreAddresses", reflect.TypeOf((*MockBridgeUser)(nil).GetStoreAddresses)) } -// ID mocks base method +// ID mocks base method. func (m *MockBridgeUser) ID() string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ID") @@ -159,13 +159,13 @@ func (m *MockBridgeUser) ID() string { return ret0 } -// ID indicates an expected call of ID +// ID indicates an expected call of ID. func (mr *MockBridgeUserMockRecorder) ID() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockBridgeUser)(nil).ID)) } -// IsCombinedAddressMode mocks base method +// IsCombinedAddressMode mocks base method. func (m *MockBridgeUser) IsCombinedAddressMode() bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IsCombinedAddressMode") @@ -173,13 +173,13 @@ func (m *MockBridgeUser) IsCombinedAddressMode() bool { return ret0 } -// IsCombinedAddressMode indicates an expected call of IsCombinedAddressMode +// IsCombinedAddressMode indicates an expected call of IsCombinedAddressMode. func (mr *MockBridgeUserMockRecorder) IsCombinedAddressMode() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsCombinedAddressMode", reflect.TypeOf((*MockBridgeUser)(nil).IsCombinedAddressMode)) } -// IsConnected mocks base method +// IsConnected mocks base method. func (m *MockBridgeUser) IsConnected() bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IsConnected") @@ -187,13 +187,13 @@ func (m *MockBridgeUser) IsConnected() bool { return ret0 } -// IsConnected indicates an expected call of IsConnected +// IsConnected indicates an expected call of IsConnected. func (mr *MockBridgeUserMockRecorder) IsConnected() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConnected", reflect.TypeOf((*MockBridgeUser)(nil).IsConnected)) } -// Logout mocks base method +// Logout mocks base method. func (m *MockBridgeUser) Logout() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Logout") @@ -201,13 +201,13 @@ func (m *MockBridgeUser) Logout() error { return ret0 } -// Logout indicates an expected call of Logout +// Logout indicates an expected call of Logout. func (mr *MockBridgeUserMockRecorder) Logout() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Logout", reflect.TypeOf((*MockBridgeUser)(nil).Logout)) } -// UpdateUser mocks base method +// UpdateUser mocks base method. func (m *MockBridgeUser) UpdateUser(arg0 context.Context) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateUser", arg0) @@ -215,36 +215,36 @@ func (m *MockBridgeUser) UpdateUser(arg0 context.Context) error { return ret0 } -// UpdateUser indicates an expected call of UpdateUser +// UpdateUser indicates an expected call of UpdateUser. func (mr *MockBridgeUserMockRecorder) UpdateUser(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUser", reflect.TypeOf((*MockBridgeUser)(nil).UpdateUser), arg0) } -// MockChangeNotifier is a mock of ChangeNotifier interface +// MockChangeNotifier is a mock of ChangeNotifier interface. type MockChangeNotifier struct { ctrl *gomock.Controller recorder *MockChangeNotifierMockRecorder } -// MockChangeNotifierMockRecorder is the mock recorder for MockChangeNotifier +// MockChangeNotifierMockRecorder is the mock recorder for MockChangeNotifier. type MockChangeNotifierMockRecorder struct { mock *MockChangeNotifier } -// NewMockChangeNotifier creates a new mock instance +// NewMockChangeNotifier creates a new mock instance. func NewMockChangeNotifier(ctrl *gomock.Controller) *MockChangeNotifier { mock := &MockChangeNotifier{ctrl: ctrl} mock.recorder = &MockChangeNotifierMockRecorder{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 *MockChangeNotifier) EXPECT() *MockChangeNotifierMockRecorder { return m.recorder } -// CanDelete mocks base method +// CanDelete mocks base method. func (m *MockChangeNotifier) CanDelete(arg0 string) (bool, func()) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CanDelete", arg0) @@ -253,67 +253,67 @@ func (m *MockChangeNotifier) CanDelete(arg0 string) (bool, func()) { return ret0, ret1 } -// CanDelete indicates an expected call of CanDelete +// CanDelete indicates an expected call of CanDelete. func (mr *MockChangeNotifierMockRecorder) CanDelete(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CanDelete", reflect.TypeOf((*MockChangeNotifier)(nil).CanDelete), arg0) } -// DeleteMessage mocks base method +// DeleteMessage mocks base method. func (m *MockChangeNotifier) DeleteMessage(arg0, arg1 string, arg2 uint32) { m.ctrl.T.Helper() m.ctrl.Call(m, "DeleteMessage", arg0, arg1, arg2) } -// DeleteMessage indicates an expected call of DeleteMessage +// DeleteMessage indicates an expected call of DeleteMessage. func (mr *MockChangeNotifierMockRecorder) DeleteMessage(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessage", reflect.TypeOf((*MockChangeNotifier)(nil).DeleteMessage), arg0, arg1, arg2) } -// MailboxCreated mocks base method +// MailboxCreated mocks base method. func (m *MockChangeNotifier) MailboxCreated(arg0, arg1 string) { m.ctrl.T.Helper() m.ctrl.Call(m, "MailboxCreated", arg0, arg1) } -// MailboxCreated indicates an expected call of MailboxCreated +// MailboxCreated indicates an expected call of MailboxCreated. func (mr *MockChangeNotifierMockRecorder) MailboxCreated(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MailboxCreated", reflect.TypeOf((*MockChangeNotifier)(nil).MailboxCreated), arg0, arg1) } -// MailboxStatus mocks base method +// MailboxStatus mocks base method. func (m *MockChangeNotifier) MailboxStatus(arg0, arg1 string, arg2, arg3, arg4 uint32) { m.ctrl.T.Helper() m.ctrl.Call(m, "MailboxStatus", arg0, arg1, arg2, arg3, arg4) } -// MailboxStatus indicates an expected call of MailboxStatus +// MailboxStatus indicates an expected call of MailboxStatus. func (mr *MockChangeNotifierMockRecorder) MailboxStatus(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MailboxStatus", reflect.TypeOf((*MockChangeNotifier)(nil).MailboxStatus), arg0, arg1, arg2, arg3, arg4) } -// Notice mocks base method +// Notice mocks base method. func (m *MockChangeNotifier) Notice(arg0, arg1 string) { m.ctrl.T.Helper() m.ctrl.Call(m, "Notice", arg0, arg1) } -// Notice indicates an expected call of Notice +// Notice indicates an expected call of Notice. func (mr *MockChangeNotifierMockRecorder) Notice(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Notice", reflect.TypeOf((*MockChangeNotifier)(nil).Notice), arg0, arg1) } -// UpdateMessage mocks base method +// UpdateMessage mocks base method. func (m *MockChangeNotifier) UpdateMessage(arg0, arg1 string, arg2, arg3 uint32, arg4 *pmapi.Message, arg5 bool) { m.ctrl.T.Helper() m.ctrl.Call(m, "UpdateMessage", arg0, arg1, arg2, arg3, arg4, arg5) } -// UpdateMessage indicates an expected call of UpdateMessage +// UpdateMessage indicates an expected call of UpdateMessage. func (mr *MockChangeNotifierMockRecorder) UpdateMessage(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMessage", reflect.TypeOf((*MockChangeNotifier)(nil).UpdateMessage), arg0, arg1, arg2, arg3, arg4, arg5) diff --git a/internal/store/mocks/utils_mocks.go b/internal/store/mocks/utils_mocks.go index 8a6c8677..ec99aa03 100644 --- a/internal/store/mocks/utils_mocks.go +++ b/internal/store/mocks/utils_mocks.go @@ -11,54 +11,54 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockListener is a mock of Listener interface +// MockListener is a mock of Listener interface. type MockListener struct { ctrl *gomock.Controller recorder *MockListenerMockRecorder } -// MockListenerMockRecorder is the mock recorder for MockListener +// MockListenerMockRecorder is the mock recorder for MockListener. type MockListenerMockRecorder struct { mock *MockListener } -// NewMockListener creates a new mock instance +// NewMockListener creates a new mock instance. func NewMockListener(ctrl *gomock.Controller) *MockListener { mock := &MockListener{ctrl: ctrl} mock.recorder = &MockListenerMockRecorder{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 *MockListener) EXPECT() *MockListenerMockRecorder { return m.recorder } -// Add mocks base method +// Add mocks base method. func (m *MockListener) Add(arg0 string, arg1 chan<- string) { m.ctrl.T.Helper() m.ctrl.Call(m, "Add", arg0, arg1) } -// Add indicates an expected call of Add +// Add indicates an expected call of Add. func (mr *MockListenerMockRecorder) Add(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockListener)(nil).Add), arg0, arg1) } -// Emit mocks base method +// Emit mocks base method. func (m *MockListener) Emit(arg0, arg1 string) { m.ctrl.T.Helper() m.ctrl.Call(m, "Emit", arg0, arg1) } -// Emit indicates an expected call of Emit +// Emit indicates an expected call of Emit. func (mr *MockListenerMockRecorder) Emit(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Emit", reflect.TypeOf((*MockListener)(nil).Emit), arg0, arg1) } -// ProvideChannel mocks base method +// ProvideChannel mocks base method. func (m *MockListener) ProvideChannel(arg0 string) <-chan string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ProvideChannel", arg0) @@ -66,55 +66,55 @@ func (m *MockListener) ProvideChannel(arg0 string) <-chan string { return ret0 } -// ProvideChannel indicates an expected call of ProvideChannel +// ProvideChannel indicates an expected call of ProvideChannel. func (mr *MockListenerMockRecorder) ProvideChannel(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvideChannel", reflect.TypeOf((*MockListener)(nil).ProvideChannel), arg0) } -// Remove mocks base method +// Remove mocks base method. func (m *MockListener) Remove(arg0 string, arg1 chan<- string) { m.ctrl.T.Helper() m.ctrl.Call(m, "Remove", arg0, arg1) } -// Remove indicates an expected call of Remove +// Remove indicates an expected call of Remove. func (mr *MockListenerMockRecorder) Remove(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockListener)(nil).Remove), arg0, arg1) } -// RetryEmit mocks base method +// RetryEmit mocks base method. func (m *MockListener) RetryEmit(arg0 string) { m.ctrl.T.Helper() m.ctrl.Call(m, "RetryEmit", arg0) } -// RetryEmit indicates an expected call of RetryEmit +// RetryEmit indicates an expected call of RetryEmit. func (mr *MockListenerMockRecorder) RetryEmit(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetryEmit", reflect.TypeOf((*MockListener)(nil).RetryEmit), arg0) } -// SetBuffer mocks base method +// SetBuffer mocks base method. func (m *MockListener) SetBuffer(arg0 string) { m.ctrl.T.Helper() m.ctrl.Call(m, "SetBuffer", arg0) } -// SetBuffer indicates an expected call of SetBuffer +// SetBuffer indicates an expected call of SetBuffer. func (mr *MockListenerMockRecorder) SetBuffer(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBuffer", reflect.TypeOf((*MockListener)(nil).SetBuffer), arg0) } -// SetLimit mocks base method +// SetLimit mocks base method. func (m *MockListener) SetLimit(arg0 string, arg1 time.Duration) { m.ctrl.T.Helper() m.ctrl.Call(m, "SetLimit", arg0, arg1) } -// SetLimit indicates an expected call of SetLimit +// SetLimit indicates an expected call of SetLimit. func (mr *MockListenerMockRecorder) SetLimit(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLimit", reflect.TypeOf((*MockListener)(nil).SetLimit), arg0, arg1) diff --git a/internal/transfer/mocks/mocks.go b/internal/transfer/mocks/mocks.go index 1c8040e0..3b57b51d 100644 --- a/internal/transfer/mocks/mocks.go +++ b/internal/transfer/mocks/mocks.go @@ -12,65 +12,65 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockPanicHandler is a mock of PanicHandler interface +// MockPanicHandler is a mock of PanicHandler interface. type MockPanicHandler struct { ctrl *gomock.Controller recorder *MockPanicHandlerMockRecorder } -// MockPanicHandlerMockRecorder is the mock recorder for MockPanicHandler +// MockPanicHandlerMockRecorder is the mock recorder for MockPanicHandler. type MockPanicHandlerMockRecorder struct { mock *MockPanicHandler } -// NewMockPanicHandler creates a new mock instance +// NewMockPanicHandler creates a new mock instance. func NewMockPanicHandler(ctrl *gomock.Controller) *MockPanicHandler { mock := &MockPanicHandler{ctrl: ctrl} mock.recorder = &MockPanicHandlerMockRecorder{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 *MockPanicHandler) EXPECT() *MockPanicHandlerMockRecorder { return m.recorder } -// HandlePanic mocks base method +// HandlePanic mocks base method. func (m *MockPanicHandler) HandlePanic() { m.ctrl.T.Helper() m.ctrl.Call(m, "HandlePanic") } -// HandlePanic indicates an expected call of HandlePanic +// HandlePanic indicates an expected call of HandlePanic. func (mr *MockPanicHandlerMockRecorder) HandlePanic() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandlePanic", reflect.TypeOf((*MockPanicHandler)(nil).HandlePanic)) } -// MockIMAPClientProvider is a mock of IMAPClientProvider interface +// MockIMAPClientProvider is a mock of IMAPClientProvider interface. type MockIMAPClientProvider struct { ctrl *gomock.Controller recorder *MockIMAPClientProviderMockRecorder } -// MockIMAPClientProviderMockRecorder is the mock recorder for MockIMAPClientProvider +// MockIMAPClientProviderMockRecorder is the mock recorder for MockIMAPClientProvider. type MockIMAPClientProviderMockRecorder struct { mock *MockIMAPClientProvider } -// NewMockIMAPClientProvider creates a new mock instance +// NewMockIMAPClientProvider creates a new mock instance. func NewMockIMAPClientProvider(ctrl *gomock.Controller) *MockIMAPClientProvider { mock := &MockIMAPClientProvider{ctrl: ctrl} mock.recorder = &MockIMAPClientProviderMockRecorder{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 *MockIMAPClientProvider) EXPECT() *MockIMAPClientProviderMockRecorder { return m.recorder } -// Authenticate mocks base method +// Authenticate mocks base method. func (m *MockIMAPClientProvider) Authenticate(arg0 sasl.Client) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Authenticate", arg0) @@ -78,13 +78,13 @@ func (m *MockIMAPClientProvider) Authenticate(arg0 sasl.Client) error { return ret0 } -// Authenticate indicates an expected call of Authenticate +// Authenticate indicates an expected call of Authenticate. func (mr *MockIMAPClientProviderMockRecorder) Authenticate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Authenticate", reflect.TypeOf((*MockIMAPClientProvider)(nil).Authenticate), arg0) } -// Capability mocks base method +// Capability mocks base method. func (m *MockIMAPClientProvider) Capability() (map[string]bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Capability") @@ -93,13 +93,13 @@ func (m *MockIMAPClientProvider) Capability() (map[string]bool, error) { return ret0, ret1 } -// Capability indicates an expected call of Capability +// Capability indicates an expected call of Capability. func (mr *MockIMAPClientProviderMockRecorder) Capability() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Capability", reflect.TypeOf((*MockIMAPClientProvider)(nil).Capability)) } -// Fetch mocks base method +// Fetch mocks base method. func (m *MockIMAPClientProvider) Fetch(arg0 *imap.SeqSet, arg1 []imap.FetchItem, arg2 chan *imap.Message) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Fetch", arg0, arg1, arg2) @@ -107,13 +107,13 @@ func (m *MockIMAPClientProvider) Fetch(arg0 *imap.SeqSet, arg1 []imap.FetchItem, return ret0 } -// Fetch indicates an expected call of Fetch +// Fetch indicates an expected call of Fetch. func (mr *MockIMAPClientProviderMockRecorder) Fetch(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockIMAPClientProvider)(nil).Fetch), arg0, arg1, arg2) } -// List mocks base method +// List mocks base method. func (m *MockIMAPClientProvider) List(arg0, arg1 string, arg2 chan *imap.MailboxInfo) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List", arg0, arg1, arg2) @@ -121,13 +121,13 @@ func (m *MockIMAPClientProvider) List(arg0, arg1 string, arg2 chan *imap.Mailbox return ret0 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockIMAPClientProviderMockRecorder) List(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockIMAPClientProvider)(nil).List), arg0, arg1, arg2) } -// Login mocks base method +// Login mocks base method. func (m *MockIMAPClientProvider) Login(arg0, arg1 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Login", arg0, arg1) @@ -135,13 +135,13 @@ func (m *MockIMAPClientProvider) Login(arg0, arg1 string) error { return ret0 } -// Login indicates an expected call of Login +// Login indicates an expected call of Login. func (mr *MockIMAPClientProviderMockRecorder) Login(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Login", reflect.TypeOf((*MockIMAPClientProvider)(nil).Login), arg0, arg1) } -// Select mocks base method +// Select mocks base method. func (m *MockIMAPClientProvider) Select(arg0 string, arg1 bool) (*imap.MailboxStatus, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Select", arg0, arg1) @@ -150,13 +150,13 @@ func (m *MockIMAPClientProvider) Select(arg0 string, arg1 bool) (*imap.MailboxSt return ret0, ret1 } -// Select indicates an expected call of Select +// Select indicates an expected call of Select. func (mr *MockIMAPClientProviderMockRecorder) Select(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Select", reflect.TypeOf((*MockIMAPClientProvider)(nil).Select), arg0, arg1) } -// State mocks base method +// State mocks base method. func (m *MockIMAPClientProvider) State() imap.ConnState { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "State") @@ -164,13 +164,13 @@ func (m *MockIMAPClientProvider) State() imap.ConnState { return ret0 } -// State indicates an expected call of State +// State indicates an expected call of State. func (mr *MockIMAPClientProviderMockRecorder) State() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "State", reflect.TypeOf((*MockIMAPClientProvider)(nil).State)) } -// Support mocks base method +// Support mocks base method. func (m *MockIMAPClientProvider) Support(arg0 string) (bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Support", arg0) @@ -179,13 +179,13 @@ func (m *MockIMAPClientProvider) Support(arg0 string) (bool, error) { return ret0, ret1 } -// Support indicates an expected call of Support +// Support indicates an expected call of Support. func (mr *MockIMAPClientProviderMockRecorder) Support(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Support", reflect.TypeOf((*MockIMAPClientProvider)(nil).Support), arg0) } -// SupportAuth mocks base method +// SupportAuth mocks base method. func (m *MockIMAPClientProvider) SupportAuth(arg0 string) (bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SupportAuth", arg0) @@ -194,13 +194,13 @@ func (m *MockIMAPClientProvider) SupportAuth(arg0 string) (bool, error) { return ret0, ret1 } -// SupportAuth indicates an expected call of SupportAuth +// SupportAuth indicates an expected call of SupportAuth. func (mr *MockIMAPClientProviderMockRecorder) SupportAuth(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupportAuth", reflect.TypeOf((*MockIMAPClientProvider)(nil).SupportAuth), arg0) } -// UidFetch mocks base method +// UidFetch mocks base method. func (m *MockIMAPClientProvider) UidFetch(arg0 *imap.SeqSet, arg1 []imap.FetchItem, arg2 chan *imap.Message) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UidFetch", arg0, arg1, arg2) @@ -208,7 +208,7 @@ func (m *MockIMAPClientProvider) UidFetch(arg0 *imap.SeqSet, arg1 []imap.FetchIt return ret0 } -// UidFetch indicates an expected call of UidFetch +// UidFetch indicates an expected call of UidFetch. func (mr *MockIMAPClientProviderMockRecorder) UidFetch(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UidFetch", reflect.TypeOf((*MockIMAPClientProvider)(nil).UidFetch), arg0, arg1, arg2) diff --git a/internal/users/mocks/listener_mocks.go b/internal/users/mocks/listener_mocks.go index 8a6c8677..ec99aa03 100644 --- a/internal/users/mocks/listener_mocks.go +++ b/internal/users/mocks/listener_mocks.go @@ -11,54 +11,54 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockListener is a mock of Listener interface +// MockListener is a mock of Listener interface. type MockListener struct { ctrl *gomock.Controller recorder *MockListenerMockRecorder } -// MockListenerMockRecorder is the mock recorder for MockListener +// MockListenerMockRecorder is the mock recorder for MockListener. type MockListenerMockRecorder struct { mock *MockListener } -// NewMockListener creates a new mock instance +// NewMockListener creates a new mock instance. func NewMockListener(ctrl *gomock.Controller) *MockListener { mock := &MockListener{ctrl: ctrl} mock.recorder = &MockListenerMockRecorder{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 *MockListener) EXPECT() *MockListenerMockRecorder { return m.recorder } -// Add mocks base method +// Add mocks base method. func (m *MockListener) Add(arg0 string, arg1 chan<- string) { m.ctrl.T.Helper() m.ctrl.Call(m, "Add", arg0, arg1) } -// Add indicates an expected call of Add +// Add indicates an expected call of Add. func (mr *MockListenerMockRecorder) Add(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockListener)(nil).Add), arg0, arg1) } -// Emit mocks base method +// Emit mocks base method. func (m *MockListener) Emit(arg0, arg1 string) { m.ctrl.T.Helper() m.ctrl.Call(m, "Emit", arg0, arg1) } -// Emit indicates an expected call of Emit +// Emit indicates an expected call of Emit. func (mr *MockListenerMockRecorder) Emit(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Emit", reflect.TypeOf((*MockListener)(nil).Emit), arg0, arg1) } -// ProvideChannel mocks base method +// ProvideChannel mocks base method. func (m *MockListener) ProvideChannel(arg0 string) <-chan string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ProvideChannel", arg0) @@ -66,55 +66,55 @@ func (m *MockListener) ProvideChannel(arg0 string) <-chan string { return ret0 } -// ProvideChannel indicates an expected call of ProvideChannel +// ProvideChannel indicates an expected call of ProvideChannel. func (mr *MockListenerMockRecorder) ProvideChannel(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvideChannel", reflect.TypeOf((*MockListener)(nil).ProvideChannel), arg0) } -// Remove mocks base method +// Remove mocks base method. func (m *MockListener) Remove(arg0 string, arg1 chan<- string) { m.ctrl.T.Helper() m.ctrl.Call(m, "Remove", arg0, arg1) } -// Remove indicates an expected call of Remove +// Remove indicates an expected call of Remove. func (mr *MockListenerMockRecorder) Remove(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockListener)(nil).Remove), arg0, arg1) } -// RetryEmit mocks base method +// RetryEmit mocks base method. func (m *MockListener) RetryEmit(arg0 string) { m.ctrl.T.Helper() m.ctrl.Call(m, "RetryEmit", arg0) } -// RetryEmit indicates an expected call of RetryEmit +// RetryEmit indicates an expected call of RetryEmit. func (mr *MockListenerMockRecorder) RetryEmit(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetryEmit", reflect.TypeOf((*MockListener)(nil).RetryEmit), arg0) } -// SetBuffer mocks base method +// SetBuffer mocks base method. func (m *MockListener) SetBuffer(arg0 string) { m.ctrl.T.Helper() m.ctrl.Call(m, "SetBuffer", arg0) } -// SetBuffer indicates an expected call of SetBuffer +// SetBuffer indicates an expected call of SetBuffer. func (mr *MockListenerMockRecorder) SetBuffer(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBuffer", reflect.TypeOf((*MockListener)(nil).SetBuffer), arg0) } -// SetLimit mocks base method +// SetLimit mocks base method. func (m *MockListener) SetLimit(arg0 string, arg1 time.Duration) { m.ctrl.T.Helper() m.ctrl.Call(m, "SetLimit", arg0, arg1) } -// SetLimit indicates an expected call of SetLimit +// SetLimit indicates an expected call of SetLimit. func (mr *MockListenerMockRecorder) SetLimit(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLimit", reflect.TypeOf((*MockListener)(nil).SetLimit), arg0, arg1) diff --git a/internal/users/mocks/mocks.go b/internal/users/mocks/mocks.go index 8293f297..83e327dd 100644 --- a/internal/users/mocks/mocks.go +++ b/internal/users/mocks/mocks.go @@ -12,30 +12,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockLocator is a mock of Locator interface +// MockLocator is a mock of Locator interface. type MockLocator struct { ctrl *gomock.Controller recorder *MockLocatorMockRecorder } -// MockLocatorMockRecorder is the mock recorder for MockLocator +// MockLocatorMockRecorder is the mock recorder for MockLocator. type MockLocatorMockRecorder struct { mock *MockLocator } -// NewMockLocator creates a new mock instance +// NewMockLocator creates a new mock instance. func NewMockLocator(ctrl *gomock.Controller) *MockLocator { mock := &MockLocator{ctrl: ctrl} mock.recorder = &MockLocatorMockRecorder{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 *MockLocator) EXPECT() *MockLocatorMockRecorder { return m.recorder } -// Clear mocks base method +// Clear mocks base method. func (m *MockLocator) Clear() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Clear") @@ -43,71 +43,71 @@ func (m *MockLocator) Clear() error { return ret0 } -// Clear indicates an expected call of Clear +// Clear indicates an expected call of Clear. func (mr *MockLocatorMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockLocator)(nil).Clear)) } -// MockPanicHandler is a mock of PanicHandler interface +// MockPanicHandler is a mock of PanicHandler interface. type MockPanicHandler struct { ctrl *gomock.Controller recorder *MockPanicHandlerMockRecorder } -// MockPanicHandlerMockRecorder is the mock recorder for MockPanicHandler +// MockPanicHandlerMockRecorder is the mock recorder for MockPanicHandler. type MockPanicHandlerMockRecorder struct { mock *MockPanicHandler } -// NewMockPanicHandler creates a new mock instance +// NewMockPanicHandler creates a new mock instance. func NewMockPanicHandler(ctrl *gomock.Controller) *MockPanicHandler { mock := &MockPanicHandler{ctrl: ctrl} mock.recorder = &MockPanicHandlerMockRecorder{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 *MockPanicHandler) EXPECT() *MockPanicHandlerMockRecorder { return m.recorder } -// HandlePanic mocks base method +// HandlePanic mocks base method. func (m *MockPanicHandler) HandlePanic() { m.ctrl.T.Helper() m.ctrl.Call(m, "HandlePanic") } -// HandlePanic indicates an expected call of HandlePanic +// HandlePanic indicates an expected call of HandlePanic. func (mr *MockPanicHandlerMockRecorder) HandlePanic() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandlePanic", reflect.TypeOf((*MockPanicHandler)(nil).HandlePanic)) } -// MockCredentialsStorer is a mock of CredentialsStorer interface +// MockCredentialsStorer is a mock of CredentialsStorer interface. type MockCredentialsStorer struct { ctrl *gomock.Controller recorder *MockCredentialsStorerMockRecorder } -// MockCredentialsStorerMockRecorder is the mock recorder for MockCredentialsStorer +// MockCredentialsStorerMockRecorder is the mock recorder for MockCredentialsStorer. type MockCredentialsStorerMockRecorder struct { mock *MockCredentialsStorer } -// NewMockCredentialsStorer creates a new mock instance +// NewMockCredentialsStorer creates a new mock instance. func NewMockCredentialsStorer(ctrl *gomock.Controller) *MockCredentialsStorer { mock := &MockCredentialsStorer{ctrl: ctrl} mock.recorder = &MockCredentialsStorerMockRecorder{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 *MockCredentialsStorer) EXPECT() *MockCredentialsStorerMockRecorder { return m.recorder } -// Add mocks base method +// Add mocks base method. func (m *MockCredentialsStorer) Add(arg0, arg1, arg2, arg3 string, arg4 []byte, arg5 []string) (*credentials.Credentials, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Add", arg0, arg1, arg2, arg3, arg4, arg5) @@ -116,13 +116,13 @@ func (m *MockCredentialsStorer) Add(arg0, arg1, arg2, arg3 string, arg4 []byte, return ret0, ret1 } -// Add indicates an expected call of Add +// Add indicates an expected call of Add. func (mr *MockCredentialsStorerMockRecorder) Add(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockCredentialsStorer)(nil).Add), arg0, arg1, arg2, arg3, arg4, arg5) } -// Delete mocks base method +// Delete mocks base method. func (m *MockCredentialsStorer) Delete(arg0 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0) @@ -130,13 +130,13 @@ func (m *MockCredentialsStorer) Delete(arg0 string) error { return ret0 } -// Delete indicates an expected call of Delete +// Delete indicates an expected call of Delete. func (mr *MockCredentialsStorerMockRecorder) Delete(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockCredentialsStorer)(nil).Delete), arg0) } -// Get mocks base method +// Get mocks base method. func (m *MockCredentialsStorer) Get(arg0 string) (*credentials.Credentials, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Get", arg0) @@ -145,13 +145,13 @@ func (m *MockCredentialsStorer) Get(arg0 string) (*credentials.Credentials, erro return ret0, ret1 } -// Get indicates an expected call of Get +// Get indicates an expected call of Get. func (mr *MockCredentialsStorerMockRecorder) Get(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCredentialsStorer)(nil).Get), arg0) } -// List mocks base method +// List mocks base method. func (m *MockCredentialsStorer) List() ([]string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "List") @@ -160,13 +160,13 @@ func (m *MockCredentialsStorer) List() ([]string, error) { return ret0, ret1 } -// List indicates an expected call of List +// List indicates an expected call of List. func (mr *MockCredentialsStorerMockRecorder) List() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockCredentialsStorer)(nil).List)) } -// Logout mocks base method +// Logout mocks base method. func (m *MockCredentialsStorer) Logout(arg0 string) (*credentials.Credentials, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Logout", arg0) @@ -175,13 +175,13 @@ func (m *MockCredentialsStorer) Logout(arg0 string) (*credentials.Credentials, e return ret0, ret1 } -// Logout indicates an expected call of Logout +// Logout indicates an expected call of Logout. func (mr *MockCredentialsStorerMockRecorder) Logout(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Logout", reflect.TypeOf((*MockCredentialsStorer)(nil).Logout), arg0) } -// SwitchAddressMode mocks base method +// SwitchAddressMode mocks base method. func (m *MockCredentialsStorer) SwitchAddressMode(arg0 string) (*credentials.Credentials, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SwitchAddressMode", arg0) @@ -190,13 +190,13 @@ func (m *MockCredentialsStorer) SwitchAddressMode(arg0 string) (*credentials.Cre return ret0, ret1 } -// SwitchAddressMode indicates an expected call of SwitchAddressMode +// SwitchAddressMode indicates an expected call of SwitchAddressMode. func (mr *MockCredentialsStorerMockRecorder) SwitchAddressMode(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwitchAddressMode", reflect.TypeOf((*MockCredentialsStorer)(nil).SwitchAddressMode), arg0) } -// UpdateEmails mocks base method +// UpdateEmails mocks base method. func (m *MockCredentialsStorer) UpdateEmails(arg0 string, arg1 []string) (*credentials.Credentials, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateEmails", arg0, arg1) @@ -205,13 +205,13 @@ func (m *MockCredentialsStorer) UpdateEmails(arg0 string, arg1 []string) (*crede return ret0, ret1 } -// UpdateEmails indicates an expected call of UpdateEmails +// UpdateEmails indicates an expected call of UpdateEmails. func (mr *MockCredentialsStorerMockRecorder) UpdateEmails(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEmails", reflect.TypeOf((*MockCredentialsStorer)(nil).UpdateEmails), arg0, arg1) } -// UpdatePassword mocks base method +// UpdatePassword mocks base method. func (m *MockCredentialsStorer) UpdatePassword(arg0 string, arg1 []byte) (*credentials.Credentials, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdatePassword", arg0, arg1) @@ -220,13 +220,13 @@ func (m *MockCredentialsStorer) UpdatePassword(arg0 string, arg1 []byte) (*crede return ret0, ret1 } -// UpdatePassword indicates an expected call of UpdatePassword +// UpdatePassword indicates an expected call of UpdatePassword. func (mr *MockCredentialsStorerMockRecorder) UpdatePassword(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePassword", reflect.TypeOf((*MockCredentialsStorer)(nil).UpdatePassword), arg0, arg1) } -// UpdateToken mocks base method +// UpdateToken mocks base method. func (m *MockCredentialsStorer) UpdateToken(arg0, arg1, arg2 string) (*credentials.Credentials, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateToken", arg0, arg1, arg2) @@ -235,36 +235,36 @@ func (m *MockCredentialsStorer) UpdateToken(arg0, arg1, arg2 string) (*credentia return ret0, ret1 } -// UpdateToken indicates an expected call of UpdateToken +// UpdateToken indicates an expected call of UpdateToken. func (mr *MockCredentialsStorerMockRecorder) UpdateToken(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateToken", reflect.TypeOf((*MockCredentialsStorer)(nil).UpdateToken), arg0, arg1, arg2) } -// MockStoreMaker is a mock of StoreMaker interface +// MockStoreMaker is a mock of StoreMaker interface. type MockStoreMaker struct { ctrl *gomock.Controller recorder *MockStoreMakerMockRecorder } -// MockStoreMakerMockRecorder is the mock recorder for MockStoreMaker +// MockStoreMakerMockRecorder is the mock recorder for MockStoreMaker. type MockStoreMakerMockRecorder struct { mock *MockStoreMaker } -// NewMockStoreMaker creates a new mock instance +// NewMockStoreMaker creates a new mock instance. func NewMockStoreMaker(ctrl *gomock.Controller) *MockStoreMaker { mock := &MockStoreMaker{ctrl: ctrl} mock.recorder = &MockStoreMakerMockRecorder{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 *MockStoreMaker) EXPECT() *MockStoreMakerMockRecorder { return m.recorder } -// New mocks base method +// New mocks base method. func (m *MockStoreMaker) New(arg0 store.BridgeUser) (*store.Store, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "New", arg0) @@ -273,13 +273,13 @@ func (m *MockStoreMaker) New(arg0 store.BridgeUser) (*store.Store, error) { return ret0, ret1 } -// New indicates an expected call of New +// New indicates an expected call of New. func (mr *MockStoreMakerMockRecorder) New(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "New", reflect.TypeOf((*MockStoreMaker)(nil).New), arg0) } -// Remove mocks base method +// Remove mocks base method. func (m *MockStoreMaker) Remove(arg0 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Remove", arg0) @@ -287,7 +287,7 @@ func (m *MockStoreMaker) Remove(arg0 string) error { return ret0 } -// Remove indicates an expected call of Remove +// Remove indicates an expected call of Remove. func (mr *MockStoreMakerMockRecorder) Remove(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockStoreMaker)(nil).Remove), arg0) diff --git a/pkg/message/mocks/mocks.go b/pkg/message/mocks/mocks.go index 0aa4b7ed..4c58525d 100644 --- a/pkg/message/mocks/mocks.go +++ b/pkg/message/mocks/mocks.go @@ -14,30 +14,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockFetcher is a mock of Fetcher interface +// MockFetcher is a mock of Fetcher interface. type MockFetcher struct { ctrl *gomock.Controller recorder *MockFetcherMockRecorder } -// MockFetcherMockRecorder is the mock recorder for MockFetcher +// MockFetcherMockRecorder is the mock recorder for MockFetcher. type MockFetcherMockRecorder struct { mock *MockFetcher } -// NewMockFetcher creates a new mock instance +// NewMockFetcher creates a new mock instance. func NewMockFetcher(ctrl *gomock.Controller) *MockFetcher { mock := &MockFetcher{ctrl: ctrl} mock.recorder = &MockFetcherMockRecorder{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 *MockFetcher) EXPECT() *MockFetcherMockRecorder { return m.recorder } -// GetAttachment mocks base method +// GetAttachment mocks base method. func (m *MockFetcher) GetAttachment(arg0 context.Context, arg1 string) (io.ReadCloser, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetAttachment", arg0, arg1) @@ -46,13 +46,13 @@ func (m *MockFetcher) GetAttachment(arg0 context.Context, arg1 string) (io.ReadC return ret0, ret1 } -// GetAttachment indicates an expected call of GetAttachment +// GetAttachment indicates an expected call of GetAttachment. func (mr *MockFetcherMockRecorder) GetAttachment(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttachment", reflect.TypeOf((*MockFetcher)(nil).GetAttachment), arg0, arg1) } -// GetMessage mocks base method +// GetMessage mocks base method. func (m *MockFetcher) GetMessage(arg0 context.Context, arg1 string) (*pmapi.Message, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetMessage", arg0, arg1) @@ -61,13 +61,13 @@ func (m *MockFetcher) GetMessage(arg0 context.Context, arg1 string) (*pmapi.Mess return ret0, ret1 } -// GetMessage indicates an expected call of GetMessage +// GetMessage indicates an expected call of GetMessage. func (mr *MockFetcherMockRecorder) GetMessage(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMessage", reflect.TypeOf((*MockFetcher)(nil).GetMessage), arg0, arg1) } -// KeyRingForAddressID mocks base method +// KeyRingForAddressID mocks base method. func (m *MockFetcher) KeyRingForAddressID(arg0 string) (*crypto.KeyRing, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "KeyRingForAddressID", arg0) @@ -76,7 +76,7 @@ func (m *MockFetcher) KeyRingForAddressID(arg0 string) (*crypto.KeyRing, error) return ret0, ret1 } -// KeyRingForAddressID indicates an expected call of KeyRingForAddressID +// KeyRingForAddressID indicates an expected call of KeyRingForAddressID. func (mr *MockFetcherMockRecorder) KeyRingForAddressID(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeyRingForAddressID", reflect.TypeOf((*MockFetcher)(nil).KeyRingForAddressID), arg0) diff --git a/pkg/pmapi/client_types.go b/pkg/pmapi/client_types.go index 73f072e1..bf87bd60 100644 --- a/pkg/pmapi/client_types.go +++ b/pkg/pmapi/client_types.go @@ -73,8 +73,6 @@ type Client interface { KeyRingForAddressID(string) (kr *crypto.KeyRing, err error) GetPublicKeysForEmail(context.Context, string) ([]PublicKey, bool, error) - - GetCurrentAuth() *Auth } type AuthRefreshHandler func(*AuthRefresh) diff --git a/pkg/pmapi/mocks/mocks.go b/pkg/pmapi/mocks/mocks.go index 1f46f6c8..03085507 100644 --- a/pkg/pmapi/mocks/mocks.go +++ b/pkg/pmapi/mocks/mocks.go @@ -17,42 +17,42 @@ import ( logrus "github.com/sirupsen/logrus" ) -// MockClient is a mock of Client interface +// MockClient is a mock of Client interface. type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } -// MockClientMockRecorder is the mock recorder for MockClient +// MockClientMockRecorder is the mock recorder for MockClient. type MockClientMockRecorder struct { mock *MockClient } -// NewMockClient creates a new mock instance +// NewMockClient creates a new mock instance. func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} mock.recorder = &MockClientMockRecorder{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 *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } -// AddAuthRefreshHandler mocks base method +// AddAuthRefreshHandler mocks base method. func (m *MockClient) AddAuthRefreshHandler(arg0 pmapi.AuthRefreshHandler) { m.ctrl.T.Helper() m.ctrl.Call(m, "AddAuthRefreshHandler", arg0) } -// AddAuthRefreshHandler indicates an expected call of AddAuthRefreshHandler +// AddAuthRefreshHandler indicates an expected call of AddAuthRefreshHandler. func (mr *MockClientMockRecorder) AddAuthRefreshHandler(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAuthRefreshHandler", reflect.TypeOf((*MockClient)(nil).AddAuthRefreshHandler), arg0) } -// Addresses mocks base method +// Addresses mocks base method. func (m *MockClient) Addresses() pmapi.AddressList { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Addresses") @@ -60,13 +60,13 @@ func (m *MockClient) Addresses() pmapi.AddressList { return ret0 } -// Addresses indicates an expected call of Addresses +// Addresses indicates an expected call of Addresses. func (mr *MockClientMockRecorder) Addresses() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Addresses", reflect.TypeOf((*MockClient)(nil).Addresses)) } -// Auth2FA mocks base method +// Auth2FA mocks base method. func (m *MockClient) Auth2FA(arg0 context.Context, arg1 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Auth2FA", arg0, arg1) @@ -74,13 +74,13 @@ func (m *MockClient) Auth2FA(arg0 context.Context, arg1 string) error { return ret0 } -// Auth2FA indicates an expected call of Auth2FA +// Auth2FA indicates an expected call of Auth2FA. func (mr *MockClientMockRecorder) Auth2FA(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Auth2FA", reflect.TypeOf((*MockClient)(nil).Auth2FA), arg0, arg1) } -// AuthDelete mocks base method +// AuthDelete mocks base method. func (m *MockClient) AuthDelete(arg0 context.Context) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AuthDelete", arg0) @@ -88,13 +88,13 @@ func (m *MockClient) AuthDelete(arg0 context.Context) error { return ret0 } -// AuthDelete indicates an expected call of AuthDelete +// AuthDelete indicates an expected call of AuthDelete. func (mr *MockClientMockRecorder) AuthDelete(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthDelete", reflect.TypeOf((*MockClient)(nil).AuthDelete), arg0) } -// AuthSalt mocks base method +// AuthSalt mocks base method. func (m *MockClient) AuthSalt(arg0 context.Context) (string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AuthSalt", arg0) @@ -103,13 +103,13 @@ func (m *MockClient) AuthSalt(arg0 context.Context) (string, error) { return ret0, ret1 } -// AuthSalt indicates an expected call of AuthSalt +// AuthSalt indicates an expected call of AuthSalt. func (mr *MockClientMockRecorder) AuthSalt(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthSalt", reflect.TypeOf((*MockClient)(nil).AuthSalt), arg0) } -// CountMessages mocks base method +// CountMessages mocks base method. func (m *MockClient) CountMessages(arg0 context.Context, arg1 string) ([]*pmapi.MessagesCount, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CountMessages", arg0, arg1) @@ -118,13 +118,13 @@ func (m *MockClient) CountMessages(arg0 context.Context, arg1 string) ([]*pmapi. return ret0, ret1 } -// CountMessages indicates an expected call of CountMessages +// CountMessages indicates an expected call of CountMessages. func (mr *MockClientMockRecorder) CountMessages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountMessages", reflect.TypeOf((*MockClient)(nil).CountMessages), arg0, arg1) } -// CreateAttachment mocks base method +// CreateAttachment mocks base method. func (m *MockClient) CreateAttachment(arg0 context.Context, arg1 *pmapi.Attachment, arg2, arg3 io.Reader) (*pmapi.Attachment, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateAttachment", arg0, arg1, arg2, arg3) @@ -133,13 +133,13 @@ func (m *MockClient) CreateAttachment(arg0 context.Context, arg1 *pmapi.Attachme return ret0, ret1 } -// CreateAttachment indicates an expected call of CreateAttachment +// CreateAttachment indicates an expected call of CreateAttachment. func (mr *MockClientMockRecorder) CreateAttachment(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAttachment", reflect.TypeOf((*MockClient)(nil).CreateAttachment), arg0, arg1, arg2, arg3) } -// CreateDraft mocks base method +// CreateDraft mocks base method. func (m *MockClient) CreateDraft(arg0 context.Context, arg1 *pmapi.Message, arg2 string, arg3 int) (*pmapi.Message, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateDraft", arg0, arg1, arg2, arg3) @@ -148,13 +148,13 @@ func (m *MockClient) CreateDraft(arg0 context.Context, arg1 *pmapi.Message, arg2 return ret0, ret1 } -// CreateDraft indicates an expected call of CreateDraft +// CreateDraft indicates an expected call of CreateDraft. func (mr *MockClientMockRecorder) CreateDraft(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDraft", reflect.TypeOf((*MockClient)(nil).CreateDraft), arg0, arg1, arg2, arg3) } -// CreateLabel mocks base method +// CreateLabel mocks base method. func (m *MockClient) CreateLabel(arg0 context.Context, arg1 *pmapi.Label) (*pmapi.Label, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateLabel", arg0, arg1) @@ -163,13 +163,13 @@ func (m *MockClient) CreateLabel(arg0 context.Context, arg1 *pmapi.Label) (*pmap return ret0, ret1 } -// CreateLabel indicates an expected call of CreateLabel +// CreateLabel indicates an expected call of CreateLabel. func (mr *MockClientMockRecorder) CreateLabel(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLabel", reflect.TypeOf((*MockClient)(nil).CreateLabel), arg0, arg1) } -// CurrentUser mocks base method +// CurrentUser mocks base method. func (m *MockClient) CurrentUser(arg0 context.Context) (*pmapi.User, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CurrentUser", arg0) @@ -178,13 +178,13 @@ func (m *MockClient) CurrentUser(arg0 context.Context) (*pmapi.User, error) { return ret0, ret1 } -// CurrentUser indicates an expected call of CurrentUser +// CurrentUser indicates an expected call of CurrentUser. func (mr *MockClientMockRecorder) CurrentUser(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentUser", reflect.TypeOf((*MockClient)(nil).CurrentUser), arg0) } -// DecryptAndVerifyCards mocks base method +// DecryptAndVerifyCards mocks base method. func (m *MockClient) DecryptAndVerifyCards(arg0 []pmapi.Card) ([]pmapi.Card, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DecryptAndVerifyCards", arg0) @@ -193,13 +193,13 @@ func (m *MockClient) DecryptAndVerifyCards(arg0 []pmapi.Card) ([]pmapi.Card, err return ret0, ret1 } -// DecryptAndVerifyCards indicates an expected call of DecryptAndVerifyCards +// DecryptAndVerifyCards indicates an expected call of DecryptAndVerifyCards. func (mr *MockClientMockRecorder) DecryptAndVerifyCards(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecryptAndVerifyCards", reflect.TypeOf((*MockClient)(nil).DecryptAndVerifyCards), arg0) } -// DeleteLabel mocks base method +// DeleteLabel mocks base method. func (m *MockClient) DeleteLabel(arg0 context.Context, arg1 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteLabel", arg0, arg1) @@ -207,13 +207,13 @@ func (m *MockClient) DeleteLabel(arg0 context.Context, arg1 string) error { return ret0 } -// DeleteLabel indicates an expected call of DeleteLabel +// DeleteLabel indicates an expected call of DeleteLabel. func (mr *MockClientMockRecorder) DeleteLabel(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLabel", reflect.TypeOf((*MockClient)(nil).DeleteLabel), arg0, arg1) } -// DeleteMessages mocks base method +// DeleteMessages mocks base method. func (m *MockClient) DeleteMessages(arg0 context.Context, arg1 []string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteMessages", arg0, arg1) @@ -221,13 +221,13 @@ func (m *MockClient) DeleteMessages(arg0 context.Context, arg1 []string) error { return ret0 } -// DeleteMessages indicates an expected call of DeleteMessages +// DeleteMessages indicates an expected call of DeleteMessages. func (mr *MockClientMockRecorder) DeleteMessages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessages", reflect.TypeOf((*MockClient)(nil).DeleteMessages), arg0, arg1) } -// EmptyFolder mocks base method +// EmptyFolder mocks base method. func (m *MockClient) EmptyFolder(arg0 context.Context, arg1, arg2 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EmptyFolder", arg0, arg1, arg2) @@ -235,13 +235,13 @@ func (m *MockClient) EmptyFolder(arg0 context.Context, arg1, arg2 string) error return ret0 } -// EmptyFolder indicates an expected call of EmptyFolder +// EmptyFolder indicates an expected call of EmptyFolder. func (mr *MockClientMockRecorder) EmptyFolder(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EmptyFolder", reflect.TypeOf((*MockClient)(nil).EmptyFolder), arg0, arg1, arg2) } -// GetAddresses mocks base method +// GetAddresses mocks base method. func (m *MockClient) GetAddresses(arg0 context.Context) (pmapi.AddressList, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetAddresses", arg0) @@ -250,13 +250,13 @@ func (m *MockClient) GetAddresses(arg0 context.Context) (pmapi.AddressList, erro return ret0, ret1 } -// GetAddresses indicates an expected call of GetAddresses +// GetAddresses indicates an expected call of GetAddresses. func (mr *MockClientMockRecorder) GetAddresses(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddresses", reflect.TypeOf((*MockClient)(nil).GetAddresses), arg0) } -// GetAttachment mocks base method +// GetAttachment mocks base method. func (m *MockClient) GetAttachment(arg0 context.Context, arg1 string) (io.ReadCloser, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetAttachment", arg0, arg1) @@ -265,13 +265,13 @@ func (m *MockClient) GetAttachment(arg0 context.Context, arg1 string) (io.ReadCl return ret0, ret1 } -// GetAttachment indicates an expected call of GetAttachment +// GetAttachment indicates an expected call of GetAttachment. func (mr *MockClientMockRecorder) GetAttachment(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttachment", reflect.TypeOf((*MockClient)(nil).GetAttachment), arg0, arg1) } -// GetContactByID mocks base method +// GetContactByID mocks base method. func (m *MockClient) GetContactByID(arg0 context.Context, arg1 string) (pmapi.Contact, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetContactByID", arg0, arg1) @@ -280,13 +280,13 @@ func (m *MockClient) GetContactByID(arg0 context.Context, arg1 string) (pmapi.Co return ret0, ret1 } -// GetContactByID indicates an expected call of GetContactByID +// GetContactByID indicates an expected call of GetContactByID. func (mr *MockClientMockRecorder) GetContactByID(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContactByID", reflect.TypeOf((*MockClient)(nil).GetContactByID), arg0, arg1) } -// GetContactEmailByEmail mocks base method +// GetContactEmailByEmail mocks base method. func (m *MockClient) GetContactEmailByEmail(arg0 context.Context, arg1 string, arg2, arg3 int) ([]pmapi.ContactEmail, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetContactEmailByEmail", arg0, arg1, arg2, arg3) @@ -295,27 +295,13 @@ func (m *MockClient) GetContactEmailByEmail(arg0 context.Context, arg1 string, a return ret0, ret1 } -// GetContactEmailByEmail indicates an expected call of GetContactEmailByEmail +// GetContactEmailByEmail indicates an expected call of GetContactEmailByEmail. func (mr *MockClientMockRecorder) GetContactEmailByEmail(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContactEmailByEmail", reflect.TypeOf((*MockClient)(nil).GetContactEmailByEmail), arg0, arg1, arg2, arg3) } -// GetCurrentAuth mocks base method -func (m *MockClient) GetCurrentAuth() *pmapi.Auth { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCurrentAuth") - ret0, _ := ret[0].(*pmapi.Auth) - return ret0 -} - -// GetCurrentAuth indicates an expected call of GetCurrentAuth -func (mr *MockClientMockRecorder) GetCurrentAuth() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentAuth", reflect.TypeOf((*MockClient)(nil).GetCurrentAuth)) -} - -// GetEvent mocks base method +// GetEvent mocks base method. func (m *MockClient) GetEvent(arg0 context.Context, arg1 string) (*pmapi.Event, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetEvent", arg0, arg1) @@ -324,13 +310,13 @@ func (m *MockClient) GetEvent(arg0 context.Context, arg1 string) (*pmapi.Event, return ret0, ret1 } -// GetEvent indicates an expected call of GetEvent +// GetEvent indicates an expected call of GetEvent. func (mr *MockClientMockRecorder) GetEvent(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEvent", reflect.TypeOf((*MockClient)(nil).GetEvent), arg0, arg1) } -// GetMailSettings mocks base method +// GetMailSettings mocks base method. func (m *MockClient) GetMailSettings(arg0 context.Context) (pmapi.MailSettings, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetMailSettings", arg0) @@ -339,13 +325,13 @@ func (m *MockClient) GetMailSettings(arg0 context.Context) (pmapi.MailSettings, return ret0, ret1 } -// GetMailSettings indicates an expected call of GetMailSettings +// GetMailSettings indicates an expected call of GetMailSettings. func (mr *MockClientMockRecorder) GetMailSettings(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMailSettings", reflect.TypeOf((*MockClient)(nil).GetMailSettings), arg0) } -// GetMessage mocks base method +// GetMessage mocks base method. func (m *MockClient) GetMessage(arg0 context.Context, arg1 string) (*pmapi.Message, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetMessage", arg0, arg1) @@ -354,13 +340,13 @@ func (m *MockClient) GetMessage(arg0 context.Context, arg1 string) (*pmapi.Messa return ret0, ret1 } -// GetMessage indicates an expected call of GetMessage +// GetMessage indicates an expected call of GetMessage. func (mr *MockClientMockRecorder) GetMessage(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMessage", reflect.TypeOf((*MockClient)(nil).GetMessage), arg0, arg1) } -// GetPublicKeysForEmail mocks base method +// GetPublicKeysForEmail mocks base method. func (m *MockClient) GetPublicKeysForEmail(arg0 context.Context, arg1 string) ([]pmapi.PublicKey, bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPublicKeysForEmail", arg0, arg1) @@ -370,13 +356,13 @@ func (m *MockClient) GetPublicKeysForEmail(arg0 context.Context, arg1 string) ([ return ret0, ret1, ret2 } -// GetPublicKeysForEmail indicates an expected call of GetPublicKeysForEmail +// GetPublicKeysForEmail indicates an expected call of GetPublicKeysForEmail. func (mr *MockClientMockRecorder) GetPublicKeysForEmail(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublicKeysForEmail", reflect.TypeOf((*MockClient)(nil).GetPublicKeysForEmail), arg0, arg1) } -// Import mocks base method +// Import mocks base method. func (m *MockClient) Import(arg0 context.Context, arg1 pmapi.ImportMsgReqs) ([]*pmapi.ImportMsgRes, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Import", arg0, arg1) @@ -385,13 +371,13 @@ func (m *MockClient) Import(arg0 context.Context, arg1 pmapi.ImportMsgReqs) ([]* return ret0, ret1 } -// Import indicates an expected call of Import +// Import indicates an expected call of Import. func (mr *MockClientMockRecorder) Import(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Import", reflect.TypeOf((*MockClient)(nil).Import), arg0, arg1) } -// IsUnlocked mocks base method +// IsUnlocked mocks base method. func (m *MockClient) IsUnlocked() bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IsUnlocked") @@ -399,13 +385,13 @@ func (m *MockClient) IsUnlocked() bool { return ret0 } -// IsUnlocked indicates an expected call of IsUnlocked +// IsUnlocked indicates an expected call of IsUnlocked. func (mr *MockClientMockRecorder) IsUnlocked() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUnlocked", reflect.TypeOf((*MockClient)(nil).IsUnlocked)) } -// KeyRingForAddressID mocks base method +// KeyRingForAddressID mocks base method. func (m *MockClient) KeyRingForAddressID(arg0 string) (*crypto.KeyRing, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "KeyRingForAddressID", arg0) @@ -414,13 +400,13 @@ func (m *MockClient) KeyRingForAddressID(arg0 string) (*crypto.KeyRing, error) { return ret0, ret1 } -// KeyRingForAddressID indicates an expected call of KeyRingForAddressID +// KeyRingForAddressID indicates an expected call of KeyRingForAddressID. func (mr *MockClientMockRecorder) KeyRingForAddressID(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeyRingForAddressID", reflect.TypeOf((*MockClient)(nil).KeyRingForAddressID), arg0) } -// LabelMessages mocks base method +// LabelMessages mocks base method. func (m *MockClient) LabelMessages(arg0 context.Context, arg1 []string, arg2 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "LabelMessages", arg0, arg1, arg2) @@ -428,13 +414,13 @@ func (m *MockClient) LabelMessages(arg0 context.Context, arg1 []string, arg2 str return ret0 } -// LabelMessages indicates an expected call of LabelMessages +// LabelMessages indicates an expected call of LabelMessages. func (mr *MockClientMockRecorder) LabelMessages(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelMessages", reflect.TypeOf((*MockClient)(nil).LabelMessages), arg0, arg1, arg2) } -// ListLabels mocks base method +// ListLabels mocks base method. func (m *MockClient) ListLabels(arg0 context.Context) ([]*pmapi.Label, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListLabels", arg0) @@ -443,13 +429,13 @@ func (m *MockClient) ListLabels(arg0 context.Context) ([]*pmapi.Label, error) { return ret0, ret1 } -// ListLabels indicates an expected call of ListLabels +// ListLabels indicates an expected call of ListLabels. func (mr *MockClientMockRecorder) ListLabels(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLabels", reflect.TypeOf((*MockClient)(nil).ListLabels), arg0) } -// ListMessages mocks base method +// ListMessages mocks base method. func (m *MockClient) ListMessages(arg0 context.Context, arg1 *pmapi.MessagesFilter) ([]*pmapi.Message, int, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListMessages", arg0, arg1) @@ -459,13 +445,13 @@ func (m *MockClient) ListMessages(arg0 context.Context, arg1 *pmapi.MessagesFilt return ret0, ret1, ret2 } -// ListMessages indicates an expected call of ListMessages +// ListMessages indicates an expected call of ListMessages. func (mr *MockClientMockRecorder) ListMessages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMessages", reflect.TypeOf((*MockClient)(nil).ListMessages), arg0, arg1) } -// MarkMessagesRead mocks base method +// MarkMessagesRead mocks base method. func (m *MockClient) MarkMessagesRead(arg0 context.Context, arg1 []string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MarkMessagesRead", arg0, arg1) @@ -473,13 +459,13 @@ func (m *MockClient) MarkMessagesRead(arg0 context.Context, arg1 []string) error return ret0 } -// MarkMessagesRead indicates an expected call of MarkMessagesRead +// MarkMessagesRead indicates an expected call of MarkMessagesRead. func (mr *MockClientMockRecorder) MarkMessagesRead(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkMessagesRead", reflect.TypeOf((*MockClient)(nil).MarkMessagesRead), arg0, arg1) } -// MarkMessagesUnread mocks base method +// MarkMessagesUnread mocks base method. func (m *MockClient) MarkMessagesUnread(arg0 context.Context, arg1 []string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MarkMessagesUnread", arg0, arg1) @@ -487,13 +473,13 @@ func (m *MockClient) MarkMessagesUnread(arg0 context.Context, arg1 []string) err return ret0 } -// MarkMessagesUnread indicates an expected call of MarkMessagesUnread +// MarkMessagesUnread indicates an expected call of MarkMessagesUnread. func (mr *MockClientMockRecorder) MarkMessagesUnread(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkMessagesUnread", reflect.TypeOf((*MockClient)(nil).MarkMessagesUnread), arg0, arg1) } -// ReloadKeys mocks base method +// ReloadKeys mocks base method. func (m *MockClient) ReloadKeys(arg0 context.Context, arg1 []byte) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ReloadKeys", arg0, arg1) @@ -501,13 +487,13 @@ func (m *MockClient) ReloadKeys(arg0 context.Context, arg1 []byte) error { return ret0 } -// ReloadKeys indicates an expected call of ReloadKeys +// ReloadKeys indicates an expected call of ReloadKeys. func (mr *MockClientMockRecorder) ReloadKeys(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReloadKeys", reflect.TypeOf((*MockClient)(nil).ReloadKeys), arg0, arg1) } -// ReorderAddresses mocks base method +// ReorderAddresses mocks base method. func (m *MockClient) ReorderAddresses(arg0 context.Context, arg1 []string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ReorderAddresses", arg0, arg1) @@ -515,13 +501,13 @@ func (m *MockClient) ReorderAddresses(arg0 context.Context, arg1 []string) error return ret0 } -// ReorderAddresses indicates an expected call of ReorderAddresses +// ReorderAddresses indicates an expected call of ReorderAddresses. func (mr *MockClientMockRecorder) ReorderAddresses(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReorderAddresses", reflect.TypeOf((*MockClient)(nil).ReorderAddresses), arg0, arg1) } -// SendMessage mocks base method +// SendMessage mocks base method. func (m *MockClient) SendMessage(arg0 context.Context, arg1 string, arg2 *pmapi.SendMessageReq) (*pmapi.Message, *pmapi.Message, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SendMessage", arg0, arg1, arg2) @@ -531,13 +517,13 @@ func (m *MockClient) SendMessage(arg0 context.Context, arg1 string, arg2 *pmapi. return ret0, ret1, ret2 } -// SendMessage indicates an expected call of SendMessage +// SendMessage indicates an expected call of SendMessage. func (mr *MockClientMockRecorder) SendMessage(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockClient)(nil).SendMessage), arg0, arg1, arg2) } -// UnlabelMessages mocks base method +// UnlabelMessages mocks base method. func (m *MockClient) UnlabelMessages(arg0 context.Context, arg1 []string, arg2 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UnlabelMessages", arg0, arg1, arg2) @@ -545,13 +531,13 @@ func (m *MockClient) UnlabelMessages(arg0 context.Context, arg1 []string, arg2 s return ret0 } -// UnlabelMessages indicates an expected call of UnlabelMessages +// UnlabelMessages indicates an expected call of UnlabelMessages. func (mr *MockClientMockRecorder) UnlabelMessages(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlabelMessages", reflect.TypeOf((*MockClient)(nil).UnlabelMessages), arg0, arg1, arg2) } -// Unlock mocks base method +// Unlock mocks base method. func (m *MockClient) Unlock(arg0 context.Context, arg1 []byte) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Unlock", arg0, arg1) @@ -559,13 +545,13 @@ func (m *MockClient) Unlock(arg0 context.Context, arg1 []byte) error { return ret0 } -// Unlock indicates an expected call of Unlock +// Unlock indicates an expected call of Unlock. func (mr *MockClientMockRecorder) Unlock(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlock", reflect.TypeOf((*MockClient)(nil).Unlock), arg0, arg1) } -// UpdateLabel mocks base method +// UpdateLabel mocks base method. func (m *MockClient) UpdateLabel(arg0 context.Context, arg1 *pmapi.Label) (*pmapi.Label, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateLabel", arg0, arg1) @@ -574,13 +560,13 @@ func (m *MockClient) UpdateLabel(arg0 context.Context, arg1 *pmapi.Label) (*pmap return ret0, ret1 } -// UpdateLabel indicates an expected call of UpdateLabel +// UpdateLabel indicates an expected call of UpdateLabel. func (mr *MockClientMockRecorder) UpdateLabel(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLabel", reflect.TypeOf((*MockClient)(nil).UpdateLabel), arg0, arg1) } -// UpdateUser mocks base method +// UpdateUser mocks base method. func (m *MockClient) UpdateUser(arg0 context.Context) (*pmapi.User, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateUser", arg0) @@ -589,72 +575,72 @@ func (m *MockClient) UpdateUser(arg0 context.Context) (*pmapi.User, error) { return ret0, ret1 } -// UpdateUser indicates an expected call of UpdateUser +// UpdateUser indicates an expected call of UpdateUser. func (mr *MockClientMockRecorder) UpdateUser(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUser", reflect.TypeOf((*MockClient)(nil).UpdateUser), arg0) } -// 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 } -// AddConnectionObserver mocks base method +// AddConnectionObserver mocks base method. func (m *MockManager) AddConnectionObserver(arg0 pmapi.ConnectionObserver) { m.ctrl.T.Helper() m.ctrl.Call(m, "AddConnectionObserver", arg0) } -// AddConnectionObserver indicates an expected call of AddConnectionObserver +// AddConnectionObserver indicates an expected call of AddConnectionObserver. func (mr *MockManagerMockRecorder) AddConnectionObserver(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddConnectionObserver", reflect.TypeOf((*MockManager)(nil).AddConnectionObserver), arg0) } -// AllowProxy mocks base method +// AllowProxy mocks base method. func (m *MockManager) AllowProxy() { m.ctrl.T.Helper() m.ctrl.Call(m, "AllowProxy") } -// AllowProxy indicates an expected call of AllowProxy +// AllowProxy indicates an expected call of AllowProxy. func (mr *MockManagerMockRecorder) AllowProxy() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllowProxy", reflect.TypeOf((*MockManager)(nil).AllowProxy)) } -// DisallowProxy mocks base method +// DisallowProxy mocks base method. func (m *MockManager) DisallowProxy() { m.ctrl.T.Helper() m.ctrl.Call(m, "DisallowProxy") } -// DisallowProxy indicates an expected call of DisallowProxy +// DisallowProxy indicates an expected call of DisallowProxy. func (mr *MockManagerMockRecorder) DisallowProxy() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisallowProxy", reflect.TypeOf((*MockManager)(nil).DisallowProxy)) } -// DownloadAndVerify mocks base method +// DownloadAndVerify mocks base method. func (m *MockManager) DownloadAndVerify(arg0 *crypto.KeyRing, arg1, arg2 string) ([]byte, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DownloadAndVerify", arg0, arg1, arg2) @@ -663,13 +649,13 @@ func (m *MockManager) DownloadAndVerify(arg0 *crypto.KeyRing, arg1, arg2 string) return ret0, ret1 } -// DownloadAndVerify indicates an expected call of DownloadAndVerify +// DownloadAndVerify indicates an expected call of DownloadAndVerify. func (mr *MockManagerMockRecorder) DownloadAndVerify(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadAndVerify", reflect.TypeOf((*MockManager)(nil).DownloadAndVerify), arg0, arg1, arg2) } -// NewClient mocks base method +// NewClient mocks base method. func (m *MockManager) NewClient(arg0, arg1, arg2 string, arg3 time.Time) pmapi.Client { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "NewClient", arg0, arg1, arg2, arg3) @@ -677,13 +663,13 @@ func (m *MockManager) NewClient(arg0, arg1, arg2 string, arg3 time.Time) pmapi.C return ret0 } -// NewClient indicates an expected call of NewClient +// NewClient indicates an expected call of NewClient. func (mr *MockManagerMockRecorder) NewClient(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewClient", reflect.TypeOf((*MockManager)(nil).NewClient), arg0, arg1, arg2, arg3) } -// NewClientWithLogin mocks base method +// NewClientWithLogin mocks base method. func (m *MockManager) NewClientWithLogin(arg0 context.Context, arg1 string, arg2 []byte) (pmapi.Client, *pmapi.Auth, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "NewClientWithLogin", arg0, arg1, arg2) @@ -693,13 +679,13 @@ func (m *MockManager) NewClientWithLogin(arg0 context.Context, arg1 string, arg2 return ret0, ret1, ret2 } -// NewClientWithLogin indicates an expected call of NewClientWithLogin +// NewClientWithLogin indicates an expected call of NewClientWithLogin. func (mr *MockManagerMockRecorder) NewClientWithLogin(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewClientWithLogin", reflect.TypeOf((*MockManager)(nil).NewClientWithLogin), arg0, arg1, arg2) } -// NewClientWithRefresh mocks base method +// NewClientWithRefresh mocks base method. func (m *MockManager) NewClientWithRefresh(arg0 context.Context, arg1, arg2 string) (pmapi.Client, *pmapi.AuthRefresh, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "NewClientWithRefresh", arg0, arg1, arg2) @@ -709,13 +695,13 @@ func (m *MockManager) NewClientWithRefresh(arg0 context.Context, arg1, arg2 stri return ret0, ret1, ret2 } -// NewClientWithRefresh indicates an expected call of NewClientWithRefresh +// NewClientWithRefresh indicates an expected call of NewClientWithRefresh. func (mr *MockManagerMockRecorder) NewClientWithRefresh(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewClientWithRefresh", reflect.TypeOf((*MockManager)(nil).NewClientWithRefresh), arg0, arg1, arg2) } -// ReportBug mocks base method +// ReportBug mocks base method. func (m *MockManager) ReportBug(arg0 context.Context, arg1 pmapi.ReportBugReq) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ReportBug", arg0, arg1) @@ -723,13 +709,13 @@ func (m *MockManager) ReportBug(arg0 context.Context, arg1 pmapi.ReportBugReq) e return ret0 } -// ReportBug indicates an expected call of ReportBug +// ReportBug indicates an expected call of ReportBug. func (mr *MockManagerMockRecorder) ReportBug(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportBug", reflect.TypeOf((*MockManager)(nil).ReportBug), arg0, arg1) } -// SendSimpleMetric mocks base method +// SendSimpleMetric mocks base method. func (m *MockManager) SendSimpleMetric(arg0 context.Context, arg1, arg2, arg3 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SendSimpleMetric", arg0, arg1, arg2, arg3) @@ -737,55 +723,55 @@ func (m *MockManager) SendSimpleMetric(arg0 context.Context, arg1, arg2, arg3 st return ret0 } -// SendSimpleMetric indicates an expected call of SendSimpleMetric +// SendSimpleMetric indicates an expected call of SendSimpleMetric. func (mr *MockManagerMockRecorder) SendSimpleMetric(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendSimpleMetric", reflect.TypeOf((*MockManager)(nil).SendSimpleMetric), arg0, arg1, arg2, arg3) } -// SetCookieJar mocks base method +// SetCookieJar mocks base method. func (m *MockManager) SetCookieJar(arg0 http.CookieJar) { m.ctrl.T.Helper() m.ctrl.Call(m, "SetCookieJar", arg0) } -// SetCookieJar indicates an expected call of SetCookieJar +// SetCookieJar indicates an expected call of SetCookieJar. func (mr *MockManagerMockRecorder) SetCookieJar(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCookieJar", reflect.TypeOf((*MockManager)(nil).SetCookieJar), arg0) } -// SetLogging mocks base method +// SetLogging mocks base method. func (m *MockManager) SetLogging(arg0 *logrus.Entry, arg1 bool) { m.ctrl.T.Helper() m.ctrl.Call(m, "SetLogging", arg0, arg1) } -// SetLogging indicates an expected call of SetLogging +// SetLogging indicates an expected call of SetLogging. func (mr *MockManagerMockRecorder) SetLogging(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogging", reflect.TypeOf((*MockManager)(nil).SetLogging), arg0, arg1) } -// SetRetryCount mocks base method +// SetRetryCount mocks base method. func (m *MockManager) SetRetryCount(arg0 int) { m.ctrl.T.Helper() m.ctrl.Call(m, "SetRetryCount", arg0) } -// SetRetryCount indicates an expected call of SetRetryCount +// SetRetryCount indicates an expected call of SetRetryCount. func (mr *MockManagerMockRecorder) SetRetryCount(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetryCount", reflect.TypeOf((*MockManager)(nil).SetRetryCount), arg0) } -// SetTransport mocks base method +// SetTransport mocks base method. func (m *MockManager) SetTransport(arg0 http.RoundTripper) { m.ctrl.T.Helper() m.ctrl.Call(m, "SetTransport", arg0) } -// SetTransport indicates an expected call of SetTransport +// SetTransport indicates an expected call of SetTransport. func (mr *MockManagerMockRecorder) SetTransport(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTransport", reflect.TypeOf((*MockManager)(nil).SetTransport), arg0) diff --git a/test/context/users.go b/test/context/users.go index ee8d2db5..1fb440b7 100644 --- a/test/context/users.go +++ b/test/context/users.go @@ -64,7 +64,16 @@ func (ctx *TestContext) LoginUser(username string, password, mailboxPassword []b // FinishLogin prevents authentication if not necessary. func (ctx *TestContext) FinishLogin(client pmapi.Client, mailboxPassword []byte) error { - user, err := ctx.users.FinishLogin(client, client.GetCurrentAuth(), mailboxPassword) + type currentAuthGetter interface { + GetCurrentAuth() *pmapi.Auth + } + + c, ok := client.(currentAuthGetter) + if c == nil || !ok { + return errors.New("cannot get current auth tokens from client") + } + + user, err := ctx.users.FinishLogin(client, c.GetCurrentAuth(), mailboxPassword) if err != nil { return errors.Wrap(err, "failed to finish login") } diff --git a/test/liveapi/persistent_clients.go b/test/liveapi/persistent_clients.go index 404d76b2..46538995 100644 --- a/test/liveapi/persistent_clients.go +++ b/test/liveapi/persistent_clients.go @@ -30,6 +30,11 @@ import ( "github.com/sirupsen/logrus" ) +type clientAuthGetter interface { + pmapi.Client + GetCurrentAuth() *pmapi.Auth +} + // persistentClients keeps authenticated clients for tests. // // We need to reduce the number of authentication done by live tests. @@ -37,15 +42,15 @@ import ( // This is not necessary for controller purposes. We can reuse the same clients // for all tests. // -//nolint[gochecknoglobals] +//nolint:gochecknoglobals // This is necessary for testing var persistentClients = struct { manager pmapi.Manager - byName map[string]pmapi.Client + byName map[string]clientAuthGetter saltByName map[string]string }{} type persistentClient struct { - pmapi.Client + clientAuthGetter username string } @@ -70,7 +75,7 @@ func SetupPersistentClients() { persistentClients.manager = pmapi.New(pmapi.NewConfig(getAppVersionName(app), constants.Version)) persistentClients.manager.SetLogging(logrus.WithField("pkg", "liveapi"), logrus.GetLevel() == logrus.TraceLevel) - persistentClients.byName = map[string]pmapi.Client{} + persistentClients.byName = map[string]clientAuthGetter{} persistentClients.saltByName = map[string]string{} } @@ -96,13 +101,18 @@ func addPersistentClient(username string, password, mailboxPassword []byte) (pma return cl, nil } - srp.RandReader = rand.New(rand.NewSource(42)) //nolint[gosec] It is OK to use weaker random number generator here + srp.RandReader = rand.New(rand.NewSource(42)) //nolint:gosec // It is OK to use weaker random number generator here - client, _, err := persistentClients.manager.NewClientWithLogin(context.Background(), username, password) + normalClient, _, err := persistentClients.manager.NewClientWithLogin(context.Background(), username, password) if err != nil { return nil, errors.Wrap(err, "failed to create new persistent client") } + client, ok := normalClient.(clientAuthGetter) + if !ok { + return nil, errors.New("cannot make clientAuthGetter") + } + salt, err := client.AuthSalt(context.Background()) if err != nil { return nil, errors.Wrap(err, "persistent client: failed to get salt")