DeforaNetworks/corteza
3
0
Fork 0
Code Activity

update mocks for sam/ and system/

Browse Source
This commit is contained in:
Tit Petric
2019-01-11 15:28:36 +01:00
parent 19abcb5a89
commit 11b25bd091
5 changed files with 160 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Makefile
+3 -3
View File
@@ -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
########################################################################################################################
sam/service/channel_mock_test.go
+25 -22
View File
@@ -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)
sam/service/message_mock_test.go
+37 -24
View File
@@ -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
system/service/team_mock_test.go
+24
View File
@@ -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)
}
system/service/user_mock_test.go
+71 -9
View File
@@ -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