Exemple #1
0
func TestChannelMessageFetchMessageCount(t *testing.T) {
	tests.WithRunner(t, func(r *runner.Runner) {
		Convey("while fetching message count since the given time", t, func() {
			channel, accounts := CreateChannelWithParticipants()
			cm1 := CreateMessage(channel.Id, accounts[0].Id, ChannelMessage_TYPE_PRIVATE_MESSAGE)
			CreateMessage(channel.Id, accounts[1].Id, ChannelMessage_TYPE_PRIVATE_MESSAGE)
			CreateMessage(channel.Id, accounts[0].Id, ChannelMessage_TYPE_PRIVATE_MESSAGE)
			CreateMessage(channel.Id, accounts[0].Id, ChannelMessage_TYPE_PRIVATE_MESSAGE)

			query := request.NewQuery()
			query.Type = ChannelMessage_TYPE_PRIVATE_MESSAGE
			query.GroupChannelId = channel.Id
			query.From = cm1.CreatedAt

			Convey("first user should see 4 messages when their account is not excluded", func() {
				c := NewChannelMessage()
				count, err := c.FetchTotalMessageCount(query)
				So(err, ShouldBeNil)
				So(count, ShouldEqual, 4)
			})

			Convey("second user should see 3 messages then their account is excluded", func() {
				c := NewChannelMessage()
				query.ExcludeField("AccountId", accounts[1].Id)
				count, err := c.FetchTotalMessageCount(query)
				So(err, ShouldBeNil)
				So(count, ShouldEqual, 3)
			})
		})
	})
}
Exemple #2
0
func FetchPostCount(u *url.URL, h http.Header, _ interface{}, context *models.Context) (int, http.Header, interface{}, error) {
	query := request.GetQuery(u)
	query = context.OverrideQuery(query)

	accountId, err := request.GetId(u)
	if err != nil {
		return response.NewBadRequest(err)
	}

	c, err := models.Cache.Channel.ByGroupName(query.GroupName)
	if err != nil {
		return response.NewBadRequest(err)
	}

	// fetch user post count in koding channel
	q := request.NewQuery()
	q.AccountId = accountId
	q.Type = models.ChannelMessage_TYPE_POST
	q.GroupChannelId = c.Id
	cm := models.NewChannelMessage()

	count, err := cm.FetchTotalMessageCount(q)
	if err != nil {
		return response.NewBadRequest(err)
	}

	res := new(models.CountResponse)
	res.TotalCount = count

	return response.NewOK(res)
}
Exemple #3
0
func TestChannelMessageFetchLatestMessages(t *testing.T) {
	tests.WithRunner(t, func(r *runner.Runner) {
		Convey("while fetching latest messages of a channel with three participants and four messages", t, func() {
			channel, accounts := CreateChannelWithParticipants()
			cm1 := CreateMessage(channel.Id, accounts[0].Id, ChannelMessage_TYPE_PRIVATE_MESSAGE)
			cm2 := CreateMessage(channel.Id, accounts[1].Id, ChannelMessage_TYPE_PRIVATE_MESSAGE)
			cm3 := CreateMessage(channel.Id, accounts[0].Id, ChannelMessage_TYPE_PRIVATE_MESSAGE)
			cm4 := CreateMessage(channel.Id, accounts[0].Id, ChannelMessage_TYPE_PRIVATE_MESSAGE)

			query := request.NewQuery()
			query.Limit = 3
			query.AddSortField("CreatedAt", request.ORDER_DESC)
			query.Type = ChannelMessage_TYPE_PRIVATE_MESSAGE

			Convey("first user should see last three messages when no parameters are set", func() {
				c := NewChannelMessage()
				cms, err := c.FetchMessagesByChannelId(channel.Id, query)
				So(err, ShouldBeNil)
				So(len(cms), ShouldEqual, 3)
				So(cms[2].Id, ShouldEqual, cm2.Id)
			})

			Convey("first user should see one message when their account id is excluded", func() {
				query.ExcludeField("AccountId", cm1.AccountId)
				c := NewChannelMessage()
				cms, err := c.FetchMessagesByChannelId(channel.Id, query)
				So(err, ShouldBeNil)
				So(len(cms), ShouldEqual, 1)
				So(cms[0].Id, ShouldEqual, cm2.Id)
			})

			Convey("second user should see two messages starting with their own message", func() {
				c := NewChannelMessage()
				query.ExcludeField("AccountId", cm2.AccountId)
				query.From = cm2.CreatedAt

				cms, err := c.FetchMessagesByChannelId(channel.Id, query)
				So(err, ShouldBeNil)
				So(len(cms), ShouldEqual, 2)
				So(cms[0].Id, ShouldEqual, cm4.Id)
				So(cms[1].Id, ShouldEqual, cm3.Id)
			})

			Convey("third user should see three messages when all parameters are set", func() {
				c := NewChannelMessage()
				query.ExcludeField("AccountId", accounts[2].Id)
				query.From = cm1.CreatedAt

				cms, err := c.FetchMessagesByChannelId(channel.Id, query)
				So(err, ShouldBeNil)
				So(len(cms), ShouldEqual, 3)
				So(cms[0].Id, ShouldEqual, cm4.Id)
				So(cms[1].Id, ShouldEqual, cm3.Id)
				So(cms[2].Id, ShouldEqual, cm2.Id)
			})
		})
	})
}
Exemple #4
0
func CacheForChannel(id int64) (string, error) {
	query := request.NewQuery().SetDefaults()
	cc, err := BuildChannelContainer(id, query)
	d, err := json.Marshal(cc)
	if err != nil {
		return "", err
	}

	return string(d), nil
}
Exemple #5
0
func CacheForChannelMessage(id int64) (string, error) {
	query := request.NewQuery().SetDefaults()
	// no need to add IsInteracted data into cache
	query.AddIsInteracted = false
	cmc, err := BuildChannelMessageContainer(id, query)
	d, err := json.Marshal(cmc)
	if err != nil {
		return "", err
	}

	return string(d), err
}
Exemple #6
0
func New(log logging.Logger, client algoliasearch.Client, indexSuffix string) *Controller {
	// TODO later on listen channel_participant_added event and remove this koding channel fetch
	c := models.NewChannel()
	q := request.NewQuery()
	q.GroupName = "koding"
	q.Name = "public"
	q.Type = models.Channel_TYPE_GROUP

	channel, err := c.ByName(q)
	if err != nil {
		log.Error("Could not fetch koding channel: %s:", err)
	}
	var channelId string
	if channel.Id != 0 {
		channelId = strconv.FormatInt(channel.Id, 10)
	}

	controller := &Controller{
		log:    log,
		client: client,
		indexes: &IndexSet{
			IndexTopics: &IndexSetItem{
				Index: client.InitIndex(IndexTopics + indexSuffix),
				Settings: &Settings{
					// empty slice means all properties will be searchable
					AttributesToIndex: []string{},
				},
			},
			IndexAccounts: &IndexSetItem{
				Index: client.InitIndex(IndexAccounts + indexSuffix),
				Settings: &Settings{
					AttributesToIndex: []string{
						"nick",
						"email",
						"firstName",
						"lastName",
						"_tags",
					},
					UnretrievableAttributes: []string{"email"},
				},
			},
			IndexMessages: &IndexSetItem{
				Index: client.InitIndex(IndexMessages + indexSuffix),
				Settings: &Settings{
					AttributesToIndex: []string{},
				},
			},
		},
		kodingChannelId: channelId,
	}

	return controller
}
Exemple #7
0
func (m *MessageReply) ListAll() ([]ChannelMessage, error) {
	query := request.NewQuery()
	query.Limit = 0
	query.Skip = 0
	return m.fetchMessages(query)
}
Exemple #8
0
func TestChannelByParticipants(t *testing.T) {
	tests.WithRunner(t, func(r *runner.Runner) {

		appConfig := config.MustRead(r.Conf.Path)
		modelhelper.Initialize(appConfig.Mongo)
		defer modelhelper.Close()

		Convey("while fetching channels by their participants", t, func() {
			_, _, groupName := CreateRandomGroupDataWithChecks()

			Convey("group name should be set in query", func() {
				q := request.NewQuery()
				q.GroupName = ""

				c := NewChannel()
				_, err := c.ByParticipants([]int64{}, q)
				So(err, ShouldNotBeNil)
				So(err, ShouldEqual, ErrGroupNameIsNotSet)
			})

			Convey("at least one participant should be passed", func() {
				q := request.NewQuery()
				q.GroupName = groupName

				c := NewChannel()
				_, err := c.ByParticipants([]int64{}, q)
				So(err, ShouldNotBeNil)
				So(err, ShouldEqual, ErrChannelParticipantIsNotSet)
			})

			acc1 := CreateAccountWithTest()
			acc2 := CreateAccountWithTest()
			acc3 := CreateAccountWithTest()

			tc1 := CreateTypedGroupedChannelWithTest(
				acc1.Id,
				Channel_TYPE_TOPIC,
				groupName,
			)
			AddParticipantsWithTest(tc1.Id, acc1.Id, acc2.Id, acc3.Id)

			tc2 := CreateTypedGroupedChannelWithTest(
				acc1.Id,
				Channel_TYPE_TOPIC,
				groupName,
			)
			AddParticipantsWithTest(tc2.Id, acc1.Id, acc2.Id, acc3.Id)

			Convey("ordering should be working by channel created_at", func() {
				q := request.NewQuery()
				q.GroupName = groupName
				q.Type = Channel_TYPE_TOPIC

				c := NewChannel()
				channels, err := c.ByParticipants([]int64{acc1.Id, acc2.Id, acc3.Id}, q)
				So(err, ShouldBeNil)
				So(len(channels), ShouldEqual, 2)
				So(channels[0].Id, ShouldEqual, tc1.Id)
				So(channels[1].Id, ShouldEqual, tc2.Id)
			})

			Convey("skip options should be working", func() {
				q := request.NewQuery()
				q.GroupName = groupName
				q.Type = Channel_TYPE_TOPIC
				q.Skip = 1

				c := NewChannel()
				channels, err := c.ByParticipants([]int64{acc1.Id, acc2.Id, acc3.Id}, q)
				So(err, ShouldBeNil)
				So(len(channels), ShouldEqual, 1)
				So(channels[0].Id, ShouldEqual, tc2.Id)
			})

			Convey("limit options should be working", func() {
				q := request.NewQuery()
				q.GroupName = groupName
				q.Type = Channel_TYPE_TOPIC
				q.Limit = 1

				c := NewChannel()
				channels, err := c.ByParticipants([]int64{acc1.Id, acc2.Id, acc3.Id}, q)
				So(err, ShouldBeNil)
				So(len(channels), ShouldEqual, 1)
				So(channels[0].Id, ShouldEqual, tc1.Id)
			})

			Convey("type option should be working", func() {
				pc1 := CreateTypedGroupedChannelWithTest(
					acc1.Id,
					Channel_TYPE_PRIVATE_MESSAGE,
					groupName,
				)
				AddParticipantsWithTest(pc1.Id, acc1.Id, acc2.Id, acc3.Id)

				q := request.NewQuery()
				q.GroupName = groupName
				q.Type = Channel_TYPE_PRIVATE_MESSAGE

				c := NewChannel()
				channels, err := c.ByParticipants([]int64{acc1.Id, acc2.Id, acc3.Id}, q)
				So(err, ShouldBeNil)
				So(len(channels), ShouldEqual, 1)
				So(channels[0].Id, ShouldEqual, pc1.Id)
			})

			Convey("all channels should be active", func() {
				// delete the second channel
				So(tc2.Delete(), ShouldBeNil)

				q := request.NewQuery()
				q.GroupName = groupName
				q.Type = Channel_TYPE_TOPIC

				c := NewChannel()
				channels, err := c.ByParticipants([]int64{acc1.Id, acc2.Id, acc3.Id}, q)
				So(err, ShouldBeNil)
				So(len(channels), ShouldEqual, 1)
				So(channels[0].Id, ShouldEqual, tc1.Id)
			})

			Convey("all members should be active", func() {
				// delete the second participant from second channel
				So(tc2.RemoveParticipant(acc2.Id), ShouldBeNil)

				q := request.NewQuery()
				q.GroupName = groupName
				q.Type = Channel_TYPE_TOPIC

				c := NewChannel()
				channels, err := c.ByParticipants([]int64{acc1.Id, acc2.Id, acc3.Id}, q)
				So(err, ShouldBeNil)
				So(len(channels), ShouldEqual, 1)
				So(channels[0].Id, ShouldEqual, tc1.Id)
			})

			Convey("if the members are also in other groups", func() {
				Convey("group context should be working", func() {
					_, _, groupName := CreateRandomGroupDataWithChecks()

					tc1 := CreateTypedGroupedChannelWithTest(
						acc1.Id,
						Channel_TYPE_TOPIC,
						groupName,
					)
					AddParticipantsWithTest(tc1.Id, acc1.Id, acc2.Id, acc3.Id)

					tc2 := CreateTypedGroupedChannelWithTest(
						acc1.Id,
						Channel_TYPE_TOPIC,
						groupName,
					)
					AddParticipantsWithTest(tc2.Id, acc1.Id, acc2.Id, acc3.Id)

					q := request.NewQuery()
					q.GroupName = groupName
					q.Type = Channel_TYPE_TOPIC

					c := NewChannel()
					channels, err := c.ByParticipants([]int64{acc1.Id, acc2.Id, acc3.Id}, q)
					So(err, ShouldBeNil)
					So(len(channels), ShouldEqual, 2)
					So(channels[0].GroupName, ShouldEqual, groupName)
				})
			})
		})
	})
}
Exemple #9
0
func TestPresenceDailyFetchActiveAccounts(t *testing.T) {
	tests.WithRunner(t, func(r *runner.Runner) {
		Convey("With given presence data", t, func() {
			acc1, _, groupName := CreateRandomGroupDataWithChecks()

			gr, err := modelhelper.GetGroup(groupName)
			tests.ResultedWithNoErrorCheck(gr, err)
			err = modelhelper.MakeAdmin(bson.ObjectIdHex(acc1.OldId), gr.Id)
			So(err, ShouldBeNil)

			p1 := &PresenceDaily{
				AccountId: acc1.Id,
				GroupName: groupName,
				CreatedAt: time.Now().UTC(),
			}
			So(p1.Create(), ShouldBeNil)
			ses, err := modelhelper.FetchOrCreateSession(acc1.Nick, groupName)
			So(err, ShouldBeNil)
			So(ses, ShouldNotBeNil)

			for i := 0; i < 5; i++ {
				// create accounts
				acc2 := CreateAccountInBothDbsWithCheck()

				// add them to presence
				p1 := &PresenceDaily{
					AccountId: acc2.Id,
					GroupName: groupName,
					CreatedAt: time.Now().UTC(),
				}
				So(p1.Create(), ShouldBeNil)
			}

			Convey("FetchActiveAccounts should not work properly if query is nil", func() {
				query := request.NewQuery()
				c1, err := (&PresenceDaily{}).FetchActiveAccounts(query)
				So(err, ShouldNotBeNil)
				So(c1, ShouldBeNil)

				Convey("FetchActiveAccounts should work properly", func() {
					query := request.NewQuery().SetDefaults()
					query.GroupName = groupName
					c1, err := (&PresenceDaily{}).FetchActiveAccounts(query)
					So(err, ShouldBeNil)
					So(c1, ShouldNotBeNil)
				})

				Convey("Pagination skip should work properly", func() {
					query := request.NewQuery().SetDefaults()
					query.GroupName = groupName
					query.Skip = 20
					c1, err := (&PresenceDaily{}).FetchActiveAccounts(query)
					So(err, ShouldNotBeNil)
					So(err, ShouldEqual, bongo.RecordNotFound)
					So(c1, ShouldBeNil)

					Convey("Pagination limit should work properly", func() {
						query := request.NewQuery().SetDefaults()
						query.GroupName = groupName
						query.Limit = 4
						c1, err := (&PresenceDaily{}).FetchActiveAccounts(query)
						So(err, ShouldBeNil)
						So(c1, ShouldNotBeNil)
						So(len(c1.Accounts), ShouldEqual, 4)
					})
				})
			})
		})
	})
}