DeforaNetworks/corteza
DeforaNetworks/corteza
3
0
Fork 0
Code

upd(all): update mocks

Browse Source
This commit is contained in:
Tit Petric 2019-03-15 00:31:25 +01:00
parent 8bedaa2846
commit e8d2be4968
10 changed files with 192 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
crm/internal/service/notification_mock_test.go
View File

@ -36,6 +36,7 @@ func (m *MockNotificationService) EXPECT() *MockNotificationServiceMockRecorder
// With mocks base method
func (m *MockNotificationService) With(ctx context.Context) NotificationService {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "With", ctx)
ret0, _ := ret[0].(NotificationService)
return ret0
@ -43,11 +44,13 @@ func (m *MockNotificationService) With(ctx context.Context) NotificationService
// With indicates an expected call of With
func (mr *MockNotificationServiceMockRecorder) With(ctx interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "With", reflect.TypeOf((*MockNotificationService)(nil).With), ctx)
}
// SendEmail mocks base method
func (m *MockNotificationService) SendEmail(message *mail_v2.Message) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendEmail", message)
ret0, _ := ret[0].(error)
return ret0
@ -55,11 +58,13 @@ func (m *MockNotificationService) SendEmail(message *mail_v2.Message) error {
// SendEmail indicates an expected call of SendEmail
func (mr *MockNotificationServiceMockRecorder) SendEmail(message interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendEmail", reflect.TypeOf((*MockNotificationService)(nil).SendEmail), message)
}
// AttachEmailRecipients mocks base method
func (m *MockNotificationService) AttachEmailRecipients(message *mail_v2.Message, field string, recipients ...string) error {
m.ctrl.T.Helper()
varargs := []interface{}{message, field}
for _, a := range recipients {
varargs = append(varargs, a)
@ -71,6 +76,7 @@ func (m *MockNotificationService) AttachEmailRecipients(message *mail_v2.Message
// AttachEmailRecipients indicates an expected call of AttachEmailRecipients
func (mr *MockNotificationServiceMockRecorder) AttachEmailRecipients(message, field interface{}, recipients ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{message, field}, recipients...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachEmailRecipients", reflect.TypeOf((*MockNotificationService)(nil).AttachEmailRecipients), varargs...)
}

10
internal/rules/resources_mock_test.go
View File

@ -36,6 +36,7 @@ func (m *MockResourcesInterface) EXPECT() *MockResourcesInterfaceMockRecorder {
// With mocks base method
func (m *MockResourcesInterface) With(ctx context.Context, db *factory.DB) ResourcesInterface {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "With", ctx, db)
ret0, _ := ret[0].(ResourcesInterface)
return ret0
@ -43,11 +44,13 @@ func (m *MockResourcesInterface) With(ctx context.Context, db *factory.DB) Resou
// With indicates an expected call of With
func (mr *MockResourcesInterfaceMockRecorder) With(ctx, db interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "With", reflect.TypeOf((*MockResourcesInterface)(nil).With), ctx, db)
}
// Check mocks base method
func (m *MockResourcesInterface) Check(resource, operation string, fallbacks ...CheckAccessFunc) Access {
m.ctrl.T.Helper()
varargs := []interface{}{resource, operation}
for _, a := range fallbacks {
varargs = append(varargs, a)
@ -59,12 +62,14 @@ func (m *MockResourcesInterface) Check(resource, operation string, fallbacks ...
// Check indicates an expected call of Check
func (mr *MockResourcesInterfaceMockRecorder) Check(resource, operation interface{}, fallbacks ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{resource, operation}, fallbacks...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Check", reflect.TypeOf((*MockResourcesInterface)(nil).Check), varargs...)
}
// Grant mocks base method
func (m *MockResourcesInterface) Grant(roleID uint64, rules []Rule) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Grant", roleID, rules)
ret0, _ := ret[0].(error)
return ret0
@ -72,11 +77,13 @@ func (m *MockResourcesInterface) Grant(roleID uint64, rules []Rule) error {
// Grant indicates an expected call of Grant
func (mr *MockResourcesInterfaceMockRecorder) Grant(roleID, rules interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Grant", reflect.TypeOf((*MockResourcesInterface)(nil).Grant), roleID, rules)
}
// Read mocks base method
func (m *MockResourcesInterface) Read(roleID uint64) ([]Rule, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Read", roleID)
ret0, _ := ret[0].([]Rule)
ret1, _ := ret[1].(error)
@ -85,11 +92,13 @@ func (m *MockResourcesInterface) Read(roleID uint64) ([]Rule, error) {
// Read indicates an expected call of Read
func (mr *MockResourcesInterfaceMockRecorder) Read(roleID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockResourcesInterface)(nil).Read), roleID)
}
// Delete mocks base method
func (m *MockResourcesInterface) Delete(roleID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", roleID)
ret0, _ := ret[0].(error)
return ret0
@ -97,5 +106,6 @@ func (m *MockResourcesInterface) Delete(roleID uint64) error {
// Delete indicates an expected call of Delete
func (mr *MockResourcesInterfaceMockRecorder) Delete(roleID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockResourcesInterface)(nil).Delete), roleID)
}

10
messaging/internal/service/attachment_mock_test.go
View File

@ -37,6 +37,7 @@ func (m *MockAttachmentService) EXPECT() *MockAttachmentServiceMockRecorder {
// With mocks base method
func (m *MockAttachmentService) With(ctx context.Context) AttachmentService {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "With", ctx)
ret0, _ := ret[0].(AttachmentService)
return ret0
@ -44,11 +45,13 @@ func (m *MockAttachmentService) With(ctx context.Context) AttachmentService {
// With indicates an expected call of With
func (mr *MockAttachmentServiceMockRecorder) With(ctx interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "With", reflect.TypeOf((*MockAttachmentService)(nil).With), ctx)
}
// FindByID mocks base method
func (m *MockAttachmentService) FindByID(id uint64) (*types.Attachment, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByID", id)
ret0, _ := ret[0].(*types.Attachment)
ret1, _ := ret[1].(error)
@ -57,11 +60,13 @@ func (m *MockAttachmentService) FindByID(id uint64) (*types.Attachment, error) {
// FindByID indicates an expected call of FindByID
func (mr *MockAttachmentServiceMockRecorder) FindByID(id interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByID", reflect.TypeOf((*MockAttachmentService)(nil).FindByID), id)
}
// Create mocks base method
func (m *MockAttachmentService) Create(name string, size int64, fh io.ReadSeeker, channelId, replyTo uint64) (*types.Attachment, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Create", name, size, fh, channelId, replyTo)
ret0, _ := ret[0].(*types.Attachment)
ret1, _ := ret[1].(error)
@ -70,11 +75,13 @@ func (m *MockAttachmentService) Create(name string, size int64, fh io.ReadSeeker
// Create indicates an expected call of Create
func (mr *MockAttachmentServiceMockRecorder) Create(name, size, fh, channelId, replyTo interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockAttachmentService)(nil).Create), name, size, fh, channelId, replyTo)
}
// OpenOriginal mocks base method
func (m *MockAttachmentService) OpenOriginal(att *types.Attachment) (io.ReadSeeker, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "OpenOriginal", att)
ret0, _ := ret[0].(io.ReadSeeker)
ret1, _ := ret[1].(error)
@ -83,11 +90,13 @@ func (m *MockAttachmentService) OpenOriginal(att *types.Attachment) (io.ReadSeek
// OpenOriginal indicates an expected call of OpenOriginal
func (mr *MockAttachmentServiceMockRecorder) OpenOriginal(att interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenOriginal", reflect.TypeOf((*MockAttachmentService)(nil).OpenOriginal), att)
}
// OpenPreview mocks base method
func (m *MockAttachmentService) OpenPreview(att *types.Attachment) (io.ReadSeeker, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "OpenPreview", att)
ret0, _ := ret[0].(io.ReadSeeker)
ret1, _ := ret[1].(error)
@ -96,5 +105,6 @@ func (m *MockAttachmentService) OpenPreview(att *types.Attachment) (io.ReadSeeke
// OpenPreview indicates an expected call of OpenPreview
func (mr *MockAttachmentServiceMockRecorder) OpenPreview(att interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenPreview", reflect.TypeOf((*MockAttachmentService)(nil).OpenPreview), att)
}

30
messaging/internal/service/channel_mock_test.go
View File

@ -36,6 +36,7 @@ func (m *MockChannelService) EXPECT() *MockChannelServiceMockRecorder {
// With mocks base method
func (m *MockChannelService) With(ctx context.Context) ChannelService {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "With", ctx)
ret0, _ := ret[0].(ChannelService)
return ret0
@ -43,11 +44,13 @@ func (m *MockChannelService) With(ctx context.Context) ChannelService {
// With indicates an expected call of With
func (mr *MockChannelServiceMockRecorder) With(ctx interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "With", reflect.TypeOf((*MockChannelService)(nil).With), ctx)
}
// FindByID mocks base method
func (m *MockChannelService) FindByID(channelID uint64) (*types.Channel, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByID", channelID)
ret0, _ := ret[0].(*types.Channel)
ret1, _ := ret[1].(error)
@ -56,11 +59,13 @@ func (m *MockChannelService) FindByID(channelID uint64) (*types.Channel, error)
// FindByID indicates an expected call of FindByID
func (mr *MockChannelServiceMockRecorder) FindByID(channelID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByID", reflect.TypeOf((*MockChannelService)(nil).FindByID), channelID)
}
// Find mocks base method
func (m *MockChannelService) Find(filter *types.ChannelFilter) (types.ChannelSet, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Find", filter)
ret0, _ := ret[0].(types.ChannelSet)
ret1, _ := ret[1].(error)
@ -69,11 +74,13 @@ func (m *MockChannelService) Find(filter *types.ChannelFilter) (types.ChannelSet
// Find indicates an expected call of Find
func (mr *MockChannelServiceMockRecorder) Find(filter interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockChannelService)(nil).Find), filter)
}
// Create mocks base method
func (m *MockChannelService) Create(channel *types.Channel) (*types.Channel, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Create", channel)
ret0, _ := ret[0].(*types.Channel)
ret1, _ := ret[1].(error)
@ -82,11 +89,13 @@ func (m *MockChannelService) Create(channel *types.Channel) (*types.Channel, err
// Create indicates an expected call of Create
func (mr *MockChannelServiceMockRecorder) Create(channel interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockChannelService)(nil).Create), channel)
}
// Update mocks base method
func (m *MockChannelService) Update(channel *types.Channel) (*types.Channel, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Update", channel)
ret0, _ := ret[0].(*types.Channel)
ret1, _ := ret[1].(error)
@ -95,11 +104,13 @@ func (m *MockChannelService) Update(channel *types.Channel) (*types.Channel, err
// Update indicates an expected call of Update
func (mr *MockChannelServiceMockRecorder) Update(channel interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockChannelService)(nil).Update), channel)
}
// FindMembers mocks base method
func (m *MockChannelService) FindMembers(channelID uint64) (types.ChannelMemberSet, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindMembers", channelID)
ret0, _ := ret[0].(types.ChannelMemberSet)
ret1, _ := ret[1].(error)
@ -108,11 +119,13 @@ func (m *MockChannelService) FindMembers(channelID uint64) (types.ChannelMemberS
// FindMembers indicates an expected call of FindMembers
func (mr *MockChannelServiceMockRecorder) FindMembers(channelID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindMembers", reflect.TypeOf((*MockChannelService)(nil).FindMembers), channelID)
}
// InviteUser mocks base method
func (m *MockChannelService) InviteUser(channelID uint64, memberIDs ...uint64) (types.ChannelMemberSet, error) {
m.ctrl.T.Helper()
varargs := []interface{}{channelID}
for _, a := range memberIDs {
varargs = append(varargs, a)
@ -125,12 +138,14 @@ func (m *MockChannelService) InviteUser(channelID uint64, memberIDs ...uint64) (
// InviteUser indicates an expected call of InviteUser
func (mr *MockChannelServiceMockRecorder) InviteUser(channelID interface{}, memberIDs ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{channelID}, memberIDs...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InviteUser", reflect.TypeOf((*MockChannelService)(nil).InviteUser), varargs...)
}
// AddMember mocks base method
func (m *MockChannelService) AddMember(channelID uint64, memberIDs ...uint64) (types.ChannelMemberSet, error) {
m.ctrl.T.Helper()
varargs := []interface{}{channelID}
for _, a := range memberIDs {
varargs = append(varargs, a)
@ -143,12 +158,14 @@ func (m *MockChannelService) AddMember(channelID uint64, memberIDs ...uint64) (t
// AddMember indicates an expected call of AddMember
func (mr *MockChannelServiceMockRecorder) AddMember(channelID interface{}, memberIDs ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{channelID}, memberIDs...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMember", reflect.TypeOf((*MockChannelService)(nil).AddMember), varargs...)
}
// DeleteMember mocks base method
func (m *MockChannelService) DeleteMember(channelID uint64, memberIDs ...uint64) error {
m.ctrl.T.Helper()
varargs := []interface{}{channelID}
for _, a := range memberIDs {
varargs = append(varargs, a)
@ -160,12 +177,14 @@ func (m *MockChannelService) DeleteMember(channelID uint64, memberIDs ...uint64)
// DeleteMember indicates an expected call of DeleteMember
func (mr *MockChannelServiceMockRecorder) DeleteMember(channelID interface{}, memberIDs ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{channelID}, memberIDs...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMember", reflect.TypeOf((*MockChannelService)(nil).DeleteMember), varargs...)
}
// SetFlag mocks base method
func (m *MockChannelService) SetFlag(ID uint64, flag types.ChannelMembershipFlag) (*types.Channel, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetFlag", ID, flag)
ret0, _ := ret[0].(*types.Channel)
ret1, _ := ret[1].(error)
@ -174,11 +193,13 @@ func (m *MockChannelService) SetFlag(ID uint64, flag types.ChannelMembershipFlag
// SetFlag indicates an expected call of SetFlag
func (mr *MockChannelServiceMockRecorder) SetFlag(ID, flag interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFlag", reflect.TypeOf((*MockChannelService)(nil).SetFlag), ID, flag)
}
// Archive mocks base method
func (m *MockChannelService) Archive(ID uint64) (*types.Channel, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Archive", ID)
ret0, _ := ret[0].(*types.Channel)
ret1, _ := ret[1].(error)
@ -187,11 +208,13 @@ func (m *MockChannelService) Archive(ID uint64) (*types.Channel, error) {
// Archive indicates an expected call of Archive
func (mr *MockChannelServiceMockRecorder) Archive(ID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Archive", reflect.TypeOf((*MockChannelService)(nil).Archive), ID)
}
// Unarchive mocks base method
func (m *MockChannelService) Unarchive(ID uint64) (*types.Channel, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Unarchive", ID)
ret0, _ := ret[0].(*types.Channel)
ret1, _ := ret[1].(error)
@ -200,11 +223,13 @@ func (m *MockChannelService) Unarchive(ID uint64) (*types.Channel, error) {
// Unarchive indicates an expected call of Unarchive
func (mr *MockChannelServiceMockRecorder) Unarchive(ID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unarchive", reflect.TypeOf((*MockChannelService)(nil).Unarchive), ID)
}
// Delete mocks base method
func (m *MockChannelService) Delete(ID uint64) (*types.Channel, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ID)
ret0, _ := ret[0].(*types.Channel)
ret1, _ := ret[1].(error)
@ -213,11 +238,13 @@ func (m *MockChannelService) Delete(ID uint64) (*types.Channel, error) {
// Delete indicates an expected call of Delete
func (mr *MockChannelServiceMockRecorder) Delete(ID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockChannelService)(nil).Delete), ID)
}
// Undelete mocks base method
func (m *MockChannelService) Undelete(ID uint64) (*types.Channel, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Undelete", ID)
ret0, _ := ret[0].(*types.Channel)
ret1, _ := ret[1].(error)
@ -226,11 +253,13 @@ func (m *MockChannelService) Undelete(ID uint64) (*types.Channel, error) {
// Undelete indicates an expected call of Undelete
func (mr *MockChannelServiceMockRecorder) Undelete(ID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Undelete", reflect.TypeOf((*MockChannelService)(nil).Undelete), ID)
}
// RecordView mocks base method
func (m *MockChannelService) RecordView(userID, channelID, lastMessageID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RecordView", userID, channelID, lastMessageID)
ret0, _ := ret[0].(error)
return ret0
@ -238,5 +267,6 @@ func (m *MockChannelService) RecordView(userID, channelID, lastMessageID uint64)
// RecordView indicates an expected call of RecordView
func (mr *MockChannelServiceMockRecorder) RecordView(userID, channelID, lastMessageID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordView", reflect.TypeOf((*MockChannelService)(nil).RecordView), userID, channelID, lastMessageID)
}

26
messaging/internal/service/message_mock_test.go
View File

@ -36,6 +36,7 @@ func (m *MockMessageService) EXPECT() *MockMessageServiceMockRecorder {
// With mocks base method
func (m *MockMessageService) With(ctx context.Context) MessageService {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "With", ctx)
ret0, _ := ret[0].(MessageService)
return ret0
@ -43,11 +44,13 @@ func (m *MockMessageService) With(ctx context.Context) MessageService {
// With indicates an expected call of With
func (mr *MockMessageServiceMockRecorder) With(ctx interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "With", reflect.TypeOf((*MockMessageService)(nil).With), ctx)
}
// Find mocks base method
func (m *MockMessageService) Find(filter *types.MessageFilter) (types.MessageSet, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Find", filter)
ret0, _ := ret[0].(types.MessageSet)
ret1, _ := ret[1].(error)
@ -56,11 +59,13 @@ func (m *MockMessageService) Find(filter *types.MessageFilter) (types.MessageSet
// Find indicates an expected call of Find
func (mr *MockMessageServiceMockRecorder) Find(filter interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockMessageService)(nil).Find), filter)
}
// FindThreads mocks base method
func (m *MockMessageService) FindThreads(filter *types.MessageFilter) (types.MessageSet, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindThreads", filter)
ret0, _ := ret[0].(types.MessageSet)
ret1, _ := ret[1].(error)
@ -69,11 +74,13 @@ func (m *MockMessageService) FindThreads(filter *types.MessageFilter) (types.Mes
// FindThreads indicates an expected call of FindThreads
func (mr *MockMessageServiceMockRecorder) FindThreads(filter interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindThreads", reflect.TypeOf((*MockMessageService)(nil).FindThreads), filter)
}
// Create mocks base method
func (m *MockMessageService) Create(messages *types.Message) (*types.Message, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Create", messages)
ret0, _ := ret[0].(*types.Message)
ret1, _ := ret[1].(error)
@ -82,11 +89,13 @@ func (m *MockMessageService) Create(messages *types.Message) (*types.Message, er
// Create indicates an expected call of Create
func (mr *MockMessageServiceMockRecorder) Create(messages interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockMessageService)(nil).Create), messages)
}
// Update mocks base method
func (m *MockMessageService) Update(messages *types.Message) (*types.Message, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Update", messages)
ret0, _ := ret[0].(*types.Message)
ret1, _ := ret[1].(error)
@ -95,11 +104,13 @@ func (m *MockMessageService) Update(messages *types.Message) (*types.Message, er
// Update indicates an expected call of Update
func (mr *MockMessageServiceMockRecorder) Update(messages interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockMessageService)(nil).Update), messages)
}
// React mocks base method
func (m *MockMessageService) React(messageID uint64, reaction string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "React", messageID, reaction)
ret0, _ := ret[0].(error)
return ret0
@ -107,11 +118,13 @@ func (m *MockMessageService) React(messageID uint64, reaction string) error {
// React indicates an expected call of React
func (mr *MockMessageServiceMockRecorder) React(messageID, reaction interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "React", reflect.TypeOf((*MockMessageService)(nil).React), messageID, reaction)
}
// RemoveReaction mocks base method
func (m *MockMessageService) RemoveReaction(messageID uint64, reaction string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RemoveReaction", messageID, reaction)
ret0, _ := ret[0].(error)
return ret0
@ -119,11 +132,13 @@ func (m *MockMessageService) RemoveReaction(messageID uint64, reaction string) e
// RemoveReaction indicates an expected call of RemoveReaction
func (mr *MockMessageServiceMockRecorder) RemoveReaction(messageID, reaction interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveReaction", reflect.TypeOf((*MockMessageService)(nil).RemoveReaction), messageID, reaction)
}
// MarkAsRead mocks base method
func (m *MockMessageService) MarkAsRead(channelID, threadID, lastReadMessageID uint64) (uint32, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "MarkAsRead", channelID, threadID, lastReadMessageID)
ret0, _ := ret[0].(uint32)
ret1, _ := ret[1].(error)
@ -132,11 +147,13 @@ func (m *MockMessageService) MarkAsRead(channelID, threadID, lastReadMessageID u
// MarkAsRead indicates an expected call of MarkAsRead
func (mr *MockMessageServiceMockRecorder) MarkAsRead(channelID, threadID, lastReadMessageID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkAsRead", reflect.TypeOf((*MockMessageService)(nil).MarkAsRead), channelID, threadID, lastReadMessageID)
}
// Pin mocks base method
func (m *MockMessageService) Pin(messageID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Pin", messageID)
ret0, _ := ret[0].(error)
return ret0
@ -144,11 +161,13 @@ func (m *MockMessageService) Pin(messageID uint64) error {
// Pin indicates an expected call of Pin
func (mr *MockMessageServiceMockRecorder) Pin(messageID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pin", reflect.TypeOf((*MockMessageService)(nil).Pin), messageID)
}
// RemovePin mocks base method
func (m *MockMessageService) RemovePin(messageID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RemovePin", messageID)
ret0, _ := ret[0].(error)
return ret0
@ -156,11 +175,13 @@ func (m *MockMessageService) RemovePin(messageID uint64) error {
// RemovePin indicates an expected call of RemovePin
func (mr *MockMessageServiceMockRecorder) RemovePin(messageID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePin", reflect.TypeOf((*MockMessageService)(nil).RemovePin), messageID)
}
// Bookmark mocks base method
func (m *MockMessageService) Bookmark(messageID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Bookmark", messageID)
ret0, _ := ret[0].(error)
return ret0
@ -168,11 +189,13 @@ func (m *MockMessageService) Bookmark(messageID uint64) error {
// Bookmark indicates an expected call of Bookmark
func (mr *MockMessageServiceMockRecorder) Bookmark(messageID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bookmark", reflect.TypeOf((*MockMessageService)(nil).Bookmark), messageID)
}
// RemoveBookmark mocks base method
func (m *MockMessageService) RemoveBookmark(messageID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RemoveBookmark", messageID)
ret0, _ := ret[0].(error)
return ret0
@ -180,11 +203,13 @@ func (m *MockMessageService) RemoveBookmark(messageID uint64) error {
// RemoveBookmark indicates an expected call of RemoveBookmark
func (mr *MockMessageServiceMockRecorder) RemoveBookmark(messageID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveBookmark", reflect.TypeOf((*MockMessageService)(nil).RemoveBookmark), messageID)
}
// Delete mocks base method
func (m *MockMessageService) Delete(ID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ID)
ret0, _ := ret[0].(error)
return ret0
@ -192,5 +217,6 @@ func (m *MockMessageService) Delete(ID uint64) error {
// Delete indicates an expected call of Delete
func (mr *MockMessageServiceMockRecorder) Delete(ID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockMessageService)(nil).Delete), ID)
}

18
system/internal/repository/mocks/credentials.go
View File

@ -5,8 +5,8 @@
package repository
import (
repository "app/system/internal/repository"
context "context"
repository "github.com/crusttech/crust/system/internal/repository"
types "github.com/crusttech/crust/system/types"
gomock "github.com/golang/mock/gomock"
factory "github.com/titpetric/factory"
@ -38,6 +38,7 @@ func (m *MockCredentialsRepository) EXPECT() *MockCredentialsRepositoryMockRecor
// With mocks base method
func (m *MockCredentialsRepository) With(ctx context.Context, db *factory.DB) repository.CredentialsRepository {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "With", ctx, db)
ret0, _ := ret[0].(repository.CredentialsRepository)
return ret0
@ -45,11 +46,13 @@ func (m *MockCredentialsRepository) With(ctx context.Context, db *factory.DB) re
// With indicates an expected call of With
func (mr *MockCredentialsRepositoryMockRecorder) With(ctx, db interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "With", reflect.TypeOf((*MockCredentialsRepository)(nil).With), ctx, db)
}
// FindByID mocks base method
func (m *MockCredentialsRepository) FindByID(ID uint64) (*types.Credentials, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByID", ID)
ret0, _ := ret[0].(*types.Credentials)
ret1, _ := ret[1].(error)
@ -58,11 +61,13 @@ func (m *MockCredentialsRepository) FindByID(ID uint64) (*types.Credentials, err
// FindByID indicates an expected call of FindByID
func (mr *MockCredentialsRepositoryMockRecorder) FindByID(ID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByID", reflect.TypeOf((*MockCredentialsRepository)(nil).FindByID), ID)
}
// FindByCredentials mocks base method
func (m *MockCredentialsRepository) FindByCredentials(kind types.CredentialsKind, credentials string) (types.CredentialsSet, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByCredentials", kind, credentials)
ret0, _ := ret[0].(types.CredentialsSet)
ret1, _ := ret[1].(error)
@ -71,11 +76,13 @@ func (m *MockCredentialsRepository) FindByCredentials(kind types.CredentialsKind
// FindByCredentials indicates an expected call of FindByCredentials
func (mr *MockCredentialsRepositoryMockRecorder) FindByCredentials(kind, credentials interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByCredentials", reflect.TypeOf((*MockCredentialsRepository)(nil).FindByCredentials), kind, credentials)
}
// FindByKind mocks base method
func (m *MockCredentialsRepository) FindByKind(ownerID uint64, kind types.CredentialsKind) (types.CredentialsSet, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByKind", ownerID, kind)
ret0, _ := ret[0].(types.CredentialsSet)
ret1, _ := ret[1].(error)
@ -84,11 +91,13 @@ func (m *MockCredentialsRepository) FindByKind(ownerID uint64, kind types.Creden
// FindByKind indicates an expected call of FindByKind
func (mr *MockCredentialsRepositoryMockRecorder) FindByKind(ownerID, kind interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByKind", reflect.TypeOf((*MockCredentialsRepository)(nil).FindByKind), ownerID, kind)
}
// FindByOwnerID mocks base method
func (m *MockCredentialsRepository) FindByOwnerID(ownerID uint64) (types.CredentialsSet, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByOwnerID", ownerID)
ret0, _ := ret[0].(types.CredentialsSet)
ret1, _ := ret[1].(error)
@ -97,11 +106,13 @@ func (m *MockCredentialsRepository) FindByOwnerID(ownerID uint64) (types.Credent
// FindByOwnerID indicates an expected call of FindByOwnerID
func (mr *MockCredentialsRepositoryMockRecorder) FindByOwnerID(ownerID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByOwnerID", reflect.TypeOf((*MockCredentialsRepository)(nil).FindByOwnerID), ownerID)
}
// Find mocks base method
func (m *MockCredentialsRepository) Find() (types.CredentialsSet, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Find")
ret0, _ := ret[0].(types.CredentialsSet)
ret1, _ := ret[1].(error)
@ -110,11 +121,13 @@ func (m *MockCredentialsRepository) Find() (types.CredentialsSet, error) {
// Find indicates an expected call of Find
func (mr *MockCredentialsRepositoryMockRecorder) Find() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockCredentialsRepository)(nil).Find))
}
// Create mocks base method
func (m *MockCredentialsRepository) Create(c *types.Credentials) (*types.Credentials, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Create", c)
ret0, _ := ret[0].(*types.Credentials)
ret1, _ := ret[1].(error)
@ -123,11 +136,13 @@ func (m *MockCredentialsRepository) Create(c *types.Credentials) (*types.Credent
// Create indicates an expected call of Create
func (mr *MockCredentialsRepositoryMockRecorder) Create(c interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockCredentialsRepository)(nil).Create), c)
}
// DeleteByID mocks base method
func (m *MockCredentialsRepository) DeleteByID(id uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteByID", id)
ret0, _ := ret[0].(error)
return ret0
@ -135,5 +150,6 @@ func (m *MockCredentialsRepository) DeleteByID(id uint64) error {
// DeleteByID indicates an expected call of DeleteByID
func (mr *MockCredentialsRepositoryMockRecorder) DeleteByID(id interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteByID", reflect.TypeOf((*MockCredentialsRepository)(nil).DeleteByID), id)
}

26
system/internal/repository/mocks/user.go
View File

@ -5,8 +5,8 @@
package repository
import (
repository "app/system/internal/repository"
context "context"
repository "github.com/crusttech/crust/system/internal/repository"
types "github.com/crusttech/crust/system/types"
gomock "github.com/golang/mock/gomock"
factory "github.com/titpetric/factory"
@ -38,6 +38,7 @@ func (m *MockUserRepository) EXPECT() *MockUserRepositoryMockRecorder {
// With mocks base method
func (m *MockUserRepository) With(ctx context.Context, db *factory.DB) repository.UserRepository {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "With", ctx, db)
ret0, _ := ret[0].(repository.UserRepository)
return ret0
@ -45,11 +46,13 @@ func (m *MockUserRepository) With(ctx context.Context, db *factory.DB) repositor
// With indicates an expected call of With
func (mr *MockUserRepositoryMockRecorder) With(ctx, db interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "With", reflect.TypeOf((*MockUserRepository)(nil).With), ctx, db)
}
// FindByEmail mocks base method
func (m *MockUserRepository) FindByEmail(email string) (*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByEmail", email)
ret0, _ := ret[0].(*types.User)
ret1, _ := ret[1].(error)
@ -58,11 +61,13 @@ func (m *MockUserRepository) FindByEmail(email string) (*types.User, error) {
// FindByEmail indicates an expected call of FindByEmail
func (mr *MockUserRepositoryMockRecorder) FindByEmail(email interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByEmail", reflect.TypeOf((*MockUserRepository)(nil).FindByEmail), email)
}
// FindByUsername mocks base method
func (m *MockUserRepository) FindByUsername(username string) (*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByUsername", username)
ret0, _ := ret[0].(*types.User)
ret1, _ := ret[1].(error)
@ -71,11 +76,13 @@ func (m *MockUserRepository) FindByUsername(username string) (*types.User, error
// FindByUsername indicates an expected call of FindByUsername
func (mr *MockUserRepositoryMockRecorder) FindByUsername(username interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByUsername", reflect.TypeOf((*MockUserRepository)(nil).FindByUsername), username)
}
// FindByID mocks base method
func (m *MockUserRepository) FindByID(id uint64) (*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByID", id)
ret0, _ := ret[0].(*types.User)
ret1, _ := ret[1].(error)
@ -84,11 +91,13 @@ func (m *MockUserRepository) FindByID(id uint64) (*types.User, error) {
// FindByID indicates an expected call of FindByID
func (mr *MockUserRepositoryMockRecorder) FindByID(id interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByID", reflect.TypeOf((*MockUserRepository)(nil).FindByID), id)
}
// FindByIDs mocks base method
func (m *MockUserRepository) FindByIDs(id ...uint64) (types.UserSet, error) {
m.ctrl.T.Helper()
varargs := []interface{}{}
for _, a := range id {
varargs = append(varargs, a)
@ -101,11 +110,13 @@ func (m *MockUserRepository) FindByIDs(id ...uint64) (types.UserSet, error) {
// FindByIDs indicates an expected call of FindByIDs
func (mr *MockUserRepositoryMockRecorder) FindByIDs(id ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByIDs", reflect.TypeOf((*MockUserRepository)(nil).FindByIDs), id...)
}
// FindBySatosaID mocks base method
func (m *MockUserRepository) FindBySatosaID(id string) (*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindBySatosaID", id)
ret0, _ := ret[0].(*types.User)
ret1, _ := ret[1].(error)
@ -114,11 +125,13 @@ func (m *MockUserRepository) FindBySatosaID(id string) (*types.User, error) {
// FindBySatosaID indicates an expected call of FindBySatosaID
func (mr *MockUserRepositoryMockRecorder) FindBySatosaID(id interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindBySatosaID", reflect.TypeOf((*MockUserRepository)(nil).FindBySatosaID), id)
}
// Find mocks base method
func (m *MockUserRepository) Find(filter *types.UserFilter) ([]*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Find", filter)
ret0, _ := ret[0].([]*types.User)
ret1, _ := ret[1].(error)
@ -127,11 +140,13 @@ func (m *MockUserRepository) Find(filter *types.UserFilter) ([]*types.User, erro
// Find indicates an expected call of Find
func (mr *MockUserRepositoryMockRecorder) Find(filter interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockUserRepository)(nil).Find), filter)
}
// Create mocks base method
func (m *MockUserRepository) Create(mod *types.User) (*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Create", mod)
ret0, _ := ret[0].(*types.User)
ret1, _ := ret[1].(error)
@ -140,11 +155,13 @@ func (m *MockUserRepository) Create(mod *types.User) (*types.User, error) {
// Create indicates an expected call of Create
func (mr *MockUserRepositoryMockRecorder) Create(mod interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockUserRepository)(nil).Create), mod)
}
// Update mocks base method
func (m *MockUserRepository) Update(mod *types.User) (*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Update", mod)
ret0, _ := ret[0].(*types.User)
ret1, _ := ret[1].(error)
@ -153,11 +170,13 @@ func (m *MockUserRepository) Update(mod *types.User) (*types.User, error) {
// Update indicates an expected call of Update
func (mr *MockUserRepositoryMockRecorder) Update(mod interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUserRepository)(nil).Update), mod)
}
// SuspendByID mocks base method
func (m *MockUserRepository) SuspendByID(id uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SuspendByID", id)
ret0, _ := ret[0].(error)
return ret0
@ -165,11 +184,13 @@ func (m *MockUserRepository) SuspendByID(id uint64) error {
// SuspendByID indicates an expected call of SuspendByID
func (mr *MockUserRepositoryMockRecorder) SuspendByID(id interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuspendByID", reflect.TypeOf((*MockUserRepository)(nil).SuspendByID), id)
}
// UnsuspendByID mocks base method
func (m *MockUserRepository) UnsuspendByID(id uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UnsuspendByID", id)
ret0, _ := ret[0].(error)
return ret0
@ -177,11 +198,13 @@ func (m *MockUserRepository) UnsuspendByID(id uint64) error {
// UnsuspendByID indicates an expected call of UnsuspendByID
func (mr *MockUserRepositoryMockRecorder) UnsuspendByID(id interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsuspendByID", reflect.TypeOf((*MockUserRepository)(nil).UnsuspendByID), id)
}
// DeleteByID mocks base method
func (m *MockUserRepository) DeleteByID(id uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteByID", id)
ret0, _ := ret[0].(error)
return ret0
@ -189,5 +212,6 @@ func (m *MockUserRepository) DeleteByID(id uint64) error {
// DeleteByID indicates an expected call of DeleteByID
func (mr *MockUserRepositoryMockRecorder) DeleteByID(id interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteByID", reflect.TypeOf((*MockUserRepository)(nil).DeleteByID), id)
}

16
system/internal/service/organisation_mock_test.go
View File

@ -36,6 +36,7 @@ func (m *MockOrganisationService) EXPECT() *MockOrganisationServiceMockRecorder
// With mocks base method
func (m *MockOrganisationService) With(ctx context.Context) OrganisationService {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "With", ctx)
ret0, _ := ret[0].(OrganisationService)
return ret0
@ -43,11 +44,13 @@ func (m *MockOrganisationService) With(ctx context.Context) OrganisationService
// With indicates an expected call of With
func (mr *MockOrganisationServiceMockRecorder) With(ctx interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "With", reflect.TypeOf((*MockOrganisationService)(nil).With), ctx)
}
// FindByID mocks base method
func (m *MockOrganisationService) FindByID(organisationID uint64) (*types.Organisation, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByID", organisationID)
ret0, _ := ret[0].(*types.Organisation)
ret1, _ := ret[1].(error)
@ -56,11 +59,13 @@ func (m *MockOrganisationService) FindByID(organisationID uint64) (*types.Organi
// FindByID indicates an expected call of FindByID
func (mr *MockOrganisationServiceMockRecorder) FindByID(organisationID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByID", reflect.TypeOf((*MockOrganisationService)(nil).FindByID), organisationID)
}
// Find mocks base method
func (m *MockOrganisationService) Find(filter *types.OrganisationFilter) ([]*types.Organisation, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Find", filter)
ret0, _ := ret[0].([]*types.Organisation)
ret1, _ := ret[1].(error)
@ -69,11 +74,13 @@ func (m *MockOrganisationService) Find(filter *types.OrganisationFilter) ([]*typ
// Find indicates an expected call of Find
func (mr *MockOrganisationServiceMockRecorder) Find(filter interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockOrganisationService)(nil).Find), filter)
}
// Create mocks base method
func (m *MockOrganisationService) Create(organisation *types.Organisation) (*types.Organisation, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Create", organisation)
ret0, _ := ret[0].(*types.Organisation)
ret1, _ := ret[1].(error)
@ -82,11 +89,13 @@ func (m *MockOrganisationService) Create(organisation *types.Organisation) (*typ
// Create indicates an expected call of Create
func (mr *MockOrganisationServiceMockRecorder) Create(organisation interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockOrganisationService)(nil).Create), organisation)
}
// Update mocks base method
func (m *MockOrganisationService) Update(organisation *types.Organisation) (*types.Organisation, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Update", organisation)
ret0, _ := ret[0].(*types.Organisation)
ret1, _ := ret[1].(error)
@ -95,11 +104,13 @@ func (m *MockOrganisationService) Update(organisation *types.Organisation) (*typ
// Update indicates an expected call of Update
func (mr *MockOrganisationServiceMockRecorder) Update(organisation interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockOrganisationService)(nil).Update), organisation)
}
// Archive mocks base method
func (m *MockOrganisationService) Archive(ID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Archive", ID)
ret0, _ := ret[0].(error)
return ret0
@ -107,11 +118,13 @@ func (m *MockOrganisationService) Archive(ID uint64) error {
// Archive indicates an expected call of Archive
func (mr *MockOrganisationServiceMockRecorder) Archive(ID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Archive", reflect.TypeOf((*MockOrganisationService)(nil).Archive), ID)
}
// Unarchive mocks base method
func (m *MockOrganisationService) Unarchive(ID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Unarchive", ID)
ret0, _ := ret[0].(error)
return ret0
@ -119,11 +132,13 @@ func (m *MockOrganisationService) Unarchive(ID uint64) error {
// Unarchive indicates an expected call of Unarchive
func (mr *MockOrganisationServiceMockRecorder) Unarchive(ID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unarchive", reflect.TypeOf((*MockOrganisationService)(nil).Unarchive), ID)
}
// Delete mocks base method
func (m *MockOrganisationService) Delete(ID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ID)
ret0, _ := ret[0].(error)
return ret0
@ -131,5 +146,6 @@ func (m *MockOrganisationService) Delete(ID uint64) error {
// Delete indicates an expected call of Delete
func (mr *MockOrganisationServiceMockRecorder) Delete(ID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockOrganisationService)(nil).Delete), ID)
}

26
system/internal/service/role_mock_test.go
View File

@ -36,6 +36,7 @@ func (m *MockRoleService) EXPECT() *MockRoleServiceMockRecorder {
// With mocks base method
func (m *MockRoleService) With(ctx context.Context) RoleService {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "With", ctx)
ret0, _ := ret[0].(RoleService)
return ret0
@ -43,11 +44,13 @@ func (m *MockRoleService) With(ctx context.Context) RoleService {
// With indicates an expected call of With
func (mr *MockRoleServiceMockRecorder) With(ctx interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "With", reflect.TypeOf((*MockRoleService)(nil).With), ctx)
}
// FindByID mocks base method
func (m *MockRoleService) FindByID(roleID uint64) (*types.Role, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByID", roleID)
ret0, _ := ret[0].(*types.Role)
ret1, _ := ret[1].(error)
@ -56,11 +59,13 @@ func (m *MockRoleService) FindByID(roleID uint64) (*types.Role, error) {
// FindByID indicates an expected call of FindByID
func (mr *MockRoleServiceMockRecorder) FindByID(roleID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByID", reflect.TypeOf((*MockRoleService)(nil).FindByID), roleID)
}
// Find mocks base method
func (m *MockRoleService) Find(filter *types.RoleFilter) ([]*types.Role, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Find", filter)
ret0, _ := ret[0].([]*types.Role)
ret1, _ := ret[1].(error)
@ -69,11 +74,13 @@ func (m *MockRoleService) Find(filter *types.RoleFilter) ([]*types.Role, error)
// Find indicates an expected call of Find
func (mr *MockRoleServiceMockRecorder) Find(filter interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockRoleService)(nil).Find), filter)
}
// Create mocks base method
func (m *MockRoleService) Create(role *types.Role) (*types.Role, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Create", role)
ret0, _ := ret[0].(*types.Role)
ret1, _ := ret[1].(error)
@ -82,11 +89,13 @@ func (m *MockRoleService) Create(role *types.Role) (*types.Role, error) {
// Create indicates an expected call of Create
func (mr *MockRoleServiceMockRecorder) Create(role interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockRoleService)(nil).Create), role)
}
// Update mocks base method
func (m *MockRoleService) Update(role *types.Role) (*types.Role, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Update", role)
ret0, _ := ret[0].(*types.Role)
ret1, _ := ret[1].(error)
@ -95,11 +104,13 @@ func (m *MockRoleService) Update(role *types.Role) (*types.Role, error) {
// Update indicates an expected call of Update
func (mr *MockRoleServiceMockRecorder) Update(role interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRoleService)(nil).Update), role)
}
// Merge mocks base method
func (m *MockRoleService) Merge(roleID, targetroleID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Merge", roleID, targetroleID)
ret0, _ := ret[0].(error)
return ret0
@ -107,11 +118,13 @@ func (m *MockRoleService) Merge(roleID, targetroleID uint64) error {
// Merge indicates an expected call of Merge
func (mr *MockRoleServiceMockRecorder) Merge(roleID, targetroleID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Merge", reflect.TypeOf((*MockRoleService)(nil).Merge), roleID, targetroleID)
}
// Move mocks base method
func (m *MockRoleService) Move(roleID, organisationID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Move", roleID, organisationID)
ret0, _ := ret[0].(error)
return ret0
@ -119,11 +132,13 @@ func (m *MockRoleService) Move(roleID, organisationID uint64) error {
// Move indicates an expected call of Move
func (mr *MockRoleServiceMockRecorder) Move(roleID, organisationID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockRoleService)(nil).Move), roleID, organisationID)
}
// Archive mocks base method
func (m *MockRoleService) Archive(ID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Archive", ID)
ret0, _ := ret[0].(error)
return ret0
@ -131,11 +146,13 @@ func (m *MockRoleService) Archive(ID uint64) error {
// Archive indicates an expected call of Archive
func (mr *MockRoleServiceMockRecorder) Archive(ID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Archive", reflect.TypeOf((*MockRoleService)(nil).Archive), ID)
}
// Unarchive mocks base method
func (m *MockRoleService) Unarchive(ID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Unarchive", ID)
ret0, _ := ret[0].(error)
return ret0
@ -143,11 +160,13 @@ func (m *MockRoleService) Unarchive(ID uint64) error {
// Unarchive indicates an expected call of Unarchive
func (mr *MockRoleServiceMockRecorder) Unarchive(ID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unarchive", reflect.TypeOf((*MockRoleService)(nil).Unarchive), ID)
}
// Delete mocks base method
func (m *MockRoleService) Delete(ID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ID)
ret0, _ := ret[0].(error)
return ret0
@ -155,11 +174,13 @@ func (m *MockRoleService) Delete(ID uint64) error {
// Delete indicates an expected call of Delete
func (mr *MockRoleServiceMockRecorder) Delete(ID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRoleService)(nil).Delete), ID)
}
// MemberList mocks base method
func (m *MockRoleService) MemberList(roleID uint64) ([]*types.RoleMember, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "MemberList", roleID)
ret0, _ := ret[0].([]*types.RoleMember)
ret1, _ := ret[1].(error)
@ -168,11 +189,13 @@ func (m *MockRoleService) MemberList(roleID uint64) ([]*types.RoleMember, error)
// MemberList indicates an expected call of MemberList
func (mr *MockRoleServiceMockRecorder) MemberList(roleID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemberList", reflect.TypeOf((*MockRoleService)(nil).MemberList), roleID)
}
// MemberAdd mocks base method
func (m *MockRoleService) MemberAdd(roleID, userID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "MemberAdd", roleID, userID)
ret0, _ := ret[0].(error)
return ret0
@ -180,11 +203,13 @@ func (m *MockRoleService) MemberAdd(roleID, userID uint64) error {
// MemberAdd indicates an expected call of MemberAdd
func (mr *MockRoleServiceMockRecorder) MemberAdd(roleID, userID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemberAdd", reflect.TypeOf((*MockRoleService)(nil).MemberAdd), roleID, userID)
}
// MemberRemove mocks base method
func (m *MockRoleService) MemberRemove(roleID, userID uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "MemberRemove", roleID, userID)
ret0, _ := ret[0].(error)
return ret0
@ -192,5 +217,6 @@ func (m *MockRoleService) MemberRemove(roleID, userID uint64) error {
// MemberRemove indicates an expected call of MemberRemove
func (mr *MockRoleServiceMockRecorder) MemberRemove(roleID, userID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemberRemove", reflect.TypeOf((*MockRoleService)(nil).MemberRemove), roleID, userID)
}

26
system/internal/service/user_mock_test.go
View File

@ -36,6 +36,7 @@ func (m *MockUserService) EXPECT() *MockUserServiceMockRecorder {
// With mocks base method
func (m *MockUserService) With(ctx context.Context) UserService {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "With", ctx)
ret0, _ := ret[0].(UserService)
return ret0
@ -43,11 +44,13 @@ func (m *MockUserService) With(ctx context.Context) UserService {
// With indicates an expected call of With
func (mr *MockUserServiceMockRecorder) With(ctx interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "With", reflect.TypeOf((*MockUserService)(nil).With), ctx)
}
// FindByUsername mocks base method
func (m *MockUserService) FindByUsername(username string) (*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByUsername", username)
ret0, _ := ret[0].(*types.User)
ret1, _ := ret[1].(error)
@ -56,11 +59,13 @@ func (m *MockUserService) FindByUsername(username string) (*types.User, error) {
// FindByUsername indicates an expected call of FindByUsername
func (mr *MockUserServiceMockRecorder) FindByUsername(username interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByUsername", reflect.TypeOf((*MockUserService)(nil).FindByUsername), username)
}
// FindByEmail mocks base method
func (m *MockUserService) FindByEmail(email string) (*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByEmail", email)
ret0, _ := ret[0].(*types.User)
ret1, _ := ret[1].(error)
@ -69,11 +74,13 @@ func (m *MockUserService) FindByEmail(email string) (*types.User, error) {
// FindByEmail indicates an expected call of FindByEmail
func (mr *MockUserServiceMockRecorder) FindByEmail(email interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByEmail", reflect.TypeOf((*MockUserService)(nil).FindByEmail), email)
}
// FindByID mocks base method
func (m *MockUserService) FindByID(id uint64) (*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindByID", id)
ret0, _ := ret[0].(*types.User)
ret1, _ := ret[1].(error)
@ -82,11 +89,13 @@ func (m *MockUserService) FindByID(id uint64) (*types.User, error) {
// FindByID indicates an expected call of FindByID
func (mr *MockUserServiceMockRecorder) FindByID(id interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByID", reflect.TypeOf((*MockUserService)(nil).FindByID), id)
}
// FindByIDs mocks base method
func (m *MockUserService) FindByIDs(id ...uint64) (types.UserSet, error) {
m.ctrl.T.Helper()
varargs := []interface{}{}
for _, a := range id {
varargs = append(varargs, a)
@ -99,11 +108,13 @@ func (m *MockUserService) FindByIDs(id ...uint64) (types.UserSet, error) {
// FindByIDs indicates an expected call of FindByIDs
func (mr *MockUserServiceMockRecorder) FindByIDs(id ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByIDs", reflect.TypeOf((*MockUserService)(nil).FindByIDs), id...)
}
// Find mocks base method
func (m *MockUserService) Find(filter *types.UserFilter) (types.UserSet, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Find", filter)
ret0, _ := ret[0].(types.UserSet)
ret1, _ := ret[1].(error)
@ -112,11 +123,13 @@ func (m *MockUserService) Find(filter *types.UserFilter) (types.UserSet, error)
// Find indicates an expected call of Find
func (mr *MockUserServiceMockRecorder) Find(filter interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockUserService)(nil).Find), filter)
}
// FindOrCreate mocks base method
func (m *MockUserService) FindOrCreate(arg0 *types.User) (*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindOrCreate", arg0)
ret0, _ := ret[0].(*types.User)
ret1, _ := ret[1].(error)
@ -125,11 +138,13 @@ func (m *MockUserService) FindOrCreate(arg0 *types.User) (*types.User, error) {
// FindOrCreate indicates an expected call of FindOrCreate
func (mr *MockUserServiceMockRecorder) FindOrCreate(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOrCreate", reflect.TypeOf((*MockUserService)(nil).FindOrCreate), arg0)
}
// Create mocks base method
func (m *MockUserService) Create(input *types.User) (*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Create", input)
ret0, _ := ret[0].(*types.User)
ret1, _ := ret[1].(error)
@ -138,11 +153,13 @@ func (m *MockUserService) Create(input *types.User) (*types.User, error) {
// Create indicates an expected call of Create
func (mr *MockUserServiceMockRecorder) Create(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockUserService)(nil).Create), input)
}
// Update mocks base method
func (m *MockUserService) Update(mod *types.User) (*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Update", mod)
ret0, _ := ret[0].(*types.User)
ret1, _ := ret[1].(error)
@ -151,11 +168,13 @@ func (m *MockUserService) Update(mod *types.User) (*types.User, error) {
// Update indicates an expected call of Update
func (mr *MockUserServiceMockRecorder) Update(mod interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUserService)(nil).Update), mod)
}
// Delete mocks base method
func (m *MockUserService) Delete(id uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", id)
ret0, _ := ret[0].(error)
return ret0
@ -163,11 +182,13 @@ func (m *MockUserService) Delete(id uint64) error {
// Delete indicates an expected call of Delete
func (mr *MockUserServiceMockRecorder) Delete(id interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockUserService)(nil).Delete), id)
}
// Suspend mocks base method
func (m *MockUserService) Suspend(id uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Suspend", id)
ret0, _ := ret[0].(error)
return ret0
@ -175,11 +196,13 @@ func (m *MockUserService) Suspend(id uint64) error {
// Suspend indicates an expected call of Suspend
func (mr *MockUserServiceMockRecorder) Suspend(id interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Suspend", reflect.TypeOf((*MockUserService)(nil).Suspend), id)
}
// Unsuspend mocks base method
func (m *MockUserService) Unsuspend(id uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Unsuspend", id)
ret0, _ := ret[0].(error)
return ret0
@ -187,11 +210,13 @@ func (m *MockUserService) Unsuspend(id uint64) error {
// Unsuspend indicates an expected call of Unsuspend
func (mr *MockUserServiceMockRecorder) Unsuspend(id interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unsuspend", reflect.TypeOf((*MockUserService)(nil).Unsuspend), id)
}
// ValidateCredentials mocks base method
func (m *MockUserService) ValidateCredentials(username, password string) (*types.User, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ValidateCredentials", username, password)
ret0, _ := ret[0].(*types.User)
ret1, _ := ret[1].(error)
@ -200,5 +225,6 @@ func (m *MockUserService) ValidateCredentials(username, password string) (*types
// ValidateCredentials indicates an expected call of ValidateCredentials
func (mr *MockUserServiceMockRecorder) ValidateCredentials(username, password interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateCredentials", reflect.TypeOf((*MockUserService)(nil).ValidateCredentials), username, password)
}