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