From e97cbcea51c1942d7cdc1b864a6b1cbc02b9b55f Mon Sep 17 00:00:00 2001 From: Denis Arh Date: Tue, 30 Oct 2018 09:31:47 +0100 Subject: [PATCH] Redo service mocking, add ch name & topic length validation --- Makefile | 5 +- internal/config/auth_settings.go | 24 + internal/config/messaging_settings.go | 57 +++ internal/payload/outgoing/settings.go | 21 + sam/service/channel.go | 80 +++- sam/service/channel_test.go | 45 ++ sam/service/main_test.go | 21 + sam/service/message_mock_test.go | 13 + sam/service/service.go | 6 + sam/service/service_mock_test.go | 654 -------------------------- sam/service/service_test.go | 12 - sam/types/channel.go | 15 + 12 files changed, 260 insertions(+), 693 deletions(-) create mode 100644 internal/config/auth_settings.go create mode 100644 internal/config/messaging_settings.go create mode 100644 internal/payload/outgoing/settings.go create mode 100644 sam/service/channel_test.go create mode 100644 sam/service/main_test.go delete mode 100644 sam/service/service_mock_test.go delete mode 100644 sam/service/service_test.go diff --git a/Makefile b/Makefile index 09e369e1d..58967eb7f 100644 --- a/Makefile +++ b/Makefile @@ -77,7 +77,7 @@ test: $(GOTEST) $(GO) tool cover -func=.cover.out test.sam: $(GOTEST) - $(GOTEST) -covermode count -coverprofile .cover.out -v ./sam/repository/... + $(GOTEST) -covermode count -coverprofile .cover.out -v ./sam/repository/... ./sam/service/... $(GO) tool cover -func=.cover.out | grep --color "^\|[^0-9]0.0%" test.sam.db: $(GOTEST) @@ -119,6 +119,9 @@ critic: $(GOCRITIC) qa: vet critic test mocks: $(GOMOCK) + # Cleanup all pre-generated + rm -f */*/*_mock_test.go + # See https://github.com/golang/mock for details $(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 diff --git a/internal/config/auth_settings.go b/internal/config/auth_settings.go new file mode 100644 index 000000000..672aa8f44 --- /dev/null +++ b/internal/config/auth_settings.go @@ -0,0 +1,24 @@ +package config + +// @todo need to decide on settings format & structure... +// type ( +// // AuthSettings holds configuration settings for auth service +// AuthSettings struct { +// User struct { +// Handle struct { +// // How long can a user's handle be +// MaxLength uint `json:"maxLength,omitempty"` +// +// // Enable user handles +// Enabled bool `json:"enabled,omitempty"` +// } `json:"handle,omitempty"` +// } `json:"user,omitempty"` +// } +// ) +// +// func DefaultAuthSettings() (s AuthSettings) { +// s.User.Handle.MaxLength = 20 +// s.User.Handle.Enabled = true +// +// return s +// } diff --git a/internal/config/messaging_settings.go b/internal/config/messaging_settings.go new file mode 100644 index 000000000..42e6bb930 --- /dev/null +++ b/internal/config/messaging_settings.go @@ -0,0 +1,57 @@ +package config + +// @todo need to decide on settings format & structure... +// type ( +// // MessagingSettings holds configuration settings for mesaging service +// MessagingSettings struct { +// Messages struct { +// Body struct { +// // How long can a message be +// MaxLength uint `json:"maxLength,omitempty"` +// +// // On render, convert textual [:)] emoji to graph. empji +// EmojiConvertToPicture bool `json:"emojiConvertToPicture,omitempty"` +// } `json:"body,omitempty"` +// +// Avatars struct { +// // Display image that users use for the avatar +// // if false, it will use initials only +// DisplaySelectedImage bool `json:"displaySelectedImage,omitempty"` +// +// // Enable avatar +// Enabled bool `json:"enabled,omitempty"` +// } `json:"avatars,omitempty"` +// } `json:"messages,omitempty"` +// +// Channels struct { +// Name struct { +// // How long can a name be +// MaxLength uint `json:"maxLength,omitempty"` +// +// // Can we have spaces in channel's name +// AllowSpaces bool `json:"allowSpaces,omitempty"` +// } `json:"name,omitempty"` +// +// Topic struct { +// // How long can a name be +// MaxLength uint `json:"maxLength,omitempty"` +// +// // Can we have spaces in channel's name +// Enabled bool `json:"enabled,omitempty"` +// } `json:"topic,omitempty"` +// } `json:"channels,omitempty"` +// } +// ) +// +// func DefaultMessagingSettings() (s MessagingSettings) { +// s.Messages.Body.MaxLength = 10000 +// s.Messages.Body.EmojiConvertToPicture = true +// s.Messages.Avatars.DisplaySelectedImage = true +// s.Messages.Avatars.Enabled = true +// s.Channels.Name.MaxLength = 40 +// s.Channels.Name.AllowSpaces = true +// s.Channels.Topic.MaxLength = 200 +// s.Channels.Topic.Enabled = true +// +// return s +// } diff --git a/internal/payload/outgoing/settings.go b/internal/payload/outgoing/settings.go new file mode 100644 index 000000000..a3108c245 --- /dev/null +++ b/internal/payload/outgoing/settings.go @@ -0,0 +1,21 @@ +package outgoing + +// @todo need to decide on settings format & structure... +// type ( +// SettingValue struct { +// Name string `json:"name"` +// Type SettingType `json:"type"` +// Value interface{} `json:"value"` +// ReadOnly bool `json:"ro"` +// } +// +// Settings []SettingValue +// +// SettingType string +// ) +// +// const ( +// SettingTypeBool SettingType = "Boolean" +// SettingTypeString SettingType = "String" +// SettingTypeNumber SettingType = "Number" +// ) diff --git a/sam/service/channel.go b/sam/service/channel.go index 60bad506b..60c50c044 100644 --- a/sam/service/channel.go +++ b/sam/service/channel.go @@ -6,7 +6,6 @@ import ( "time" "github.com/pkg/errors" - "github.com/titpetric/factory" "github.com/crusttech/crust/internal/auth" @@ -17,7 +16,7 @@ import ( type ( channel struct { - db *factory.DB + db db ctx context.Context usr authService.UserService @@ -58,6 +57,11 @@ type ( // } ) +const ( + settingsChannelNameLength = 40 + settingsChannelTopicLength = 200 +) + func Channel() ChannelService { return (&channel{ usr: authService.DefaultUser, @@ -250,6 +254,18 @@ func (svc *channel) Create(in *types.Channel) (out *types.Channel, err error) { return errors.New("Not allowed to create group channels") } + if len(in.Name) == 0 { + return errors.New("Channel name not provided") + } + + if settingsChannelNameLength > 0 && len(in.Name) > settingsChannelNameLength { + return errors.Errorf("Channel name (%d characters) too long (max: %d)", len(in.Name), settingsChannelNameLength) + } + + if len(in.Topic) > 0 && settingsChannelTopicLength > 0 && len(in.Topic) > settingsChannelTopicLength { + return errors.Errorf("Channel topic (%d characters) too long (max: %d)", len(in.Topic), settingsChannelTopicLength) + } + // This is a fresh channel, just copy values out = &types.Channel{ Name: in.Name, @@ -287,12 +303,11 @@ func (svc *channel) Create(in *types.Channel) (out *types.Channel, err error) { // Create the first message, doing this directly with repository to circumvent // message service constraints - svc.scheduleSystemMessage( - out, - "@%d created new %s channel, topic is: %s", - chCreatorID, - "", - "") + if len(out.Topic) == 0 { + svc.scheduleSystemMessage(out, `<@%d> created new %s channel *%s*`, chCreatorID, out.Type) + } else { + svc.scheduleSystemMessage(out, `<@%d> created new %s channel *%s*, topic: %s`, chCreatorID, out.Type, out.Topic) + } _ = msg if err != nil { @@ -334,68 +349,81 @@ func (svc *channel) checkGroupExistance(mm types.ChannelMemberSet) (*types.Chann } } -func (svc *channel) Update(ch *types.Channel) (out *types.Channel, err error) { - return out, svc.db.Transaction(func() (err error) { +func (svc *channel) Update(in *types.Channel) (ch *types.Channel, err error) { + return ch, svc.db.Transaction(func() (err error) { + var changed bool + // @todo [SECURITY] can user access this channel? - if out, err = svc.channel.FindChannelByID(ch.ID); err != nil { + if ch, err = svc.channel.FindChannelByID(in.ID); err != nil { return } - if out.ArchivedAt != nil { + if ch.ArchivedAt != nil { return errors.New("Not allowed to edit archived channels") - } else if out.DeletedAt != nil { + } else if ch.DeletedAt != nil { return errors.New("Not allowed to edit deleted channels") } - if out.Type != ch.Type { + if in.Type.IsValid() && ch.Type != in.Type { // @todo [SECURITY] check if user can create public channels - if ch.Type == types.ChannelTypePublic && false { + if in.Type == types.ChannelTypePublic && false { return errors.New("Not allowed to change type of this channel to public") } // @todo [SECURITY] check if user can create private channels - if ch.Type == types.ChannelTypePrivate && false { + if in.Type == types.ChannelTypePrivate && false { return errors.New("Not allowed to change type of this channel to private") } // @todo [SECURITY] check if user can create group channels - if ch.Type == types.ChannelTypeGroup && false { + if in.Type == types.ChannelTypeGroup && false { return errors.New("Not allowed to change type of this channel to group") } + + changed = true } var chUpdatorId = repository.Identity(svc.ctx) - // Copy values - if out.Name != ch.Name { + if len(in.Name) > 0 && ch.Name != in.Name { // @todo [SECURITY] can we change channel's name? if false { return errors.New("Not allowed to rename channel") + } else if settingsChannelNameLength > 0 && len(in.Name) > settingsChannelNameLength { + return errors.Errorf("Channel name (%d characters) too long (max: %d)", len(in.Name), settingsChannelNameLength) } else { - svc.scheduleSystemMessage(ch, "@%d renamed channel %s (was: %s)", chUpdatorId, out.Name, ch.Name) + svc.scheduleSystemMessage(in, "<@%d> renamed channel %s (was: %s)", chUpdatorId, in.Name, ch.Name) } - out.Name = ch.Name + + ch.Name = in.Name + changed = true } - if out.Topic != ch.Topic && true { + if len(in.Topic) > 0 && ch.Topic != in.Topic { // @todo [SECURITY] can we change channel's topic? if false { return errors.New("Not allowed to change channel topic") + } else if settingsChannelTopicLength > 0 && len(in.Topic) > settingsChannelTopicLength { + return errors.Errorf("Channel topic (%d characters) too long (max: %d)", len(in.Topic), settingsChannelTopicLength) } else { - svc.scheduleSystemMessage(ch, "@%d changed channel topic: %s (was: %s)", chUpdatorId, out.Topic, ch.Topic) + svc.scheduleSystemMessage(in, "<@%d> changed channel topic: %s (was: %s)", chUpdatorId, in.Topic, ch.Topic) } - out.Topic = ch.Topic + ch.Topic = in.Topic + changed = true } + if !changed { + return nil + } // Save the updated channel - if out, err = svc.channel.UpdateChannel(ch); err != nil { + if ch, err = svc.channel.UpdateChannel(in); err != nil { return } svc.flushSystemMessages() - return svc.sendChannelEvent(out) + return svc.sendChannelEvent(ch) }) } diff --git a/sam/service/channel_test.go b/sam/service/channel_test.go new file mode 100644 index 000000000..ddae9dc3c --- /dev/null +++ b/sam/service/channel_test.go @@ -0,0 +1,45 @@ +package service + +import ( + "context" + "strings" + "testing" + + authTypes "github.com/crusttech/crust/auth/types" + "github.com/crusttech/crust/internal/auth" + "github.com/crusttech/crust/sam/types" +) + +// func TestChannelCreation(t *testing.T) { +// mockCtrl := gomock.NewController(t) +// defer mockCtrl.Finish() +// +// chRpoMock := NewMockRepository(mockCtrl) +// chRpoMock.EXPECT().WithCtx(gomock.Any()).AnyTimes().Return(chRpoMock) +// chRpoMock.EXPECT(). +// FindUserByID(usr.ID). +// Times(1). +// Return(usr, nil) +// +// svc := channel{ +// channel: +// } +// +// svc.Create() +// } + +func TestChannelNameTooShort(t *testing.T) { + // mockCtrl := gomock.NewController(t) + // defer mockCtrl.Finish() + + ctx := context.TODO() + auth.SetIdentityToContext(ctx, &authTypes.User{}) + + svc := channel{db: &mockDB{}, ctx: ctx} + e := func(out *types.Channel, err error) error { return err } + + longName := strings.Repeat("X", settingsChannelNameLength+1) + + assert(t, e(svc.Create(&types.Channel{})) != nil, "Should not allow to create unnamed channels") + assert(t, e(svc.Create(&types.Channel{Name: longName})) != nil, "Should not allow to create channel with really long name") +} diff --git a/sam/service/main_test.go b/sam/service/main_test.go new file mode 100644 index 000000000..44db976fe --- /dev/null +++ b/sam/service/main_test.go @@ -0,0 +1,21 @@ +package service + +import ( + "fmt" + "runtime" + "testing" +) + +type mockDB struct{} + +func (mockDB) Transaction(callback func() error) error { return callback() } + +func assert(t *testing.T, ok bool, format string, args ...interface{}) bool { + if !ok { + _, file, line, _ := runtime.Caller(1) + caller := fmt.Sprintf("\nAsserted at:%s:%d", file, line) + + t.Fatalf(format+caller, args...) + } + return ok +} diff --git a/sam/service/message_mock_test.go b/sam/service/message_mock_test.go index 48fb6e87e..6a31ed88f 100644 --- a/sam/service/message_mock_test.go +++ b/sam/service/message_mock_test.go @@ -59,6 +59,19 @@ func (mr *MockMessageServiceMockRecorder) Find(filter interface{}) *gomock.Call 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) { + 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 { + 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) { ret := m.ctrl.Call(m, "Create", messages) diff --git a/sam/service/service.go b/sam/service/service.go index 90b773c60..f25f8f2be 100644 --- a/sam/service/service.go +++ b/sam/service/service.go @@ -7,6 +7,12 @@ import ( "github.com/crusttech/crust/internal/store" ) +type ( + db interface { + Transaction(callback func() error) error + } +) + var ( o sync.Once DefaultAttachment AttachmentService diff --git a/sam/service/service_mock_test.go b/sam/service/service_mock_test.go deleted file mode 100644 index 2b89daa10..000000000 --- a/sam/service/service_mock_test.go +++ /dev/null @@ -1,654 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: sam/service/service_test.go - -// Package service is a generated GoMock package. -package service - -import ( - context "context" - repository "github.com/crusttech/crust/sam/repository" - types "github.com/crusttech/crust/sam/types" - gomock "github.com/golang/mock/gomock" - reflect "reflect" -) - -// MockRepository is a mock of Repository interface -type MockRepository struct { - ctrl *gomock.Controller - recorder *MockRepositoryMockRecorder -} - -// MockRepositoryMockRecorder is the mock recorder for MockRepository -type MockRepositoryMockRecorder struct { - mock *MockRepository -} - -// NewMockRepository creates a new mock instance -func NewMockRepository(ctrl *gomock.Controller) *MockRepository { - mock := &MockRepository{ctrl: ctrl} - mock.recorder = &MockRepositoryMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockRepository) EXPECT() *MockRepositoryMockRecorder { - return m.recorder -} - -// BeginWith mocks base method -func (m *MockRepository) BeginWith(ctx context.Context, callback repository.BeginCallback) error { - ret := m.ctrl.Call(m, "BeginWith", ctx, callback) - ret0, _ := ret[0].(error) - return ret0 -} - -// BeginWith indicates an expected call of BeginWith -func (mr *MockRepositoryMockRecorder) BeginWith(ctx, callback interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginWith", reflect.TypeOf((*MockRepository)(nil).BeginWith), ctx, callback) -} - -// Begin mocks base method -func (m *MockRepository) Begin() error { - ret := m.ctrl.Call(m, "Begin") - ret0, _ := ret[0].(error) - return ret0 -} - -// Begin indicates an expected call of Begin -func (mr *MockRepositoryMockRecorder) Begin() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Begin", reflect.TypeOf((*MockRepository)(nil).Begin)) -} - -// Rollback mocks base method -func (m *MockRepository) Rollback() error { - ret := m.ctrl.Call(m, "Rollback") - ret0, _ := ret[0].(error) - return ret0 -} - -// Rollback indicates an expected call of Rollback -func (mr *MockRepositoryMockRecorder) Rollback() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockRepository)(nil).Rollback)) -} - -// Commit mocks base method -func (m *MockRepository) Commit() error { - ret := m.ctrl.Call(m, "Commit") - ret0, _ := ret[0].(error) - return ret0 -} - -// Commit indicates an expected call of Commit -func (mr *MockRepositoryMockRecorder) Commit() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockRepository)(nil).Commit)) -} - -// WithCtx mocks base method -func (m *MockRepository) WithCtx(ctx context.Context) repository.Interfaces { - ret := m.ctrl.Call(m, "WithCtx", ctx) - ret0, _ := ret[0].(repository.Interfaces) - return ret0 -} - -// WithCtx indicates an expected call of WithCtx -func (mr *MockRepositoryMockRecorder) WithCtx(ctx interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithCtx", reflect.TypeOf((*MockRepository)(nil).WithCtx), ctx) -} - -// FindAttachmentByID mocks base method -func (m *MockRepository) FindAttachmentByID(id uint64) (*types.Attachment, error) { - ret := m.ctrl.Call(m, "FindAttachmentByID", id) - ret0, _ := ret[0].(*types.Attachment) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindAttachmentByID indicates an expected call of FindAttachmentByID -func (mr *MockRepositoryMockRecorder) FindAttachmentByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindAttachmentByID", reflect.TypeOf((*MockRepository)(nil).FindAttachmentByID), id) -} - -// FindAttachmentByMessageID mocks base method -func (m *MockRepository) FindAttachmentByMessageID(IDs ...uint64) (types.MessageAttachmentSet, error) { - varargs := []interface{}{} - for _, a := range IDs { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "FindAttachmentByMessageID", varargs...) - ret0, _ := ret[0].(types.MessageAttachmentSet) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindAttachmentByMessageID indicates an expected call of FindAttachmentByMessageID -func (mr *MockRepositoryMockRecorder) FindAttachmentByMessageID(IDs ...interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindAttachmentByMessageID", reflect.TypeOf((*MockRepository)(nil).FindAttachmentByMessageID), IDs...) -} - -// CreateAttachment mocks base method -func (m *MockRepository) CreateAttachment(mod *types.Attachment) (*types.Attachment, error) { - ret := m.ctrl.Call(m, "CreateAttachment", mod) - ret0, _ := ret[0].(*types.Attachment) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateAttachment indicates an expected call of CreateAttachment -func (mr *MockRepositoryMockRecorder) CreateAttachment(mod interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAttachment", reflect.TypeOf((*MockRepository)(nil).CreateAttachment), mod) -} - -// DeleteAttachmentByID mocks base method -func (m *MockRepository) DeleteAttachmentByID(id uint64) error { - ret := m.ctrl.Call(m, "DeleteAttachmentByID", id) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteAttachmentByID indicates an expected call of DeleteAttachmentByID -func (mr *MockRepositoryMockRecorder) DeleteAttachmentByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAttachmentByID", reflect.TypeOf((*MockRepository)(nil).DeleteAttachmentByID), id) -} - -// BindAttachment mocks base method -func (m *MockRepository) BindAttachment(attachmentId, messageId uint64) error { - ret := m.ctrl.Call(m, "BindAttachment", attachmentId, messageId) - ret0, _ := ret[0].(error) - return ret0 -} - -// BindAttachment indicates an expected call of BindAttachment -func (mr *MockRepositoryMockRecorder) BindAttachment(attachmentId, messageId interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindAttachment", reflect.TypeOf((*MockRepository)(nil).BindAttachment), attachmentId, messageId) -} - -// FindChannelByID mocks base method -func (m *MockRepository) FindChannelByID(id uint64) (*types.Channel, error) { - ret := m.ctrl.Call(m, "FindChannelByID", id) - ret0, _ := ret[0].(*types.Channel) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindChannelByID indicates an expected call of FindChannelByID -func (mr *MockRepositoryMockRecorder) FindChannelByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindChannelByID", reflect.TypeOf((*MockRepository)(nil).FindChannelByID), id) -} - -// FindDirectChannelByUserID mocks base method -func (m *MockRepository) FindDirectChannelByUserID(fromUserID, toUserID uint64) (*types.Channel, error) { - ret := m.ctrl.Call(m, "FindDirectChannelByUserID", fromUserID, toUserID) - ret0, _ := ret[0].(*types.Channel) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindDirectChannelByUserID indicates an expected call of FindDirectChannelByUserID -func (mr *MockRepositoryMockRecorder) FindDirectChannelByUserID(fromUserID, toUserID interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindDirectChannelByUserID", reflect.TypeOf((*MockRepository)(nil).FindDirectChannelByUserID), fromUserID, toUserID) -} - -// FindChannels mocks base method -func (m *MockRepository) FindChannels(filter *types.ChannelFilter) ([]*types.Channel, error) { - ret := m.ctrl.Call(m, "FindChannels", filter) - ret0, _ := ret[0].([]*types.Channel) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindChannels indicates an expected call of FindChannels -func (mr *MockRepositoryMockRecorder) FindChannels(filter interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindChannels", reflect.TypeOf((*MockRepository)(nil).FindChannels), filter) -} - -// CreateChannel mocks base method -func (m *MockRepository) CreateChannel(mod *types.Channel) (*types.Channel, error) { - ret := m.ctrl.Call(m, "CreateChannel", mod) - ret0, _ := ret[0].(*types.Channel) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateChannel indicates an expected call of CreateChannel -func (mr *MockRepositoryMockRecorder) CreateChannel(mod interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChannel", reflect.TypeOf((*MockRepository)(nil).CreateChannel), mod) -} - -// UpdateChannel mocks base method -func (m *MockRepository) UpdateChannel(mod *types.Channel) (*types.Channel, error) { - ret := m.ctrl.Call(m, "UpdateChannel", mod) - ret0, _ := ret[0].(*types.Channel) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateChannel indicates an expected call of UpdateChannel -func (mr *MockRepositoryMockRecorder) UpdateChannel(mod interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChannel", reflect.TypeOf((*MockRepository)(nil).UpdateChannel), mod) -} - -// FindChannelsMembershipsByMemberId mocks base method -func (m *MockRepository) FindChannelsMembershipsByMemberId(memberId uint64) ([]*types.ChannelMember, error) { - ret := m.ctrl.Call(m, "FindChannelsMembershipsByMemberId", memberId) - ret0, _ := ret[0].([]*types.ChannelMember) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindChannelsMembershipsByMemberId indicates an expected call of FindChannelsMembershipsByMemberId -func (mr *MockRepositoryMockRecorder) FindChannelsMembershipsByMemberId(memberId interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindChannelsMembershipsByMemberId", reflect.TypeOf((*MockRepository)(nil).FindChannelsMembershipsByMemberId), memberId) -} - -// AddChannelMember mocks base method -func (m *MockRepository) AddChannelMember(mod *types.ChannelMember) (*types.ChannelMember, error) { - ret := m.ctrl.Call(m, "AddChannelMember", mod) - ret0, _ := ret[0].(*types.ChannelMember) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AddChannelMember indicates an expected call of AddChannelMember -func (mr *MockRepositoryMockRecorder) AddChannelMember(mod interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChannelMember", reflect.TypeOf((*MockRepository)(nil).AddChannelMember), mod) -} - -// RemoveChannelMember mocks base method -func (m *MockRepository) RemoveChannelMember(channelID, userID uint64) error { - ret := m.ctrl.Call(m, "RemoveChannelMember", channelID, userID) - ret0, _ := ret[0].(error) - return ret0 -} - -// RemoveChannelMember indicates an expected call of RemoveChannelMember -func (mr *MockRepositoryMockRecorder) RemoveChannelMember(channelID, userID interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveChannelMember", reflect.TypeOf((*MockRepository)(nil).RemoveChannelMember), channelID, userID) -} - -// ArchiveChannelByID mocks base method -func (m *MockRepository) ArchiveChannelByID(id uint64) error { - ret := m.ctrl.Call(m, "ArchiveChannelByID", id) - ret0, _ := ret[0].(error) - return ret0 -} - -// ArchiveChannelByID indicates an expected call of ArchiveChannelByID -func (mr *MockRepositoryMockRecorder) ArchiveChannelByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArchiveChannelByID", reflect.TypeOf((*MockRepository)(nil).ArchiveChannelByID), id) -} - -// UnarchiveChannelByID mocks base method -func (m *MockRepository) UnarchiveChannelByID(id uint64) error { - ret := m.ctrl.Call(m, "UnarchiveChannelByID", id) - ret0, _ := ret[0].(error) - return ret0 -} - -// UnarchiveChannelByID indicates an expected call of UnarchiveChannelByID -func (mr *MockRepositoryMockRecorder) UnarchiveChannelByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnarchiveChannelByID", reflect.TypeOf((*MockRepository)(nil).UnarchiveChannelByID), id) -} - -// DeleteChannelByID mocks base method -func (m *MockRepository) DeleteChannelByID(id uint64) error { - ret := m.ctrl.Call(m, "DeleteChannelByID", id) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteChannelByID indicates an expected call of DeleteChannelByID -func (mr *MockRepositoryMockRecorder) DeleteChannelByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChannelByID", reflect.TypeOf((*MockRepository)(nil).DeleteChannelByID), id) -} - -// FindMessageByID mocks base method -func (m *MockRepository) FindMessageByID(id uint64) (*types.Message, error) { - ret := m.ctrl.Call(m, "FindMessageByID", id) - ret0, _ := ret[0].(*types.Message) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindMessageByID indicates an expected call of FindMessageByID -func (mr *MockRepositoryMockRecorder) FindMessageByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindMessageByID", reflect.TypeOf((*MockRepository)(nil).FindMessageByID), id) -} - -// FindMessages mocks base method -func (m *MockRepository) FindMessages(filter *types.MessageFilter) (types.MessageSet, error) { - ret := m.ctrl.Call(m, "FindMessages", filter) - ret0, _ := ret[0].(types.MessageSet) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindMessages indicates an expected call of FindMessages -func (mr *MockRepositoryMockRecorder) FindMessages(filter interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindMessages", reflect.TypeOf((*MockRepository)(nil).FindMessages), filter) -} - -// CreateMessage mocks base method -func (m *MockRepository) CreateMessage(mod *types.Message) (*types.Message, error) { - ret := m.ctrl.Call(m, "CreateMessage", mod) - ret0, _ := ret[0].(*types.Message) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateMessage indicates an expected call of CreateMessage -func (mr *MockRepositoryMockRecorder) CreateMessage(mod interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMessage", reflect.TypeOf((*MockRepository)(nil).CreateMessage), mod) -} - -// UpdateMessage mocks base method -func (m *MockRepository) UpdateMessage(mod *types.Message) (*types.Message, error) { - ret := m.ctrl.Call(m, "UpdateMessage", mod) - ret0, _ := ret[0].(*types.Message) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateMessage indicates an expected call of UpdateMessage -func (mr *MockRepositoryMockRecorder) UpdateMessage(mod interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMessage", reflect.TypeOf((*MockRepository)(nil).UpdateMessage), mod) -} - -// DeleteMessageByID mocks base method -func (m *MockRepository) DeleteMessageByID(id uint64) error { - ret := m.ctrl.Call(m, "DeleteMessageByID", id) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteMessageByID indicates an expected call of DeleteMessageByID -func (mr *MockRepositoryMockRecorder) DeleteMessageByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageByID", reflect.TypeOf((*MockRepository)(nil).DeleteMessageByID), id) -} - -// FindOrganisationByID mocks base method -func (m *MockRepository) FindOrganisationByID(id uint64) (*types.Organisation, error) { - ret := m.ctrl.Call(m, "FindOrganisationByID", id) - ret0, _ := ret[0].(*types.Organisation) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindOrganisationByID indicates an expected call of FindOrganisationByID -func (mr *MockRepositoryMockRecorder) FindOrganisationByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOrganisationByID", reflect.TypeOf((*MockRepository)(nil).FindOrganisationByID), id) -} - -// FindOrganisations mocks base method -func (m *MockRepository) FindOrganisations(filter *types.OrganisationFilter) ([]*types.Organisation, error) { - ret := m.ctrl.Call(m, "FindOrganisations", filter) - ret0, _ := ret[0].([]*types.Organisation) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindOrganisations indicates an expected call of FindOrganisations -func (mr *MockRepositoryMockRecorder) FindOrganisations(filter interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOrganisations", reflect.TypeOf((*MockRepository)(nil).FindOrganisations), filter) -} - -// CreateOrganisation mocks base method -func (m *MockRepository) CreateOrganisation(mod *types.Organisation) (*types.Organisation, error) { - ret := m.ctrl.Call(m, "CreateOrganisation", mod) - ret0, _ := ret[0].(*types.Organisation) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateOrganisation indicates an expected call of CreateOrganisation -func (mr *MockRepositoryMockRecorder) CreateOrganisation(mod interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrganisation", reflect.TypeOf((*MockRepository)(nil).CreateOrganisation), mod) -} - -// UpdateOrganisation mocks base method -func (m *MockRepository) UpdateOrganisation(mod *types.Organisation) (*types.Organisation, error) { - ret := m.ctrl.Call(m, "UpdateOrganisation", mod) - ret0, _ := ret[0].(*types.Organisation) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateOrganisation indicates an expected call of UpdateOrganisation -func (mr *MockRepositoryMockRecorder) UpdateOrganisation(mod interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOrganisation", reflect.TypeOf((*MockRepository)(nil).UpdateOrganisation), mod) -} - -// ArchiveOrganisationByID mocks base method -func (m *MockRepository) ArchiveOrganisationByID(id uint64) error { - ret := m.ctrl.Call(m, "ArchiveOrganisationByID", id) - ret0, _ := ret[0].(error) - return ret0 -} - -// ArchiveOrganisationByID indicates an expected call of ArchiveOrganisationByID -func (mr *MockRepositoryMockRecorder) ArchiveOrganisationByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArchiveOrganisationByID", reflect.TypeOf((*MockRepository)(nil).ArchiveOrganisationByID), id) -} - -// UnarchiveOrganisationByID mocks base method -func (m *MockRepository) UnarchiveOrganisationByID(id uint64) error { - ret := m.ctrl.Call(m, "UnarchiveOrganisationByID", id) - ret0, _ := ret[0].(error) - return ret0 -} - -// UnarchiveOrganisationByID indicates an expected call of UnarchiveOrganisationByID -func (mr *MockRepositoryMockRecorder) UnarchiveOrganisationByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnarchiveOrganisationByID", reflect.TypeOf((*MockRepository)(nil).UnarchiveOrganisationByID), id) -} - -// DeleteOrganisationByID mocks base method -func (m *MockRepository) DeleteOrganisationByID(id uint64) error { - ret := m.ctrl.Call(m, "DeleteOrganisationByID", id) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteOrganisationByID indicates an expected call of DeleteOrganisationByID -func (mr *MockRepositoryMockRecorder) DeleteOrganisationByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOrganisationByID", reflect.TypeOf((*MockRepository)(nil).DeleteOrganisationByID), id) -} - -// FindReactionByID mocks base method -func (m *MockRepository) FindReactionByID(id uint64) (*types.Reaction, error) { - ret := m.ctrl.Call(m, "FindReactionByID", id) - ret0, _ := ret[0].(*types.Reaction) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindReactionByID indicates an expected call of FindReactionByID -func (mr *MockRepositoryMockRecorder) FindReactionByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindReactionByID", reflect.TypeOf((*MockRepository)(nil).FindReactionByID), id) -} - -// FindReactionsByRange mocks base method -func (m *MockRepository) FindReactionsByRange(channelID, fromReactionID, toReactionID uint64) ([]*types.Reaction, error) { - ret := m.ctrl.Call(m, "FindReactionsByRange", channelID, fromReactionID, toReactionID) - ret0, _ := ret[0].([]*types.Reaction) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindReactionsByRange indicates an expected call of FindReactionsByRange -func (mr *MockRepositoryMockRecorder) FindReactionsByRange(channelID, fromReactionID, toReactionID interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindReactionsByRange", reflect.TypeOf((*MockRepository)(nil).FindReactionsByRange), channelID, fromReactionID, toReactionID) -} - -// CreateReaction mocks base method -func (m *MockRepository) CreateReaction(mod *types.Reaction) (*types.Reaction, error) { - ret := m.ctrl.Call(m, "CreateReaction", mod) - ret0, _ := ret[0].(*types.Reaction) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateReaction indicates an expected call of CreateReaction -func (mr *MockRepositoryMockRecorder) CreateReaction(mod interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReaction", reflect.TypeOf((*MockRepository)(nil).CreateReaction), mod) -} - -// DeleteReactionByID mocks base method -func (m *MockRepository) DeleteReactionByID(id uint64) error { - ret := m.ctrl.Call(m, "DeleteReactionByID", id) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteReactionByID indicates an expected call of DeleteReactionByID -func (mr *MockRepositoryMockRecorder) DeleteReactionByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReactionByID", reflect.TypeOf((*MockRepository)(nil).DeleteReactionByID), id) -} - -// FindTeamByID mocks base method -func (m *MockRepository) FindTeamByID(id uint64) (*types.Team, error) { - ret := m.ctrl.Call(m, "FindTeamByID", id) - ret0, _ := ret[0].(*types.Team) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindTeamByID indicates an expected call of FindTeamByID -func (mr *MockRepositoryMockRecorder) FindTeamByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindTeamByID", reflect.TypeOf((*MockRepository)(nil).FindTeamByID), id) -} - -// FindTeams mocks base method -func (m *MockRepository) FindTeams(filter *types.TeamFilter) ([]*types.Team, error) { - ret := m.ctrl.Call(m, "FindTeams", filter) - ret0, _ := ret[0].([]*types.Team) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindTeams indicates an expected call of FindTeams -func (mr *MockRepositoryMockRecorder) FindTeams(filter interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindTeams", reflect.TypeOf((*MockRepository)(nil).FindTeams), filter) -} - -// CreateTeam mocks base method -func (m *MockRepository) CreateTeam(mod *types.Team) (*types.Team, error) { - ret := m.ctrl.Call(m, "CreateTeam", mod) - ret0, _ := ret[0].(*types.Team) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTeam indicates an expected call of CreateTeam -func (mr *MockRepositoryMockRecorder) CreateTeam(mod interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTeam", reflect.TypeOf((*MockRepository)(nil).CreateTeam), mod) -} - -// UpdateTeam mocks base method -func (m *MockRepository) UpdateTeam(mod *types.Team) (*types.Team, error) { - ret := m.ctrl.Call(m, "UpdateTeam", mod) - ret0, _ := ret[0].(*types.Team) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateTeam indicates an expected call of UpdateTeam -func (mr *MockRepositoryMockRecorder) UpdateTeam(mod interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTeam", reflect.TypeOf((*MockRepository)(nil).UpdateTeam), mod) -} - -// ArchiveTeamByID mocks base method -func (m *MockRepository) ArchiveTeamByID(id uint64) error { - ret := m.ctrl.Call(m, "ArchiveTeamByID", id) - ret0, _ := ret[0].(error) - return ret0 -} - -// ArchiveTeamByID indicates an expected call of ArchiveTeamByID -func (mr *MockRepositoryMockRecorder) ArchiveTeamByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArchiveTeamByID", reflect.TypeOf((*MockRepository)(nil).ArchiveTeamByID), id) -} - -// UnarchiveTeamByID mocks base method -func (m *MockRepository) UnarchiveTeamByID(id uint64) error { - ret := m.ctrl.Call(m, "UnarchiveTeamByID", id) - ret0, _ := ret[0].(error) - return ret0 -} - -// UnarchiveTeamByID indicates an expected call of UnarchiveTeamByID -func (mr *MockRepositoryMockRecorder) UnarchiveTeamByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnarchiveTeamByID", reflect.TypeOf((*MockRepository)(nil).UnarchiveTeamByID), id) -} - -// DeleteTeamByID mocks base method -func (m *MockRepository) DeleteTeamByID(id uint64) error { - ret := m.ctrl.Call(m, "DeleteTeamByID", id) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteTeamByID indicates an expected call of DeleteTeamByID -func (mr *MockRepositoryMockRecorder) DeleteTeamByID(id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTeamByID", reflect.TypeOf((*MockRepository)(nil).DeleteTeamByID), id) -} - -// MergeTeamByID mocks base method -func (m *MockRepository) MergeTeamByID(id, targetTeamID uint64) error { - ret := m.ctrl.Call(m, "MergeTeamByID", id, targetTeamID) - ret0, _ := ret[0].(error) - return ret0 -} - -// MergeTeamByID indicates an expected call of MergeTeamByID -func (mr *MockRepositoryMockRecorder) MergeTeamByID(id, targetTeamID interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeTeamByID", reflect.TypeOf((*MockRepository)(nil).MergeTeamByID), id, targetTeamID) -} - -// MoveTeamByID mocks base method -func (m *MockRepository) MoveTeamByID(id, targetOrganisationID uint64) error { - ret := m.ctrl.Call(m, "MoveTeamByID", id, targetOrganisationID) - ret0, _ := ret[0].(error) - return ret0 -} - -// MoveTeamByID indicates an expected call of MoveTeamByID -func (mr *MockRepositoryMockRecorder) MoveTeamByID(id, targetOrganisationID interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveTeamByID", reflect.TypeOf((*MockRepository)(nil).MoveTeamByID), id, targetOrganisationID) -} - -// EventQueuePull mocks base method -func (m *MockRepository) EventQueuePull(origin uint64) ([]*types.EventQueueItem, error) { - ret := m.ctrl.Call(m, "EventQueuePull", origin) - ret0, _ := ret[0].([]*types.EventQueueItem) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EventQueuePull indicates an expected call of EventQueuePull -func (mr *MockRepositoryMockRecorder) EventQueuePull(origin interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventQueuePull", reflect.TypeOf((*MockRepository)(nil).EventQueuePull), origin) -} - -// EventQueuePush mocks base method -func (m *MockRepository) EventQueuePush(eqi *types.EventQueueItem) error { - ret := m.ctrl.Call(m, "EventQueuePush", eqi) - ret0, _ := ret[0].(error) - return ret0 -} - -// EventQueuePush indicates an expected call of EventQueuePush -func (mr *MockRepositoryMockRecorder) EventQueuePush(eqi interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventQueuePush", reflect.TypeOf((*MockRepository)(nil).EventQueuePush), eqi) -} - -// EventQueueSync mocks base method -func (m *MockRepository) EventQueueSync(origin, id uint64) error { - ret := m.ctrl.Call(m, "EventQueueSync", origin, id) - ret0, _ := ret[0].(error) - return ret0 -} - -// EventQueueSync indicates an expected call of EventQueueSync -func (mr *MockRepositoryMockRecorder) EventQueueSync(origin, id interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventQueueSync", reflect.TypeOf((*MockRepository)(nil).EventQueueSync), origin, id) -} diff --git a/sam/service/service_test.go b/sam/service/service_test.go deleted file mode 100644 index 80e845ec8..000000000 --- a/sam/service/service_test.go +++ /dev/null @@ -1,12 +0,0 @@ -package service - -import ( - "github.com/crusttech/crust/sam/repository" -) - -type ( - // For gomock to generate one-for-all mocked struct - Repository interface { - repository.Interfaces - } -) diff --git a/sam/types/channel.go b/sam/types/channel.go index 3b1ee0e01..7e9d95e31 100644 --- a/sam/types/channel.go +++ b/sam/types/channel.go @@ -83,3 +83,18 @@ const ( ChannelTypePrivate = "private" ChannelTypeGroup = "group" ) + +func (mtype ChannelType) String() string { + return string(mtype) +} + +func (mtype ChannelType) IsValid() bool { + switch mtype { + case ChannelTypePublic, + ChannelTypePrivate, + ChannelTypeGroup: + return true + } + + return false +}