From e8d2be4968c8380982f8bd6fd650269f5b3a3bd0 Mon Sep 17 00:00:00 2001 From: Tit Petric Date: Fri, 15 Mar 2019 00:31:25 +0100 Subject: [PATCH] upd(all): update mocks --- .../service/notification_mock_test.go | 6 ++++ internal/rules/resources_mock_test.go | 10 +++++++ .../internal/service/attachment_mock_test.go | 10 +++++++ .../internal/service/channel_mock_test.go | 30 +++++++++++++++++++ .../internal/service/message_mock_test.go | 26 ++++++++++++++++ .../internal/repository/mocks/credentials.go | 18 ++++++++++- system/internal/repository/mocks/user.go | 26 +++++++++++++++- .../service/organisation_mock_test.go | 16 ++++++++++ system/internal/service/role_mock_test.go | 26 ++++++++++++++++ system/internal/service/user_mock_test.go | 26 ++++++++++++++++ 10 files changed, 192 insertions(+), 2 deletions(-) diff --git a/crm/internal/service/notification_mock_test.go b/crm/internal/service/notification_mock_test.go index b308a88ab..d8419c838 100644 --- a/crm/internal/service/notification_mock_test.go +++ b/crm/internal/service/notification_mock_test.go @@ -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...) } diff --git a/internal/rules/resources_mock_test.go b/internal/rules/resources_mock_test.go index bb7f2c8b3..07d25f23c 100644 --- a/internal/rules/resources_mock_test.go +++ b/internal/rules/resources_mock_test.go @@ -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) } diff --git a/messaging/internal/service/attachment_mock_test.go b/messaging/internal/service/attachment_mock_test.go index 1562530c4..d68793bc6 100644 --- a/messaging/internal/service/attachment_mock_test.go +++ b/messaging/internal/service/attachment_mock_test.go @@ -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) } diff --git a/messaging/internal/service/channel_mock_test.go b/messaging/internal/service/channel_mock_test.go index 49631c2cc..47b5520a2 100644 --- a/messaging/internal/service/channel_mock_test.go +++ b/messaging/internal/service/channel_mock_test.go @@ -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) } diff --git a/messaging/internal/service/message_mock_test.go b/messaging/internal/service/message_mock_test.go index 23c3479e2..3f6cccb9a 100644 --- a/messaging/internal/service/message_mock_test.go +++ b/messaging/internal/service/message_mock_test.go @@ -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) } diff --git a/system/internal/repository/mocks/credentials.go b/system/internal/repository/mocks/credentials.go index d4adeb99b..a6c0a48e9 100644 --- a/system/internal/repository/mocks/credentials.go +++ b/system/internal/repository/mocks/credentials.go @@ -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) } diff --git a/system/internal/repository/mocks/user.go b/system/internal/repository/mocks/user.go index 0c7b432e1..ed4417847 100644 --- a/system/internal/repository/mocks/user.go +++ b/system/internal/repository/mocks/user.go @@ -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) } diff --git a/system/internal/service/organisation_mock_test.go b/system/internal/service/organisation_mock_test.go index f058fff17..846e5016e 100644 --- a/system/internal/service/organisation_mock_test.go +++ b/system/internal/service/organisation_mock_test.go @@ -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) } diff --git a/system/internal/service/role_mock_test.go b/system/internal/service/role_mock_test.go index 8b61f660e..13f799ce6 100644 --- a/system/internal/service/role_mock_test.go +++ b/system/internal/service/role_mock_test.go @@ -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) } diff --git a/system/internal/service/user_mock_test.go b/system/internal/service/user_mock_test.go index e912aa511..b49edf1fd 100644 --- a/system/internal/service/user_mock_test.go +++ b/system/internal/service/user_mock_test.go @@ -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) }