func (mwc *Controller) CreateBotUser() {
mwc.log.Notice("Creating bot user")
_, err := models.CreateAccountInBothDbsWithNick("bot")
if err != nil {
mwc.log.Error("Could not create bot account")
}
}
func TestCheckOwnership(t *testing.T) {
tests.WithRunner(t, func(r *runner.Runner) {
Convey("accounts can own things", t, func() {
account, groupChannel, groupName := models.CreateRandomGroupDataWithChecks()
ses, err := modelhelper.FetchOrCreateSession(account.Nick, groupName)
tests.ResultedWithNoErrorCheck(ses, err)
tedsAccount, err := models.CreateAccountInBothDbsWithNick("ted")
tests.ResultedWithNoErrorCheck(tedsAccount, err)
bobsPost, err := rest.CreatePost(groupChannel.Id, ses.ClientId)
tests.ResultedWithNoErrorCheck(bobsPost, err)
Convey("it should say when an account owns a post", func() {
isOwner, err := rest.CheckPostOwnership(account, bobsPost)
So(err, ShouldBeNil)
So(isOwner, ShouldBeTrue)
})
Convey("it should say when an account doesn't own a post", func() {
isOwner, err := rest.CheckPostOwnership(tedsAccount, bobsPost)
So(err, ShouldBeNil)
So(isOwner, ShouldBeFalse)
})
bobsChannel, err := rest.CreateChannelByGroupNameAndType(account.Id, groupName, models.Channel_TYPE_TOPIC, ses.ClientId)
So(err, ShouldBeNil)
Convey("it should say when an account owns a channel", func() {
isOwner, err := rest.CheckChannelOwnership(account, bobsChannel)
So(err, ShouldBeNil)
So(isOwner, ShouldBeTrue)
})
Convey("it should say when an account doesn't own a channel", func() {
isOwner, err := rest.CheckChannelOwnership(tedsAccount, bobsChannel)
So(err, ShouldBeNil)
So(isOwner, ShouldBeFalse)
})
})
})
}
func TestChannelHistory(t *testing.T) {
tests.WithRunner(t, func(r *runner.Runner) {
Convey("While testing history of a channel", t, func() {
Convey("We should be able to create it(channel) first", func() {
groupName := models.RandomGroupName()
account, err := models.CreateAccountInBothDbsWithNick("sinan")
So(err, ShouldBeNil)
So(account, ShouldNotBeNil)
ses, err := modelhelper.FetchOrCreateSession(account.Nick, groupName)
So(err, ShouldBeNil)
So(ses, ShouldNotBeNil)
channel := models.CreateTypedGroupedChannelWithTest(
account.Id,
models.Channel_TYPE_GROUP,
groupName,
)
_, err = channel.AddParticipant(account.Id)
So(err, ShouldBeNil)
Convey("While posting a new message to it", func() {
var channelParticipant *models.ChannelParticipant
var err error
Convey("We should be able to create a participant first", func() {
channelParticipant, err = rest.CreateChannelParticipant(channel.Id, ses.ClientId)
So(err, ShouldBeNil)
So(channelParticipant, ShouldNotBeNil)
Convey("Create posts with created participant", func() {
channel := channel
for i := 0; i < 10; i++ {
post, err := rest.CreatePost(channel.Id, ses.ClientId)
So(err, ShouldBeNil)
So(post, ShouldNotBeNil)
So(post.Id, ShouldNotEqual, 0)
So(post.Body, ShouldNotEqual, "")
}
Convey("We should be able to fetch the history", func() {
history, err := rest.GetHistory(
channel.Id,
&request.Query{
AccountId: account.Id,
},
ses.ClientId,
)
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 10)
})
Convey("We should be not able to fetch the history if the clientId is not set", func() {
history, err := rest.GetHistory(
channel.Id,
&request.Query{
AccountId: account.Id,
},
"",
)
So(err, ShouldNotBeNil)
So(history, ShouldBeNil)
})
Convey("We should be not able to fetch the history if the clientId doesnt exist", func() {
history, err := rest.GetHistory(
channel.Id,
&request.Query{
AccountId: account.Id,
},
"foobarzaa",
)
So(err, ShouldNotBeNil)
So(history, ShouldBeNil)
})
Convey("We should be able to get channel message count", func() {
count, err := rest.CountHistory(channel.Id)
So(err, ShouldBeNil)
So(count, ShouldNotBeNil)
So(count.TotalCount, ShouldEqual, 10)
})
})
Convey("We should be able to check history according to request", func() {
channel := channel
for i := 0; i < 5; i++ {
body := fmt.Sprintf("body%d", i)
post, err := rest.CreatePostWithBodyAndAuth(channel.Id, body, ses.ClientId)
// we need to wait while posting messages
// if we dont use time sleep, Added_at field of the messages is
// gonna be equal and this behavior is not expected situation
// Then, tests will not be worked correctly
time.Sleep(1000 * time.Millisecond)
So(err, ShouldBeNil)
So(post, ShouldNotBeNil)
So(post.Id, ShouldNotEqual, 0)
So(post.Body, ShouldNotEqual, "")
}
bodyMes := "postMid message"
postMid, err := rest.CreatePostWithBodyAndAuth(channel.Id, bodyMes, ses.ClientId)
So(postMid, ShouldNotBeNil)
So(err, ShouldBeNil)
for i := 5; i < 10; i++ {
time.Sleep(1000 * time.Millisecond)
body := fmt.Sprintf("body%d", i)
post, err := rest.CreatePostWithBodyAndAuth(channel.Id, body, ses.ClientId)
So(err, ShouldBeNil)
So(post, ShouldNotBeNil)
So(post.Id, ShouldNotEqual, 0)
So(post.Body, ShouldNotEqual, "")
}
Convey("We should able to fetch the history with query request ", func() {
history, err := rest.GetHistory(
channel.Id,
&request.Query{
AccountId: account.Id,
},
ses.ClientId,
)
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 11)
})
Convey("We should able to fetch the history with query ADDED AT & ASC ", func() {
history, err := rest.GetHistory(
channel.Id,
&request.Query{
From: postMid.CreatedAt,
SortOrder: "ASC",
},
ses.ClientId,
)
var historyArr []string
arr := []string{"postMid message", "body5", "body6", "body7", "body8", "body9"}
for _, x := range history.MessageList {
historyArr = append(historyArr, x.Message.Body)
}
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 6)
So(arr, ShouldResemble, historyArr)
})
Convey("We should able to fetch the history with query ADDED AT & DESC ", func() {
history, err := rest.GetHistory(
channel.Id,
&request.Query{
From: postMid.CreatedAt,
SortOrder: "DESC",
},
ses.ClientId,
)
var historyArr []string
arr := []string{"body4", "body3", "body2", "body1", "body0"}
for _, x := range history.MessageList {
historyArr = append(historyArr, x.Message.Body)
}
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 5)
So(arr, ShouldResemble, historyArr)
})
Convey("We should able to fetch the with query ADDED AT & DESC ORDER& LIMIT ", func() {
history, err := rest.GetHistory(
channel.Id,
&request.Query{
From: postMid.CreatedAt,
SortOrder: "DESC",
Limit: 3,
},
ses.ClientId,
)
var historyArr []string
arr := []string{"body4", "body3", "body2"}
for _, x := range history.MessageList {
historyArr = append(historyArr, x.Message.Body)
}
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 3)
So(arr, ShouldResemble, historyArr)
})
Convey("We should able to fetch the with query ADDED AT & ASC ORDER& LIMIT ", func() {
history, err := rest.GetHistory(
channel.Id,
&request.Query{
From: postMid.CreatedAt,
SortOrder: "ASC",
Limit: 3,
},
ses.ClientId,
)
var historyArr []string
arr := []string{"postMid message", "body5", "body6"}
for _, x := range history.MessageList {
historyArr = append(historyArr, x.Message.Body)
}
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 3)
So(arr, ShouldResemble, historyArr)
})
})
})
})
})
})
})
}
func TestChannelParticipantOperations(t *testing.T) {
tests.WithRunner(t, func(r *runner.Runner) {
Convey("while testing channel participants", t, func() {
Convey("First Create Users and initiate conversation", func() {
ownerAccount, groupChannel, groupName := models.CreateRandomGroupDataWithChecks()
ownerSes, err := modelhelper.FetchOrCreateSession(ownerAccount.Nick, groupName)
So(err, ShouldBeNil)
So(ownerSes, ShouldNotBeNil)
secondAccount, err := models.CreateAccountInBothDbs()
tests.ResultedWithNoErrorCheck(secondAccount, err)
_, err = groupChannel.AddParticipant(secondAccount.Id)
So(err, ShouldBeNil)
thirdAccount, err := models.CreateAccountInBothDbs()
tests.ResultedWithNoErrorCheck(thirdAccount, err)
_, err = groupChannel.AddParticipant(thirdAccount.Id)
So(err, ShouldBeNil)
forthAccount, err := models.CreateAccountInBothDbs()
tests.ResultedWithNoErrorCheck(forthAccount, err)
_, err = groupChannel.AddParticipant(forthAccount.Id)
So(err, ShouldBeNil)
devrim, err := models.CreateAccountInBothDbsWithNick("devrim")
tests.ResultedWithNoErrorCheck(devrim, err)
_, err = groupChannel.AddParticipant(devrim.Id)
So(err, ShouldBeNil)
ses, err := modelhelper.FetchOrCreateSession(ownerAccount.Nick, groupName)
tests.ResultedWithNoErrorCheck(ses, err)
secondSes, err := modelhelper.FetchOrCreateSession(secondAccount.Nick, groupName)
tests.ResultedWithNoErrorCheck(secondSes, err)
pmr := models.ChannelRequest{}
pmr.AccountId = ownerAccount.Id
pmr.Body = "new conversation"
pmr.GroupName = groupName
pmr.Recipients = []string{"devrim"}
channelContainer, err := rest.SendPrivateChannelRequest(pmr, ownerSes.ClientId)
So(err, ShouldBeNil)
So(channelContainer, ShouldNotBeNil)
Convey("First user should be able to add second and third users to conversation", func() {
_, err = rest.AddChannelParticipant(channelContainer.Channel.Id, ownerSes.ClientId, secondAccount.Id, thirdAccount.Id)
So(err, ShouldBeNil)
participants, err := rest.ListChannelParticipants(channelContainer.Channel.Id, ownerSes.ClientId)
So(err, ShouldBeNil)
So(participants, ShouldNotBeNil)
// it is four because first user is "devrim" here
So(len(participants), ShouldEqual, 4)
Convey("First user should not be able to re-add second participant", func() {
_, err = rest.AddChannelParticipant(channelContainer.Channel.Id, ownerSes.ClientId, secondAccount.Id)
So(err, ShouldBeNil)
participants, err := rest.ListChannelParticipants(channelContainer.Channel.Id, ownerSes.ClientId)
So(err, ShouldBeNil)
So(participants, ShouldNotBeNil)
So(len(participants), ShouldEqual, 4)
})
Convey("Second user should be able to leave conversation", func() {
// token of account -> secondAccount
_, err = rest.DeleteChannelParticipant(channelContainer.Channel.Id, secondSes.ClientId, secondAccount.Id)
So(err, ShouldBeNil)
participants, err := rest.ListChannelParticipants(channelContainer.Channel.Id, ownerSes.ClientId)
So(err, ShouldBeNil)
So(participants, ShouldNotBeNil)
So(len(participants), ShouldEqual, 3)
Convey("A user who is not participant of a conversation should not be able to add another user to the conversation", func() {
_, err = rest.AddChannelParticipant(channelContainer.Channel.Id, secondSes.ClientId, forthAccount.Id)
So(err, ShouldNotBeNil)
participants, err := rest.ListChannelParticipants(channelContainer.Channel.Id, ownerSes.ClientId)
So(err, ShouldBeNil)
So(participants, ShouldNotBeNil)
So(len(participants), ShouldEqual, 3)
})
})
Convey("Channel owner should be able to kick another conversation participant", func() {
_, err = rest.DeleteChannelParticipant(channelContainer.Channel.Id, ownerSes.ClientId, secondAccount.Id)
So(err, ShouldBeNil)
participants, err := rest.ListChannelParticipants(channelContainer.Channel.Id, ownerSes.ClientId)
So(err, ShouldBeNil)
So(participants, ShouldNotBeNil)
So(len(participants), ShouldEqual, 3)
})
Convey("when a user is blocked", func() {
_, err = rest.BlockChannelParticipant(channelContainer.Channel.Id, ownerSes.ClientId, secondAccount.Id)
So(err, ShouldBeNil)
Convey("it should not be in channel participant list", func() {
participants, err := rest.ListChannelParticipants(channelContainer.Channel.Id, ownerSes.ClientId)
So(err, ShouldBeNil)
So(participants, ShouldNotBeNil)
So(len(participants), ShouldEqual, 3)
})
Convey("should not be able to add it back", func() {
_, err = rest.AddChannelParticipant(channelContainer.Channel.Id, ownerSes.ClientId, secondAccount.Id)
So(err, ShouldNotBeNil)
})
Convey("should be able to unblock", func() {
_, err = rest.UnblockChannelParticipant(channelContainer.Channel.Id, ownerSes.ClientId, secondAccount.Id)
So(err, ShouldBeNil)
Convey("it should not be in channel participant list still", func() {
participants, err := rest.ListChannelParticipants(channelContainer.Channel.Id, ownerSes.ClientId)
So(err, ShouldBeNil)
So(participants, ShouldNotBeNil)
So(len(participants), ShouldEqual, 3)
})
Convey("when we add the same user as participant", func() {
_, err = rest.AddChannelParticipant(channelContainer.Channel.Id, ownerSes.ClientId, secondAccount.Id, thirdAccount.Id)
So(err, ShouldBeNil)
Convey("it should be in channel participant list", func() {
participants, err := rest.ListChannelParticipants(channelContainer.Channel.Id, ownerSes.ClientId)
So(err, ShouldBeNil)
So(participants, ShouldNotBeNil)
So(len(participants), ShouldEqual, 4)
})
})
})
})
Convey("Second user should not be able to kick another conversation participant", func() {
_, err = rest.DeleteChannelParticipant(channelContainer.Channel.Id, secondSes.ClientId, thirdAccount.Id)
So(err, ShouldNotBeNil)
})
})
Convey("First user should be able to invite second user", func() {
_, err = rest.InviteChannelParticipant(channelContainer.Channel.Id, ownerSes.ClientId, secondAccount.Id)
So(err, ShouldBeNil)
participants, err := rest.ListChannelParticipants(channelContainer.Channel.Id, ownerSes.ClientId)
So(err, ShouldBeNil)
So(participants, ShouldNotBeNil)
// it is four because first user is "devrim" here
So(len(participants), ShouldEqual, 2)
Convey("Second user should be able to reject invitation", func() {
ses, err := modelhelper.FetchOrCreateSession(secondAccount.Nick, groupName)
So(err, ShouldBeNil)
So(ses, ShouldNotBeNil)
err = rest.RejectInvitation(channelContainer.Channel.Id, ses.ClientId)
So(err, ShouldBeNil)
participants, err := rest.ListChannelParticipants(channelContainer.Channel.Id, ownerSes.ClientId)
So(err, ShouldBeNil)
So(participants, ShouldNotBeNil)
So(len(participants), ShouldEqual, 2)
})
Convey("Second user should be able to accept invitation", func() {
ses, err := modelhelper.FetchOrCreateSession(secondAccount.Nick, groupName)
So(err, ShouldBeNil)
So(ses, ShouldNotBeNil)
err = rest.AcceptInvitation(channelContainer.Channel.Id, ses.ClientId)
So(err, ShouldBeNil)
participants, err := rest.ListChannelParticipants(channelContainer.Channel.Id, ownerSes.ClientId)
So(err, ShouldBeNil)
So(participants, ShouldNotBeNil)
So(len(participants), ShouldEqual, 3)
})
})
// TODO Until we find a better way for handling async stuff, this test is skipped. Instead of sleep, we should use some
// timeouts for testing these kind of stuff.
SkipConvey("All private messages must be deleted when all participant users leave the channel", func() {
account := models.NewAccount()
err = account.ByNick("devrim")
So(err, ShouldBeNil)
_, err = rest.DeleteChannelParticipant(channelContainer.Channel.Id, ses.ClientId, account.Id)
So(err, ShouldBeNil)
_, err = rest.DeleteChannelParticipant(channelContainer.Channel.Id, ownerSes.ClientId, ownerAccount.Id)
So(err, ShouldBeNil)
time.Sleep(1 * time.Second)
testChannel := models.NewChannel()
err := testChannel.ById(channelContainer.Channel.Id)
So(err, ShouldEqual, bongo.RecordNotFound)
testChannelList := models.NewChannelMessageList()
err = bongo.B.Unscoped().Where("channel_id = ?", channelContainer.Channel.Id).Find(testChannelList).Error
So(err, ShouldEqual, bongo.RecordNotFound)
testMessage := models.NewChannelMessage()
err = bongo.B.Unscoped().Where("initial_channel_id = ?", channelContainer.Channel.Id).Find(testMessage).Error
So(err, ShouldEqual, bongo.RecordNotFound)
})
Convey("Users should not be able to add/remove users to/from bot channels", func() {
ownerAccount, _, groupName := models.CreateRandomGroupDataWithChecks()
participant := models.NewAccount()
participant.OldId = AccountOldId.Hex()
participant, err = rest.CreateAccount(participant)
So(err, ShouldBeNil)
So(participant, ShouldNotBeNil)
ses, err := modelhelper.FetchOrCreateSession(ownerAccount.Nick, groupName)
So(err, ShouldBeNil)
ch, err := rest.CreateChannelByGroupNameAndType(ownerAccount.Id, groupName, models.Channel_TYPE_BOT, ses.ClientId)
So(err, ShouldBeNil)
So(ch, ShouldNotBeNil)
// account is -> ownerAccount.Id
_, err = rest.AddChannelParticipant(ch.Id, ses.ClientId, participant.Id)
So(strings.Contains(err.Error(), "can not add participants for bot channel"), ShouldBeTrue)
})
Convey("Users should be able to add/remove users to/from topic channels", func() {
ownerAccount, _, groupName := models.CreateRandomGroupDataWithChecks()
participant := models.NewAccount()
participant.OldId = AccountOldId.Hex()
participant, err = rest.CreateAccount(participant)
So(err, ShouldBeNil)
So(participant, ShouldNotBeNil)
ses, err := modelhelper.FetchOrCreateSession(ownerAccount.Nick, groupName)
So(err, ShouldBeNil)
ch, err := rest.CreateChannelByGroupNameAndType(ownerAccount.Id, groupName, models.Channel_TYPE_TOPIC, ses.ClientId)
So(err, ShouldBeNil)
So(ch, ShouldNotBeNil)
// account is -> ownerAccount.Id
_, err = rest.AddChannelParticipant(ch.Id, ses.ClientId, participant.Id)
So(err, ShouldBeNil)
Convey("adding same user again should success", func() {
_, err = rest.AddChannelParticipant(ch.Id, ses.ClientId, participant.Id)
So(err, ShouldBeNil)
})
_, err = rest.DeleteChannelParticipant(ch.Id, ses.ClientId, participant.Id)
So(err, ShouldBeNil)
Convey("removing same user again should success", func() {
_, err = rest.DeleteChannelParticipant(ch.Id, ses.ClientId, participant.Id)
So(err, ShouldBeNil)
})
})
Convey("while removing users from group channels", func() {
ownerAccount, _, groupName := models.CreateRandomGroupDataWithChecks()
participant := models.NewAccount()
participant.OldId = AccountOldId.Hex()
participant, err = rest.CreateAccount(participant)
So(err, ShouldBeNil)
So(participant, ShouldNotBeNil)
participant2 := models.NewAccount()
participant2.OldId = AccountOldId.Hex()
participant2, err = rest.CreateAccount(participant2)
So(err, ShouldBeNil)
So(participant2, ShouldNotBeNil)
ownerSes, err := modelhelper.FetchOrCreateSession(ownerAccount.Nick, groupName)
So(err, ShouldBeNil)
ses, err := modelhelper.FetchOrCreateSession(participant.Nick, groupName)
So(err, ShouldBeNil)
ch, err := rest.CreateChannelByGroupNameAndType(ownerAccount.Id, groupName, models.Channel_TYPE_GROUP, ownerSes.ClientId)
So(err, ShouldBeNil)
So(ch, ShouldNotBeNil)
// ownerSes session is admin's session data
_, err = rest.AddChannelParticipant(ch.Id, ownerSes.ClientId, participant.Id)
So(err, ShouldBeNil)
_, err = rest.AddChannelParticipant(ch.Id, ownerSes.ClientId, participant2.Id)
So(err, ShouldBeNil)
Convey("owner should be able to remove user from group channel", func() {
// ownerSes session is admin's session data
_, err = rest.DeleteChannelParticipant(ch.Id, ownerSes.ClientId, participant2.Id)
So(err, ShouldBeNil)
})
Convey("nonOwner should not be able to remove user from group channel", func() {
// ses session is participant's session data
_, err = rest.DeleteChannelParticipant(ch.Id, ses.ClientId, participant2.Id)
So(err, ShouldNotBeNil)
})
})
})
})
})
}
func TestTeam(t *testing.T) {
r := runner.New("test")
if err := r.Init(); err != nil {
t.Fatalf("couldnt start bongo %s", err.Error())
}
defer r.Close()
appConfig := config.MustRead(r.Conf.Path)
// init mongo connection
modelhelper.Initialize(appConfig.Mongo)
defer modelhelper.Close()
handler := NewController(r.Log, appConfig)
Convey("given a group", t, func() {
// create admin
admin, err := models.CreateAccountInBothDbsWithNick("sinan")
So(err, ShouldBeNil)
So(admin, ShouldNotBeNil)
acc1, err := models.CreateAccountInBothDbs()
So(err, ShouldBeNil)
So(acc1, ShouldNotBeNil)
// create another account
acc2, err := models.CreateAccountInBothDbs()
So(err, ShouldBeNil)
So(acc2, ShouldNotBeNil)
groupName := models.RandomGroupName()
groupChannel := models.CreateTypedGroupedChannelWithTest(admin.Id, models.Channel_TYPE_GROUP, groupName)
So(groupChannel, ShouldNotBeNil)
defaultChannel1 := models.CreateTypedGroupedChannelWithTest(admin.Id, models.Channel_TYPE_TOPIC, groupName)
So(defaultChannel1, ShouldNotBeNil)
defaultChannel2 := models.CreateTypedGroupedChannelWithTest(admin.Id, models.Channel_TYPE_TOPIC, groupName)
So(defaultChannel2, ShouldNotBeNil)
group := &mongomodels.Group{
Id: bson.NewObjectId(),
Body: groupName,
Title: groupName,
Slug: groupName,
Privacy: "private",
Visibility: "hidden",
SocialApiChannelId: strconv.FormatInt(groupChannel.Id, 10),
DefaultChannels: []string{
strconv.FormatInt(defaultChannel1.Id, 10),
strconv.FormatInt(defaultChannel2.Id, 10),
},
}
err = modelhelper.CreateGroup(group)
So(err, ShouldBeNil)
Convey("should success if channel is not in db", func() {
cp := &models.ChannelParticipant{
AccountId: acc1.Id,
ChannelId: math.MaxInt64,
}
err := handler.HandleParticipant(cp)
So(err, ShouldBeNil)
})
Convey("should success if channel is not a group channel", func() {
cp := &models.ChannelParticipant{
AccountId: acc1.Id,
ChannelId: defaultChannel1.Id,
}
err := handler.HandleParticipant(cp)
So(err, ShouldBeNil)
})
Convey("should success if group is not in mongo", func() {
groupName := models.RandomGroupName()
groupChan := models.CreateTypedGroupedChannelWithTest(admin.Id, models.Channel_TYPE_GROUP, groupName)
So(groupChan, ShouldNotBeNil)
cp := &models.ChannelParticipant{
AccountId: acc1.Id,
ChannelId: groupChan.Id,
}
err := handler.HandleParticipant(cp)
So(err, ShouldBeNil)
})
Convey("new participant should be in default channels", func() {
cp := &models.ChannelParticipant{
AccountId: acc1.Id,
ChannelId: groupChannel.Id,
StatusConstant: models.ChannelParticipant_STATUS_ACTIVE,
}
err := handler.HandleParticipant(cp)
So(err, ShouldBeNil)
isParticipant, err := defaultChannel1.IsParticipant(acc1.Id)
So(err, ShouldBeNil)
So(isParticipant, ShouldBeTrue)
isParticipant, err = defaultChannel2.IsParticipant(acc1.Id)
So(err, ShouldBeNil)
So(isParticipant, ShouldBeTrue)
Convey("after leaving group channel", func() {
cp := &models.ChannelParticipant{
AccountId: acc1.Id,
ChannelId: groupChannel.Id,
StatusConstant: models.ChannelParticipant_STATUS_LEFT,
}
err := handler.HandleParticipant(cp)
So(err, ShouldBeNil)
Convey("should be removed from default channels", func() {
isParticipant, err := defaultChannel1.IsParticipant(acc1.Id)
So(err, ShouldBeNil)
So(isParticipant, ShouldBeFalse)
isParticipant, err = defaultChannel2.IsParticipant(acc1.Id)
So(err, ShouldBeNil)
So(isParticipant, ShouldBeFalse)
})
Convey("should be removed from all channels", func() {
ids, err := cp.FetchAllParticipatedChannelIdsInGroup(cp.AccountId, groupChannel.GroupName)
So(err, ShouldBeNil)
So(len(ids), ShouldEqual, 0)
})
})
Convey("after being blocked", func() {
cp := &models.ChannelParticipant{
AccountId: acc1.Id,
ChannelId: groupChannel.Id,
StatusConstant: models.ChannelParticipant_STATUS_BLOCKED,
}
err := handler.HandleParticipant(cp)
So(err, ShouldBeNil)
Convey("should be removed from default channels", func() {
isParticipant, err := defaultChannel1.IsParticipant(acc1.Id)
So(err, ShouldBeNil)
So(isParticipant, ShouldBeFalse)
isParticipant, err = defaultChannel2.IsParticipant(acc1.Id)
So(err, ShouldBeNil)
So(isParticipant, ShouldBeFalse)
})
})
})
Convey("should success if default channels is not available anymore", func() {
// delete the channel
So(defaultChannel1.Delete(), ShouldBeNil)
cp := &models.ChannelParticipant{
AccountId: acc1.Id,
ChannelId: groupChannel.Id,
StatusConstant: models.ChannelParticipant_STATUS_ACTIVE,
}
err := handler.HandleParticipant(cp)
So(err, ShouldBeNil)
})
})
}
func TestAccountTesting(t *testing.T) {
runner, handler := getTestHandler()
defer runner.Close()
// init mongo connection
appConfig := config.MustRead(runner.Conf.Path)
modelhelper.Initialize(appConfig.Mongo)
defer modelhelper.Close()
Convey("given some fake account", t, func() {
acc, _, name := models.CreateRandomGroupDataWithChecks()
So(name, ShouldNotBeNil)
So(acc, ShouldNotBeNil)
Convey("it should save the document to algolia", func() {
err := handler.AccountCreated(acc)
So(err, ShouldBeNil)
Convey("it should be able to fetch algolia data", func() {
// make sure account is there
So(doBasicTestForAccount(handler, acc.OldId), ShouldBeNil)
_, err = modelhelper.GetUser(acc.Nick)
So(err, ShouldBeNil)
// update user's email
selector := bson.M{"username": acc.Nick}
newEmail := "mehmetalixsavasx1x2x" + models.RandomGroupName() + "@koding.com"
updateQuery := bson.M{"email": newEmail}
err = modelhelper.UpdateUser(selector, updateQuery)
So(err, ShouldBeNil)
err = handler.AccountUpdated(acc)
So(err, ShouldBeNil)
index, err := handler.indexes.GetIndex(IndexAccounts)
So(err, ShouldBeNil)
params := make(map[string]interface{})
record, err := index.Search("mehmetalixsavasx1x2x", params)
So(err, ShouldBeNil)
hist, ok := record.(map[string]interface{})["hits"]
usernames := make([]string, 0)
objects := make([]string, 0)
if ok {
hinter, ok := hist.([]interface{})
if ok {
for _, v := range hinter {
val, k := v.(map[string]interface{})
if k {
object := val["objectID"].(string)
value := val["nick"].(string)
usernames = append(usernames, value)
objects = append(objects, object)
_, err = index.DeleteObject(object)
So(err, ShouldBeNil)
}
}
}
}
So(usernames, ShouldNotBeNil)
So(objects, ShouldNotBeNil)
})
Convey("it should be able to fetch many account with given query", func() {
So(doBasicTestForAccount(handler, acc.OldId), ShouldBeNil)
// we create 10 acc for algolia test
for i := 0; i < 10; i++ {
ac, _, _ := models.CreateRandomGroupDataWithChecks()
err := handler.AccountCreated(ac)
So(err, ShouldBeNil)
selector := bson.M{"username": ac.Nick}
newEmail := "mehmetali-test" + models.RandomGroupName() + "@koding.com"
updateQuery := bson.M{"email": newEmail}
err = modelhelper.UpdateUser(selector, updateQuery)
So(err, ShouldBeNil)
err = handler.AccountUpdated(ac)
So(err, ShouldBeNil)
time.Sleep(1 * time.Second)
}
//required for getting algolia datas correctly
time.Sleep(5 * time.Second)
_, err = modelhelper.GetUser(acc.Nick)
So(err, ShouldBeNil)
index, err := handler.indexes.GetIndex(IndexAccounts)
So(err, ShouldBeNil)
params := make(map[string]interface{})
record, err := index.Search("mehmetali-test", params)
So(err, ShouldBeNil)
hist, ok := record.(map[string]interface{})["hits"]
usernames := make([]string, 0)
objects := make([]string, 0)
if ok {
hinter, ok := hist.([]interface{})
if ok {
for _, v := range hinter {
val, k := v.(map[string]interface{})
if k {
object := val["objectID"].(string)
value := val["nick"].(string)
usernames = append(usernames, value)
objects = append(objects, object)
}
}
}
}
So(len(usernames), ShouldBeGreaterThan, 0)
So(len(objects), ShouldBeGreaterThan, 0)
Convey("it should be able to delete many account with given query", func() {
So(doBasicTestForAccount(handler, acc.OldId), ShouldBeNil)
for i := 0; i < 10; i++ {
ac, _, _ := models.CreateRandomGroupDataWithChecks()
err := handler.AccountCreated(ac)
So(err, ShouldBeNil)
selector := bson.M{"username": ac.Nick}
newEmail := "mehmetali-test" + models.RandomGroupName() + "@koding.com"
updateQuery := bson.M{"email": newEmail}
err = modelhelper.UpdateUser(selector, updateQuery)
So(err, ShouldBeNil)
err = handler.AccountUpdated(ac)
So(err, ShouldBeNil)
time.Sleep(1 * time.Second)
}
time.Sleep(5 * time.Second)
_, err = modelhelper.GetUser(acc.Nick)
So(err, ShouldBeNil)
_, err := handler.indexes.GetIndex(IndexAccounts)
So(err, ShouldBeNil)
usernames := make([]string, 0)
objects := make([]string, 0)
nbHits, _ := record.(map[string]interface{})["nbHits"]
nbPages, _ := record.(map[string]interface{})["nbPages"]
var pages float64 = nbPages.(float64)
var nbHit float64 = nbHits.(float64)
for pages > 0 && nbHit != 0 {
record, err := index.Search("mehmetali-test", params)
hist, ok := record.(map[string]interface{})["hits"]
// fmt.Println("hist is :", hist)
nbHits, _ := record.(map[string]interface{})["nbHits"]
nbPages, _ := record.(map[string]interface{})["nbPages"]
pages = nbPages.(float64)
nbHit = nbHits.(float64)
if ok {
hinter, ok := hist.([]interface{})
if ok {
for _, v := range hinter {
val, k := v.(map[string]interface{})
if k {
object := val["objectID"].(string)
value := val["nick"].(string)
usernames = append(usernames, value)
objects = append(objects, object)
_, err = index.DeleteObject(object)
So(err, ShouldBeNil)
}
}
}
}
}
lenghtUsernames := len(usernames)
lenghtObjects := len(objects)
So(lenghtUsernames, ShouldBeGreaterThan, 10)
So(lenghtObjects, ShouldBeGreaterThan, 10)
})
Convey("it should have delete algolia accounts", func() {
fmt.Println("=============>>>>>>>>>>>>>>>>>>>")
fmt.Println("=============>>>>>>>>>>>>>>>>>>>")
fmt.Println("it should have delete algolia accounts")
fmt.Println("=============>>>>>>>>>>>>>>>>>>>")
fmt.Println("=============>>>>>>>>>>>>>>>>>>>")
// make sure account is there
So(doBasicTestForAccount(handler, acc.OldId), ShouldBeNil)
for i := 0; i < 10; i++ {
rand.Seed(time.Now().UnixNano())
strconv.FormatInt(rand.Int63(), 10)
name := "guter-" + strconv.FormatInt(rand.Int63(), 10)
ac, _ := models.CreateAccountInBothDbsWithNick(name)
err := handler.AccountCreated(ac)
So(err, ShouldBeNil)
selector := bson.M{"username": ac.Nick}
newEmail := "mehmetali-test" + models.RandomGroupName() + "@koding.com"
updateQuery := bson.M{"email": newEmail}
err = modelhelper.UpdateUser(selector, updateQuery)
So(err, ShouldBeNil)
err = handler.AccountUpdated(ac)
So(err, ShouldBeNil)
time.Sleep(1 * time.Second)
}
time.Sleep(5 * time.Second)
_, err = handler.indexes.GetIndex(IndexAccounts)
So(err, ShouldBeNil)
// record, _ := index.Search("mehmetalisa", map[string]interface{}{"restrictSearchableAttributes": "email"})
// params := make(map[string]interface{})
params := map[string]interface{}{"restrictSearchableAttributes": "nick"}
record, _ := index.Search("guter-", params)
hits, _ := record.(map[string]interface{})["nbHits"]
hit := hits.(float64)
So(hit, ShouldBeGreaterThan, 0)
err = handler.DeleteNicksWithQuery("guter-")
So(err, ShouldBeNil)
// necessary for getting datas from algolia,
time.Sleep(5 * time.Second)
r, err := index.Search("guter-", params)
So(err, ShouldBeNil)
nbHits, _ := r.(map[string]interface{})["nbHits"]
nbHit := nbHits.(float64)
So(nbHit, ShouldBeLessThan, 10)
})
})
})
})
}
func TestPrivateMesssages(t *testing.T) {
tests.WithRunner(t, func(r *runner.Runner) {
Convey("while testing private channels", t, func() {
devrim, err := models.CreateAccountInBothDbsWithNick("devrim")
So(err, ShouldBeNil)
So(devrim, ShouldNotBeNil)
sinan, err := models.CreateAccountInBothDbsWithNick("sinan")
So(err, ShouldBeNil)
So(sinan, ShouldNotBeNil)
groupName := models.RandomGroupName()
// cretae admin user
account, err := models.CreateAccountInBothDbs()
tests.ResultedWithNoErrorCheck(account, err)
models.CreateTypedGroupedChannelWithTest(
account.Id,
models.Channel_TYPE_GROUP,
groupName,
)
// fetch admin's session
ses, err := modelhelper.FetchOrCreateSession(account.Nick, groupName)
So(err, ShouldBeNil)
So(ses, ShouldNotBeNil)
groupChannel, err := rest.CreateChannelByGroupNameAndType(
account.Id,
groupName,
models.Channel_TYPE_GROUP,
ses.ClientId,
)
tests.ResultedWithNoErrorCheck(groupChannel, err)
recipient := models.NewAccount()
recipient.OldId = AccountOldId2.Hex()
recipient, err = rest.CreateAccount(recipient)
So(err, ShouldBeNil)
So(recipient, ShouldNotBeNil)
recipient2 := models.NewAccount()
recipient2.OldId = AccountOldId3.Hex()
recipient2, err = rest.CreateAccount(recipient2)
So(err, ShouldBeNil)
So(recipient2, ShouldNotBeNil)
Convey("participants should be a member of parent group", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body message for private message @devrim @sinan"
pmr.GroupName = groupName
pmr.Recipients = []string{"devrim", "sinan"}
_, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldNotBeNil)
})
_, err = groupChannel.AddParticipant(sinan.Id)
So(err, ShouldBeNil)
_, err = groupChannel.AddParticipant(devrim.Id)
So(err, ShouldBeNil)
Convey("one can send private message to one person", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body message for private message @devrim @sinan"
pmr.GroupName = groupName
pmr.Recipients = []string{"devrim", "sinan"}
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
})
Convey("0 recipient should not fail", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body for private message"
pmr.GroupName = groupName
pmr.Recipients = []string{}
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
})
Convey("if sender is not defined but token is added, then shouldn't fail to create PM", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = 0
pmr.Body = "this is a body for private message"
pmr.GroupName = ""
pmr.Recipients = []string{}
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
})
Convey("one can send private message to multiple person", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body for private message @sinan"
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan"}
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
})
Convey("private message response should have created channel", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body for private message @devrim @sinan"
pmr.GroupName = groupName
pmr.Recipients = []string{"devrim", "sinan"}
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
So(cmc.Channel.TypeConstant, ShouldEqual, models.Channel_TYPE_PRIVATE_MESSAGE)
So(cmc.Channel.Id, ShouldBeGreaterThan, 0)
So(cmc.Channel.GroupName, ShouldEqual, groupName)
So(cmc.Channel.PrivacyConstant, ShouldEqual, models.Channel_PRIVACY_PRIVATE)
})
Convey("private message response should have participant status data", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body for private message @devrim @sinan"
pmr.GroupName = groupName
pmr.Recipients = []string{"devrim", "sinan"}
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
So(cmc.IsParticipant, ShouldBeTrue)
})
Convey("private message response should have participant count", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body for @sinan private message @devrim"
pmr.GroupName = groupName
pmr.Recipients = []string{"devrim", "sinan"}
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
So(cmc.ParticipantCount, ShouldEqual, 3)
})
Convey("private message response should have participant preview", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is @sinan a body for @devrim private message"
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan", "devrim"}
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
So(len(cmc.ParticipantsPreview), ShouldEqual, 3)
})
Convey("private message response should have last Message", func() {
body := "hi @devrim this is a body for private message also for @sinan"
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = body
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan", "devrim"}
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
So(cmc.LastMessage.Message.Body, ShouldEqual, body)
})
Convey("private message should be listed by all recipients", func() {
body := "hi @devrim this is a body for private message also for @sinan"
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = body
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan", "devrim"}
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
pm, err := rest.GetPrivateChannels(&request.Query{AccountId: account.Id, GroupName: groupName}, ses.ClientId)
So(err, ShouldBeNil)
So(pm, ShouldNotBeNil)
So(len(pm), ShouldNotEqual, 0)
So(pm[0], ShouldNotBeNil)
So(pm[0].Channel.TypeConstant, ShouldEqual, models.Channel_TYPE_PRIVATE_MESSAGE)
So(pm[0].Channel.Id, ShouldEqual, cmc.Channel.Id)
So(pm[0].Channel.GroupName, ShouldEqual, cmc.Channel.GroupName)
So(pm[0].LastMessage.Message.Body, ShouldEqual, cmc.LastMessage.Message.Body)
So(pm[0].Channel.PrivacyConstant, ShouldEqual, models.Channel_PRIVACY_PRIVATE)
So(len(pm[0].ParticipantsPreview), ShouldEqual, 3)
So(pm[0].IsParticipant, ShouldBeTrue)
})
Convey("user should be able to search private messages via purpose field", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "search private messages"
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan", "devrim"}
pmr.Purpose = "test me up"
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
query := request.Query{AccountId: account.Id, GroupName: groupName}
_, err = rest.SearchPrivateChannels(&query, ses.ClientId)
So(err, ShouldNotBeNil)
query.Name = "test"
pm, err := rest.SearchPrivateChannels(&query, ses.ClientId)
So(err, ShouldBeNil)
So(pm, ShouldNotBeNil)
So(len(pm), ShouldNotEqual, 0)
So(pm[0], ShouldNotBeNil)
So(pm[0].Channel.TypeConstant, ShouldEqual, models.Channel_TYPE_PRIVATE_MESSAGE)
So(pm[0].Channel.Id, ShouldEqual, cmc.Channel.Id)
So(pm[0].Channel.GroupName, ShouldEqual, cmc.Channel.GroupName)
So(pm[0].LastMessage.Message.Body, ShouldEqual, cmc.LastMessage.Message.Body)
So(pm[0].Channel.PrivacyConstant, ShouldEqual, models.Channel_PRIVACY_PRIVATE)
So(pm[0].IsParticipant, ShouldBeTrue)
})
payload := gorm.Hstore{}
bar := "bar"
payload["foo"] = &bar
Convey("given payload should be populated", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body message for private message @devrim @sinan"
pmr.GroupName = groupName
pmr.Recipients = []string{"devrim", "sinan"}
pmr.Payload = payload
pcr, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(pcr, ShouldNotBeNil)
So(pcr.Channel, ShouldNotBeNil)
So(pcr.Channel.Payload, ShouldNotBeNil)
So(len(pcr.Channel.Payload), ShouldBeGreaterThan, 0)
So(*pcr.Channel.Payload["foo"], ShouldEqual, bar)
})
Convey("user join activity should be listed by recipients", func() {
groupName := models.RandomGroupName()
// cretae admin user
account, err := models.CreateAccountInBothDbs()
tests.ResultedWithNoErrorCheck(account, err)
// fetch admin's session
ses, err := modelhelper.FetchOrCreateSession(account.Nick, groupName)
So(err, ShouldBeNil)
So(ses, ShouldNotBeNil)
groupChannel := models.CreateTypedGroupedChannelWithTest(
account.Id,
models.Channel_TYPE_GROUP,
groupName,
)
So(groupChannel, ShouldNotBeNil)
_, err = groupChannel.AddParticipant(account.Id)
So(err, ShouldBeNil)
_, err = groupChannel.AddParticipant(devrim.Id)
So(err, ShouldBeNil)
_, err = groupChannel.AddParticipant(sinan.Id)
So(err, ShouldBeNil)
_, err = groupChannel.AddParticipant(recipient.Id)
So(err, ShouldBeNil)
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "test private message participants"
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan", "devrim"}
if pmr.Payload == nil {
pmr.Payload = gorm.Hstore{}
}
pic := "pictureSomethingLikeThat"
pmr.Payload["link_embed"] = &pic
cc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cc, ShouldNotBeNil)
history, err := rest.GetHistory(
cc.Channel.Id,
&request.Query{
AccountId: account.Id,
},
ses.ClientId,
)
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 2)
// add participant
_, err = rest.AddChannelParticipant(cc.Channel.Id, ses.ClientId, recipient.Id)
So(err, ShouldBeNil)
history, err = rest.GetHistory(
cc.Channel.Id,
&request.Query{
AccountId: account.Id,
},
ses.ClientId,
)
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 3)
So(history.MessageList[0].Message, ShouldNotBeNil)
So(history.MessageList[0].Message.TypeConstant, ShouldEqual, models.ChannelMessage_TYPE_SYSTEM)
So(history.MessageList[0].Message.Payload, ShouldNotBeNil)
addedBy, ok := history.MessageList[0].Message.Payload["addedBy"]
So(ok, ShouldBeTrue)
So(*addedBy, ShouldEqual, account.Nick)
systemType, ok := history.MessageList[0].Message.Payload["systemType"]
So(ok, ShouldBeTrue)
So(*systemType, ShouldEqual, models.ChannelRequestMessage_TYPE_JOIN)
// we set link_embed into the payloadof the system message above.
// But system message payload data will not have payload defined
// by client side or else
// As a result, system message will not be able to have link_embed payload data
_, k := history.MessageList[0].Message.Payload["link_embed"]
So(k, ShouldBeFalse)
// try to add same participant
_, err = rest.AddChannelParticipant(cc.Channel.Id, ses.ClientId, recipient.Id)
So(err, ShouldBeNil)
history, err = rest.GetHistory(
cc.Channel.Id,
&request.Query{
AccountId: account.Id,
},
ses.ClientId,
)
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 3)
})
Convey("user should not be able to edit join messages", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "test private message participants again"
pmr.GroupName = groupName
pmr.Recipients = []string{"devrim"}
cc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cc, ShouldNotBeNil)
_, err = rest.AddChannelParticipant(cc.Channel.Id, ses.ClientId, recipient.Id)
So(err, ShouldBeNil)
ses, err := modelhelper.FetchOrCreateSession(account.Nick, groupName)
So(err, ShouldBeNil)
So(ses, ShouldNotBeNil)
history, err := rest.GetHistory(
cc.Channel.Id,
&request.Query{
AccountId: account.Id,
},
ses.ClientId,
)
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 3)
joinMessage := history.MessageList[0].Message
So(joinMessage, ShouldNotBeNil)
_, err = rest.UpdatePost(joinMessage, ses.ClientId)
So(err, ShouldNotBeNil)
})
Convey("first chat message should include initial participants", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "test initial participation message"
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan", "devrim"}
cc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cc, ShouldNotBeNil)
ses, err := modelhelper.FetchOrCreateSession(account.Nick, groupName)
So(err, ShouldBeNil)
So(ses, ShouldNotBeNil)
history, err := rest.GetHistory(
cc.Channel.Id,
&request.Query{
AccountId: account.Id,
},
ses.ClientId,
)
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 2)
joinMessage := history.MessageList[1].Message
So(joinMessage.TypeConstant, ShouldEqual, models.ChannelMessage_TYPE_SYSTEM)
So(joinMessage.Payload, ShouldNotBeNil)
initialParticipants, ok := joinMessage.Payload["initialParticipants"]
So(ok, ShouldBeTrue)
systemType, ok := history.MessageList[1].Message.Payload["systemType"]
So(ok, ShouldBeTrue)
So(*systemType, ShouldEqual, models.ChannelRequestMessage_TYPE_INIT)
participants := make([]string, 0)
err = json.Unmarshal([]byte(*initialParticipants), &participants)
So(err, ShouldBeNil)
So(len(participants), ShouldEqual, 2)
So(participants, ShouldContain, "devrim")
// So(*addedBy, ShouldEqual, account.OldId)
})
Convey("targetted account should be able to list private message channel of himself", nil)
})
})
}
func TestCollaborationChannels(t *testing.T) {
tests.WithRunner(t, func(r *runner.Runner) {
Convey("while testing collaboration channel", t, func() {
devrim, err := models.CreateAccountInBothDbsWithNick("devrim")
So(err, ShouldBeNil)
So(devrim, ShouldNotBeNil)
sinan, err := models.CreateAccountInBothDbsWithNick("sinan")
So(err, ShouldBeNil)
So(sinan, ShouldNotBeNil)
groupName := models.RandomGroupName()
// cretae admin user
account, err := models.CreateAccountInBothDbs()
tests.ResultedWithNoErrorCheck(account, err)
// fetch admin's session
ses, err := modelhelper.FetchOrCreateSession(account.Nick, groupName)
So(err, ShouldBeNil)
So(ses, ShouldNotBeNil)
groupChannel := models.CreateTypedGroupedChannelWithTest(
account.Id,
models.Channel_TYPE_GROUP,
groupName,
)
groupChannel.AddParticipant(account.Id)
_, err = groupChannel.AddParticipant(devrim.Id)
So(err, ShouldBeNil)
_, err = groupChannel.AddParticipant(sinan.Id)
So(err, ShouldBeNil)
recipient, err := models.CreateAccountInBothDbs()
tests.ResultedWithNoErrorCheck(recipient, err)
recipient2, err := models.CreateAccountInBothDbs()
tests.ResultedWithNoErrorCheck(recipient2, err)
Convey("one can send initiate the collaboration channel with only him", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body for private message"
pmr.GroupName = groupName
pmr.Recipients = []string{}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
})
Convey("one can send initiate the collaboration channel with 2 participants", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body message for private message @devrim @sinan"
pmr.GroupName = groupName
pmr.Recipients = []string{"devrim", "sinan"}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
})
Convey("if group name is nil, should not fail to create collaboration channel", func() {
ses, err := modelhelper.FetchOrCreateSession(sinan.Nick, "koding")
So(err, ShouldBeNil)
So(ses, ShouldNotBeNil)
groupChannel, err := rest.CreateChannelByGroupNameAndType(
sinan.Id,
"koding",
models.Channel_TYPE_GROUP,
ses.ClientId,
)
tests.ResultedWithNoErrorCheck(groupChannel, err)
groupChannel.AddParticipant(devrim.Id) // ignore error
groupChannel.AddParticipant(account.Id) // ignore error
groupChannel.AddParticipant(sinan.Id) // ignore error
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body for private message @devrim @sinan"
pmr.GroupName = ""
pmr.Recipients = []string{"devrim", "sinan"}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
})
// we give token as parameter to SendPrivateChannelRequest
// handler sets the accountId and groupname if not defined in handler's function
// So it should not return any error unless account is defined
Convey("if sender is not defined should not fail to create collaboration channel", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = 0
pmr.Body = "this is a body for private message"
pmr.GroupName = ""
pmr.Recipients = []string{}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
})
Convey("one can send private message to multiple person", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body for private message @sinan"
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan"}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
})
Convey("response should have created channel", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body for private message @devrim @sinan"
pmr.GroupName = groupName
pmr.Recipients = []string{"devrim", "sinan"}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
So(cmc.Channel.TypeConstant, ShouldEqual, models.Channel_TYPE_COLLABORATION)
So(cmc.Channel.Id, ShouldBeGreaterThan, 0)
So(cmc.Channel.GroupName, ShouldEqual, groupName)
So(cmc.Channel.PrivacyConstant, ShouldEqual, models.Channel_PRIVACY_PRIVATE)
})
Convey("send response should have participant status data", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body for private message @devrim @sinan"
pmr.GroupName = groupName
pmr.Recipients = []string{"devrim", "sinan"}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
So(cmc.IsParticipant, ShouldBeTrue)
})
Convey("send response should have participant count", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is a body for @sinan private message @devrim"
pmr.GroupName = groupName
pmr.Recipients = []string{"devrim", "sinan"}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
So(cmc.ParticipantCount, ShouldEqual, 3)
})
Convey("send response should have participant preview", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "this is @sinan a body for @devrim private message"
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan", "devrim"}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
So(len(cmc.ParticipantsPreview), ShouldEqual, 3)
})
Convey("send response should have last Message", func() {
body := "hi @devrim this is a body for private message also for @sinan"
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = body
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan", "devrim"}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
So(cmc.LastMessage.Message.Body, ShouldEqual, body)
})
Convey("channel messages should be listed by all recipients", func() {
// // use a different group name
// // in order not to interfere with another request
// groupName := "testgroup" + strconv.FormatInt(rand.Int63(), 10)
body := "hi @devrim this is a body for private message also for @sinan"
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = body
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan", "devrim"}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cmc, ShouldNotBeNil)
query := &request.Query{
AccountId: account.Id,
GroupName: groupName,
Type: models.Channel_TYPE_COLLABORATION,
}
pm, err := rest.GetPrivateChannels(query, ses.ClientId)
So(err, ShouldBeNil)
So(pm, ShouldNotBeNil)
So(len(pm), ShouldNotEqual, 0)
So(pm[0], ShouldNotBeNil)
So(pm[0].Channel.TypeConstant, ShouldEqual, models.Channel_TYPE_COLLABORATION)
So(pm[0].Channel.Id, ShouldEqual, cmc.Channel.Id)
So(pm[0].Channel.GroupName, ShouldEqual, cmc.Channel.GroupName)
So(pm[0].LastMessage.Message.Body, ShouldEqual, cmc.LastMessage.Message.Body)
So(pm[0].Channel.PrivacyConstant, ShouldEqual, models.Channel_PRIVACY_PRIVATE)
So(len(pm[0].ParticipantsPreview), ShouldEqual, 3)
So(pm[0].IsParticipant, ShouldBeTrue)
})
Convey("user should be able to search collaboration channels via purpose field", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "search collaboration channel"
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan", "devrim"}
pmr.Purpose = "test me up"
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cmc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
query := request.Query{
AccountId: account.Id,
GroupName: groupName,
Type: models.Channel_TYPE_COLLABORATION,
}
_, err = rest.SearchPrivateChannels(&query, ses.ClientId)
So(err, ShouldNotBeNil)
query.Name = "test"
pm, err := rest.SearchPrivateChannels(&query, ses.ClientId)
So(err, ShouldBeNil)
So(pm, ShouldNotBeNil)
So(len(pm), ShouldNotEqual, 0)
So(pm[0], ShouldNotBeNil)
So(pm[0].Channel.TypeConstant, ShouldEqual, models.Channel_TYPE_COLLABORATION)
So(pm[0].Channel.Id, ShouldEqual, cmc.Channel.Id)
So(pm[0].Channel.GroupName, ShouldEqual, cmc.Channel.GroupName)
So(pm[0].LastMessage.Message.Body, ShouldEqual, cmc.LastMessage.Message.Body)
So(pm[0].Channel.PrivacyConstant, ShouldEqual, models.Channel_PRIVACY_PRIVATE)
So(pm[0].IsParticipant, ShouldBeTrue)
})
Convey("user join activity should be listed by recipients", func() {
groupName := models.RandomGroupName()
// cretae admin user
account, err := models.CreateAccountInBothDbs()
tests.ResultedWithNoErrorCheck(account, err)
// fetch admin's session
ses, err := modelhelper.FetchOrCreateSession(account.Nick, groupName)
So(err, ShouldBeNil)
So(ses, ShouldNotBeNil)
groupChannel := models.CreateTypedGroupedChannelWithTest(
account.Id,
models.Channel_TYPE_GROUP,
groupName,
)
So(groupChannel, ShouldNotBeNil)
_, err = groupChannel.AddParticipant(account.Id)
So(err, ShouldBeNil)
_, err = groupChannel.AddParticipant(devrim.Id)
So(err, ShouldBeNil)
_, err = groupChannel.AddParticipant(sinan.Id)
So(err, ShouldBeNil)
_, err = groupChannel.AddParticipant(recipient.Id)
So(err, ShouldBeNil)
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "test collaboration channel participants"
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan", "devrim"}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cc, ShouldNotBeNil)
history, err := rest.GetHistory(
cc.Channel.Id,
&request.Query{
AccountId: account.Id,
},
ses.ClientId,
)
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 2)
// add participant
_, err = rest.AddChannelParticipant(cc.Channel.Id, ses.ClientId, recipient.Id)
So(err, ShouldBeNil)
history, err = rest.GetHistory(
cc.Channel.Id,
&request.Query{
AccountId: account.Id,
},
ses.ClientId,
)
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 3)
So(history.MessageList[0].Message, ShouldNotBeNil)
So(history.MessageList[0].Message.TypeConstant, ShouldEqual, models.ChannelMessage_TYPE_SYSTEM)
So(history.MessageList[0].Message.Payload, ShouldNotBeNil)
addedBy, ok := history.MessageList[0].Message.Payload["addedBy"]
So(ok, ShouldBeTrue)
So(*addedBy, ShouldEqual, account.Nick)
systemType, ok := history.MessageList[0].Message.Payload["systemType"]
So(ok, ShouldBeTrue)
So(*systemType, ShouldEqual, models.ChannelRequestMessage_TYPE_JOIN)
// try to add same participant
_, err = rest.AddChannelParticipant(cc.Channel.Id, ses.ClientId, recipient.Id)
So(err, ShouldBeNil)
history, err = rest.GetHistory(
cc.Channel.Id,
&request.Query{
AccountId: account.Id,
},
ses.ClientId,
)
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 3)
})
Convey("user should not be able to edit join messages", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "test collaboration channel participants again"
pmr.GroupName = groupName
pmr.Recipients = []string{"devrim"}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cc, ShouldNotBeNil)
_, err = rest.AddChannelParticipant(cc.Channel.Id, ses.ClientId, recipient.Id)
So(err, ShouldBeNil)
ses, err := modelhelper.FetchOrCreateSession(account.Nick, groupName)
So(err, ShouldBeNil)
So(ses, ShouldNotBeNil)
history, err := rest.GetHistory(
cc.Channel.Id,
&request.Query{
AccountId: account.Id,
},
ses.ClientId,
)
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 3)
joinMessage := history.MessageList[0].Message
So(joinMessage, ShouldNotBeNil)
_, err = rest.UpdatePost(joinMessage, ses.ClientId)
So(err, ShouldNotBeNil)
})
Convey("first chat message should include initial participants", func() {
pmr := models.ChannelRequest{}
pmr.AccountId = account.Id
pmr.Body = "test initial participation message"
pmr.GroupName = groupName
pmr.Recipients = []string{"sinan", "devrim"}
pmr.TypeConstant = models.Channel_TYPE_COLLABORATION
cc, err := rest.SendPrivateChannelRequest(pmr, ses.ClientId)
So(err, ShouldBeNil)
So(cc, ShouldNotBeNil)
ses, err := modelhelper.FetchOrCreateSession(account.Nick, groupName)
So(err, ShouldBeNil)
So(ses, ShouldNotBeNil)
history, err := rest.GetHistory(
cc.Channel.Id,
&request.Query{
AccountId: account.Id,
},
ses.ClientId,
)
So(err, ShouldBeNil)
So(history, ShouldNotBeNil)
So(len(history.MessageList), ShouldEqual, 2)
joinMessage := history.MessageList[1].Message
So(joinMessage.TypeConstant, ShouldEqual, models.ChannelMessage_TYPE_SYSTEM)
So(joinMessage.Payload, ShouldNotBeNil)
initialParticipants, ok := joinMessage.Payload["initialParticipants"]
So(ok, ShouldBeTrue)
systemType, ok := history.MessageList[1].Message.Payload["systemType"]
So(ok, ShouldBeTrue)
So(*systemType, ShouldEqual, models.ChannelRequestMessage_TYPE_INIT)
participants := make([]string, 0)
err = json.Unmarshal([]byte(*initialParticipants), &participants)
So(err, ShouldBeNil)
So(len(participants), ShouldEqual, 2)
So(participants, ShouldContain, "devrim")
// So(*addedBy, ShouldEqual, account.OldId)
})
})
})
}