del(all): remove unused/defunct mocks
This commit is contained in:
Tit Petric
@@ -128,25 +128,16 @@ qa: vet critic test
|
||||
|
||||
mocks: $(GOMOCK)
|
||||
# Cleanup all pre-generated
|
||||
find -name '*_mock_test.go' -path internal/ -delete
|
||||
find -name '*_mock_test.go' -delete
|
||||
rm -rf system/internal/repository/mocks && mkdir -p system/internal/repository/mocks
|
||||
|
||||
# See https://github.com/golang/mock for details
|
||||
$(MOCKGEN) -package service -source crm/internal/service/notification.go -destination crm/internal/service/notification_mock_test.go
|
||||
|
||||
$(MOCKGEN) -package service -source messaging/internal/service/attachment.go -destination messaging/internal/service/attachment_mock_test.go
|
||||
$(MOCKGEN) -package service -source messaging/internal/service/channel.go -destination messaging/internal/service/channel_mock_test.go
|
||||
$(MOCKGEN) -package service -source messaging/internal/service/message.go -destination messaging/internal/service/message_mock_test.go
|
||||
$(MOCKGEN) -package service -source system/internal/service/organisation.go -destination system/internal/service/organisation_mock_test.go
|
||||
$(MOCKGEN) -package service -source system/internal/service/role.go -destination system/internal/service/role_mock_test.go
|
||||
$(MOCKGEN) -package service -source system/internal/service/user.go -destination system/internal/service/user_mock_test.go
|
||||
|
||||
$(MOCKGEN) -package mail -source internal/mail/mail.go -destination internal/mail/mail_mock_test.go
|
||||
$(MOCKGEN) -package rules -source internal/rules/interfaces.go -destination internal/rules/resources_mock_test.go
|
||||
|
||||
mkdir -p system/internal/repository/mocks
|
||||
$(MOCKGEN) -package repository -source system/internal/repository/user.go -destination system/internal/repository/mocks/user.go
|
||||
$(MOCKGEN) -package repository -source system/internal/repository/credentials.go -destination system/internal/repository/mocks/credentials.go
|
||||
|
||||
$(MOCKGEN) -package mail -source internal/mail/mail.go -destination internal/mail/mail_mock_test.go
|
||||
$(MOCKGEN) -package rules -source internal/rules/interfaces.go -destination internal/rules/resources_mock_test.go
|
||||
|
||||
|
||||
|
||||
########################################################################################################################
|
||||
# Toolset
|
||||
|
||||
@@ -1,82 +0,0 @@
|
||||
// Code generated by MockGen. DO NOT EDIT.
|
||||
// Source: crm/internal/service/notification.go
|
||||
|
||||
// Package service is a generated GoMock package.
|
||||
package service
|
||||
|
||||
import (
|
||||
context "context"
|
||||
gomock "github.com/golang/mock/gomock"
|
||||
mail_v2 "gopkg.in/mail.v2"
|
||||
reflect "reflect"
|
||||
)
|
||||
|
||||
// MockNotificationService is a mock of NotificationService interface
|
||||
type MockNotificationService struct {
|
||||
ctrl *gomock.Controller
|
||||
recorder *MockNotificationServiceMockRecorder
|
||||
}
|
||||
|
||||
// MockNotificationServiceMockRecorder is the mock recorder for MockNotificationService
|
||||
type MockNotificationServiceMockRecorder struct {
|
||||
mock *MockNotificationService
|
||||
}
|
||||
|
||||
// NewMockNotificationService creates a new mock instance
|
||||
func NewMockNotificationService(ctrl *gomock.Controller) *MockNotificationService {
|
||||
mock := &MockNotificationService{ctrl: ctrl}
|
||||
mock.recorder = &MockNotificationServiceMockRecorder{mock}
|
||||
return mock
|
||||
}
|
||||
|
||||
// EXPECT returns an object that allows the caller to indicate expected use
|
||||
func (m *MockNotificationService) EXPECT() *MockNotificationServiceMockRecorder {
|
||||
return m.recorder
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "AttachEmailRecipients", varargs...)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// 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...)
|
||||
}
|
||||
@@ -1,110 +0,0 @@
|
||||
// Code generated by MockGen. DO NOT EDIT.
|
||||
// Source: messaging/internal/service/attachment.go
|
||||
|
||||
// Package service is a generated GoMock package.
|
||||
package service
|
||||
|
||||
import (
|
||||
context "context"
|
||||
types "github.com/crusttech/crust/messaging/types"
|
||||
gomock "github.com/golang/mock/gomock"
|
||||
io "io"
|
||||
reflect "reflect"
|
||||
)
|
||||
|
||||
// MockAttachmentService is a mock of AttachmentService interface
|
||||
type MockAttachmentService struct {
|
||||
ctrl *gomock.Controller
|
||||
recorder *MockAttachmentServiceMockRecorder
|
||||
}
|
||||
|
||||
// MockAttachmentServiceMockRecorder is the mock recorder for MockAttachmentService
|
||||
type MockAttachmentServiceMockRecorder struct {
|
||||
mock *MockAttachmentService
|
||||
}
|
||||
|
||||
// NewMockAttachmentService creates a new mock instance
|
||||
func NewMockAttachmentService(ctrl *gomock.Controller) *MockAttachmentService {
|
||||
mock := &MockAttachmentService{ctrl: ctrl}
|
||||
mock.recorder = &MockAttachmentServiceMockRecorder{mock}
|
||||
return mock
|
||||
}
|
||||
|
||||
// EXPECT returns an object that allows the caller to indicate expected use
|
||||
func (m *MockAttachmentService) EXPECT() *MockAttachmentServiceMockRecorder {
|
||||
return m.recorder
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
}
|
||||
@@ -1,272 +0,0 @@
|
||||
// Code generated by MockGen. DO NOT EDIT.
|
||||
// Source: messaging/internal/service/channel.go
|
||||
|
||||
// Package service is a generated GoMock package.
|
||||
package service
|
||||
|
||||
import (
|
||||
context "context"
|
||||
types "github.com/crusttech/crust/messaging/types"
|
||||
gomock "github.com/golang/mock/gomock"
|
||||
reflect "reflect"
|
||||
)
|
||||
|
||||
// MockChannelService is a mock of ChannelService interface
|
||||
type MockChannelService struct {
|
||||
ctrl *gomock.Controller
|
||||
recorder *MockChannelServiceMockRecorder
|
||||
}
|
||||
|
||||
// MockChannelServiceMockRecorder is the mock recorder for MockChannelService
|
||||
type MockChannelServiceMockRecorder struct {
|
||||
mock *MockChannelService
|
||||
}
|
||||
|
||||
// NewMockChannelService creates a new mock instance
|
||||
func NewMockChannelService(ctrl *gomock.Controller) *MockChannelService {
|
||||
mock := &MockChannelService{ctrl: ctrl}
|
||||
mock.recorder = &MockChannelServiceMockRecorder{mock}
|
||||
return mock
|
||||
}
|
||||
|
||||
// EXPECT returns an object that allows the caller to indicate expected use
|
||||
func (m *MockChannelService) EXPECT() *MockChannelServiceMockRecorder {
|
||||
return m.recorder
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "InviteUser", varargs...)
|
||||
ret0, _ := ret[0].(types.ChannelMemberSet)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "AddMember", varargs...)
|
||||
ret0, _ := ret[0].(types.ChannelMemberSet)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "DeleteMember", varargs...)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
}
|
||||
@@ -1,222 +0,0 @@
|
||||
// Code generated by MockGen. DO NOT EDIT.
|
||||
// Source: messaging/internal/service/message.go
|
||||
|
||||
// Package service is a generated GoMock package.
|
||||
package service
|
||||
|
||||
import (
|
||||
context "context"
|
||||
types "github.com/crusttech/crust/messaging/types"
|
||||
gomock "github.com/golang/mock/gomock"
|
||||
reflect "reflect"
|
||||
)
|
||||
|
||||
// MockMessageService is a mock of MessageService interface
|
||||
type MockMessageService struct {
|
||||
ctrl *gomock.Controller
|
||||
recorder *MockMessageServiceMockRecorder
|
||||
}
|
||||
|
||||
// MockMessageServiceMockRecorder is the mock recorder for MockMessageService
|
||||
type MockMessageServiceMockRecorder struct {
|
||||
mock *MockMessageService
|
||||
}
|
||||
|
||||
// NewMockMessageService creates a new mock instance
|
||||
func NewMockMessageService(ctrl *gomock.Controller) *MockMessageService {
|
||||
mock := &MockMessageService{ctrl: ctrl}
|
||||
mock.recorder = &MockMessageServiceMockRecorder{mock}
|
||||
return mock
|
||||
}
|
||||
|
||||
// EXPECT returns an object that allows the caller to indicate expected use
|
||||
func (m *MockMessageService) EXPECT() *MockMessageServiceMockRecorder {
|
||||
return m.recorder
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
}
|
||||
@@ -1,151 +0,0 @@
|
||||
// Code generated by MockGen. DO NOT EDIT.
|
||||
// Source: system/internal/service/organisation.go
|
||||
|
||||
// Package service is a generated GoMock package.
|
||||
package service
|
||||
|
||||
import (
|
||||
context "context"
|
||||
types "github.com/crusttech/crust/system/types"
|
||||
gomock "github.com/golang/mock/gomock"
|
||||
reflect "reflect"
|
||||
)
|
||||
|
||||
// MockOrganisationService is a mock of OrganisationService interface
|
||||
type MockOrganisationService struct {
|
||||
ctrl *gomock.Controller
|
||||
recorder *MockOrganisationServiceMockRecorder
|
||||
}
|
||||
|
||||
// MockOrganisationServiceMockRecorder is the mock recorder for MockOrganisationService
|
||||
type MockOrganisationServiceMockRecorder struct {
|
||||
mock *MockOrganisationService
|
||||
}
|
||||
|
||||
// NewMockOrganisationService creates a new mock instance
|
||||
func NewMockOrganisationService(ctrl *gomock.Controller) *MockOrganisationService {
|
||||
mock := &MockOrganisationService{ctrl: ctrl}
|
||||
mock.recorder = &MockOrganisationServiceMockRecorder{mock}
|
||||
return mock
|
||||
}
|
||||
|
||||
// EXPECT returns an object that allows the caller to indicate expected use
|
||||
func (m *MockOrganisationService) EXPECT() *MockOrganisationServiceMockRecorder {
|
||||
return m.recorder
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
}
|
||||
@@ -1,222 +0,0 @@
|
||||
// Code generated by MockGen. DO NOT EDIT.
|
||||
// Source: system/internal/service/role.go
|
||||
|
||||
// Package service is a generated GoMock package.
|
||||
package service
|
||||
|
||||
import (
|
||||
context "context"
|
||||
types "github.com/crusttech/crust/system/types"
|
||||
gomock "github.com/golang/mock/gomock"
|
||||
reflect "reflect"
|
||||
)
|
||||
|
||||
// MockRoleService is a mock of RoleService interface
|
||||
type MockRoleService struct {
|
||||
ctrl *gomock.Controller
|
||||
recorder *MockRoleServiceMockRecorder
|
||||
}
|
||||
|
||||
// MockRoleServiceMockRecorder is the mock recorder for MockRoleService
|
||||
type MockRoleServiceMockRecorder struct {
|
||||
mock *MockRoleService
|
||||
}
|
||||
|
||||
// NewMockRoleService creates a new mock instance
|
||||
func NewMockRoleService(ctrl *gomock.Controller) *MockRoleService {
|
||||
mock := &MockRoleService{ctrl: ctrl}
|
||||
mock.recorder = &MockRoleServiceMockRecorder{mock}
|
||||
return mock
|
||||
}
|
||||
|
||||
// EXPECT returns an object that allows the caller to indicate expected use
|
||||
func (m *MockRoleService) EXPECT() *MockRoleServiceMockRecorder {
|
||||
return m.recorder
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
}
|
||||
@@ -1,230 +0,0 @@
|
||||
// Code generated by MockGen. DO NOT EDIT.
|
||||
// Source: system/internal/service/user.go
|
||||
|
||||
// Package service is a generated GoMock package.
|
||||
package service
|
||||
|
||||
import (
|
||||
context "context"
|
||||
types "github.com/crusttech/crust/system/types"
|
||||
gomock "github.com/golang/mock/gomock"
|
||||
reflect "reflect"
|
||||
)
|
||||
|
||||
// MockUserService is a mock of UserService interface
|
||||
type MockUserService struct {
|
||||
ctrl *gomock.Controller
|
||||
recorder *MockUserServiceMockRecorder
|
||||
}
|
||||
|
||||
// MockUserServiceMockRecorder is the mock recorder for MockUserService
|
||||
type MockUserServiceMockRecorder struct {
|
||||
mock *MockUserService
|
||||
}
|
||||
|
||||
// NewMockUserService creates a new mock instance
|
||||
func NewMockUserService(ctrl *gomock.Controller) *MockUserService {
|
||||
mock := &MockUserService{ctrl: ctrl}
|
||||
mock.recorder = &MockUserServiceMockRecorder{mock}
|
||||
return mock
|
||||
}
|
||||
|
||||
// EXPECT returns an object that allows the caller to indicate expected use
|
||||
func (m *MockUserService) EXPECT() *MockUserServiceMockRecorder {
|
||||
return m.recorder
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "FindByIDs", varargs...)
|
||||
ret0, _ := ret[0].(types.UserSet)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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)
|
||||
}
|
||||
Reference in New Issue
Block a user