mirrors/mostlymatter
1
0
Форкнуть 0
Код Задачи Запросы на слияние Действия Пакеты Проекты Релизы Вики Активность

Replacing {require,assert}.{Nil,NotNil} with {require,assert}.{NoError,Error} in the store tests (when comparing errors) (#16886)

Просмотр исходного кода 
* Replacing require.Nil with require.NoError

* More replacements

* More Nil/NotNill to NoError/Error

* Other detected errors

* renaming apperr to err

* Removed not needed line

* Rename old appErr variables that are no longer model.AppError values

* Fixing tiny typo

* Reverting changes outside the store (accidentally added)

* Apply suggestions from code review

Co-authored-by: Doug Lauder <wiggin77@warpmail.net>

Co-authored-by: Doug Lauder <wiggin77@warpmail.net>
Этот коммит содержится в:
Jesús Espino
2021-02-10 11:34:41 +01:00
коммит произвёл GitHub
родитель 5f043b0a08
Коммит 0e9ad9f7f8
56 изменённых файлов: 5061 добавлений и 5106 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

66
store/searchtest/channel_layer.go
Просмотреть файл

@@ -70,100 +70,100 @@ func TestSearchChannelStore(t *testing.T, s store.Store, testEngine *SearchTestE
Store: s,
}
err := th.SetupBasicFixtures()
require.Nil(t, err)
require.NoError(t, err)
defer th.CleanFixtures()
runTestSearch(t, testEngine, searchChannelStoreTests, th)
}
func testAutocompleteChannelByName(t *testing.T, th *SearchTestHelper) {
alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "Channel Alternate", "", model.CHANNEL_OPEN, false)
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteChannel(alternate)
res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-a", false)
require.Nil(t, apperr)
res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-a", false)
require.NoError(t, err)
th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id}, res)
}
func testAutocompleteChannelByDisplayName(t *testing.T, th *SearchTestHelper) {
alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "ChannelAlternate", "", model.CHANNEL_OPEN, false)
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteChannel(alternate)
res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "ChannelA", false)
require.Nil(t, apperr)
res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "ChannelA", false)
require.NoError(t, err)
th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id}, res)
}
func testAutocompleteChannelByNameSplittedWithDashChar(t *testing.T, th *SearchTestHelper) {
alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "ChannelAlternate", "", model.CHANNEL_OPEN, false)
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteChannel(alternate)
res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-a", false)
require.Nil(t, apperr)
res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-a", false)
require.NoError(t, err)
th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id}, res)
}
func testAutocompleteChannelByNameSplittedWithUnderscoreChar(t *testing.T, th *SearchTestHelper) {
alternate, err := th.createChannel(th.Team.Id, "channel_alternate", "ChannelAlternate", "", model.CHANNEL_OPEN, false)
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteChannel(alternate)
res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel_a", false)
require.Nil(t, apperr)
res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel_a", false)
require.NoError(t, err)
th.checkChannelIdsMatch(t, []string{alternate.Id}, res)
}
func testAutocompleteChannelByDisplayNameSplittedByWhitespaces(t *testing.T, th *SearchTestHelper) {
alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "Channel Alternate", "", model.CHANNEL_OPEN, false)
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteChannel(alternate)
res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "Channel A", false)
require.Nil(t, apperr)
res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "Channel A", false)
require.NoError(t, err)
th.checkChannelIdsMatch(t, []string{alternate.Id}, res)
}
func testAutocompleteAllChannelsIfTermIsEmpty(t *testing.T, th *SearchTestHelper) {
alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "Channel Alternate", "", model.CHANNEL_OPEN, false)
require.Nil(t, err)
require.NoError(t, err)
other, err := th.createChannel(th.Team.Id, "other-channel", "Other Channel", "", model.CHANNEL_OPEN, false)
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteChannel(alternate)
defer th.deleteChannel(other)
res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "", false)
require.Nil(t, apperr)
res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "", false)
require.NoError(t, err)
th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id, other.Id}, res)
}
func testSearchChannelsInCaseInsensitiveManner(t *testing.T, th *SearchTestHelper) {
alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "ChannelAlternate", "", model.CHANNEL_OPEN, false)
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteChannel(alternate)
res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channela", false)
require.Nil(t, apperr)
res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channela", false)
require.NoError(t, err)
th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id}, res)
res, apperr = th.Store.Channel().AutocompleteInTeam(th.Team.Id, "ChAnNeL-a", false)
require.Nil(t, apperr)
res, err = th.Store.Channel().AutocompleteInTeam(th.Team.Id, "ChAnNeL-a", false)
require.NoError(t, err)
th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id}, res)
}
func testSearchOnlyPublicChannels(t *testing.T, th *SearchTestHelper) {
alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "ChannelAlternate", "", model.CHANNEL_PRIVATE, false)
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteChannel(alternate)
res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-a", false)
require.Nil(t, apperr)
res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-a", false)
require.NoError(t, err)
th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id}, res)
}
func testSearchShouldSupportHavingHyphenAsLastCharacter(t *testing.T, th *SearchTestHelper) {
alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "ChannelAlternate", "", model.CHANNEL_OPEN, false)
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteChannel(alternate)
res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-", false)
require.Nil(t, apperr)
res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-", false)
require.NoError(t, err)
th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id}, res)
}
func testSearchShouldSupportAutocompleteWithArchivedChannels(t *testing.T, th *SearchTestHelper) {
res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-", true)
require.Nil(t, apperr)
res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-", true)
require.NoError(t, err)
th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, th.ChannelDeleted.Id}, res)
}

