From 11b25bd091c8cdf6bd0a51ab4ec99ead80a737b1 Mon Sep 17 00:00:00 2001 From: Tit Petric Date: Fri, 11 Jan 2019 15:28:36 +0100 Subject: [PATCH] update mocks for sam/ and system/ --- Makefile | 6 +-- sam/service/channel_mock_test.go | 47 ++++++++++--------- sam/service/message_mock_test.go | 61 ++++++++++++++---------- system/service/team_mock_test.go | 24 ++++++++++ system/service/user_mock_test.go | 80 ++++++++++++++++++++++++++++---- 5 files changed, 160 insertions(+), 58 deletions(-) diff --git a/Makefile b/Makefile index bb5840b22..9687f9f07 100644 --- a/Makefile +++ b/Makefile @@ -143,9 +143,9 @@ mocks: $(GOMOCK) $(MOCKGEN) -package service -source sam/service/attachment.go -destination sam/service/attachment_mock_test.go $(MOCKGEN) -package service -source sam/service/channel.go -destination sam/service/channel_mock_test.go $(MOCKGEN) -package service -source sam/service/message.go -destination sam/service/message_mock_test.go - $(MOCKGEN) -package service -source sam/service/organisation.go -destination sam/service/organisation_mock_test.go - $(MOCKGEN) -package service -source sam/service/team.go -destination sam/service/team_mock_test.go - $(MOCKGEN) -package service -source system/service/user.go -destination system/service/user_mock_test.go + $(MOCKGEN) -package service -source system/service/organisation.go -destination system/service/organisation_mock_test.go + $(MOCKGEN) -package service -source system/service/team.go -destination system/service/team_mock_test.go + $(MOCKGEN) -package service -source system/service/user.go -destination system/service/user_mock_test.go ######################################################################################################################## diff --git a/sam/service/channel_mock_test.go b/sam/service/channel_mock_test.go index 5354124de..8433f8654 100644 --- a/sam/service/channel_mock_test.go +++ b/sam/service/channel_mock_test.go @@ -98,19 +98,6 @@ func (mr *MockChannelServiceMockRecorder) Update(channel interface{}) *gomock.Ca return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockChannelService)(nil).Update), channel) } -// FindByMembership mocks base method -func (m *MockChannelService) FindByMembership() ([]*types.Channel, error) { - ret := m.ctrl.Call(m, "FindByMembership") - ret0, _ := ret[0].([]*types.Channel) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindByMembership indicates an expected call of FindByMembership -func (mr *MockChannelServiceMockRecorder) FindByMembership() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByMembership", reflect.TypeOf((*MockChannelService)(nil).FindByMembership)) -} - // FindMembers mocks base method func (m *MockChannelService) FindMembers(channelID uint64) (types.ChannelMemberSet, error) { ret := m.ctrl.Call(m, "FindMembers", channelID) @@ -178,10 +165,11 @@ func (mr *MockChannelServiceMockRecorder) DeleteMember(channelID interface{}, me } // Archive mocks base method -func (m *MockChannelService) Archive(ID uint64) error { +func (m *MockChannelService) Archive(ID uint64) (*types.Channel, error) { ret := m.ctrl.Call(m, "Archive", ID) - ret0, _ := ret[0].(error) - return ret0 + ret0, _ := ret[0].(*types.Channel) + ret1, _ := ret[1].(error) + return ret0, ret1 } // Archive indicates an expected call of Archive @@ -190,10 +178,11 @@ func (mr *MockChannelServiceMockRecorder) Archive(ID interface{}) *gomock.Call { } // Unarchive mocks base method -func (m *MockChannelService) Unarchive(ID uint64) error { +func (m *MockChannelService) Unarchive(ID uint64) (*types.Channel, error) { ret := m.ctrl.Call(m, "Unarchive", ID) - ret0, _ := ret[0].(error) - return ret0 + ret0, _ := ret[0].(*types.Channel) + ret1, _ := ret[1].(error) + return ret0, ret1 } // Unarchive indicates an expected call of Unarchive @@ -202,10 +191,11 @@ func (mr *MockChannelServiceMockRecorder) Unarchive(ID interface{}) *gomock.Call } // Delete mocks base method -func (m *MockChannelService) Delete(ID uint64) error { +func (m *MockChannelService) Delete(ID uint64) (*types.Channel, error) { ret := m.ctrl.Call(m, "Delete", ID) - ret0, _ := ret[0].(error) - return ret0 + ret0, _ := ret[0].(*types.Channel) + ret1, _ := ret[1].(error) + return ret0, ret1 } // Delete indicates an expected call of Delete @@ -213,6 +203,19 @@ func (mr *MockChannelServiceMockRecorder) Delete(ID interface{}) *gomock.Call { 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) { + ret := m.ctrl.Call(m, "Undelete", ID) + ret0, _ := ret[0].(*types.Channel) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Undelete indicates an expected call of Undelete +func (mr *MockChannelServiceMockRecorder) Undelete(ID interface{}) *gomock.Call { + 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 { ret := m.ctrl.Call(m, "RecordView", userID, channelID, lastMessageID) diff --git a/sam/service/message_mock_test.go b/sam/service/message_mock_test.go index 6a31ed88f..8a5d09a07 100644 --- a/sam/service/message_mock_test.go +++ b/sam/service/message_mock_test.go @@ -110,16 +110,29 @@ func (mr *MockMessageServiceMockRecorder) React(messageID, reaction interface{}) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "React", reflect.TypeOf((*MockMessageService)(nil).React), messageID, reaction) } -// Unreact mocks base method -func (m *MockMessageService) Unreact(messageID uint64, reaction string) error { - ret := m.ctrl.Call(m, "Unreact", messageID, reaction) +// RemoveReaction mocks base method +func (m *MockMessageService) RemoveReaction(messageID uint64, reaction string) error { + ret := m.ctrl.Call(m, "RemoveReaction", messageID, reaction) ret0, _ := ret[0].(error) return ret0 } -// Unreact indicates an expected call of Unreact -func (mr *MockMessageServiceMockRecorder) Unreact(messageID, reaction interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unreact", reflect.TypeOf((*MockMessageService)(nil).Unreact), messageID, reaction) +// RemoveReaction indicates an expected call of RemoveReaction +func (mr *MockMessageServiceMockRecorder) RemoveReaction(messageID, reaction interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveReaction", reflect.TypeOf((*MockMessageService)(nil).RemoveReaction), messageID, reaction) +} + +// MarkAsUnread mocks base method +func (m *MockMessageService) MarkAsUnread(messageID uint64) (uint32, error) { + ret := m.ctrl.Call(m, "MarkAsUnread", messageID) + ret0, _ := ret[0].(uint32) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// MarkAsUnread indicates an expected call of MarkAsUnread +func (mr *MockMessageServiceMockRecorder) MarkAsUnread(messageID interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkAsUnread", reflect.TypeOf((*MockMessageService)(nil).MarkAsUnread), messageID) } // Pin mocks base method @@ -134,40 +147,40 @@ func (mr *MockMessageServiceMockRecorder) Pin(messageID interface{}) *gomock.Cal return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pin", reflect.TypeOf((*MockMessageService)(nil).Pin), messageID) } -// Unpin mocks base method -func (m *MockMessageService) Unpin(messageID uint64) error { - ret := m.ctrl.Call(m, "Unpin", messageID) +// RemovePin mocks base method +func (m *MockMessageService) RemovePin(messageID uint64) error { + ret := m.ctrl.Call(m, "RemovePin", messageID) ret0, _ := ret[0].(error) return ret0 } -// Unpin indicates an expected call of Unpin -func (mr *MockMessageServiceMockRecorder) Unpin(messageID interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unpin", reflect.TypeOf((*MockMessageService)(nil).Unpin), messageID) +// RemovePin indicates an expected call of RemovePin +func (mr *MockMessageServiceMockRecorder) RemovePin(messageID interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePin", reflect.TypeOf((*MockMessageService)(nil).RemovePin), messageID) } -// Flag mocks base method -func (m *MockMessageService) Flag(messageID uint64) error { - ret := m.ctrl.Call(m, "Flag", messageID) +// Bookmark mocks base method +func (m *MockMessageService) Bookmark(messageID uint64) error { + ret := m.ctrl.Call(m, "Bookmark", messageID) ret0, _ := ret[0].(error) return ret0 } -// Flag indicates an expected call of Flag -func (mr *MockMessageServiceMockRecorder) Flag(messageID interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Flag", reflect.TypeOf((*MockMessageService)(nil).Flag), messageID) +// Bookmark indicates an expected call of Bookmark +func (mr *MockMessageServiceMockRecorder) Bookmark(messageID interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bookmark", reflect.TypeOf((*MockMessageService)(nil).Bookmark), messageID) } -// Unflag mocks base method -func (m *MockMessageService) Unflag(messageID uint64) error { - ret := m.ctrl.Call(m, "Unflag", messageID) +// RemoveBookmark mocks base method +func (m *MockMessageService) RemoveBookmark(messageID uint64) error { + ret := m.ctrl.Call(m, "RemoveBookmark", messageID) ret0, _ := ret[0].(error) return ret0 } -// Unflag indicates an expected call of Unflag -func (mr *MockMessageServiceMockRecorder) Unflag(messageID interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unflag", reflect.TypeOf((*MockMessageService)(nil).Unflag), messageID) +// RemoveBookmark indicates an expected call of RemoveBookmark +func (mr *MockMessageServiceMockRecorder) RemoveBookmark(messageID interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveBookmark", reflect.TypeOf((*MockMessageService)(nil).RemoveBookmark), messageID) } // Delete mocks base method diff --git a/system/service/team_mock_test.go b/system/service/team_mock_test.go index a3d5a5d91..7f5a0d629 100644 --- a/system/service/team_mock_test.go +++ b/system/service/team_mock_test.go @@ -157,3 +157,27 @@ func (m *MockTeamService) Delete(ID uint64) error { func (mr *MockTeamServiceMockRecorder) Delete(ID interface{}) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockTeamService)(nil).Delete), ID) } + +// MemberAdd mocks base method +func (m *MockTeamService) MemberAdd(teamID, userID uint64) error { + ret := m.ctrl.Call(m, "MemberAdd", teamID, userID) + ret0, _ := ret[0].(error) + return ret0 +} + +// MemberAdd indicates an expected call of MemberAdd +func (mr *MockTeamServiceMockRecorder) MemberAdd(teamID, userID interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemberAdd", reflect.TypeOf((*MockTeamService)(nil).MemberAdd), teamID, userID) +} + +// MemberRemove mocks base method +func (m *MockTeamService) MemberRemove(teamID, userID uint64) error { + ret := m.ctrl.Call(m, "MemberRemove", teamID, userID) + ret0, _ := ret[0].(error) + return ret0 +} + +// MemberRemove indicates an expected call of MemberRemove +func (mr *MockTeamServiceMockRecorder) MemberRemove(teamID, userID interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemberRemove", reflect.TypeOf((*MockTeamService)(nil).MemberRemove), teamID, userID) +} diff --git a/system/service/user_mock_test.go b/system/service/user_mock_test.go index 8d4970a2f..1d198cff7 100644 --- a/system/service/user_mock_test.go +++ b/system/service/user_mock_test.go @@ -46,6 +46,32 @@ func (mr *MockUserServiceMockRecorder) With(ctx interface{}) *gomock.Call { 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) { + ret := m.ctrl.Call(m, "FindByUsername", username) + ret0, _ := ret[0].(*types.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FindByUsername indicates an expected call of FindByUsername +func (mr *MockUserServiceMockRecorder) FindByUsername(username interface{}) *gomock.Call { + 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) { + ret := m.ctrl.Call(m, "FindByEmail", email) + ret0, _ := ret[0].(*types.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FindByEmail indicates an expected call of FindByEmail +func (mr *MockUserServiceMockRecorder) FindByEmail(email interface{}) *gomock.Call { + 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) { ret := m.ctrl.Call(m, "FindByID", id) @@ -72,6 +98,19 @@ func (mr *MockUserServiceMockRecorder) Find(filter interface{}) *gomock.Call { 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) { + ret := m.ctrl.Call(m, "FindOrCreate", arg0) + ret0, _ := ret[0].(*types.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FindOrCreate indicates an expected call of FindOrCreate +func (mr *MockUserServiceMockRecorder) FindOrCreate(arg0 interface{}) *gomock.Call { + 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) { ret := m.ctrl.Call(m, "Create", input) @@ -98,17 +137,40 @@ func (mr *MockUserServiceMockRecorder) Update(mod interface{}) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUserService)(nil).Update), mod) } -// FindOrCreate mocks base method -func (m *MockUserService) FindOrCreate(arg0 *types.User) (*types.User, error) { - ret := m.ctrl.Call(m, "FindOrCreate", arg0) - ret0, _ := ret[0].(*types.User) - ret1, _ := ret[1].(error) - return ret0, ret1 +// Delete mocks base method +func (m *MockUserService) Delete(id uint64) error { + ret := m.ctrl.Call(m, "Delete", id) + ret0, _ := ret[0].(error) + return ret0 } -// FindOrCreate indicates an expected call of FindOrCreate -func (mr *MockUserServiceMockRecorder) FindOrCreate(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOrCreate", reflect.TypeOf((*MockUserService)(nil).FindOrCreate), arg0) +// Delete indicates an expected call of Delete +func (mr *MockUserServiceMockRecorder) Delete(id interface{}) *gomock.Call { + 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 { + ret := m.ctrl.Call(m, "Suspend", id) + ret0, _ := ret[0].(error) + return ret0 +} + +// Suspend indicates an expected call of Suspend +func (mr *MockUserServiceMockRecorder) Suspend(id interface{}) *gomock.Call { + 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 { + ret := m.ctrl.Call(m, "Unsuspend", id) + ret0, _ := ret[0].(error) + return ret0 +} + +// Unsuspend indicates an expected call of Unsuspend +func (mr *MockUserServiceMockRecorder) Unsuspend(id interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unsuspend", reflect.TypeOf((*MockUserService)(nil).Unsuspend), id) } // ValidateCredentials mocks base method