// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved. // See License.txt for license information. package storetest import ( "sort" "strings" "testing" "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/mattermost/gorp" "github.com/mattermost/mattermost-server/model" "github.com/mattermost/mattermost-server/store" ) type SqlSupplier interface { GetMaster() *gorp.DbMap } func TestChannelStore(t *testing.T, ss store.Store, s SqlSupplier) { createDefaultRoles(t, ss) t.Run("Save", func(t *testing.T) { testChannelStoreSave(t, ss) }) t.Run("SaveDirectChannel", func(t *testing.T) { testChannelStoreSaveDirectChannel(t, ss) }) t.Run("CreateDirectChannel", func(t *testing.T) { testChannelStoreCreateDirectChannel(t, ss) }) t.Run("Update", func(t *testing.T) { testChannelStoreUpdate(t, ss) }) t.Run("GetChannelUnread", func(t *testing.T) { testGetChannelUnread(t, ss) }) t.Run("Get", func(t *testing.T) { testChannelStoreGet(t, ss) }) t.Run("GetForPost", func(t *testing.T) { testChannelStoreGetForPost(t, ss) }) t.Run("Restore", func(t *testing.T) { testChannelStoreRestore(t, ss) }) t.Run("Delete", func(t *testing.T) { testChannelStoreDelete(t, ss) }) t.Run("GetByName", func(t *testing.T) { testChannelStoreGetByName(t, ss) }) t.Run("GetByNames", func(t *testing.T) { testChannelStoreGetByNames(t, ss) }) t.Run("GetDeletedByName", func(t *testing.T) { testChannelStoreGetDeletedByName(t, ss) }) t.Run("GetDeleted", func(t *testing.T) { testChannelStoreGetDeleted(t, ss) }) t.Run("ChannelMemberStore", func(t *testing.T) { testChannelMemberStore(t, ss) }) t.Run("ChannelDeleteMemberStore", func(t *testing.T) { testChannelDeleteMemberStore(t, ss) }) t.Run("GetChannels", func(t *testing.T) { testChannelStoreGetChannels(t, ss) }) t.Run("GetMoreChannels", func(t *testing.T) { testChannelStoreGetMoreChannels(t, ss) }) t.Run("GetPublicChannelsForTeam", func(t *testing.T) { testChannelStoreGetPublicChannelsForTeam(t, ss) }) t.Run("GetPublicChannelsByIdsForTeam", func(t *testing.T) { testChannelStoreGetPublicChannelsByIdsForTeam(t, ss) }) t.Run("GetChannelCounts", func(t *testing.T) { testChannelStoreGetChannelCounts(t, ss) }) t.Run("GetMembersForUser", func(t *testing.T) { testChannelStoreGetMembersForUser(t, ss) }) t.Run("UpdateLastViewedAt", func(t *testing.T) { testChannelStoreUpdateLastViewedAt(t, ss) }) t.Run("IncrementMentionCount", func(t *testing.T) { testChannelStoreIncrementMentionCount(t, ss) }) t.Run("UpdateChannelMember", func(t *testing.T) { testUpdateChannelMember(t, ss) }) t.Run("GetMember", func(t *testing.T) { testGetMember(t, ss) }) t.Run("GetMemberForPost", func(t *testing.T) { testChannelStoreGetMemberForPost(t, ss) }) t.Run("GetMemberCount", func(t *testing.T) { testGetMemberCount(t, ss) }) t.Run("SearchMore", func(t *testing.T) { testChannelStoreSearchMore(t, ss) }) t.Run("SearchInTeam", func(t *testing.T) { testChannelStoreSearchInTeam(t, ss) }) t.Run("AutocompleteInTeamForSearch", func(t *testing.T) { testChannelStoreAutocompleteInTeamForSearch(t, ss) }) t.Run("GetMembersByIds", func(t *testing.T) { testChannelStoreGetMembersByIds(t, ss) }) t.Run("AnalyticsDeletedTypeCount", func(t *testing.T) { testChannelStoreAnalyticsDeletedTypeCount(t, ss) }) t.Run("GetPinnedPosts", func(t *testing.T) { testChannelStoreGetPinnedPosts(t, ss) }) t.Run("MaxChannelsPerTeam", func(t *testing.T) { testChannelStoreMaxChannelsPerTeam(t, ss) }) t.Run("GetChannelsByScheme", func(t *testing.T) { testChannelStoreGetChannelsByScheme(t, ss) }) t.Run("MigrateChannelMembers", func(t *testing.T) { testChannelStoreMigrateChannelMembers(t, ss) }) t.Run("ResetAllChannelSchemes", func(t *testing.T) { testResetAllChannelSchemes(t, ss) }) t.Run("ClearAllCustomRoleAssignments", func(t *testing.T) { testChannelStoreClearAllCustomRoleAssignments(t, ss) }) t.Run("MaterializedPublicChannels", func(t *testing.T) { testMaterializedPublicChannels(t, ss, s) }) t.Run("GetAllChannelsForExportAfter", func(t *testing.T) { testChannelStoreGetAllChannelsForExportAfter(t, ss) }) t.Run("GetChannelMembersForExport", func(t *testing.T) { testChannelStoreGetChannelMembersForExport(t, ss) }) t.Run("RemoveAllDeactivatedMembers", func(t *testing.T) { testChannelStoreRemoveAllDeactivatedMembers(t, ss) }) } func testChannelStoreSave(t *testing.T, ss store.Store) { teamId := model.NewId() o1 := model.Channel{} o1.TeamId = teamId o1.DisplayName = "Name" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN if err := (<-ss.Channel().Save(&o1, -1)).Err; err != nil { t.Fatal("couldn't save item", err) } if err := (<-ss.Channel().Save(&o1, -1)).Err; err == nil { t.Fatal("shouldn't be able to update from save") } o1.Id = "" if err := (<-ss.Channel().Save(&o1, -1)).Err; err == nil { t.Fatal("should be unique name") } o1.Id = "" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_DIRECT if err := (<-ss.Channel().Save(&o1, -1)).Err; err == nil { t.Fatal("Should not be able to save direct channel") } } func testChannelStoreSaveDirectChannel(t *testing.T, ss store.Store) { teamId := model.NewId() o1 := model.Channel{} o1.TeamId = teamId o1.DisplayName = "Name" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_DIRECT u1 := &model.User{} u1.Email = MakeEmail() u1.Nickname = model.NewId() store.Must(ss.User().Save(u1)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u1.Id}, -1)) u2 := &model.User{} u2.Email = MakeEmail() u2.Nickname = model.NewId() store.Must(ss.User().Save(u2)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u2.Id}, -1)) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = u1.Id m1.NotifyProps = model.GetDefaultChannelNotifyProps() m2 := model.ChannelMember{} m2.ChannelId = o1.Id m2.UserId = u2.Id m2.NotifyProps = model.GetDefaultChannelNotifyProps() if err := (<-ss.Channel().SaveDirectChannel(&o1, &m1, &m2)).Err; err != nil { t.Fatal("couldn't save direct channel", err) } members := (<-ss.Channel().GetMembers(o1.Id, 0, 100)).Data.(*model.ChannelMembers) if len(*members) != 2 { t.Fatal("should have saved 2 members") } if err := (<-ss.Channel().SaveDirectChannel(&o1, &m1, &m2)).Err; err == nil { t.Fatal("shouldn't be able to update from save") } // Attempt to save a direct channel that already exists o1a := model.Channel{ TeamId: o1.TeamId, DisplayName: o1.DisplayName, Name: o1.Name, Type: o1.Type, } if result := <-ss.Channel().SaveDirectChannel(&o1a, &m1, &m2); result.Err == nil { t.Fatal("should've failed to save a duplicate direct channel") } else if result.Err.Id != store.CHANNEL_EXISTS_ERROR { t.Fatal("should've returned CHANNEL_EXISTS_ERROR") } else if returned := result.Data.(*model.Channel); returned.Id != o1.Id { t.Fatal("should've returned original channel when saving a duplicate direct channel") } // Attempt to save a non-direct channel o1.Id = "" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN if err := (<-ss.Channel().SaveDirectChannel(&o1, &m1, &m2)).Err; err == nil { t.Fatal("Should not be able to save non-direct channel") } // Save yourself Direct Message o1.Id = "" o1.DisplayName = "Myself" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_DIRECT if err := (<-ss.Channel().SaveDirectChannel(&o1, &m1, &m1)).Err; err != nil { t.Fatal("couldn't save direct channel", err) } members = (<-ss.Channel().GetMembers(o1.Id, 0, 100)).Data.(*model.ChannelMembers) if len(*members) != 1 { t.Fatal("should have saved just 1 member") } } func testChannelStoreCreateDirectChannel(t *testing.T, ss store.Store) { u1 := &model.User{} u1.Email = MakeEmail() u1.Nickname = model.NewId() store.Must(ss.User().Save(u1)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u1.Id}, -1)) u2 := &model.User{} u2.Email = MakeEmail() u2.Nickname = model.NewId() store.Must(ss.User().Save(u2)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u2.Id}, -1)) res := <-ss.Channel().CreateDirectChannel(u1.Id, u2.Id) if res.Err != nil { t.Fatal("couldn't create direct channel", res.Err) } c1 := res.Data.(*model.Channel) defer func() { <-ss.Channel().PermanentDeleteMembersByChannel(c1.Id) <-ss.Channel().PermanentDelete(c1.Id) }() members := (<-ss.Channel().GetMembers(c1.Id, 0, 100)).Data.(*model.ChannelMembers) if len(*members) != 2 { t.Fatal("should have saved 2 members") } } func testChannelStoreUpdate(t *testing.T, ss store.Store) { o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Name" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o1, -1)) o2 := model.Channel{} o2.TeamId = o1.TeamId o2.DisplayName = "Name" o2.Name = "zz" + model.NewId() + "b" o2.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o2, -1)) time.Sleep(100 * time.Millisecond) if err := (<-ss.Channel().Update(&o1)).Err; err != nil { t.Fatal(err) } o1.DeleteAt = 100 if err := (<-ss.Channel().Update(&o1)).Err; err == nil { t.Fatal("Update should have failed because channel is archived") } o1.DeleteAt = 0 o1.Id = "missing" if err := (<-ss.Channel().Update(&o1)).Err; err == nil { t.Fatal("Update should have failed because of missing key") } o1.Id = model.NewId() if err := (<-ss.Channel().Update(&o1)).Err; err == nil { t.Fatal("Update should have faile because id change") } o2.Name = o1.Name if err := (<-ss.Channel().Update(&o2)).Err; err == nil { t.Fatal("Update should have failed because of existing name") } } func testGetChannelUnread(t *testing.T, ss store.Store) { teamId1 := model.NewId() teamId2 := model.NewId() uid := model.NewId() m1 := &model.TeamMember{TeamId: teamId1, UserId: uid} m2 := &model.TeamMember{TeamId: teamId2, UserId: uid} store.Must(ss.Team().SaveMember(m1, -1)) store.Must(ss.Team().SaveMember(m2, -1)) notifyPropsModel := model.GetDefaultChannelNotifyProps() // Setup Channel 1 c1 := &model.Channel{TeamId: m1.TeamId, Name: model.NewId(), DisplayName: "Downtown", Type: model.CHANNEL_OPEN, TotalMsgCount: 100} store.Must(ss.Channel().Save(c1, -1)) cm1 := &model.ChannelMember{ChannelId: c1.Id, UserId: m1.UserId, NotifyProps: notifyPropsModel, MsgCount: 90} store.Must(ss.Channel().SaveMember(cm1)) // Setup Channel 2 c2 := &model.Channel{TeamId: m2.TeamId, Name: model.NewId(), DisplayName: "Cultural", Type: model.CHANNEL_OPEN, TotalMsgCount: 100} store.Must(ss.Channel().Save(c2, -1)) cm2 := &model.ChannelMember{ChannelId: c2.Id, UserId: m2.UserId, NotifyProps: notifyPropsModel, MsgCount: 90, MentionCount: 5} store.Must(ss.Channel().SaveMember(cm2)) // Check for Channel 1 if resp := <-ss.Channel().GetChannelUnread(c1.Id, uid); resp.Err != nil { t.Fatal(resp.Err) } else { ch := resp.Data.(*model.ChannelUnread) if c1.Id != ch.ChannelId { t.Fatal("wrong channel id") } if teamId1 != ch.TeamId { t.Fatal("wrong team id for channel 1") } if ch.NotifyProps == nil { t.Fatal("wrong props for channel 1") } if ch.MentionCount != 0 { t.Fatal("wrong MentionCount for channel 1") } if ch.MsgCount != 10 { t.Fatal("wrong MsgCount for channel 1") } } // Check for Channel 2 if resp2 := <-ss.Channel().GetChannelUnread(c2.Id, uid); resp2.Err != nil { t.Fatal(resp2.Err) } else { ch2 := resp2.Data.(*model.ChannelUnread) if c2.Id != ch2.ChannelId { t.Fatal("wrong channel id") } if teamId2 != ch2.TeamId { t.Fatal("wrong team id") } if ch2.MentionCount != 5 { t.Fatal("wrong MentionCount for channel 2") } if ch2.MsgCount != 10 { t.Fatal("wrong MsgCount for channel 2") } } } func testChannelStoreGet(t *testing.T, ss store.Store) { o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Name" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o1, -1)) if r1 := <-ss.Channel().Get(o1.Id, false); r1.Err != nil { t.Fatal(r1.Err) } else { if r1.Data.(*model.Channel).ToJson() != o1.ToJson() { t.Fatal("invalid returned channel") } } if err := (<-ss.Channel().Get("", false)).Err; err == nil { t.Fatal("Missing id should have failed") } u1 := &model.User{} u1.Email = MakeEmail() u1.Nickname = model.NewId() store.Must(ss.User().Save(u1)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u1.Id}, -1)) u2 := model.User{} u2.Email = MakeEmail() u2.Nickname = model.NewId() store.Must(ss.User().Save(&u2)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u2.Id}, -1)) o2 := model.Channel{} o2.TeamId = model.NewId() o2.DisplayName = "Direct Name" o2.Name = "zz" + model.NewId() + "b" o2.Type = model.CHANNEL_DIRECT m1 := model.ChannelMember{} m1.ChannelId = o2.Id m1.UserId = u1.Id m1.NotifyProps = model.GetDefaultChannelNotifyProps() m2 := model.ChannelMember{} m2.ChannelId = o2.Id m2.UserId = u2.Id m2.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveDirectChannel(&o2, &m1, &m2)) if r2 := <-ss.Channel().Get(o2.Id, false); r2.Err != nil { t.Fatal(r2.Err) } else { if r2.Data.(*model.Channel).ToJson() != o2.ToJson() { t.Fatal("invalid returned channel") } } if r4 := <-ss.Channel().Get(o2.Id, true); r4.Err != nil { t.Fatal(r4.Err) } else { if r4.Data.(*model.Channel).ToJson() != o2.ToJson() { t.Fatal("invalid returned channel") } } if r3 := <-ss.Channel().GetAll(o1.TeamId); r3.Err != nil { t.Fatal(r3.Err) } else { channels := r3.Data.([]*model.Channel) if len(channels) == 0 { t.Fatal("too little") } } if r3 := <-ss.Channel().GetTeamChannels(o1.TeamId); r3.Err != nil { t.Fatal(r3.Err) } else { channels := r3.Data.(*model.ChannelList) if len(*channels) == 0 { t.Fatal("too little") } } } func testChannelStoreGetForPost(t *testing.T, ss store.Store) { o1 := store.Must(ss.Channel().Save(&model.Channel{ TeamId: model.NewId(), DisplayName: "Name", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, }, -1)).(*model.Channel) p1 := store.Must(ss.Post().Save(&model.Post{ UserId: model.NewId(), ChannelId: o1.Id, Message: "test", })).(*model.Post) if r1 := <-ss.Channel().GetForPost(p1.Id); r1.Err != nil { t.Fatal(r1.Err) } else if r1.Data.(*model.Channel).Id != o1.Id { t.Fatal("incorrect channel returned") } } func testChannelStoreRestore(t *testing.T, ss store.Store) { o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Channel1" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o1, -1)) if r := <-ss.Channel().Delete(o1.Id, model.GetMillis()); r.Err != nil { t.Fatal(r.Err) } if r := <-ss.Channel().Get(o1.Id, false); r.Data.(*model.Channel).DeleteAt == 0 { t.Fatal("should have been deleted") } if r := <-ss.Channel().Restore(o1.Id, model.GetMillis()); r.Err != nil { t.Fatal(r.Err) } if r := <-ss.Channel().Get(o1.Id, false); r.Data.(*model.Channel).DeleteAt != 0 { t.Fatal("should have been restored") } } func testChannelStoreDelete(t *testing.T, ss store.Store) { o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Channel1" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o1, -1)) o2 := model.Channel{} o2.TeamId = o1.TeamId o2.DisplayName = "Channel2" o2.Name = "zz" + model.NewId() + "b" o2.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o2, -1)) o3 := model.Channel{} o3.TeamId = o1.TeamId o3.DisplayName = "Channel3" o3.Name = "zz" + model.NewId() + "b" o3.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o3, -1)) o4 := model.Channel{} o4.TeamId = o1.TeamId o4.DisplayName = "Channel4" o4.Name = "zz" + model.NewId() + "b" o4.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o4, -1)) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = model.NewId() m1.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m1)) m2 := model.ChannelMember{} m2.ChannelId = o2.Id m2.UserId = m1.UserId m2.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m2)) if r := <-ss.Channel().Delete(o1.Id, model.GetMillis()); r.Err != nil { t.Fatal(r.Err) } if r := <-ss.Channel().Get(o1.Id, false); r.Data.(*model.Channel).DeleteAt == 0 { t.Fatal("should have been deleted") } if r := <-ss.Channel().Delete(o3.Id, model.GetMillis()); r.Err != nil { t.Fatal(r.Err) } cresult := <-ss.Channel().GetChannels(o1.TeamId, m1.UserId, false) require.Nil(t, cresult.Err) list := cresult.Data.(*model.ChannelList) if len(*list) != 1 { t.Fatal("invalid number of channels") } cresult = <-ss.Channel().GetMoreChannels(o1.TeamId, m1.UserId, 0, 100) require.Nil(t, cresult.Err) list = cresult.Data.(*model.ChannelList) if len(*list) != 1 { t.Fatal("invalid number of channels") } cresult = <-ss.Channel().PermanentDelete(o2.Id) require.Nil(t, cresult.Err) cresult = <-ss.Channel().GetChannels(o1.TeamId, m1.UserId, false) if assert.NotNil(t, cresult.Err) { require.Equal(t, "store.sql_channel.get_channels.not_found.app_error", cresult.Err.Id) } else { require.Equal(t, &model.ChannelList{}, cresult.Data.(*model.ChannelList)) } if r := <-ss.Channel().PermanentDeleteByTeam(o1.TeamId); r.Err != nil { t.Fatal(r.Err) } } func testChannelStoreGetByName(t *testing.T, ss store.Store) { o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Name" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o1, -1)) r1 := <-ss.Channel().GetByName(o1.TeamId, o1.Name, true) if r1.Err != nil { t.Fatal(r1.Err) } else { if r1.Data.(*model.Channel).ToJson() != o1.ToJson() { t.Fatal("invalid returned channel") } } if err := (<-ss.Channel().GetByName(o1.TeamId, "", true)).Err; err == nil { t.Fatal("Missing id should have failed") } if r1 := <-ss.Channel().GetByName(o1.TeamId, o1.Name, false); r1.Err != nil { t.Fatal(r1.Err) } else { if r1.Data.(*model.Channel).ToJson() != o1.ToJson() { t.Fatal("invalid returned channel") } } if err := (<-ss.Channel().GetByName(o1.TeamId, "", false)).Err; err == nil { t.Fatal("Missing id should have failed") } store.Must(ss.Channel().Delete(r1.Data.(*model.Channel).Id, model.GetMillis())) if err := (<-ss.Channel().GetByName(o1.TeamId, r1.Data.(*model.Channel).Name, false)).Err; err == nil { t.Fatal("Deleted channel should not be returned by GetByName()") } } func testChannelStoreGetByNames(t *testing.T, ss store.Store) { o1 := model.Channel{ TeamId: model.NewId(), DisplayName: "Name", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o1, -1)) o2 := model.Channel{ TeamId: o1.TeamId, DisplayName: "Name", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o2, -1)) for index, tc := range []struct { TeamId string Names []string ExpectedIds []string }{ {o1.TeamId, []string{o1.Name}, []string{o1.Id}}, {o1.TeamId, []string{o1.Name, o2.Name}, []string{o1.Id, o2.Id}}, {o1.TeamId, nil, nil}, {o1.TeamId, []string{"foo"}, nil}, {o1.TeamId, []string{o1.Name, "foo", o2.Name, o2.Name}, []string{o1.Id, o2.Id}}, {"", []string{o1.Name, "foo", o2.Name, o2.Name}, []string{o1.Id, o2.Id}}, {"asd", []string{o1.Name, "foo", o2.Name, o2.Name}, nil}, } { r := <-ss.Channel().GetByNames(tc.TeamId, tc.Names, true) require.Nil(t, r.Err) channels := r.Data.([]*model.Channel) var ids []string for _, channel := range channels { ids = append(ids, channel.Id) } sort.Strings(ids) sort.Strings(tc.ExpectedIds) assert.Equal(t, tc.ExpectedIds, ids, "tc %v", index) } store.Must(ss.Channel().Delete(o1.Id, model.GetMillis())) store.Must(ss.Channel().Delete(o2.Id, model.GetMillis())) r := <-ss.Channel().GetByNames(o1.TeamId, []string{o1.Name}, false) require.Nil(t, r.Err) channels := r.Data.([]*model.Channel) assert.Len(t, channels, 0) } func testChannelStoreGetDeletedByName(t *testing.T, ss store.Store) { o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Name" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o1, -1)) now := model.GetMillis() store.Must(ss.Channel().Delete(o1.Id, now)) o1.DeleteAt = now o1.UpdateAt = now if r1 := <-ss.Channel().GetDeletedByName(o1.TeamId, o1.Name); r1.Err != nil { t.Fatal(r1.Err) } else { if r1.Data.(*model.Channel).ToJson() != o1.ToJson() { t.Fatal("invalid returned channel") } } if err := (<-ss.Channel().GetDeletedByName(o1.TeamId, "")).Err; err == nil { t.Fatal("Missing id should have failed") } } func testChannelStoreGetDeleted(t *testing.T, ss store.Store) { o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Channel1" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o1, -1)) store.Must(ss.Channel().Delete(o1.Id, model.GetMillis())) cresult := <-ss.Channel().GetDeleted(o1.TeamId, 0, 100) if cresult.Err != nil { t.Fatal(cresult.Err) } list := cresult.Data.(*model.ChannelList) if len(*list) != 1 { t.Fatal("wrong list") } if (*list)[0].Name != o1.Name { t.Fatal("missing channel") } o2 := model.Channel{} o2.TeamId = o1.TeamId o2.DisplayName = "Channel2" o2.Name = "zz" + model.NewId() + "b" o2.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o2, -1)) cresult = <-ss.Channel().GetDeleted(o1.TeamId, 0, 100) if cresult.Err != nil { t.Fatal(cresult.Err) } list = cresult.Data.(*model.ChannelList) if len(*list) != 1 { t.Fatal("wrong list") } o3 := model.Channel{} o3.TeamId = o1.TeamId o3.DisplayName = "Channel3" o3.Name = "zz" + model.NewId() + "b" o3.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o3, -1)) store.Must(ss.Channel().SetDeleteAt(o3.Id, model.GetMillis(), model.GetMillis())) cresult = <-ss.Channel().GetDeleted(o1.TeamId, 0, 100) if cresult.Err != nil { t.Fatal(cresult.Err) } list = cresult.Data.(*model.ChannelList) if len(*list) != 2 { t.Fatal("wrong list length") } cresult = <-ss.Channel().GetDeleted(o1.TeamId, 0, 1) if cresult.Err != nil { t.Fatal(cresult.Err) } list = cresult.Data.(*model.ChannelList) if len(*list) != 1 { t.Fatal("wrong list length") } cresult = <-ss.Channel().GetDeleted(o1.TeamId, 1, 1) if cresult.Err != nil { t.Fatal(cresult.Err) } list = cresult.Data.(*model.ChannelList) if len(*list) != 1 { t.Fatal("wrong list length") } } func testChannelMemberStore(t *testing.T, ss store.Store) { c1 := model.Channel{} c1.TeamId = model.NewId() c1.DisplayName = "NameName" c1.Name = "zz" + model.NewId() + "b" c1.Type = model.CHANNEL_OPEN c1 = *store.Must(ss.Channel().Save(&c1, -1)).(*model.Channel) c1t1 := (<-ss.Channel().Get(c1.Id, false)).Data.(*model.Channel) assert.EqualValues(t, 0, c1t1.ExtraUpdateAt, "ExtraUpdateAt should be 0") u1 := model.User{} u1.Email = MakeEmail() u1.Nickname = model.NewId() store.Must(ss.User().Save(&u1)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u1.Id}, -1)) u2 := model.User{} u2.Email = MakeEmail() u2.Nickname = model.NewId() store.Must(ss.User().Save(&u2)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u2.Id}, -1)) o1 := model.ChannelMember{} o1.ChannelId = c1.Id o1.UserId = u1.Id o1.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&o1)) o2 := model.ChannelMember{} o2.ChannelId = c1.Id o2.UserId = u2.Id o2.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&o2)) c1t2 := (<-ss.Channel().Get(c1.Id, false)).Data.(*model.Channel) assert.EqualValues(t, 0, c1t2.ExtraUpdateAt, "ExtraUpdateAt should be 0") count := (<-ss.Channel().GetMemberCount(o1.ChannelId, true)).Data.(int64) if count != 2 { t.Fatal("should have saved 2 members") } count = (<-ss.Channel().GetMemberCount(o1.ChannelId, true)).Data.(int64) if count != 2 { t.Fatal("should have saved 2 members") } if ss.Channel().GetMemberCountFromCache(o1.ChannelId) != 2 { t.Fatal("should have saved 2 members") } if ss.Channel().GetMemberCountFromCache("junk") != 0 { t.Fatal("should have saved 0 members") } count = (<-ss.Channel().GetMemberCount(o1.ChannelId, false)).Data.(int64) if count != 2 { t.Fatal("should have saved 2 members") } store.Must(ss.Channel().RemoveMember(o2.ChannelId, o2.UserId)) count = (<-ss.Channel().GetMemberCount(o1.ChannelId, false)).Data.(int64) if count != 1 { t.Fatal("should have removed 1 member") } c1t3 := (<-ss.Channel().Get(c1.Id, false)).Data.(*model.Channel) assert.EqualValues(t, 0, c1t3.ExtraUpdateAt, "ExtraUpdateAt should be 0") member := (<-ss.Channel().GetMember(o1.ChannelId, o1.UserId)).Data.(*model.ChannelMember) if member.ChannelId != o1.ChannelId { t.Fatal("should have go member") } if err := (<-ss.Channel().SaveMember(&o1)).Err; err == nil { t.Fatal("Should have been a duplicate") } c1t4 := (<-ss.Channel().Get(c1.Id, false)).Data.(*model.Channel) assert.EqualValues(t, 0, c1t4.ExtraUpdateAt, "ExtraUpdateAt should be 0") } func testChannelDeleteMemberStore(t *testing.T, ss store.Store) { c1 := model.Channel{} c1.TeamId = model.NewId() c1.DisplayName = "NameName" c1.Name = "zz" + model.NewId() + "b" c1.Type = model.CHANNEL_OPEN c1 = *store.Must(ss.Channel().Save(&c1, -1)).(*model.Channel) c1t1 := (<-ss.Channel().Get(c1.Id, false)).Data.(*model.Channel) assert.EqualValues(t, 0, c1t1.ExtraUpdateAt, "ExtraUpdateAt should be 0") u1 := model.User{} u1.Email = MakeEmail() u1.Nickname = model.NewId() store.Must(ss.User().Save(&u1)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u1.Id}, -1)) u2 := model.User{} u2.Email = MakeEmail() u2.Nickname = model.NewId() store.Must(ss.User().Save(&u2)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u2.Id}, -1)) o1 := model.ChannelMember{} o1.ChannelId = c1.Id o1.UserId = u1.Id o1.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&o1)) o2 := model.ChannelMember{} o2.ChannelId = c1.Id o2.UserId = u2.Id o2.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&o2)) c1t2 := (<-ss.Channel().Get(c1.Id, false)).Data.(*model.Channel) assert.EqualValues(t, 0, c1t2.ExtraUpdateAt, "ExtraUpdateAt should be 0") count := (<-ss.Channel().GetMemberCount(o1.ChannelId, false)).Data.(int64) if count != 2 { t.Fatal("should have saved 2 members") } store.Must(ss.Channel().PermanentDeleteMembersByUser(o2.UserId)) count = (<-ss.Channel().GetMemberCount(o1.ChannelId, false)).Data.(int64) if count != 1 { t.Fatal("should have removed 1 member") } if r1 := <-ss.Channel().PermanentDeleteMembersByChannel(o1.ChannelId); r1.Err != nil { t.Fatal(r1.Err) } count = (<-ss.Channel().GetMemberCount(o1.ChannelId, false)).Data.(int64) if count != 0 { t.Fatal("should have removed all members") } } func testChannelStoreGetChannels(t *testing.T, ss store.Store) { o2 := model.Channel{} o2.TeamId = model.NewId() o2.DisplayName = "Channel2" o2.Name = "zz" + model.NewId() + "b" o2.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o2, -1)) o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Channel1" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o1, -1)) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = model.NewId() m1.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m1)) m2 := model.ChannelMember{} m2.ChannelId = o1.Id m2.UserId = model.NewId() m2.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m2)) m3 := model.ChannelMember{} m3.ChannelId = o2.Id m3.UserId = model.NewId() m3.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m3)) cresult := <-ss.Channel().GetChannels(o1.TeamId, m1.UserId, false) list := cresult.Data.(*model.ChannelList) if (*list)[0].Id != o1.Id { t.Fatal("missing channel") } acresult := <-ss.Channel().GetAllChannelMembersForUser(m1.UserId, false, false) ids := acresult.Data.(map[string]string) if _, ok := ids[o1.Id]; !ok { t.Fatal("missing channel") } acresult2 := <-ss.Channel().GetAllChannelMembersForUser(m1.UserId, true, false) ids2 := acresult2.Data.(map[string]string) if _, ok := ids2[o1.Id]; !ok { t.Fatal("missing channel") } acresult3 := <-ss.Channel().GetAllChannelMembersForUser(m1.UserId, true, false) ids3 := acresult3.Data.(map[string]string) if _, ok := ids3[o1.Id]; !ok { t.Fatal("missing channel") } if !ss.Channel().IsUserInChannelUseCache(m1.UserId, o1.Id) { t.Fatal("missing channel") } if ss.Channel().IsUserInChannelUseCache(m1.UserId, o2.Id) { t.Fatal("missing channel") } if ss.Channel().IsUserInChannelUseCache(m1.UserId, "blahblah") { t.Fatal("missing channel") } if ss.Channel().IsUserInChannelUseCache("blahblah", "blahblah") { t.Fatal("missing channel") } ss.Channel().InvalidateAllChannelMembersForUser(m1.UserId) } func testChannelStoreGetMoreChannels(t *testing.T, ss store.Store) { teamId := model.NewId() otherTeamId := model.NewId() userId := model.NewId() otherUserId1 := model.NewId() otherUserId2 := model.NewId() // o1 is a channel on the team to which the user (and the other user 1) belongs o1 := model.Channel{ TeamId: teamId, DisplayName: "Channel1", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o1, -1)) store.Must(ss.Channel().SaveMember(&model.ChannelMember{ ChannelId: o1.Id, UserId: userId, NotifyProps: model.GetDefaultChannelNotifyProps(), })) store.Must(ss.Channel().SaveMember(&model.ChannelMember{ ChannelId: o1.Id, UserId: otherUserId1, NotifyProps: model.GetDefaultChannelNotifyProps(), })) // o2 is a channel on the other team to which the user belongs o2 := model.Channel{ TeamId: otherTeamId, DisplayName: "Channel2", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o2, -1)) store.Must(ss.Channel().SaveMember(&model.ChannelMember{ ChannelId: o2.Id, UserId: otherUserId2, NotifyProps: model.GetDefaultChannelNotifyProps(), })) // o3 is a channel on the team to which the user does not belong, and thus should show up // in "more channels" o3 := model.Channel{ TeamId: teamId, DisplayName: "ChannelA", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o3, -1)) // o4 is a private channel on the team to which the user does not belong o4 := model.Channel{ TeamId: teamId, DisplayName: "ChannelB", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_PRIVATE, } store.Must(ss.Channel().Save(&o4, -1)) // o5 is another private channel on the team to which the user does belong o5 := model.Channel{ TeamId: teamId, DisplayName: "ChannelC", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_PRIVATE, } store.Must(ss.Channel().Save(&o5, -1)) store.Must(ss.Channel().SaveMember(&model.ChannelMember{ ChannelId: o5.Id, UserId: userId, NotifyProps: model.GetDefaultChannelNotifyProps(), })) t.Run("only o3 listed in more channels", func(t *testing.T) { result := <-ss.Channel().GetMoreChannels(teamId, userId, 0, 100) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o3}, result.Data.(*model.ChannelList)) }) // o6 is another channel on the team to which the user does not belong, and would thus // start showing up in "more channels". o6 := model.Channel{ TeamId: teamId, DisplayName: "ChannelD", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o6, -1)) // o7 is another channel on the team to which the user does not belong, but is deleted, // and thus would not start showing up in "more channels" o7 := model.Channel{ TeamId: teamId, DisplayName: "ChannelD", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o7, -1)) store.Must(ss.Channel().Delete(o7.Id, model.GetMillis())) t.Run("both o3 and o6 listed in more channels", func(t *testing.T) { result := <-ss.Channel().GetMoreChannels(teamId, userId, 0, 100) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o3, &o6}, result.Data.(*model.ChannelList)) }) t.Run("only o3 listed in more channels with offset 0, limit 1", func(t *testing.T) { result := <-ss.Channel().GetMoreChannels(teamId, userId, 0, 1) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o3}, result.Data.(*model.ChannelList)) }) t.Run("only o6 listed in more channels with offset 1, limit 1", func(t *testing.T) { result := <-ss.Channel().GetMoreChannels(teamId, userId, 1, 1) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o6}, result.Data.(*model.ChannelList)) }) t.Run("verify analytics for open channels", func(t *testing.T) { result := <-ss.Channel().AnalyticsTypeCount(teamId, model.CHANNEL_OPEN) require.Nil(t, result.Err) require.EqualValues(t, 4, result.Data.(int64)) }) t.Run("verify analytics for private channels", func(t *testing.T) { result := <-ss.Channel().AnalyticsTypeCount(teamId, model.CHANNEL_PRIVATE) require.Nil(t, result.Err) require.EqualValues(t, 2, result.Data.(int64)) }) } func testChannelStoreGetPublicChannelsForTeam(t *testing.T, ss store.Store) { teamId := model.NewId() // o1 is a public channel on the team o1 := model.Channel{ TeamId: teamId, DisplayName: "OpenChannel1Team1", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o1, -1)) // o2 is a public channel on another team o2 := model.Channel{ TeamId: model.NewId(), DisplayName: "OpenChannel1Team2", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o2, -1)) // o3 is a private channel on the team o3 := model.Channel{ TeamId: teamId, DisplayName: "PrivateChannel1Team1", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_PRIVATE, } store.Must(ss.Channel().Save(&o3, -1)) t.Run("only o1 initially listed in public channels", func(t *testing.T) { result := <-ss.Channel().GetPublicChannelsForTeam(teamId, 0, 100) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o1}, result.Data.(*model.ChannelList)) }) // o4 is another public channel on the team o4 := model.Channel{ TeamId: teamId, DisplayName: "OpenChannel2Team1", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o4, -1)) // o5 is another public, but deleted channel on the team o5 := model.Channel{ TeamId: teamId, DisplayName: "OpenChannel3Team1", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o5, -1)) store.Must(ss.Channel().Delete(o5.Id, model.GetMillis())) t.Run("both o1 and o4 listed in public channels", func(t *testing.T) { cresult := <-ss.Channel().GetPublicChannelsForTeam(teamId, 0, 100) require.Nil(t, cresult.Err) require.Equal(t, &model.ChannelList{&o1, &o4}, cresult.Data.(*model.ChannelList)) }) t.Run("only o1 listed in public channels with offset 0, limit 1", func(t *testing.T) { result := <-ss.Channel().GetPublicChannelsForTeam(teamId, 0, 1) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o1}, result.Data.(*model.ChannelList)) }) t.Run("only o4 listed in public channels with offset 1, limit 1", func(t *testing.T) { result := <-ss.Channel().GetPublicChannelsForTeam(teamId, 1, 1) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o4}, result.Data.(*model.ChannelList)) }) t.Run("verify analytics for open channels", func(t *testing.T) { result := <-ss.Channel().AnalyticsTypeCount(teamId, model.CHANNEL_OPEN) require.Nil(t, result.Err) require.EqualValues(t, 3, result.Data.(int64)) }) t.Run("verify analytics for private channels", func(t *testing.T) { result := <-ss.Channel().AnalyticsTypeCount(teamId, model.CHANNEL_PRIVATE) require.Nil(t, result.Err) require.EqualValues(t, 1, result.Data.(int64)) }) } func testChannelStoreGetPublicChannelsByIdsForTeam(t *testing.T, ss store.Store) { teamId := model.NewId() // oc1 is a public channel on the team oc1 := model.Channel{ TeamId: teamId, DisplayName: "OpenChannel1Team1", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&oc1, -1)) // oc2 is a public channel on another team oc2 := model.Channel{ TeamId: model.NewId(), DisplayName: "OpenChannel2TeamOther", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&oc2, -1)) // pc3 is a private channel on the team pc3 := model.Channel{ TeamId: teamId, DisplayName: "PrivateChannel3Team1", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_PRIVATE, } store.Must(ss.Channel().Save(&pc3, -1)) t.Run("oc1 by itself should be found as a public channel in the team", func(t *testing.T) { result := <-ss.Channel().GetPublicChannelsByIdsForTeam(teamId, []string{oc1.Id}) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&oc1}, result.Data.(*model.ChannelList)) }) t.Run("only oc1, among others, should be found as a public channel in the team", func(t *testing.T) { result := <-ss.Channel().GetPublicChannelsByIdsForTeam(teamId, []string{oc1.Id, oc2.Id, model.NewId(), pc3.Id}) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&oc1}, result.Data.(*model.ChannelList)) }) // oc4 is another public channel on the team oc4 := model.Channel{ TeamId: teamId, DisplayName: "OpenChannel4Team1", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&oc4, -1)) // oc4 is another public, but deleted channel on the team oc5 := model.Channel{ TeamId: teamId, DisplayName: "OpenChannel4Team1", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&oc5, -1)) store.Must(ss.Channel().Delete(oc5.Id, model.GetMillis())) t.Run("only oc1 and oc4, among others, should be found as a public channel in the team", func(t *testing.T) { result := <-ss.Channel().GetPublicChannelsByIdsForTeam(teamId, []string{oc1.Id, oc2.Id, model.NewId(), pc3.Id, oc4.Id}) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&oc1, &oc4}, result.Data.(*model.ChannelList)) }) t.Run("random channel id should not be found as a public channel in the team", func(t *testing.T) { result := <-ss.Channel().GetPublicChannelsByIdsForTeam(teamId, []string{model.NewId()}) require.NotNil(t, result.Err) require.Equal(t, result.Err.Id, "store.sql_channel.get_channels_by_ids.not_found.app_error") }) } func testChannelStoreGetChannelCounts(t *testing.T, ss store.Store) { o2 := model.Channel{} o2.TeamId = model.NewId() o2.DisplayName = "Channel2" o2.Name = "zz" + model.NewId() + "b" o2.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o2, -1)) o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Channel1" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o1, -1)) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = model.NewId() m1.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m1)) m2 := model.ChannelMember{} m2.ChannelId = o1.Id m2.UserId = model.NewId() m2.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m2)) m3 := model.ChannelMember{} m3.ChannelId = o2.Id m3.UserId = model.NewId() m3.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m3)) cresult := <-ss.Channel().GetChannelCounts(o1.TeamId, m1.UserId) counts := cresult.Data.(*model.ChannelCounts) if len(counts.Counts) != 1 { t.Fatal("wrong number of counts") } if len(counts.UpdateTimes) != 1 { t.Fatal("wrong number of update times") } } func testChannelStoreGetMembersForUser(t *testing.T, ss store.Store) { t1 := model.Team{} t1.DisplayName = "Name" t1.Name = model.NewId() t1.Email = MakeEmail() t1.Type = model.TEAM_OPEN store.Must(ss.Team().Save(&t1)) o1 := model.Channel{} o1.TeamId = t1.Id o1.DisplayName = "Channel1" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o1, -1)) o2 := model.Channel{} o2.TeamId = o1.TeamId o2.DisplayName = "Channel2" o2.Name = "zz" + model.NewId() + "b" o2.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o2, -1)) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = model.NewId() m1.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m1)) m2 := model.ChannelMember{} m2.ChannelId = o2.Id m2.UserId = m1.UserId m2.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m2)) cresult := <-ss.Channel().GetMembersForUser(o1.TeamId, m1.UserId) members := cresult.Data.(*model.ChannelMembers) // no unread messages if len(*members) != 2 { t.Fatal("wrong number of members") } } func testChannelStoreUpdateLastViewedAt(t *testing.T, ss store.Store) { o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Channel1" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN o1.TotalMsgCount = 25 o1.LastPostAt = 12345 store.Must(ss.Channel().Save(&o1, -1)) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = model.NewId() m1.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m1)) o2 := model.Channel{} o2.TeamId = model.NewId() o2.DisplayName = "Channel1" o2.Name = "zz" + model.NewId() + "c" o2.Type = model.CHANNEL_OPEN o2.TotalMsgCount = 26 o2.LastPostAt = 123456 store.Must(ss.Channel().Save(&o2, -1)) m2 := model.ChannelMember{} m2.ChannelId = o2.Id m2.UserId = m1.UserId m2.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m2)) if result := <-ss.Channel().UpdateLastViewedAt([]string{m1.ChannelId}, m1.UserId); result.Err != nil { t.Fatal("failed to update", result.Err) } else if result.Data.(map[string]int64)[o1.Id] != o1.LastPostAt { t.Fatal("last viewed at time incorrect") } if result := <-ss.Channel().UpdateLastViewedAt([]string{m1.ChannelId, m2.ChannelId}, m1.UserId); result.Err != nil { t.Fatal("failed to update", result.Err) } else if result.Data.(map[string]int64)[o2.Id] != o2.LastPostAt { t.Fatal("last viewed at time incorrect") } rm1 := store.Must(ss.Channel().GetMember(m1.ChannelId, m1.UserId)).(*model.ChannelMember) assert.Equal(t, rm1.LastViewedAt, o1.LastPostAt) assert.Equal(t, rm1.LastUpdateAt, o1.LastPostAt) assert.Equal(t, rm1.MsgCount, o1.TotalMsgCount) rm2 := store.Must(ss.Channel().GetMember(m2.ChannelId, m2.UserId)).(*model.ChannelMember) assert.Equal(t, rm2.LastViewedAt, o2.LastPostAt) assert.Equal(t, rm2.LastUpdateAt, o2.LastPostAt) assert.Equal(t, rm2.MsgCount, o2.TotalMsgCount) if result := <-ss.Channel().UpdateLastViewedAt([]string{m1.ChannelId}, "missing id"); result.Err != nil { t.Fatal("failed to update") } } func testChannelStoreIncrementMentionCount(t *testing.T, ss store.Store) { o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "Channel1" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN o1.TotalMsgCount = 25 store.Must(ss.Channel().Save(&o1, -1)) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = model.NewId() m1.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m1)) err := (<-ss.Channel().IncrementMentionCount(m1.ChannelId, m1.UserId)).Err if err != nil { t.Fatal("failed to update") } err = (<-ss.Channel().IncrementMentionCount(m1.ChannelId, "missing id")).Err if err != nil { t.Fatal("failed to update") } err = (<-ss.Channel().IncrementMentionCount("missing id", m1.UserId)).Err if err != nil { t.Fatal("failed to update") } err = (<-ss.Channel().IncrementMentionCount("missing id", "missing id")).Err if err != nil { t.Fatal("failed to update") } } func testUpdateChannelMember(t *testing.T, ss store.Store) { userId := model.NewId() c1 := &model.Channel{ TeamId: model.NewId(), DisplayName: model.NewId(), Name: model.NewId(), Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(c1, -1)) m1 := &model.ChannelMember{ ChannelId: c1.Id, UserId: userId, NotifyProps: model.GetDefaultChannelNotifyProps(), } store.Must(ss.Channel().SaveMember(m1)) m1.NotifyProps["test"] = "sometext" if result := <-ss.Channel().UpdateMember(m1); result.Err != nil { t.Fatal(result.Err) } m1.UserId = "" if result := <-ss.Channel().UpdateMember(m1); result.Err == nil { t.Fatal("bad user id - should fail") } } func testGetMember(t *testing.T, ss store.Store) { userId := model.NewId() c1 := &model.Channel{ TeamId: model.NewId(), DisplayName: model.NewId(), Name: model.NewId(), Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(c1, -1)) c2 := &model.Channel{ TeamId: c1.TeamId, DisplayName: model.NewId(), Name: model.NewId(), Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(c2, -1)) m1 := &model.ChannelMember{ ChannelId: c1.Id, UserId: userId, NotifyProps: model.GetDefaultChannelNotifyProps(), } store.Must(ss.Channel().SaveMember(m1)) m2 := &model.ChannelMember{ ChannelId: c2.Id, UserId: userId, NotifyProps: model.GetDefaultChannelNotifyProps(), } store.Must(ss.Channel().SaveMember(m2)) if result := <-ss.Channel().GetMember(model.NewId(), userId); result.Err == nil { t.Fatal("should've failed to get member for non-existent channel") } if result := <-ss.Channel().GetMember(c1.Id, model.NewId()); result.Err == nil { t.Fatal("should've failed to get member for non-existent user") } if result := <-ss.Channel().GetMember(c1.Id, userId); result.Err != nil { t.Fatal("shouldn't have errored when getting member", result.Err) } else if member := result.Data.(*model.ChannelMember); member.ChannelId != c1.Id { t.Fatal("should've gotten member of channel 1") } else if member.UserId != userId { t.Fatal("should've gotten member for user") } if result := <-ss.Channel().GetMember(c2.Id, userId); result.Err != nil { t.Fatal("shouldn't have errored when getting member", result.Err) } else if member := result.Data.(*model.ChannelMember); member.ChannelId != c2.Id { t.Fatal("should've gotten member of channel 2") } else if member.UserId != userId { t.Fatal("should've gotten member for user") } if result := <-ss.Channel().GetAllChannelMembersNotifyPropsForChannel(c2.Id, false); result.Err != nil { t.Fatal(result.Err) } else { props := result.Data.(map[string]model.StringMap) if len(props) == 0 { t.Fatal("should not be empty") } } if result := <-ss.Channel().GetAllChannelMembersNotifyPropsForChannel(c2.Id, true); result.Err != nil { t.Fatal(result.Err) } else { props := result.Data.(map[string]model.StringMap) if len(props) == 0 { t.Fatal("should not be empty") } } ss.Channel().InvalidateCacheForChannelMembersNotifyProps(c2.Id) } func testChannelStoreGetMemberForPost(t *testing.T, ss store.Store) { o1 := store.Must(ss.Channel().Save(&model.Channel{ TeamId: model.NewId(), DisplayName: "Name", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, }, -1)).(*model.Channel) m1 := store.Must(ss.Channel().SaveMember(&model.ChannelMember{ ChannelId: o1.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps(), })).(*model.ChannelMember) p1 := store.Must(ss.Post().Save(&model.Post{ UserId: model.NewId(), ChannelId: o1.Id, Message: "test", })).(*model.Post) if r1 := <-ss.Channel().GetMemberForPost(p1.Id, m1.UserId); r1.Err != nil { t.Fatal(r1.Err) } else if r1.Data.(*model.ChannelMember).ToJson() != m1.ToJson() { t.Fatal("invalid returned channel member") } if r2 := <-ss.Channel().GetMemberForPost(p1.Id, model.NewId()); r2.Err == nil { t.Fatal("shouldn't have returned a member") } } func testGetMemberCount(t *testing.T, ss store.Store) { teamId := model.NewId() c1 := model.Channel{ TeamId: teamId, DisplayName: "Channel1", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&c1, -1)) c2 := model.Channel{ TeamId: teamId, DisplayName: "Channel2", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&c2, -1)) u1 := &model.User{ Email: MakeEmail(), DeleteAt: 0, } store.Must(ss.User().Save(u1)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1)) m1 := model.ChannelMember{ ChannelId: c1.Id, UserId: u1.Id, NotifyProps: model.GetDefaultChannelNotifyProps(), } store.Must(ss.Channel().SaveMember(&m1)) if result := <-ss.Channel().GetMemberCount(c1.Id, false); result.Err != nil { t.Fatalf("failed to get member count: %v", result.Err) } else if result.Data.(int64) != 1 { t.Fatalf("got incorrect member count %v", result.Data) } u2 := model.User{ Email: MakeEmail(), DeleteAt: 0, } store.Must(ss.User().Save(&u2)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id}, -1)) m2 := model.ChannelMember{ ChannelId: c1.Id, UserId: u2.Id, NotifyProps: model.GetDefaultChannelNotifyProps(), } store.Must(ss.Channel().SaveMember(&m2)) if result := <-ss.Channel().GetMemberCount(c1.Id, false); result.Err != nil { t.Fatalf("failed to get member count: %v", result.Err) } else if result.Data.(int64) != 2 { t.Fatalf("got incorrect member count %v", result.Data) } // make sure members of other channels aren't counted u3 := model.User{ Email: MakeEmail(), DeleteAt: 0, } store.Must(ss.User().Save(&u3)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u3.Id}, -1)) m3 := model.ChannelMember{ ChannelId: c2.Id, UserId: u3.Id, NotifyProps: model.GetDefaultChannelNotifyProps(), } store.Must(ss.Channel().SaveMember(&m3)) if result := <-ss.Channel().GetMemberCount(c1.Id, false); result.Err != nil { t.Fatalf("failed to get member count: %v", result.Err) } else if result.Data.(int64) != 2 { t.Fatalf("got incorrect member count %v", result.Data) } // make sure inactive users aren't counted u4 := &model.User{ Email: MakeEmail(), DeleteAt: 10000, } store.Must(ss.User().Save(u4)) store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u4.Id}, -1)) m4 := model.ChannelMember{ ChannelId: c1.Id, UserId: u4.Id, NotifyProps: model.GetDefaultChannelNotifyProps(), } store.Must(ss.Channel().SaveMember(&m4)) if result := <-ss.Channel().GetMemberCount(c1.Id, false); result.Err != nil { t.Fatalf("failed to get member count: %v", result.Err) } else if result.Data.(int64) != 2 { t.Fatalf("got incorrect member count %v", result.Data) } } func testChannelStoreSearchMore(t *testing.T, ss store.Store) { teamId := model.NewId() otherTeamId := model.NewId() o1 := model.Channel{ TeamId: teamId, DisplayName: "ChannelA", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o1, -1)) m1 := model.ChannelMember{ ChannelId: o1.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps(), } store.Must(ss.Channel().SaveMember(&m1)) m2 := model.ChannelMember{ ChannelId: o1.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps(), } store.Must(ss.Channel().SaveMember(&m2)) o2 := model.Channel{ TeamId: otherTeamId, DisplayName: "Channel2", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o2, -1)) m3 := model.ChannelMember{ ChannelId: o2.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps(), } store.Must(ss.Channel().SaveMember(&m3)) o3 := model.Channel{ TeamId: teamId, DisplayName: "ChannelA", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o3, -1)) o4 := model.Channel{ TeamId: teamId, DisplayName: "ChannelB", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_PRIVATE, } store.Must(ss.Channel().Save(&o4, -1)) o5 := model.Channel{ TeamId: teamId, DisplayName: "ChannelC", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_PRIVATE, } store.Must(ss.Channel().Save(&o5, -1)) o6 := model.Channel{ TeamId: teamId, DisplayName: "Off-Topic", Name: "off-topic", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o6, -1)) o7 := model.Channel{ TeamId: teamId, DisplayName: "Off-Set", Name: "off-set", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o7, -1)) o8 := model.Channel{ TeamId: teamId, DisplayName: "Off-Limit", Name: "off-limit", Type: model.CHANNEL_PRIVATE, } store.Must(ss.Channel().Save(&o8, -1)) o9 := model.Channel{ TeamId: teamId, DisplayName: "Channel With Purpose", Purpose: "This can now be searchable!", Name: "with-purpose", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o9, -1)) o10 := model.Channel{ TeamId: teamId, DisplayName: "ChannelA", Name: "channel-a-deleted", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o10, -1)) o10.DeleteAt = model.GetMillis() o10.UpdateAt = o10.DeleteAt store.Must(ss.Channel().Delete(o10.Id, o10.DeleteAt)) t.Run("three public channels matching 'ChannelA', but already a member of one and one deleted", func(t *testing.T) { result := <-ss.Channel().SearchMore(m1.UserId, teamId, "ChannelA") require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o3}, result.Data.(*model.ChannelList)) }) t.Run("one public channels, but already a member", func(t *testing.T) { result := <-ss.Channel().SearchMore(m1.UserId, teamId, o4.Name) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{}, result.Data.(*model.ChannelList)) }) t.Run("three matching channels, but only two public", func(t *testing.T) { result := <-ss.Channel().SearchMore(m1.UserId, teamId, "off-") require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o7, &o6}, result.Data.(*model.ChannelList)) }) t.Run("one channel matching 'off-topic'", func(t *testing.T) { result := <-ss.Channel().SearchMore(m1.UserId, teamId, "off-topic") require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o6}, result.Data.(*model.ChannelList)) }) t.Run("search purpose", func(t *testing.T) { result := <-ss.Channel().SearchMore(m1.UserId, teamId, "now searchable") require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o9}, result.Data.(*model.ChannelList)) }) } type ByChannelDisplayName model.ChannelList func (s ByChannelDisplayName) Len() int { return len(s) } func (s ByChannelDisplayName) Swap(i, j int) { s[i], s[j] = s[j], s[i] } func (s ByChannelDisplayName) Less(i, j int) bool { if s[i].DisplayName != s[j].DisplayName { return s[i].DisplayName < s[j].DisplayName } return s[i].Id < s[j].Id } func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) { teamId := model.NewId() otherTeamId := model.NewId() o1 := model.Channel{ TeamId: teamId, DisplayName: "ChannelA", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o1, -1)) o2 := model.Channel{ TeamId: otherTeamId, DisplayName: "ChannelA", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o2, -1)) m1 := model.ChannelMember{ ChannelId: o1.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps(), } store.Must(ss.Channel().SaveMember(&m1)) m2 := model.ChannelMember{ ChannelId: o1.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps(), } store.Must(ss.Channel().SaveMember(&m2)) m3 := model.ChannelMember{ ChannelId: o2.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps(), } store.Must(ss.Channel().SaveMember(&m3)) o3 := model.Channel{ TeamId: teamId, DisplayName: "ChannelA (alternate)", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o3, -1)) o4 := model.Channel{ TeamId: teamId, DisplayName: "Channel B", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_PRIVATE, } store.Must(ss.Channel().Save(&o4, -1)) o5 := model.Channel{ TeamId: teamId, DisplayName: "Channel C", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_PRIVATE, } store.Must(ss.Channel().Save(&o5, -1)) o6 := model.Channel{ TeamId: teamId, DisplayName: "Off-Topic", Name: "off-topic", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o6, -1)) o7 := model.Channel{ TeamId: teamId, DisplayName: "Off-Set", Name: "off-set", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o7, -1)) o8 := model.Channel{ TeamId: teamId, DisplayName: "Off-Limit", Name: "off-limit", Type: model.CHANNEL_PRIVATE, } store.Must(ss.Channel().Save(&o8, -1)) o9 := model.Channel{ TeamId: teamId, DisplayName: "Town Square", Name: "town-square", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o9, -1)) o10 := model.Channel{ TeamId: teamId, DisplayName: "The", Name: "the", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o10, -1)) o11 := model.Channel{ TeamId: teamId, DisplayName: "Native Mobile Apps", Name: "native-mobile-apps", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o11, -1)) o12 := model.Channel{ TeamId: teamId, DisplayName: "ChannelZ", Purpose: "This can now be searchable!", Name: "with-purpose", Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o12, -1)) o13 := model.Channel{ TeamId: teamId, DisplayName: "ChannelA (deleted)", Name: model.NewId(), Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o13, -1)) o13.DeleteAt = model.GetMillis() o13.UpdateAt = o13.DeleteAt store.Must(ss.Channel().Delete(o13.Id, o13.DeleteAt)) testCases := []struct { Description string TeamId string Term string IncludeDeleted bool ExpectedResults *model.ChannelList }{ {"ChannelA", teamId, "ChannelA", false, &model.ChannelList{&o1, &o3}}, {"ChannelA, include deleted", teamId, "ChannelA", true, &model.ChannelList{&o1, &o3, &o13}}, {"ChannelA, other team", otherTeamId, "ChannelA", false, &model.ChannelList{&o2}}, {"empty string", teamId, "", false, &model.ChannelList{&o1, &o3, &o12, &o11, &o7, &o6, &o10, &o9}}, {"no matches", teamId, "blargh", false, &model.ChannelList{}}, {"prefix", teamId, "off-", false, &model.ChannelList{&o7, &o6}}, {"full match with dash", teamId, "off-topic", false, &model.ChannelList{&o6}}, {"town square", teamId, "town square", false, &model.ChannelList{&o9}}, {"the in name", teamId, "the", false, &model.ChannelList{&o10}}, {"Mobile", teamId, "Mobile", false, &model.ChannelList{&o11}}, {"search purpose", teamId, "now searchable", false, &model.ChannelList{&o12}}, {"pipe ignored", teamId, "town square |", false, &model.ChannelList{&o9}}, } for name, search := range map[string]func(teamId string, term string, includeDeleted bool) store.StoreChannel{ "AutocompleteInTeam": ss.Channel().AutocompleteInTeam, "SearchInTeam": ss.Channel().SearchInTeam, } { for _, testCase := range testCases { t.Run(testCase.Description, func(t *testing.T) { result := <-search(testCase.TeamId, testCase.Term, testCase.IncludeDeleted) require.Nil(t, result.Err) channels := result.Data.(*model.ChannelList) // AutoCompleteInTeam doesn't currently sort its output results. if name == "AutocompleteInTeam" { sort.Sort(ByChannelDisplayName(*channels)) } require.Equal(t, testCase.ExpectedResults, channels) }) } } } func testChannelStoreAutocompleteInTeamForSearch(t *testing.T, ss store.Store) { u1 := &model.User{} u1.Email = MakeEmail() u1.Username = "user1" + model.NewId() u1.Nickname = model.NewId() store.Must(ss.User().Save(u1)) u2 := &model.User{} u2.Email = MakeEmail() u2.Username = "user2" + model.NewId() u2.Nickname = model.NewId() store.Must(ss.User().Save(u2)) u3 := &model.User{} u3.Email = MakeEmail() u3.Username = "user3" + model.NewId() u3.Nickname = model.NewId() store.Must(ss.User().Save(u3)) u4 := &model.User{} u4.Email = MakeEmail() u4.Username = "user4" + model.NewId() u4.Nickname = model.NewId() store.Must(ss.User().Save(u4)) o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "ChannelA" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o1, -1)) m1 := model.ChannelMember{} m1.ChannelId = o1.Id m1.UserId = u1.Id m1.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m1)) o2 := model.Channel{} o2.TeamId = model.NewId() o2.DisplayName = "Channel2" o2.Name = "zz" + model.NewId() + "b" o2.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o2, -1)) m2 := model.ChannelMember{} m2.ChannelId = o2.Id m2.UserId = m1.UserId m2.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m2)) o3 := model.Channel{} o3.TeamId = o1.TeamId o3.DisplayName = "ChannelA" o3.Name = "zz" + model.NewId() + "b" o3.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o3, -1)) m3 := model.ChannelMember{} m3.ChannelId = o3.Id m3.UserId = m1.UserId m3.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m3)) store.Must(ss.Channel().SetDeleteAt(o3.Id, 100, 100)) o4 := model.Channel{} o4.TeamId = o1.TeamId o4.DisplayName = "ChannelA" o4.Name = "zz" + model.NewId() + "b" o4.Type = model.CHANNEL_PRIVATE store.Must(ss.Channel().Save(&o4, -1)) m4 := model.ChannelMember{} m4.ChannelId = o4.Id m4.UserId = m1.UserId m4.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m4)) o5 := model.Channel{} o5.TeamId = o1.TeamId o5.DisplayName = "ChannelC" o5.Name = "zz" + model.NewId() + "b" o5.Type = model.CHANNEL_PRIVATE store.Must(ss.Channel().Save(&o5, -1)) store.Must(ss.Channel().CreateDirectChannel(u1.Id, u2.Id)) store.Must(ss.Channel().CreateDirectChannel(u2.Id, u3.Id)) tt := []struct { name string term string includeDeleted bool expectedMatches int }{ {"Empty search (list all)", "", false, 4}, {"Narrow search", "ChannelA", false, 2}, {"Wide search", "Cha", false, 3}, {"Direct messages", "user", false, 1}, {"Wide search with archived channels", "Cha", true, 4}, {"Narrow with archived channels", "ChannelA", true, 3}, {"Direct messages with archived channels", "user", true, 1}, {"Search without results", "blarg", true, 0}, } for _, tc := range tt { t.Run(tc.name, func(t *testing.T) { result := <-ss.Channel().AutocompleteInTeamForSearch(o1.TeamId, m1.UserId, "ChannelA", false) require.Nil(t, result.Err) channels := result.Data.(*model.ChannelList) require.Len(t, *channels, 2) }) } } func testChannelStoreGetMembersByIds(t *testing.T, ss store.Store) { o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "ChannelA" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o1, -1)) m1 := &model.ChannelMember{ChannelId: o1.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps()} store.Must(ss.Channel().SaveMember(m1)) if r := <-ss.Channel().GetMembersByIds(m1.ChannelId, []string{m1.UserId}); r.Err != nil { t.Fatal(r.Err) } else { rm1 := (*r.Data.(*model.ChannelMembers))[0] if rm1.ChannelId != m1.ChannelId { t.Fatal("bad team id") } if rm1.UserId != m1.UserId { t.Fatal("bad user id") } } m2 := &model.ChannelMember{ChannelId: o1.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps()} store.Must(ss.Channel().SaveMember(m2)) if r := <-ss.Channel().GetMembersByIds(m1.ChannelId, []string{m1.UserId, m2.UserId, model.NewId()}); r.Err != nil { t.Fatal(r.Err) } else { rm := (*r.Data.(*model.ChannelMembers)) if len(rm) != 2 { t.Fatal("return wrong number of results") } } if r := <-ss.Channel().GetMembersByIds(m1.ChannelId, []string{}); r.Err == nil { t.Fatal("empty user ids - should have failed") } } func testChannelStoreAnalyticsDeletedTypeCount(t *testing.T, ss store.Store) { o1 := model.Channel{} o1.TeamId = model.NewId() o1.DisplayName = "ChannelA" o1.Name = "zz" + model.NewId() + "b" o1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o1, -1)) o2 := model.Channel{} o2.TeamId = model.NewId() o2.DisplayName = "Channel2" o2.Name = "zz" + model.NewId() + "b" o2.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&o2, -1)) p3 := model.Channel{} p3.TeamId = model.NewId() p3.DisplayName = "Channel3" p3.Name = "zz" + model.NewId() + "b" p3.Type = model.CHANNEL_PRIVATE store.Must(ss.Channel().Save(&p3, -1)) u1 := &model.User{} u1.Email = MakeEmail() u1.Nickname = model.NewId() store.Must(ss.User().Save(u1)) u2 := &model.User{} u2.Email = MakeEmail() u2.Nickname = model.NewId() store.Must(ss.User().Save(u2)) var d4 *model.Channel if result := <-ss.Channel().CreateDirectChannel(u1.Id, u2.Id); result.Err != nil { t.Fatalf(result.Err.Error()) } else { d4 = result.Data.(*model.Channel) } defer func() { <-ss.Channel().PermanentDeleteMembersByChannel(d4.Id) <-ss.Channel().PermanentDelete(d4.Id) }() var openStartCount int64 if result := <-ss.Channel().AnalyticsDeletedTypeCount("", "O"); result.Err != nil { t.Fatal(result.Err.Error()) } else { openStartCount = result.Data.(int64) } var privateStartCount int64 if result := <-ss.Channel().AnalyticsDeletedTypeCount("", "P"); result.Err != nil { t.Fatal(result.Err.Error()) } else { privateStartCount = result.Data.(int64) } var directStartCount int64 if result := <-ss.Channel().AnalyticsDeletedTypeCount("", "D"); result.Err != nil { t.Fatal(result.Err.Error()) } else { directStartCount = result.Data.(int64) } store.Must(ss.Channel().Delete(o1.Id, model.GetMillis())) store.Must(ss.Channel().Delete(o2.Id, model.GetMillis())) store.Must(ss.Channel().Delete(p3.Id, model.GetMillis())) store.Must(ss.Channel().Delete(d4.Id, model.GetMillis())) if result := <-ss.Channel().AnalyticsDeletedTypeCount("", "O"); result.Err != nil { t.Fatal(result.Err.Error()) } else { if result.Data.(int64) != openStartCount+2 { t.Fatalf("Wrong open channel deleted count.") } } if result := <-ss.Channel().AnalyticsDeletedTypeCount("", "P"); result.Err != nil { t.Fatal(result.Err.Error()) } else { if result.Data.(int64) != privateStartCount+1 { t.Fatalf("Wrong private channel deleted count.") } } if result := <-ss.Channel().AnalyticsDeletedTypeCount("", "D"); result.Err != nil { t.Fatal(result.Err.Error()) } else { if result.Data.(int64) != directStartCount+1 { t.Fatalf("Wrong direct channel deleted count.") } } } func testChannelStoreGetPinnedPosts(t *testing.T, ss store.Store) { o1 := store.Must(ss.Channel().Save(&model.Channel{ TeamId: model.NewId(), DisplayName: "Name", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, }, -1)).(*model.Channel) p1 := store.Must(ss.Post().Save(&model.Post{ UserId: model.NewId(), ChannelId: o1.Id, Message: "test", IsPinned: true, })).(*model.Post) if r1 := <-ss.Channel().GetPinnedPosts(o1.Id); r1.Err != nil { t.Fatal(r1.Err) } else if r1.Data.(*model.PostList).Posts[p1.Id] == nil { t.Fatal("didn't return relevant pinned posts") } o2 := store.Must(ss.Channel().Save(&model.Channel{ TeamId: model.NewId(), DisplayName: "Name", Name: "zz" + model.NewId() + "b", Type: model.CHANNEL_OPEN, }, -1)).(*model.Channel) store.Must(ss.Post().Save(&model.Post{ UserId: model.NewId(), ChannelId: o2.Id, Message: "test", })) if r2 := <-ss.Channel().GetPinnedPosts(o2.Id); r2.Err != nil { t.Fatal(r2.Err) } else if len(r2.Data.(*model.PostList).Posts) != 0 { t.Fatal("wasn't supposed to return posts") } } func testChannelStoreMaxChannelsPerTeam(t *testing.T, ss store.Store) { channel := &model.Channel{ TeamId: model.NewId(), DisplayName: "Channel", Name: model.NewId(), Type: model.CHANNEL_OPEN, } result := <-ss.Channel().Save(channel, 0) assert.NotEqual(t, nil, result.Err) assert.Equal(t, result.Err.Id, "store.sql_channel.save_channel.limit.app_error") channel.Id = "" result = <-ss.Channel().Save(channel, 1) assert.Nil(t, result.Err) } func testChannelStoreGetChannelsByScheme(t *testing.T, ss store.Store) { // Create some schemes. s1 := &model.Scheme{ DisplayName: model.NewId(), Name: model.NewId(), Description: model.NewId(), Scope: model.SCHEME_SCOPE_CHANNEL, } s2 := &model.Scheme{ DisplayName: model.NewId(), Name: model.NewId(), Description: model.NewId(), Scope: model.SCHEME_SCOPE_CHANNEL, } s1 = (<-ss.Scheme().Save(s1)).Data.(*model.Scheme) s2 = (<-ss.Scheme().Save(s2)).Data.(*model.Scheme) // Create and save some teams. c1 := &model.Channel{ TeamId: model.NewId(), DisplayName: "Name", Name: model.NewId(), Type: model.CHANNEL_OPEN, SchemeId: &s1.Id, } c2 := &model.Channel{ TeamId: model.NewId(), DisplayName: "Name", Name: model.NewId(), Type: model.CHANNEL_OPEN, SchemeId: &s1.Id, } c3 := &model.Channel{ TeamId: model.NewId(), DisplayName: "Name", Name: model.NewId(), Type: model.CHANNEL_OPEN, } _ = (<-ss.Channel().Save(c1, 100)).Data.(*model.Channel) _ = (<-ss.Channel().Save(c2, 100)).Data.(*model.Channel) _ = (<-ss.Channel().Save(c3, 100)).Data.(*model.Channel) // Get the channels by a valid Scheme ID. res1 := <-ss.Channel().GetChannelsByScheme(s1.Id, 0, 100) assert.Nil(t, res1.Err) d1 := res1.Data.(model.ChannelList) assert.Len(t, d1, 2) // Get the channels by a valid Scheme ID where there aren't any matching Channel. res2 := <-ss.Channel().GetChannelsByScheme(s2.Id, 0, 100) assert.Nil(t, res2.Err) d2 := res2.Data.(model.ChannelList) assert.Len(t, d2, 0) // Get the channels by an invalid Scheme ID. res3 := <-ss.Channel().GetChannelsByScheme(model.NewId(), 0, 100) assert.Nil(t, res3.Err) d3 := res3.Data.(model.ChannelList) assert.Len(t, d3, 0) } func testChannelStoreMigrateChannelMembers(t *testing.T, ss store.Store) { s1 := model.NewId() c1 := &model.Channel{ TeamId: model.NewId(), DisplayName: "Name", Name: model.NewId(), Type: model.CHANNEL_OPEN, SchemeId: &s1, } c1 = (<-ss.Channel().Save(c1, 100)).Data.(*model.Channel) cm1 := &model.ChannelMember{ ChannelId: c1.Id, UserId: model.NewId(), ExplicitRoles: "channel_admin channel_user", NotifyProps: model.GetDefaultChannelNotifyProps(), } cm2 := &model.ChannelMember{ ChannelId: c1.Id, UserId: model.NewId(), ExplicitRoles: "channel_user", NotifyProps: model.GetDefaultChannelNotifyProps(), } cm3 := &model.ChannelMember{ ChannelId: c1.Id, UserId: model.NewId(), ExplicitRoles: "something_else", NotifyProps: model.GetDefaultChannelNotifyProps(), } cm1 = (<-ss.Channel().SaveMember(cm1)).Data.(*model.ChannelMember) cm2 = (<-ss.Channel().SaveMember(cm2)).Data.(*model.ChannelMember) cm3 = (<-ss.Channel().SaveMember(cm3)).Data.(*model.ChannelMember) lastDoneChannelId := strings.Repeat("0", 26) lastDoneUserId := strings.Repeat("0", 26) for { res := <-ss.Channel().MigrateChannelMembers(lastDoneChannelId, lastDoneUserId) if assert.Nil(t, res.Err) { if res.Data == nil { break } data := res.Data.(map[string]string) lastDoneChannelId = data["ChannelId"] lastDoneUserId = data["UserId"] } } ss.Channel().ClearCaches() res1 := <-ss.Channel().GetMember(cm1.ChannelId, cm1.UserId) assert.Nil(t, res1.Err) cm1b := res1.Data.(*model.ChannelMember) assert.Equal(t, "", cm1b.ExplicitRoles) assert.True(t, cm1b.SchemeUser) assert.True(t, cm1b.SchemeAdmin) res2 := <-ss.Channel().GetMember(cm2.ChannelId, cm2.UserId) assert.Nil(t, res2.Err) cm2b := res2.Data.(*model.ChannelMember) assert.Equal(t, "", cm2b.ExplicitRoles) assert.True(t, cm2b.SchemeUser) assert.False(t, cm2b.SchemeAdmin) res3 := <-ss.Channel().GetMember(cm3.ChannelId, cm3.UserId) assert.Nil(t, res3.Err) cm3b := res3.Data.(*model.ChannelMember) assert.Equal(t, "something_else", cm3b.ExplicitRoles) assert.False(t, cm3b.SchemeUser) assert.False(t, cm3b.SchemeAdmin) } func testResetAllChannelSchemes(t *testing.T, ss store.Store) { s1 := &model.Scheme{ Name: model.NewId(), DisplayName: model.NewId(), Description: model.NewId(), Scope: model.SCHEME_SCOPE_CHANNEL, } s1 = (<-ss.Scheme().Save(s1)).Data.(*model.Scheme) c1 := &model.Channel{ TeamId: model.NewId(), DisplayName: "Name", Name: model.NewId(), Type: model.CHANNEL_OPEN, SchemeId: &s1.Id, } c2 := &model.Channel{ TeamId: model.NewId(), DisplayName: "Name", Name: model.NewId(), Type: model.CHANNEL_OPEN, SchemeId: &s1.Id, } c1 = (<-ss.Channel().Save(c1, 100)).Data.(*model.Channel) c2 = (<-ss.Channel().Save(c2, 100)).Data.(*model.Channel) assert.Equal(t, s1.Id, *c1.SchemeId) assert.Equal(t, s1.Id, *c2.SchemeId) res := <-ss.Channel().ResetAllChannelSchemes() assert.Nil(t, res.Err) c1 = (<-ss.Channel().Get(c1.Id, true)).Data.(*model.Channel) c2 = (<-ss.Channel().Get(c2.Id, true)).Data.(*model.Channel) assert.Equal(t, "", *c1.SchemeId) assert.Equal(t, "", *c2.SchemeId) } func testChannelStoreClearAllCustomRoleAssignments(t *testing.T, ss store.Store) { c := &model.Channel{ TeamId: model.NewId(), DisplayName: "Name", Name: model.NewId(), Type: model.CHANNEL_OPEN, } c = (<-ss.Channel().Save(c, 100)).Data.(*model.Channel) m1 := &model.ChannelMember{ ChannelId: c.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps(), ExplicitRoles: "channel_user channel_admin system_user_access_token", } m2 := &model.ChannelMember{ ChannelId: c.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps(), ExplicitRoles: "channel_user custom_role channel_admin another_custom_role", } m3 := &model.ChannelMember{ ChannelId: c.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps(), ExplicitRoles: "channel_user", } m4 := &model.ChannelMember{ ChannelId: c.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps(), ExplicitRoles: "custom_only", } store.Must(ss.Channel().SaveMember(m1)) store.Must(ss.Channel().SaveMember(m2)) store.Must(ss.Channel().SaveMember(m3)) store.Must(ss.Channel().SaveMember(m4)) require.Nil(t, (<-ss.Channel().ClearAllCustomRoleAssignments()).Err) r1 := <-ss.Channel().GetMember(m1.ChannelId, m1.UserId) require.Nil(t, r1.Err) assert.Equal(t, m1.ExplicitRoles, r1.Data.(*model.ChannelMember).Roles) r2 := <-ss.Channel().GetMember(m2.ChannelId, m2.UserId) require.Nil(t, r2.Err) assert.Equal(t, "channel_user channel_admin", r2.Data.(*model.ChannelMember).Roles) r3 := <-ss.Channel().GetMember(m3.ChannelId, m3.UserId) require.Nil(t, r3.Err) assert.Equal(t, m3.ExplicitRoles, r3.Data.(*model.ChannelMember).Roles) r4 := <-ss.Channel().GetMember(m4.ChannelId, m4.UserId) require.Nil(t, r4.Err) assert.Equal(t, "", r4.Data.(*model.ChannelMember).Roles) } // testMaterializedPublicChannels tests edge cases involving the triggers and stored procedures // that materialize the PublicChannels table. func testMaterializedPublicChannels(t *testing.T, ss store.Store, s SqlSupplier) { teamId := model.NewId() // o1 is a public channel on the team o1 := model.Channel{ TeamId: teamId, DisplayName: "Open Channel", Name: model.NewId(), Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o1, -1)) // o2 is another public channel on the team o2 := model.Channel{ TeamId: teamId, DisplayName: "Open Channel 2", Name: model.NewId(), Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o2, -1)) t.Run("o1 and o2 initially listed in public channels", func(t *testing.T) { result := <-ss.Channel().SearchInTeam(teamId, "", true) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o1, &o2}, result.Data.(*model.ChannelList)) }) o1.DeleteAt = model.GetMillis() o1.UpdateAt = model.GetMillis() store.Must(ss.Channel().Delete(o1.Id, o1.DeleteAt)) t.Run("o1 still listed in public channels when marked as deleted", func(t *testing.T) { result := <-ss.Channel().SearchInTeam(teamId, "", true) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o1, &o2}, result.Data.(*model.ChannelList)) }) <-ss.Channel().PermanentDelete(o1.Id) t.Run("o1 no longer listed in public channels when permanently deleted", func(t *testing.T) { result := <-ss.Channel().SearchInTeam(teamId, "", true) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o2}, result.Data.(*model.ChannelList)) }) o2.Type = model.CHANNEL_PRIVATE require.Nil(t, (<-ss.Channel().Update(&o2)).Err) t.Run("o2 no longer listed since now private", func(t *testing.T) { result := <-ss.Channel().SearchInTeam(teamId, "", true) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{}, result.Data.(*model.ChannelList)) }) o2.Type = model.CHANNEL_OPEN require.Nil(t, (<-ss.Channel().Update(&o2)).Err) t.Run("o2 listed once again since now public", func(t *testing.T) { result := <-ss.Channel().SearchInTeam(teamId, "", true) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o2}, result.Data.(*model.ChannelList)) }) // o3 is a public channel on the team that already existed in the PublicChannels table. o3 := model.Channel{ Id: model.NewId(), TeamId: teamId, DisplayName: "Open Channel 3", Name: model.NewId(), Type: model.CHANNEL_OPEN, } _, err := s.GetMaster().ExecNoTimeout(` INSERT INTO PublicChannels(Id, DeleteAt, TeamId, DisplayName, Name, Header, Purpose) VALUES (:Id, :DeleteAt, :TeamId, :DisplayName, :Name, :Header, :Purpose); `, map[string]interface{}{ "Id": o3.Id, "DeleteAt": o3.DeleteAt, "TeamId": o3.TeamId, "DisplayName": o3.DisplayName, "Name": o3.Name, "Header": o3.Header, "Purpose": o3.Purpose, }) require.Nil(t, err) o3.DisplayName = "Open Channel 3 - Modified" _, err = s.GetMaster().ExecNoTimeout(` INSERT INTO Channels(Id, CreateAt, UpdateAt, DeleteAt, TeamId, Type, DisplayName, Name, Header, Purpose, LastPostAt, TotalMsgCount, ExtraUpdateAt, CreatorId) VALUES (:Id, :CreateAt, :UpdateAt, :DeleteAt, :TeamId, :Type, :DisplayName, :Name, :Header, :Purpose, :LastPostAt, :TotalMsgCount, :ExtraUpdateAt, :CreatorId); `, map[string]interface{}{ "Id": o3.Id, "CreateAt": o3.CreateAt, "UpdateAt": o3.UpdateAt, "DeleteAt": o3.DeleteAt, "TeamId": o3.TeamId, "Type": o3.Type, "DisplayName": o3.DisplayName, "Name": o3.Name, "Header": o3.Header, "Purpose": o3.Purpose, "LastPostAt": o3.LastPostAt, "TotalMsgCount": o3.TotalMsgCount, "ExtraUpdateAt": o3.ExtraUpdateAt, "CreatorId": o3.CreatorId, }) require.Nil(t, err) t.Run("verify o3 INSERT converted to UPDATE", func(t *testing.T) { result := <-ss.Channel().SearchInTeam(teamId, "", true) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o2, &o3}, result.Data.(*model.ChannelList)) }) // o4 is a public channel on the team that existed in the Channels table but was omitted from the PublicChannels table. o4 := model.Channel{ TeamId: teamId, DisplayName: "Open Channel 4", Name: model.NewId(), Type: model.CHANNEL_OPEN, } store.Must(ss.Channel().Save(&o4, -1)) _, err = s.GetMaster().ExecNoTimeout(` DELETE FROM PublicChannels WHERE Id = :Id `, map[string]interface{}{ "Id": o4.Id, }) require.Nil(t, err) o4.DisplayName += " - Modified" require.Nil(t, (<-ss.Channel().Update(&o4)).Err) t.Run("verify o4 UPDATE converted to INSERT", func(t *testing.T) { result := <-ss.Channel().SearchInTeam(teamId, "", true) require.Nil(t, result.Err) require.Equal(t, &model.ChannelList{&o2, &o3, &o4}, result.Data.(*model.ChannelList)) }) } func testChannelStoreGetAllChannelsForExportAfter(t *testing.T, ss store.Store) { t1 := model.Team{} t1.DisplayName = "Name" t1.Name = model.NewId() t1.Email = MakeEmail() t1.Type = model.TEAM_OPEN store.Must(ss.Team().Save(&t1)) c1 := model.Channel{} c1.TeamId = t1.Id c1.DisplayName = "Channel1" c1.Name = "zz" + model.NewId() + "b" c1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&c1, -1)) r1 := <-ss.Channel().GetAllChannelsForExportAfter(10000, strings.Repeat("0", 26)) assert.Nil(t, r1.Err) d1 := r1.Data.([]*model.ChannelForExport) found := false for _, c := range d1 { if c.Id == c1.Id { found = true assert.Equal(t, t1.Id, c.TeamId) assert.Nil(t, c.SchemeId) assert.Equal(t, t1.Name, c.TeamName) } } assert.True(t, found) } func testChannelStoreGetChannelMembersForExport(t *testing.T, ss store.Store) { t1 := model.Team{} t1.DisplayName = "Name" t1.Name = model.NewId() t1.Email = MakeEmail() t1.Type = model.TEAM_OPEN store.Must(ss.Team().Save(&t1)) c1 := model.Channel{} c1.TeamId = t1.Id c1.DisplayName = "Channel1" c1.Name = "zz" + model.NewId() + "b" c1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&c1, -1)) c2 := model.Channel{} c2.TeamId = model.NewId() c2.DisplayName = "Channel2" c2.Name = "zz" + model.NewId() + "b" c2.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&c2, -1)) u1 := model.User{} u1.Email = MakeEmail() u1.Nickname = model.NewId() store.Must(ss.User().Save(&u1)) m1 := model.ChannelMember{} m1.ChannelId = c1.Id m1.UserId = u1.Id m1.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m1)) m2 := model.ChannelMember{} m2.ChannelId = c2.Id m2.UserId = u1.Id m2.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m2)) r1 := <-ss.Channel().GetChannelMembersForExport(u1.Id, t1.Id) assert.Nil(t, r1.Err) d1 := r1.Data.([]*model.ChannelMemberForExport) assert.Len(t, d1, 1) cmfe1 := d1[0] assert.Equal(t, c1.Name, cmfe1.ChannelName) assert.Equal(t, c1.Id, cmfe1.ChannelId) assert.Equal(t, u1.Id, cmfe1.UserId) } func testChannelStoreRemoveAllDeactivatedMembers(t *testing.T, ss store.Store) { // Set up all the objects needed in the store. t1 := model.Team{} t1.DisplayName = "Name" t1.Name = model.NewId() t1.Email = MakeEmail() t1.Type = model.TEAM_OPEN store.Must(ss.Team().Save(&t1)) c1 := model.Channel{} c1.TeamId = t1.Id c1.DisplayName = "Channel1" c1.Name = "zz" + model.NewId() + "b" c1.Type = model.CHANNEL_OPEN store.Must(ss.Channel().Save(&c1, -1)) u1 := model.User{} u1.Email = MakeEmail() u1.Nickname = model.NewId() store.Must(ss.User().Save(&u1)) u2 := model.User{} u2.Email = MakeEmail() u2.Nickname = model.NewId() store.Must(ss.User().Save(&u2)) u3 := model.User{} u3.Email = MakeEmail() u3.Nickname = model.NewId() store.Must(ss.User().Save(&u3)) m1 := model.ChannelMember{} m1.ChannelId = c1.Id m1.UserId = u1.Id m1.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m1)) m2 := model.ChannelMember{} m2.ChannelId = c1.Id m2.UserId = u2.Id m2.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m2)) m3 := model.ChannelMember{} m3.ChannelId = c1.Id m3.UserId = u3.Id m3.NotifyProps = model.GetDefaultChannelNotifyProps() store.Must(ss.Channel().SaveMember(&m3)) // Get all the channel members. Check there are 3. r1 := <-ss.Channel().GetMembers(c1.Id, 0, 1000) assert.Nil(t, r1.Err) d1 := r1.Data.(*model.ChannelMembers) assert.Len(t, *d1, 3) // Deactivate users 1 & 2. u1.DeleteAt = model.GetMillis() u2.DeleteAt = model.GetMillis() require.Nil(t, (<-ss.User().Update(&u1, true)).Err) require.Nil(t, (<-ss.User().Update(&u2, true)).Err) // Remove all deactivated users from the channel. assert.Nil(t, (<-ss.Channel().RemoveAllDeactivatedMembers(c1.Id)).Err) // Get all the channel members. Check there is now only 1: m3. r2 := <-ss.Channel().GetMembers(c1.Id, 0, 1000) assert.Nil(t, r1.Err) d2 := r2.Data.(*model.ChannelMembers) assert.Len(t, *d2, 1) assert.Equal(t, (*d2)[0].UserId, u3.Id) }