Removed AppError from searchlayer/user_layer.go (#16532)

Automatic Merge

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)
+			listOfAllowedChannels, nErr := s.getListOfAllowedChannelsForTeam(teamId, options.ViewRestrictions)
-			if err != nil {
+			if nErr != nil {
-				mlog.Error("Encountered error on Search.", mlog.String("search_engine", engine.GetName()), mlog.Err(err))
+				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)
+		users, nErr := s.UserStore.GetProfileByIds(uchanIds, nil, false)
-		uchan <- store.StoreResult{Data: users, NErr: err}
+		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)
+		users, nErr := s.UserStore.GetProfileByIds(nuchanIds, nil, false)
-		nuchan <- store.StoreResult{Data: users, NErr: err}
+		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
+			return nil, errors.Wrap(err, "failed to get team channels")
-			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)
-			}
 		}
 		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)
+			listOfAllowedChannels, nErr := s.getListOfAllowedChannelsForTeam(teamId, options.ViewRestrictions)
-			if err != nil {
+			if nErr != nil {
-				mlog.Error("Encountered error on AutocompleteUsersInChannel.", mlog.String("search_engine", engine.GetName()), mlog.Err(err))
+				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)
+			autocomplete, nErr := s.autocompleteUsersInChannelByEngine(engine, teamId, channelId, term, options)
-			if err != nil {
+			if nErr != nil {
-				mlog.Error("Encountered error on AutocompleteUsersInChannel.", mlog.String("search_engine", engine.GetName()), mlog.Err(err))
+				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()))

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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alt", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel("", th.ChannelBasic.Id, "", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, apperr)
+		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)
+	users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options)
-	require.Nil(t, apperr)
+	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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "altfirstname", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicfirstname", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "altlastname", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basiclastname", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternatenickname", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicnickname", options)
-		require.Nil(t, apperr)
+		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)
+	_, err = th.Store.User().Update(userAlternate, false)
-	require.Nil(t, apperr)
+	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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "useralt@test.email.com", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "success_", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "simulator.amazon.com", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "useralt@test.email.com", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "success_", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "simulator.amazon.com", options)
-		require.Nil(t, apperr)
+		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)
+	users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "success_", options)
-	require.Nil(t, apperr)
+	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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate.username", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, ".username", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate_username", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "_username", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate-username", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "-username", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate%", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "alternate%", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate_", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "alternate_", options)
-		require.Nil(t, apperr)
+		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)
+	_, err = th.Store.User().Update(userAlternate, true)
-	require.Nil(t, apperr)
+	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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "basicusername", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "basicusername", options)
-		require.Nil(t, apperr)
+		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)
+	_, err = th.Store.User().Update(userAlternate, true)
-	require.Nil(t, apperr)
+	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)
+	_, err = th.Store.User().Update(userAlternate2, true)
-	require.Nil(t, apperr)
+	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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "@basicusername", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "@basicusername", options)
-		require.Nil(t, apperr)
+		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)
+	users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "BaSiCUsErNaMe", options)
-	require.Nil(t, apperr)
+	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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "zi", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "ho", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "서강준", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "안신원", options)
-		require.Nil(t, apperr)
+		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)
+	users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate-", options)
-	require.Nil(t, apperr)
+	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)
+		users, err := th.Store.User().Search(th.Team.Id, "", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search("", "basicusername", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "basicusername1", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "falseuser", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "basicusername", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "basicusername1", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "", optionsWithLimit)
-		require.Nil(t, apperr)
+		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)
+	users, err := th.Store.User().Search(th.Team.Id, "alternate.", options)
-	require.Nil(t, apperr)
+	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)
+	users, err := th.Store.User().Search(th.Team.Id, "alternate-", options)
-	require.Nil(t, apperr)
+	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)
+	users, err := th.Store.User().Search(th.Team.Id, "alternate_", options)
-	require.Nil(t, apperr)
+	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)
+		users, err := th.Store.User().Search(th.Team.Id, "basicfirstname", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "basicfirstname1", options)
-		require.Nil(t, apperr)
+		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)
+		users, err := th.Store.User().Search(th.Team.Id, "basicfirstname1", options)
-		require.Nil(t, apperr)
+		require.Nil(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users)
 	})
 }