From 8b6ac5f5d2a7a2fbfa3c88498b02a3bb3552ecd9 Mon Sep 17 00:00:00 2001 From: SimonSimonB Date: Mon, 4 Jan 2021 05:45:17 +0100 Subject: [PATCH] Removed AppError from searchlayer/user_layer.go (#16532) Automatic Merge --- store/searchlayer/user_layer.go | 47 +++--- store/searchtest/user_layer.go | 264 ++++++++++++++++---------------- 2 files changed, 152 insertions(+), 159 deletions(-) diff --git a/store/searchlayer/user_layer.go b/store/searchlayer/user_layer.go index 2d9d769adf..b57c950e3a 100644 --- a/store/searchlayer/user_layer.go +++ b/store/searchlayer/user_layer.go @@ -4,14 +4,13 @@ package searchlayer import ( - "errors" - "net/http" "strings" "github.com/mattermost/mattermost-server/v5/mlog" "github.com/mattermost/mattermost-server/v5/model" "github.com/mattermost/mattermost-server/v5/services/searchengine" "github.com/mattermost/mattermost-server/v5/store" + "github.com/pkg/errors" ) type SearchUserStore struct { @@ -36,9 +35,9 @@ func (s *SearchUserStore) deleteUserIndex(user *model.User) { func (s *SearchUserStore) Search(teamId, term string, options *model.UserSearchOptions) ([]*model.User, error) { for _, engine := range s.rootStore.searchEngine.GetActiveEngines() { if engine.IsSearchEnabled() { - listOfAllowedChannels, err := s.getListOfAllowedChannelsForTeam(teamId, options.ViewRestrictions) - if err != nil { - mlog.Error("Encountered error on Search.", mlog.String("search_engine", engine.GetName()), mlog.Err(err)) + listOfAllowedChannels, nErr := s.getListOfAllowedChannelsForTeam(teamId, options.ViewRestrictions) + if nErr != nil { + mlog.Error("Encountered error on Search.", mlog.String("search_engine", engine.GetName()), mlog.Err(nErr)) continue } @@ -100,7 +99,7 @@ func (s *SearchUserStore) PermanentDelete(userId string) error { return err } -func (s *SearchUserStore) autocompleteUsersInChannelByEngine(engine searchengine.SearchEngineInterface, teamId, channelId, term string, options *model.UserSearchOptions) (*model.UserAutocompleteInChannel, *model.AppError) { +func (s *SearchUserStore) autocompleteUsersInChannelByEngine(engine searchengine.SearchEngineInterface, teamId, channelId, term string, options *model.UserSearchOptions) (*model.UserAutocompleteInChannel, error) { var err *model.AppError uchanIds := []string{} nuchanIds := []string{} @@ -116,15 +115,15 @@ func (s *SearchUserStore) autocompleteUsersInChannelByEngine(engine searchengine uchan := make(chan store.StoreResult, 1) go func() { - users, err := s.UserStore.GetProfileByIds(uchanIds, nil, false) - uchan <- store.StoreResult{Data: users, NErr: err} + users, nErr := s.UserStore.GetProfileByIds(uchanIds, nil, false) + uchan <- store.StoreResult{Data: users, NErr: nErr} close(uchan) }() nuchan := make(chan store.StoreResult, 1) go func() { - users, err := s.UserStore.GetProfileByIds(nuchanIds, nil, false) - nuchan <- store.StoreResult{Data: users, NErr: err} + users, nErr := s.UserStore.GetProfileByIds(nuchanIds, nil, false) + nuchan <- store.StoreResult{Data: users, NErr: nErr} close(nuchan) }() @@ -132,14 +131,14 @@ func (s *SearchUserStore) autocompleteUsersInChannelByEngine(engine searchengine result := <-uchan if result.NErr != nil { - return nil, model.NewAppError("autocompleteUsersInChannelByEngine", "app.user.get_profiles.app_error", nil, result.NErr.Error(), http.StatusInternalServerError) + return nil, errors.Wrap(result.NErr, "failed to get user profiles by ids") } inUsers := result.Data.([]*model.User) autocomplete.InChannel = inUsers result = <-nuchan if result.NErr != nil { - return nil, model.NewAppError("autocompleteUsersInChannelByEngine", "app.user.get_profiles.app_error", nil, result.NErr.Error(), http.StatusInternalServerError) + return nil, errors.Wrap(result.NErr, "failed to get user profiles by ids") } outUsers := result.Data.([]*model.User) autocomplete.OutOfChannel = outUsers @@ -158,7 +157,7 @@ func (s *SearchUserStore) autocompleteUsersInChannelByEngine(engine searchengine // - If we receive channels restrictions we get: // - If we don't have team id, we get those restricted channels (guest accounts and quick search) // - If we have a team id then we only return those restricted channels that belongs to that team -func (s *SearchUserStore) getListOfAllowedChannelsForTeam(teamId string, viewRestrictions *model.ViewUsersRestrictions) ([]string, *model.AppError) { +func (s *SearchUserStore) getListOfAllowedChannelsForTeam(teamId string, viewRestrictions *model.ViewUsersRestrictions) ([]string, error) { var listOfAllowedChannels []string if viewRestrictions == nil && teamId == "" { // nil return without error means all channels are allowed @@ -168,13 +167,7 @@ func (s *SearchUserStore) getListOfAllowedChannelsForTeam(teamId string, viewRes if teamId != "" && (viewRestrictions == nil || strings.Contains(strings.Join(viewRestrictions.Teams, "."), teamId)) { channels, err := s.rootStore.Channel().GetTeamChannels(teamId) if err != nil { - var nfErr *store.ErrNotFound - switch { - case errors.As(err, &nfErr): - return nil, model.NewAppError("getListOfAllowedChannelsForTeam", "app.channel.get_channels.not_found.app_error", nil, nfErr.Error(), http.StatusNotFound) - default: - return nil, model.NewAppError("getListOfAllowedChannelsForTeam", "app.channel.get_channels.get.app_error", nil, err.Error(), http.StatusInternalServerError) - } + return nil, errors.Wrap(err, "failed to get team channels") } for _, channel := range *channels { listOfAllowedChannels = append(listOfAllowedChannels, channel.Id) @@ -185,7 +178,7 @@ func (s *SearchUserStore) getListOfAllowedChannelsForTeam(teamId string, viewRes if len(viewRestrictions.Channels) > 0 { channels, err := s.rootStore.Channel().GetChannelsByIds(viewRestrictions.Channels, false) if err != nil { - return nil, model.NewAppError("getListOfAllowedChannelsForTeam", "app.channel.get_channels_by_ids.app_error", nil, err.Error(), http.StatusInternalServerError) + return nil, errors.Wrap(err, "failed to get channels by ids") } for _, c := range channels { if teamId == "" || (teamId != "" && c.TeamId == teamId) { @@ -201,18 +194,18 @@ func (s *SearchUserStore) getListOfAllowedChannelsForTeam(teamId string, viewRes func (s *SearchUserStore) AutocompleteUsersInChannel(teamId, channelId, term string, options *model.UserSearchOptions) (*model.UserAutocompleteInChannel, error) { for _, engine := range s.rootStore.searchEngine.GetActiveEngines() { if engine.IsAutocompletionEnabled() { - listOfAllowedChannels, err := s.getListOfAllowedChannelsForTeam(teamId, options.ViewRestrictions) - if err != nil { - mlog.Error("Encountered error on AutocompleteUsersInChannel.", mlog.String("search_engine", engine.GetName()), mlog.Err(err)) + listOfAllowedChannels, nErr := s.getListOfAllowedChannelsForTeam(teamId, options.ViewRestrictions) + if nErr != nil { + mlog.Error("Encountered error on AutocompleteUsersInChannel.", mlog.String("search_engine", engine.GetName()), mlog.Err(nErr)) continue } if listOfAllowedChannels != nil && len(listOfAllowedChannels) == 0 { return &model.UserAutocompleteInChannel{}, nil } options.ListOfAllowedChannels = listOfAllowedChannels - autocomplete, err := s.autocompleteUsersInChannelByEngine(engine, teamId, channelId, term, options) - if err != nil { - mlog.Error("Encountered error on AutocompleteUsersInChannel.", mlog.String("search_engine", engine.GetName()), mlog.Err(err)) + autocomplete, nErr := s.autocompleteUsersInChannelByEngine(engine, teamId, channelId, term, options) + if nErr != nil { + mlog.Error("Encountered error on AutocompleteUsersInChannel.", mlog.String("search_engine", engine.GetName()), mlog.Err(nErr)) continue } mlog.Debug("Using the first available search engine", mlog.String("search_engine", engine.GetName())) diff --git a/store/searchtest/user_layer.go b/store/searchtest/user_layer.go index 7fb85b250b..2352a524f7 100644 --- a/store/searchtest/user_layer.go +++ b/store/searchtest/user_layer.go @@ -223,32 +223,32 @@ func testHonorChannelRestrictionsAutocompletingUsers(t *testing.T, th *SearchTes 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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, userAlternate, guest}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) }) t.Run("Autocomplete users with term and channel restrictions", func(t *testing.T) { options := createDefaultOptions(true, false, false) options.ViewRestrictions = &model.ViewUsersRestrictions{Channels: []string{th.ChannelBasic.Id}} - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alt", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alt", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) }) t.Run("Autocomplete users with all channels restricted", func(t *testing.T) { options := createDefaultOptions(true, false, false) options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{}, Channels: []string{}} - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) }) t.Run("Autocomplete users with all channels restricted but with empty team", func(t *testing.T) { options := createDefaultOptions(true, false, false) options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{}, Channels: []string{}} - users, apperr := th.Store.User().AutocompleteUsersInChannel("", th.ChannelBasic.Id, "", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel("", th.ChannelBasic.Id, "", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) }) @@ -266,16 +266,16 @@ func testHonorTeamRestrictionsAutocompletingUsers(t *testing.T, th *SearchTestHe t.Run("Should return results for users in the team", func(t *testing.T) { options := createDefaultOptions(true, false, false) options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{th.Team.Id}} - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel) }) t.Run("Should return empty because we're filtering all the teams", func(t *testing.T) { options := createDefaultOptions(true, false, false) options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{}, Channels: []string{}} - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) }) @@ -296,16 +296,16 @@ func testShouldReturnNothingWithoutProperAccess(t *testing.T, th *SearchTestHelp t.Run("Should return results users for the defined channel in the list", func(t *testing.T) { options := createDefaultOptions(true, false, false) options.ListOfAllowedChannels = []string{th.ChannelBasic.Id} - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) }) t.Run("Should return empty because we're filtering all the channels", func(t *testing.T) { options := createDefaultOptions(true, false, false) options.ListOfAllowedChannels = []string{} - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) }) @@ -319,8 +319,8 @@ func testAutocompleteUserByUsername(t *testing.T, th *SearchTestHelper) { _, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id}) require.Nil(t, err) options := createDefaultOptions(false, false, false) - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel) } @@ -334,15 +334,15 @@ func testAutocompleteUserByFirstName(t *testing.T, th *SearchTestHelper) { require.Nil(t, err) t.Run("Should autocomplete users when the first name is unique", func(t *testing.T) { options := createDefaultOptions(true, false, false) - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "altfirstname", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "altfirstname", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicfirstname", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicfirstname", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel) }) @@ -357,15 +357,15 @@ func testAutocompleteUserByLastName(t *testing.T, th *SearchTestHelper) { require.Nil(t, err) t.Run("Should return results when the last name is unique", func(t *testing.T) { options := createDefaultOptions(true, false, false) - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "altlastname", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "altlastname", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basiclastname", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basiclastname", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel) }) @@ -380,15 +380,15 @@ func testAutocompleteUserByNickName(t *testing.T, th *SearchTestHelper) { require.Nil(t, err) t.Run("Should return results when the nickname is unique", func(t *testing.T) { options := createDefaultOptions(true, false, false) - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternatenickname", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternatenickname", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicnickname", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicnickname", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel) }) @@ -397,8 +397,8 @@ func testAutocompleteUserByEmail(t *testing.T, th *SearchTestHelper) { userAlternate, err := th.createUser("alternateusername", "alternatenickname", "firstname", "altlastname") require.Nil(t, err) userAlternate.Email = "useralt@test.email.com" - _, apperr := th.Store.User().Update(userAlternate, false) - require.Nil(t, apperr) + _, err = th.Store.User().Update(userAlternate, false) + require.Nil(t, err) defer th.deleteUser(userAlternate) err = th.addUserToTeams(userAlternate, []string{th.Team.Id}) require.Nil(t, err) @@ -406,48 +406,48 @@ func testAutocompleteUserByEmail(t *testing.T, th *SearchTestHelper) { require.Nil(t, err) t.Run("Should autocomplete users when the email is unique", func(t *testing.T) { options := createDefaultOptions(false, true, false) - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "useralt@test.email.com", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "useralt@test.email.com", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "success_", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "success_", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "simulator.amazon.com", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "simulator.amazon.com", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "useralt@test.email.com", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "useralt@test.email.com", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "success_", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "success_", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "simulator.amazon.com", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "simulator.amazon.com", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users) }) } func testShouldNotMatchSpecificQueriesEmail(t *testing.T, th *SearchTestHelper) { options := createDefaultOptions(false, false, false) - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "success_", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "success_", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) } @@ -461,22 +461,22 @@ func testAutocompleteUserByUsernameWithDot(t *testing.T, th *SearchTestHelper) { require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate.username", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate.username", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, ".username", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, ".username", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) }) @@ -491,22 +491,22 @@ func testAutocompleteUserByUsernameWithUnderscore(t *testing.T, th *SearchTestHe require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate_username", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate_username", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "_username", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "_username", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) }) @@ -521,22 +521,22 @@ func testAutocompleteUserByUsernameWithHyphen(t *testing.T, th *SearchTestHelper require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate-username", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate-username", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "-username", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "-username", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) }) @@ -552,15 +552,15 @@ func testShouldEscapePercentageCharacter(t *testing.T, th *SearchTestHelper) { require.Nil(t, err) t.Run("Should autocomplete users escaping percentage symbol", func(t *testing.T) { options := createDefaultOptions(false, false, false) - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate%", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate%", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "alternate%", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "alternate%", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users) }) } @@ -574,15 +574,15 @@ func testShouldEscapeUnderscoreCharacter(t *testing.T, th *SearchTestHelper) { require.Nil(t, err) t.Run("Should autocomplete users escaping underscore symbol", func(t *testing.T) { options := createDefaultOptions(false, false, false) - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate_", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate_", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "alternate_", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "alternate_", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users) }) } @@ -591,8 +591,8 @@ func testShouldBeAbleToSearchInactiveUsers(t *testing.T, th *SearchTestHelper) { userAlternate, err := th.createUser("basicusernamealternate", "alternatenickname", "firstname", "altlastname") require.Nil(t, err) userAlternate.DeleteAt = model.GetMillis() - _, apperr := th.Store.User().Update(userAlternate, true) - require.Nil(t, apperr) + _, err = th.Store.User().Update(userAlternate, true) + require.Nil(t, err) defer th.deleteUser(userAlternate) err = th.addUserToTeams(userAlternate, []string{th.Team.Id}) require.Nil(t, err) @@ -600,28 +600,28 @@ func testShouldBeAbleToSearchInactiveUsers(t *testing.T, th *SearchTestHelper) { require.Nil(t, err) t.Run("Should autocomplete inactive users if we allow it", func(t *testing.T) { options := createDefaultOptions(false, false, true) - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "basicusername", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "basicusername", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "basicusername", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "basicusername", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2}, users) }) } @@ -630,14 +630,14 @@ func testShouldBeAbleToSearchFilteringByRole(t *testing.T, th *SearchTestHelper) userAlternate, err := th.createUser("basicusernamealternate", "alternatenickname", "firstname", "altlastname") require.Nil(t, err) userAlternate.Roles = "system_admin system_user" - _, apperr := th.Store.User().Update(userAlternate, true) - require.Nil(t, apperr) + _, err = th.Store.User().Update(userAlternate, true) + require.Nil(t, err) defer th.deleteUser(userAlternate) userAlternate2, err := th.createUser("basicusernamealternate2", "alternatenickname2", "firstname2", "altlastname2") require.Nil(t, err) userAlternate2.Roles = "system_user" - _, apperr = th.Store.User().Update(userAlternate2, true) - require.Nil(t, apperr) + _, err = th.Store.User().Update(userAlternate2, true) + require.Nil(t, err) defer th.deleteUser(userAlternate2) err = th.addUserToTeams(userAlternate, []string{th.Team.Id}) require.Nil(t, err) @@ -648,16 +648,16 @@ func testShouldBeAbleToSearchFilteringByRole(t *testing.T, th *SearchTestHelper) t.Run("Should autocomplete users filtering by roles", func(t *testing.T) { options := createDefaultOptions(false, false, true) options.Role = "system_admin" - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) }) t.Run("Should search users filtering by roles", func(t *testing.T) { options := createDefaultOptions(false, false, true) options.Role = "system_admin" - users, apperr := th.Store.User().Search(th.Team.Id, "", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users) }) } @@ -665,23 +665,23 @@ func testShouldBeAbleToSearchFilteringByRole(t *testing.T, th *SearchTestHelper) 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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "@basicusername", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "@basicusername", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "@basicusername", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "@basicusername", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2}, users) }) } func testSearchUsersShouldBeCaseInsensitive(t *testing.T, th *SearchTestHelper) { options := createDefaultOptions(false, false, false) - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "BaSiCUsErNaMe", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "BaSiCUsErNaMe", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel) } @@ -697,15 +697,15 @@ func testSearchOneTwoCharUsersnameAndFirstLastNames(t *testing.T, th *SearchTest require.Nil(t, err) t.Run("Should support two characters in the full name", func(t *testing.T) { options := createDefaultOptions(true, false, false) - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "zi", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "zi", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "ho", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "ho", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) }) @@ -722,15 +722,15 @@ func testShouldSupportKoreanCharacters(t *testing.T, th *SearchTestHelper) { require.Nil(t, err) t.Run("Should support hanja korean characters", func(t *testing.T) { options := createDefaultOptions(true, false, false) - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "서강준", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "서강준", options) + require.Nil(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, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "안신원", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "안신원", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) }) @@ -745,8 +745,8 @@ func testSearchWithHyphenAtTheEndOfTheTerm(t *testing.T, th *SearchTestHelper) { _, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id}) require.Nil(t, err) options := createDefaultOptions(true, false, false) - users, apperr := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate-", options) - require.Nil(t, apperr) + users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate-", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel) } @@ -754,40 +754,40 @@ func testSearchWithHyphenAtTheEndOfTheTerm(t *testing.T, th *SearchTestHelper) { 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, apperr := th.Store.User().Search(th.Team.Id, "", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "", options) + require.Nil(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, apperr := th.Store.User().Search("", "basicusername", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search("", "basicusername", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "basicusername1", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "basicusername1", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "falseuser", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "falseuser", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "basicusername", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "basicusername", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "basicusername1", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "basicusername1", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users) }) t.Run("Should honor the limit when searching users in team", func(t *testing.T) { @@ -795,8 +795,8 @@ func testSearchUsersInTeam(t *testing.T, th *SearchTestHelper) { Limit: 1, } - users, apperr := th.Store.User().Search(th.Team.Id, "", optionsWithLimit) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "", optionsWithLimit) + require.Nil(t, err) require.Len(t, users, 1) }) } @@ -810,8 +810,8 @@ func testSearchUsersInTeamUsernameWithDot(t *testing.T, th *SearchTestHelper) { _, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id}) require.Nil(t, err) options := createDefaultOptions(true, false, false) - users, apperr := th.Store.User().Search(th.Team.Id, "alternate.", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "alternate.", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users) } @@ -824,8 +824,8 @@ func testSearchUsersInTeamUsernameWithHyphen(t *testing.T, th *SearchTestHelper) _, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id}) require.Nil(t, err) options := createDefaultOptions(true, false, false) - users, apperr := th.Store.User().Search(th.Team.Id, "alternate-", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "alternate-", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users) } @@ -838,28 +838,28 @@ func testSearchUsersInTeamUsernameWithUnderscore(t *testing.T, th *SearchTestHel _, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id}) require.Nil(t, err) options := createDefaultOptions(true, false, false) - users, apperr := th.Store.User().Search(th.Team.Id, "alternate_", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "alternate_", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users) } 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, apperr := th.Store.User().Search(th.Team.Id, "basicfirstname", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "basicfirstname", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "basicfirstname1", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "basicfirstname1", options) + require.Nil(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, apperr := th.Store.User().Search(th.Team.Id, "basicfirstname1", options) - require.Nil(t, apperr) + users, err := th.Store.User().Search(th.Team.Id, "basicfirstname1", options) + require.Nil(t, err) th.assertUsersMatchInAnyOrder(t, []*model.User{}, users) }) }