636
store/searchtest/file_info_layer.go
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

96
store/searchtest/helper.go
Просмотреть файл

@@ -147,29 +147,19 @@ func (th *SearchTestHelper) CleanFixtures() error {
}
func (th *SearchTestHelper) createTeam(name, displayName, teamType string) (*model.Team, error) {
team, appError := th.Store.Team().Save(&model.Team{
return th.Store.Team().Save(&model.Team{
Name: name,
DisplayName: displayName,
Type: teamType,
})
if appError != nil {
return nil, errors.New(appError.Error())
}
return team, nil
}
func (th *SearchTestHelper) deleteTeam(team *model.Team) error {
appError := th.Store.Team().RemoveAllMembersByTeam(team.Id)
if appError != nil {
return errors.New(appError.Error())
}
err := th.Store.Team().PermanentDelete(team.Id)
err := th.Store.Team().RemoveAllMembersByTeam(team.Id)
if err != nil {
return err
}
return nil
return th.Store.Team().PermanentDelete(team.Id)
}
func (th *SearchTestHelper) makeEmail() string {
@@ -177,7 +167,7 @@ func (th *SearchTestHelper) makeEmail() string {
}
func (th *SearchTestHelper) createUser(username, nickname, firstName, lastName string) (*model.User, error) {
user, appError := th.Store.User().Save(&model.User{
return th.Store.User().Save(&model.User{
Username: username,
Password: username,
Nickname: nickname,
@@ -185,15 +175,10 @@ func (th *SearchTestHelper) createUser(username, nickname, firstName, lastName s
LastName: lastName,
Email: th.makeEmail(),
})
if appError != nil {
return nil, errors.New(appError.Error())
}
return user, nil
}
func (th *SearchTestHelper) createGuest(username, nickname, firstName, lastName string) (*model.User, error) {
user, appError := th.Store.User().Save(&model.User{
return th.Store.User().Save(&model.User{
Username: username,
Password: username,
Nickname: nickname,
@@ -202,26 +187,16 @@ func (th *SearchTestHelper) createGuest(username, nickname, firstName, lastName
Email: th.makeEmail(),
Roles: model.SYSTEM_GUEST_ROLE_ID,
})
if appError != nil {
return nil, errors.New(appError.Error())
}
return user, nil
}
func (th *SearchTestHelper) deleteUser(user *model.User) error {
appError := th.Store.User().PermanentDelete(user.Id)
if appError != nil {
return errors.New(appError.Error())
}
return nil
return th.Store.User().PermanentDelete(user.Id)
}
func (th *SearchTestHelper) cleanAllUsers() error {
users, apperr := th.Store.User().GetAll()
if apperr != nil {
return apperr
users, err := th.Store.User().GetAll()
if err != nil {
return err
}
for _, u := range users {
@@ -241,9 +216,9 @@ func (th *SearchTestHelper) createBot(username, displayName, ownerID string) (*m
OwnerId: ownerID,
}
user, apperr := th.Store.User().Save(model.UserFromBot(botModel))
if apperr != nil {
return nil, errors.New(apperr.Error())
user, err := th.Store.User().Save(model.UserFromBot(botModel))
if err != nil {
return nil, errors.New(err.Error())
}
botModel.UserId = user.Id
@@ -265,21 +240,21 @@ func (th *SearchTestHelper) deleteBot(botID string) error {
}
func (th *SearchTestHelper) createChannel(teamID, name, displayName, purpose, channelType string, deleted bool) (*model.Channel, error) {
channel, appError := th.Store.Channel().Save(&model.Channel{
channel, err := th.Store.Channel().Save(&model.Channel{
TeamId: teamID,
DisplayName: displayName,
Name: name,
Type: channelType,
Purpose: purpose,
}, 999)
if appError != nil {
return nil, errors.New(appError.Error())
if err != nil {
return nil, err
}
if deleted {
appError := th.Store.Channel().Delete(channel.Id, model.GetMillis())
if appError != nil {
return nil, errors.New(appError.Error())
err := th.Store.Channel().Delete(channel.Id, model.GetMillis())
if err != nil {
return nil, err
}
}
@@ -324,9 +299,9 @@ func (th *SearchTestHelper) createGroupChannel(teamID, displayName string, users
Type: model.CHANNEL_GROUP,
}
channel, apperr := th.Store.Channel().Save(group, 10000)
if apperr != nil {
return nil, errors.New(apperr.Error())
channel, err := th.Store.Channel().Save(group, 10000)
if err != nil {
return nil, errors.New(err.Error())
}
for _, user := range users {
@@ -341,17 +316,12 @@ func (th *SearchTestHelper) createGroupChannel(teamID, displayName string, users
}
func (th *SearchTestHelper) deleteChannel(channel *model.Channel) error {
appError := th.Store.Channel().PermanentDeleteMembersByChannel(channel.Id)
if appError != nil {
return errors.New(appError.Error())
}
err := th.Store.Channel().PermanentDelete(channel.Id)
err := th.Store.Channel().PermanentDeleteMembersByChannel(channel.Id)
if err != nil {
return err
}
return nil
return th.Store.Channel().PermanentDelete(channel.Id)
}
func (th *SearchTestHelper) deleteChannels(channels []*model.Channel) error {
@@ -384,12 +354,7 @@ func (th *SearchTestHelper) createPost(userID, channelID, message, hashtags, pos
creationTime = createAt
}
postModel := th.createPostModel(userID, channelID, message, hashtags, postType, creationTime, pinned)
post, appError := th.Store.Post().Save(postModel)
if appError != nil {
return nil, errors.New(appError.Error())
}
return post, nil
return th.Store.Post().Save(postModel)
}
func (th *SearchTestHelper) createFileInfoModel(creatorID, postID, name, content, extension, mimeType string, createAt, size int64) *model.FileInfo {
@@ -414,23 +379,14 @@ func (th *SearchTestHelper) createFileInfo(creatorID, postID, name, content, ext
creationTime = createAt
}
fileInfoModel := th.createFileInfoModel(creatorID, postID, name, content, extension, mimeType, creationTime, size)
fileInfo, appError := th.Store.FileInfo().Save(fileInfoModel)
if appError != nil {
return nil, errors.New(appError.Error())
}
return fileInfo, nil
return th.Store.FileInfo().Save(fileInfoModel)
}
func (th *SearchTestHelper) createReply(userID, message, hashtags string, parent *model.Post, createAt int64, pinned bool) (*model.Post, error) {
replyModel := th.createPostModel(userID, parent.ChannelId, message, hashtags, parent.Type, createAt, pinned)
replyModel.ParentId = parent.Id
replyModel.RootId = parent.Id
reply, appError := th.Store.Post().Save(replyModel)
if appError != nil {
return nil, errors.New(appError.Error())
}
return reply, nil
return th.Store.Post().Save(replyModel)
}
func (th *SearchTestHelper) deleteUserPosts(userID string) error {

676
store/searchtest/post_layer.go
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

276
store/searchtest/user_layer.go
Просмотреть файл

@@ -159,7 +159,7 @@ func TestSearchUserStore(t *testing.T, s store.Store, testEngine *SearchTestEngi
Store: s,
}
err := th.SetupBasicFixtures()
require.Nil(t, err)
require.NoError(t, err)
defer th.CleanFixtures()
runTestSearch(t, testEngine, searchUserStoreTests, th)
}
@@ -170,13 +170,13 @@ func testGetAllUsersInChannelWithEmptyTerm(t *testing.T, th *SearchTestHelper) {
Limit: model.USER_SEARCH_DEFAULT_LIMIT,
}
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
t.Run("Should be able to correctly honor limit when autocompleting", func(t *testing.T) {
result, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
require.Len(t, result.InChannel, 1)
require.Len(t, result.OutOfChannel, 1)
})
@@ -184,7 +184,7 @@ func testGetAllUsersInChannelWithEmptyTerm(t *testing.T, th *SearchTestHelper) {
t.Run("Return all users in team", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
})
@@ -192,15 +192,15 @@ func testGetAllUsersInChannelWithEmptyTerm(t *testing.T, th *SearchTestHelper) {
t.Run("Return all users in teams even though some of them don't have a team associated", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
userAlternate, err := th.createUser("user-alternate", "user-alternate", "user", "alternate")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
userGuest, err := th.createGuest("user-guest", "user-guest", "user", "guest")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userGuest)
// In case teamId and channelId are empty our current logic goes through Search
users, err := th.Store.User().Search("", "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2, th.UserAnotherTeam,
userAlternate, userGuest}, users)
})
@@ -208,24 +208,24 @@ func testGetAllUsersInChannelWithEmptyTerm(t *testing.T, th *SearchTestHelper) {
func testHonorChannelRestrictionsAutocompletingUsers(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("user-alternate", "user-alternate", "user", "alternate")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
guest, err := th.createGuest("guest", "guest", "guest", "one")
require.Nil(t, err)
require.NoError(t, err)
err = th.addUserToTeams(guest, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(guest, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(guest)
t.Run("Autocomplete users with channel restrictions", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
options.ViewRestrictions = &model.ViewUsersRestrictions{Channels: []string{th.ChannelBasic.Id}}
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, userAlternate, guest}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
@@ -233,7 +233,7 @@ func testHonorChannelRestrictionsAutocompletingUsers(t *testing.T, th *SearchTes
options := createDefaultOptions(true, false, false)
options.ViewRestrictions = &model.ViewUsersRestrictions{Channels: []string{th.ChannelBasic.Id}}
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alt", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
@@ -241,7 +241,7 @@ func testHonorChannelRestrictionsAutocompletingUsers(t *testing.T, th *SearchTes
options := createDefaultOptions(true, false, false)
options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{}, Channels: []string{}}
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
@@ -249,7 +249,7 @@ func testHonorChannelRestrictionsAutocompletingUsers(t *testing.T, th *SearchTes
options := createDefaultOptions(true, false, false)
options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{}, Channels: []string{}}
users, err := th.Store.User().AutocompleteUsersInChannel("", th.ChannelBasic.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
@@ -258,7 +258,7 @@ func testHonorChannelRestrictionsAutocompletingUsers(t *testing.T, th *SearchTes
options.ViewRestrictions = &model.ViewUsersRestrictions{Channels: []string{th.ChannelBasic.Id}}
// In case teamId and channelId are empty our current logic goes through Search
users, err := th.Store.User().Search("", "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate, guest, th.User}, users)
})
}
@@ -268,7 +268,7 @@ func testHonorTeamRestrictionsAutocompletingUsers(t *testing.T, th *SearchTestHe
options := createDefaultOptions(true, false, false)
options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{th.Team.Id}}
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
})
@@ -276,7 +276,7 @@ func testHonorTeamRestrictionsAutocompletingUsers(t *testing.T, th *SearchTestHe
options := createDefaultOptions(true, false, false)
options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{}, Channels: []string{}}
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
@@ -284,11 +284,11 @@ func testHonorTeamRestrictionsAutocompletingUsers(t *testing.T, th *SearchTestHe
options := createDefaultOptions(true, false, false)
options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{th.AnotherTeam.Id}}
users, err := th.Store.User().Search(th.Team.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users)
acusers, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, acusers.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, acusers.OutOfChannel)
})
@@ -298,7 +298,7 @@ func testShouldReturnNothingWithoutProperAccess(t *testing.T, th *SearchTestHelp
options := createDefaultOptions(true, false, false)
options.ListOfAllowedChannels = []string{th.ChannelBasic.Id}
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
@@ -306,351 +306,351 @@ func testShouldReturnNothingWithoutProperAccess(t *testing.T, th *SearchTestHelp
options := createDefaultOptions(true, false, false)
options.ListOfAllowedChannels = []string{}
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
}
func testAutocompleteUserByUsername(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("alternateusername", "alternatenick", "user", "alternate")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
}
func testAutocompleteUserByFirstName(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("user-alternate", "user-alternate", "altfirstname", "lastname")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
t.Run("Should autocomplete users when the first name is unique", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "altfirstname", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should autocomplete users for in the channel and out of the channel with the same first name", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicfirstname", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
})
}
func testAutocompleteUserByLastName(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("user-alternate", "user-alternate", "firstname", "altlastname")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
t.Run("Should return results when the last name is unique", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "altlastname", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should return results for in the channel and out of the channel with the same last name", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basiclastname", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
})
}
func testAutocompleteUserByNickName(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("alternateusername", "alternatenickname", "firstname", "altlastname")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
t.Run("Should return results when the nickname is unique", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternatenickname", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should return users that share the same part of the nickname", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicnickname", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
})
}
func testAutocompleteUserByEmail(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("alternateusername", "alternatenickname", "firstname", "altlastname")
require.Nil(t, err)
require.NoError(t, err)
userAlternate.Email = "useralt@test.email.com"
_, err = th.Store.User().Update(userAlternate, false)
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
t.Run("Should autocomplete users when the email is unique", func(t *testing.T) {
options := createDefaultOptions(false, true, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "useralt@test.email.com", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should autocomplete users that share the same email user prefix", func(t *testing.T) {
options := createDefaultOptions(false, true, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "success_", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
})
t.Run("Should autocomplete users that share the same email domain", func(t *testing.T) {
options := createDefaultOptions(false, true, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "simulator.amazon.com", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
})
t.Run("Should search users when the email is unique", func(t *testing.T) {
options := createDefaultOptions(false, true, false)
users, err := th.Store.User().Search(th.Team.Id, "useralt@test.email.com", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
})
t.Run("Should search users that share the same email user prefix", func(t *testing.T) {
options := createDefaultOptions(false, true, false)
users, err := th.Store.User().Search(th.Team.Id, "success_", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users)
})
t.Run("Should search users that share the same email domain", func(t *testing.T) {
options := createDefaultOptions(false, true, false)
users, err := th.Store.User().Search(th.Team.Id, "simulator.amazon.com", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users)
})
}
func testShouldNotMatchSpecificQueriesEmail(t *testing.T, th *SearchTestHelper) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "success_", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
}
func testAutocompleteUserByUsernameWithDot(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("alternate.username", "alternatenickname", "firstname", "altlastname")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
t.Run("Should return results when searching for the whole username with Dot", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate.username", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should return results when searching for part of the username including the Dot", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, ".username", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should return results when searching for part of the username not including the Dot", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
}
func testAutocompleteUserByUsernameWithUnderscore(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("alternate_username", "alternatenickname", "firstname", "altlastname")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
t.Run("Should return results when searching for the whole username with underscore", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate_username", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should return results when searching for part of the username including the underscore", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "_username", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should return results when searching for part of the username not including the underscore", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
}
func testAutocompleteUserByUsernameWithHyphen(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("alternate-username", "alternatenickname", "firstname", "altlastname")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
t.Run("Should return results when searching for the whole username with hyphen", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate-username", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should return results when searching for part of the username including the hyphen", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "-username", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should return results when searching for part of the username not including the hyphen", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
}
func testShouldEscapePercentageCharacter(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("alternateusername", "alternate%nickname", "firstname", "altlastname")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
t.Run("Should autocomplete users escaping percentage symbol", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate%", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should search users escaping percentage symbol", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().Search(th.Team.Id, "alternate%", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
})
}
func testShouldEscapeUnderscoreCharacter(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("alternate_username", "alternatenickname", "firstname", "altlastname")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
t.Run("Should autocomplete users escaping underscore symbol", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate_", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should search users escaping underscore symbol", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().Search(th.Team.Id, "alternate_", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
})
}
func testShouldBeAbleToSearchInactiveUsers(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("basicusernamealternate", "alternatenickname", "firstname", "altlastname")
require.Nil(t, err)
require.NoError(t, err)
userAlternate.DeleteAt = model.GetMillis()
_, err = th.Store.User().Update(userAlternate, true)
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
t.Run("Should autocomplete inactive users if we allow it", func(t *testing.T) {
options := createDefaultOptions(false, false, true)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
})
t.Run("Should search inactive users if we allow it", func(t *testing.T) {
options := createDefaultOptions(false, false, true)
users, err := th.Store.User().Search(th.Team.Id, "basicusername", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2, userAlternate}, users)
})
t.Run("Shouldn't autocomplete inactive users if we don't allow it", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
})
t.Run("Shouldn't search inactive users if we don't allow it", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().Search(th.Team.Id, "basicusername", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2}, users)
})
}
func testShouldBeAbleToSearchFilteringByRole(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("basicusernamealternate", "alternatenickname", "firstname", "altlastname")
require.Nil(t, err)
require.NoError(t, err)
userAlternate.Roles = "system_admin system_user"
_, err = th.Store.User().Update(userAlternate, true)
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
userAlternate2, err := th.createUser("basicusernamealternate2", "alternatenickname2", "firstname2", "altlastname2")
require.Nil(t, err)
require.NoError(t, err)
userAlternate2.Roles = "system_user"
_, err = th.Store.User().Update(userAlternate2, true)
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate2)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
err = th.addUserToTeams(userAlternate2, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
t.Run("Should autocomplete users filtering by roles", func(t *testing.T) {
options := createDefaultOptions(false, false, true)
options.Role = "system_admin"
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
@@ -658,7 +658,7 @@ func testShouldBeAbleToSearchFilteringByRole(t *testing.T, th *SearchTestHelper)
options := createDefaultOptions(false, false, true)
options.Role = "system_admin"
users, err := th.Store.User().Search(th.Team.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
})
}
@@ -667,14 +667,14 @@ func testShouldIgnoreLeadingAtSymbols(t *testing.T, th *SearchTestHelper) {
t.Run("Should autocomplete ignoring the @ symbol at the beginning", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "@basicusername", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
})
t.Run("Should search ignoring the @ symbol at the beginning", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().Search(th.Team.Id, "@basicusername", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2}, users)
})
}
@@ -682,31 +682,31 @@ func testShouldIgnoreLeadingAtSymbols(t *testing.T, th *SearchTestHelper) {
func testSearchUsersShouldBeCaseInsensitive(t *testing.T, th *SearchTestHelper) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "BaSiCUsErNaMe", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
}
func testSearchOneTwoCharUsersnameAndFirstLastNames(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("ho", "alternatenickname", "zi", "k")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
t.Run("Should support two characters in the full name", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "zi", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should support two characters in the username", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "ho", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
@@ -714,24 +714,24 @@ func testSearchOneTwoCharUsersnameAndFirstLastNames(t *testing.T, th *SearchTest
func testShouldSupportKoreanCharacters(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("alternate-username", "alternate-nickname", "서강준", "안신원")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
t.Run("Should support hanja korean characters", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "서강준", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
t.Run("Should support hangul korean characters", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "안신원", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
})
@@ -739,15 +739,15 @@ func testShouldSupportKoreanCharacters(t *testing.T, th *SearchTestHelper) {
func testSearchWithHyphenAtTheEndOfTheTerm(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("alternate-username", "alternate-nickname", "altfirst", "altlast")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate-", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
}
@@ -756,39 +756,39 @@ func testSearchUsersInTeam(t *testing.T, th *SearchTestHelper) {
t.Run("Should return all the team users", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().Search(th.Team.Id, "", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2}, users)
})
t.Run("Should return all the team users with no team id", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().Search("", "basicusername", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2, th.UserAnotherTeam}, users)
})
t.Run("Should return all the team users filtered by username", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().Search(th.Team.Id, "basicusername1", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users)
})
t.Run("Should not return spurious results", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().Search(th.Team.Id, "falseuser", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users)
})
t.Run("Should return all the team users filtered by username and with channel restrictions", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
options.ViewRestrictions = &model.ViewUsersRestrictions{Channels: []string{th.ChannelBasic.Id}}
users, err := th.Store.User().Search(th.Team.Id, "basicusername", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users)
})
t.Run("Should return all the team users filtered by username and with all channel restricted", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
options.ViewRestrictions = &model.ViewUsersRestrictions{Channels: []string{}}
users, err := th.Store.User().Search(th.Team.Id, "basicusername1", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users)
})
t.Run("Should honor the limit when searching users in team", func(t *testing.T) {
@@ -797,50 +797,50 @@ func testSearchUsersInTeam(t *testing.T, th *SearchTestHelper) {
}
users, err := th.Store.User().Search(th.Team.Id, "", optionsWithLimit)
require.Nil(t, err)
require.NoError(t, err)
require.Len(t, users, 1)
})
}
func testSearchUsersInTeamUsernameWithDot(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("alternate.username", "altnickname", "altfirst", "altlast")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().Search(th.Team.Id, "alternate.", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
}
func testSearchUsersInTeamUsernameWithHyphen(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("alternate-username", "altnickname", "altfirst", "altlast")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().Search(th.Team.Id, "alternate-", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
}
func testSearchUsersInTeamUsernameWithUnderscore(t *testing.T, th *SearchTestHelper) {
userAlternate, err := th.createUser("alternate_username", "altnickname", "altfirst", "altlast")
require.Nil(t, err)
require.NoError(t, err)
defer th.deleteUser(userAlternate)
err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
require.Nil(t, err)
require.NoError(t, err)
_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
require.Nil(t, err)
require.NoError(t, err)
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().Search(th.Team.Id, "alternate_", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
}
@@ -848,19 +848,19 @@ func testSearchUsersByFullName(t *testing.T, th *SearchTestHelper) {
t.Run("Should search users by full name", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().Search(th.Team.Id, "basicfirstname", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2}, users)
})
t.Run("Should search user by full name", func(t *testing.T) {
options := createDefaultOptions(true, false, false)
users, err := th.Store.User().Search(th.Team.Id, "basicfirstname1", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users)
})
t.Run("Should return empty when search by full name and is deactivated", func(t *testing.T) {
options := createDefaultOptions(false, false, false)
users, err := th.Store.User().Search(th.Team.Id, "basicfirstname1", options)
require.Nil(t, err)
require.NoError(t, err)
th.assertUsersMatchInAnyOrder(t, []*model.User{}, users)
})
}