DeforaNetworks/corteza
3
0
Fork 0
Code Activity

Redo service mocking, add ch name & topic length validation

Browse Source
This commit is contained in:
Denis Arh
2018-10-30 09:31:47 +01:00
parent 07c5c866f5
commit e97cbcea51
12 changed files with 260 additions and 693 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Makefile
View File

@@ -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

24
internal/config/auth_settings.go Normal file
View File

@@ -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
// }

57
internal/config/messaging_settings.go Normal file
View File

@@ -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
// }

21
internal/payload/outgoing/settings.go Normal file
View File

@@ -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"
// )

80
sam/service/channel.go
View File

@@ -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,
"<PRIVATE-OR-PUBLIC>",
"<TOPIC>")
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)
})
}

45
sam/service/channel_test.go Normal file
View File

@@ -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")
}

21
sam/service/main_test.go Normal file
View File

@@ -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
}

13
sam/service/message_mock_test.go
View File

@@ -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)

6
sam/service/service.go
View File

@@ -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

654
sam/service/service_mock_test.go
View File

@@ -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)
}

12
sam/service/service_test.go
View File

@@ -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
}
)

15
sam/types/channel.go
View File

@@ -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
}