[MM-16667] Migrate User.GetByUsername to Sync by default #11453 (#11520)

* Migrate User.GetByUsername to Sync by default #11453

* fix app errors #11453

* fix app errors #11453

* fix cmd error #11453

* fix shadow var #11453

* fix shadow user var #11453

* fix test error

* fix test error #11453

app/command_groupmsg.go

@@ -47,10 +47,9 @@ func (me *groupmsgProvider) DoCommand(a *App, args *model.CommandArgs, message s
 	for _, username := range users {
 		username = strings.TrimSpace(username)
 		username = strings.TrimPrefix(username, "@")
-		if result := <-a.Srv.Store.User().GetByUsername(username); result.Err != nil {
+		if targetUser, err := a.Srv.Store.User().GetByUsername(username); err != nil {
 			invalidUsernames = append(invalidUsernames, username)
 		} else {
-			targetUser := result.Data.(*model.User)
 			_, exists := targetUsers[targetUser.Id]
 			if !exists && targetUser.Id != args.UserId {
 				targetUsers[targetUser.Id] = targetUser

app/command_invite.go

@@ -49,16 +49,15 @@ func (me *InviteProvider) DoCommand(a *App, args *model.CommandArgs, message str
 	targetUsername := splitMessage[0]
 	targetUsername = strings.TrimPrefix(targetUsername, "@")
 
-	result := <-a.Srv.Store.User().GetByUsername(targetUsername)
+	userProfile, err := a.Srv.Store.User().GetByUsername(targetUsername)
-	if result.Err != nil {
+	if err != nil {
-		mlog.Error(result.Err.Error())
+		mlog.Error(err.Error())
 		return &model.CommandResponse{
 			Text:         args.T("api.command_invite.missing_user.app_error"),
 			ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL,
 		}
 	}
 
-	userProfile := result.Data.(*model.User)
 	if userProfile.DeleteAt != 0 {
 		return &model.CommandResponse{
 			Text:         args.T("api.command_invite.missing_user.app_error"),
@@ -67,7 +66,6 @@ func (me *InviteProvider) DoCommand(a *App, args *model.CommandArgs, message str
 	}
 
 	var channelToJoin *model.Channel
-	var err *model.AppError
 	// User set a channel to add the invited user
 	if len(splitMessage) > 1 && splitMessage[1] != "" {
 		targetChannelName := strings.TrimPrefix(strings.TrimSpace(splitMessage[1]), "~")

app/command_msg.go

@@ -48,12 +48,10 @@ func (me *msgProvider) DoCommand(a *App, args *model.CommandArgs, message string
 	targetUsername = strings.SplitN(message, " ", 2)[0]
 	targetUsername = strings.TrimPrefix(targetUsername, "@")
 
-	var userProfile *model.User
+	userProfile, err := a.Srv.Store.User().GetByUsername(targetUsername)
-	if result := <-a.Srv.Store.User().GetByUsername(targetUsername); result.Err != nil {
+	if err != nil {
-		mlog.Error(result.Err.Error())
+		mlog.Error(err.Error())
 		return &model.CommandResponse{Text: args.T("api.command_msg.missing.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-	} else {
-		userProfile = result.Data.(*model.User)
 	}
 
 	if userProfile.Id == args.UserId {
@@ -70,7 +68,8 @@ func (me *msgProvider) DoCommand(a *App, args *model.CommandArgs, message string
 				return &model.CommandResponse{Text: args.T("api.command_msg.permission.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 			}
 
-			if directChannel, err := a.GetOrCreateDirectChannel(args.UserId, userProfile.Id); err != nil {
+			var directChannel *model.Channel
+			if directChannel, err = a.GetOrCreateDirectChannel(args.UserId, userProfile.Id); err != nil {
 				mlog.Error(err.Error())
 				return &model.CommandResponse{Text: args.T("api.command_msg.dm_fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 			} else {
@@ -89,7 +88,7 @@ func (me *msgProvider) DoCommand(a *App, args *model.CommandArgs, message string
 		post.Message = parsedMessage
 		post.ChannelId = targetChannelId
 		post.UserId = args.UserId
-		if _, err := a.CreatePostMissingChannel(post, true); err != nil {
+		if _, err = a.CreatePostMissingChannel(post, true); err != nil {
 			return &model.CommandResponse{Text: args.T("api.command_msg.fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 		}
 	}

app/command_remove.go

@@ -107,15 +107,14 @@ func doCommand(a *App, args *model.CommandArgs, message string) *model.CommandRe
 	targetUsername = strings.SplitN(message, " ", 2)[0]
 	targetUsername = strings.TrimPrefix(targetUsername, "@")
 
-	result := <-a.Srv.Store.User().GetByUsername(targetUsername)
+	userProfile, err := a.Srv.Store.User().GetByUsername(targetUsername)
-	if result.Err != nil {
+	if err != nil {
-		mlog.Error(result.Err.Error())
+		mlog.Error(err.Error())
 		return &model.CommandResponse{
 			Text:         args.T("api.command_remove.missing.app_error"),
 			ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL,
 		}
 	}
-	userProfile := result.Data.(*model.User)
 	if userProfile.DeleteAt != 0 {
 		return &model.CommandResponse{
 			Text:         args.T("api.command_remove.missing.app_error"),

app/import_functions.go

@@ -293,9 +293,9 @@ func (a *App) ImportUser(data *UserImportData, dryRun bool) *model.AppError {
 	hasUserEmailVerifiedChanged := false
 
 	var user *model.User
-	if result := <-a.Srv.Store.User().GetByUsername(*data.Username); result.Err == nil {
+	var err *model.AppError
-		user = result.Data.(*model.User)
+	user, err = a.Srv.Store.User().GetByUsername(*data.Username)
-	} else {
+	if err != nil {
 		user = &model.User{}
 		user.MakeNonNil()
 		user.SetDefaultNotifications()
@@ -470,7 +470,6 @@ func (a *App) ImportUser(data *UserImportData, dryRun bool) *model.AppError {
 		}
 	}
 
-	var err *model.AppError
 	var savedUser *model.User
 	if user.Id == "" {
 		if savedUser, err = a.createUser(user); err != nil {
@@ -826,15 +825,16 @@ func (a *App) ImportUserChannels(user *model.User, team *model.Team, teamMember
 }
 
 func (a *App) ImportReaction(data *ReactionImportData, post *model.Post, dryRun bool) *model.AppError {
-	if err := validateReactionImportData(data, post.CreateAt); err != nil {
+	var err *model.AppError
+	if err = validateReactionImportData(data, post.CreateAt); err != nil {
 		return err
 	}
 
-	result := <-a.Srv.Store.User().GetByUsername(*data.User)
+	var user *model.User
-	if result.Err != nil {
+	user, err = a.Srv.Store.User().GetByUsername(*data.User)
-		return model.NewAppError("BulkImport", "app.import.import_post.user_not_found.error", map[string]interface{}{"Username": data.User}, result.Err.Error(), http.StatusBadRequest)
+	if err != nil {
+		return model.NewAppError("BulkImport", "app.import.import_post.user_not_found.error", map[string]interface{}{"Username": data.User}, err.Error(), http.StatusBadRequest)
 	}
-	user := result.Data.(*model.User)
 
 	reaction := &model.Reaction{
 		UserId:    user.Id,
@@ -842,22 +842,24 @@ func (a *App) ImportReaction(data *ReactionImportData, post *model.Post, dryRun
 		EmojiName: *data.EmojiName,
 		CreateAt:  *data.CreateAt,
 	}
-	if _, err := a.Srv.Store.Reaction().Save(reaction); err != nil {
+	if _, err = a.Srv.Store.Reaction().Save(reaction); err != nil {
 		return err
 	}
+
 	return nil
 }
 
 func (a *App) ImportReply(data *ReplyImportData, post *model.Post, teamId string, dryRun bool) *model.AppError {
-	if err := validateReplyImportData(data, post.CreateAt, a.MaxPostSize()); err != nil {
+	var err *model.AppError
+	if err = validateReplyImportData(data, post.CreateAt, a.MaxPostSize()); err != nil {
 		return err
 	}
 
-	result := <-a.Srv.Store.User().GetByUsername(*data.User)
+	var user *model.User
-	if result.Err != nil {
+	user, err = a.Srv.Store.User().GetByUsername(*data.User)
-		return model.NewAppError("BulkImport", "app.import.import_post.user_not_found.error", map[string]interface{}{"Username": data.User}, result.Err.Error(), http.StatusBadRequest)
+	if err != nil {
+		return model.NewAppError("BulkImport", "app.import.import_post.user_not_found.error", map[string]interface{}{"Username": data.User}, err.Error(), http.StatusBadRequest)
 	}
-	user := result.Data.(*model.User)
 
 	// Check if this post already exists.
 	replies, err := a.Srv.Store.Post().GetPostsCreatedAt(post.ChannelId, *data.CreateAt)
@@ -951,11 +953,11 @@ func (a *App) ImportPost(data *PostImportData, dryRun bool) *model.AppError {
 		return model.NewAppError("BulkImport", "app.import.import_post.channel_not_found.error", map[string]interface{}{"ChannelName": *data.Channel}, err.Error(), http.StatusBadRequest)
 	}
 
-	result := <-a.Srv.Store.User().GetByUsername(*data.User)
+	var user *model.User
-	if result.Err != nil {
+	user, err = a.Srv.Store.User().GetByUsername(*data.User)
-		return model.NewAppError("BulkImport", "app.import.import_post.user_not_found.error", map[string]interface{}{"Username": *data.User}, result.Err.Error(), http.StatusBadRequest)
+	if err != nil {
+		return model.NewAppError("BulkImport", "app.import.import_post.user_not_found.error", map[string]interface{}{"Username": *data.User}, err.Error(), http.StatusBadRequest)
 	}
-	user := result.Data.(*model.User)
 
 	// Check if this post already exists.
 	posts, err := a.Srv.Store.Post().GetPostsCreatedAt(channel.Id, *data.CreateAt)
@@ -983,7 +985,8 @@ func (a *App) ImportPost(data *PostImportData, dryRun bool) *model.AppError {
 	post.Hashtags, _ = model.ParseHashtags(post.Message)
 
 	if data.Attachments != nil {
-		fileIds, err := a.uploadAttachments(data.Attachments, post, team.Id, dryRun)
+		var fileIds []string
+		fileIds, err = a.uploadAttachments(data.Attachments, post, team.Id, dryRun)
 		if err != nil {
 			return err
 		}
@@ -991,11 +994,11 @@ func (a *App) ImportPost(data *PostImportData, dryRun bool) *model.AppError {
 	}
 
 	if post.Id == "" {
-		if _, err := a.Srv.Store.Post().Save(post); err != nil {
+		if _, err = a.Srv.Store.Post().Save(post); err != nil {
 			return err
 		}
 	} else {
-		if _, err := a.Srv.Store.Post().Overwrite(post); err != nil {
+		if _, err = a.Srv.Store.Post().Overwrite(post); err != nil {
 			return err
 		}
 	}
@@ -1004,11 +1007,11 @@ func (a *App) ImportPost(data *PostImportData, dryRun bool) *model.AppError {
 		var preferences model.Preferences
 
 		for _, username := range *data.FlaggedBy {
-			result := <-a.Srv.Store.User().GetByUsername(username)
+			var user *model.User
-			if result.Err != nil {
+			user, err = a.Srv.Store.User().GetByUsername(username)
-				return model.NewAppError("BulkImport", "app.import.import_post.user_not_found.error", map[string]interface{}{"Username": username}, result.Err.Error(), http.StatusBadRequest)
+			if err != nil {
+				return model.NewAppError("BulkImport", "app.import.import_post.user_not_found.error", map[string]interface{}{"Username": username}, err.Error(), http.StatusBadRequest)
 			}
-			user := result.Data.(*model.User)
 
 			preferences = append(preferences, model.Preference{
 				UserId:   user.Id,
@@ -1065,7 +1068,8 @@ func (a *App) UpdateFileInfoWithPostId(post *model.Post) {
 	}
 }
 func (a *App) ImportDirectChannel(data *DirectChannelImportData, dryRun bool) *model.AppError {
-	if err := validateDirectChannelImportData(data); err != nil {
+	var err *model.AppError
+	if err = validateDirectChannelImportData(data); err != nil {
 		return err
 	}
 
@@ -1077,11 +1081,11 @@ func (a *App) ImportDirectChannel(data *DirectChannelImportData, dryRun bool) *m
 	var userIds []string
 	userMap := make(map[string]string)
 	for _, username := range *data.Members {
-		result := <-a.Srv.Store.User().GetByUsername(username)
+		var user *model.User
-		if result.Err != nil {
+		user, err = a.Srv.Store.User().GetByUsername(username)
-			return model.NewAppError("BulkImport", "app.import.import_direct_channel.member_not_found.error", nil, result.Err.Error(), http.StatusBadRequest)
+		if err != nil {
+			return model.NewAppError("BulkImport", "app.import.import_direct_channel.member_not_found.error", nil, err.Error(), http.StatusBadRequest)
 		}
-		user := result.Data.(*model.User)
 		userIds = append(userIds, user.Id)
 		userMap[username] = user.Id
 	}
@@ -1140,7 +1144,8 @@ func (a *App) ImportDirectChannel(data *DirectChannelImportData, dryRun bool) *m
 }
 
 func (a *App) ImportDirectPost(data *DirectPostImportData, dryRun bool) *model.AppError {
-	if err := validateDirectPostImportData(data, a.MaxPostSize()); err != nil {
+	var err *model.AppError
+	if err = validateDirectPostImportData(data, a.MaxPostSize()); err != nil {
 		return err
 	}
 
@@ -1151,34 +1156,35 @@ func (a *App) ImportDirectPost(data *DirectPostImportData, dryRun bool) *model.A
 
 	var userIds []string
 	for _, username := range *data.ChannelMembers {
-		result := <-a.Srv.Store.User().GetByUsername(username)
+		var user *model.User
-		if result.Err != nil {
+		user, err = a.Srv.Store.User().GetByUsername(username)
-			return model.NewAppError("BulkImport", "app.import.import_direct_post.channel_member_not_found.error", nil, result.Err.Error(), http.StatusBadRequest)
+		if err != nil {
+			return model.NewAppError("BulkImport", "app.import.import_direct_post.channel_member_not_found.error", nil, err.Error(), http.StatusBadRequest)
 		}
-		user := result.Data.(*model.User)
 		userIds = append(userIds, user.Id)
 	}
 
 	var channel *model.Channel
+	var ch *model.Channel
 	if len(userIds) == 2 {
-		ch, err := a.createDirectChannel(userIds[0], userIds[1])
+		ch, err = a.createDirectChannel(userIds[0], userIds[1])
 		if err != nil && err.Id != store.CHANNEL_EXISTS_ERROR {
 			return model.NewAppError("BulkImport", "app.import.import_direct_post.create_direct_channel.error", nil, err.Error(), http.StatusBadRequest)
 		}
 		channel = ch
 	} else {
-		ch, err := a.createGroupChannel(userIds, userIds[0])
+		ch, err = a.createGroupChannel(userIds, userIds[0])
 		if err != nil && err.Id != store.CHANNEL_EXISTS_ERROR {
 			return model.NewAppError("BulkImport", "app.import.import_direct_post.create_group_channel.error", nil, err.Error(), http.StatusBadRequest)
 		}
 		channel = ch
 	}
 
-	result := <-a.Srv.Store.User().GetByUsername(*data.User)
+	var user *model.User
-	if result.Err != nil {
+	user, err = a.Srv.Store.User().GetByUsername(*data.User)
+	if err != nil {
 		return model.NewAppError("BulkImport", "app.import.import_direct_post.user_not_found.error", map[string]interface{}{"Username": *data.User}, "", http.StatusBadRequest)
 	}
-	user := result.Data.(*model.User)
 
 	// Check if this post already exists.
 	posts, err := a.Srv.Store.Post().GetPostsCreatedAt(channel.Id, *data.CreateAt)
@@ -1206,7 +1212,8 @@ func (a *App) ImportDirectPost(data *DirectPostImportData, dryRun bool) *model.A
 	post.Hashtags, _ = model.ParseHashtags(post.Message)
 
 	if data.Attachments != nil {
-		fileIds, err := a.uploadAttachments(data.Attachments, post, "noteam", dryRun)
+		var fileIds []string
+		fileIds, err = a.uploadAttachments(data.Attachments, post, "noteam", dryRun)
 		if err != nil {
 			return err
 		}
@@ -1214,11 +1221,11 @@ func (a *App) ImportDirectPost(data *DirectPostImportData, dryRun bool) *model.A
 	}
 
 	if post.Id == "" {
-		if _, err := a.Srv.Store.Post().Save(post); err != nil {
+		if _, err = a.Srv.Store.Post().Save(post); err != nil {
 			return err
 		}
 	} else {
-		if _, err := a.Srv.Store.Post().Overwrite(post); err != nil {
+		if _, err = a.Srv.Store.Post().Overwrite(post); err != nil {
 			return err
 		}
 	}
@@ -1227,11 +1234,11 @@ func (a *App) ImportDirectPost(data *DirectPostImportData, dryRun bool) *model.A
 		var preferences model.Preferences
 
 		for _, username := range *data.FlaggedBy {
-			result := <-a.Srv.Store.User().GetByUsername(username)
+			var user *model.User
-			if result.Err != nil {
+			user, err = a.Srv.Store.User().GetByUsername(username)
+			if err != nil {
 				return model.NewAppError("BulkImport", "app.import.import_direct_post.user_not_found.error", map[string]interface{}{"Username": username}, "", http.StatusBadRequest)
 			}
-			user := result.Data.(*model.User)
 
 			preferences = append(preferences, model.Preference{
 				UserId:   user.Id,

app/user.go

@@ -408,7 +408,7 @@ func (a *App) IsUsernameTaken(name string) bool {
 		return false
 	}
 
-	if result := <-a.Srv.Store.User().GetByUsername(name); result.Err != nil {
+	if _, err := a.Srv.Store.User().GetByUsername(name); err != nil {
 		return false
 	}
 
@@ -420,12 +420,12 @@ func (a *App) GetUser(userId string) (*model.User, *model.AppError) {
 }
 
 func (a *App) GetUserByUsername(username string) (*model.User, *model.AppError) {
-	result := <-a.Srv.Store.User().GetByUsername(username)
+	result, err := a.Srv.Store.User().GetByUsername(username)
-	if result.Err != nil && result.Err.Id == "store.sql_user.get_by_username.app_error" {
+	if err != nil && err.Id == "store.sql_user.get_by_username.app_error" {
-		result.Err.StatusCode = http.StatusNotFound
+		err.StatusCode = http.StatusNotFound
-		return nil, result.Err
+		return nil, err
 	}
-	return result.Data.(*model.User), nil
+	return result, nil
 }
 
 func (a *App) GetUserByEmail(email string) (*model.User, *model.AppError) {

app/webhook.go

@@ -589,10 +589,10 @@ func (a *App) HandleIncomingWebhook(hookId string, req *model.IncomingWebhookReq
 
 	if len(channelName) != 0 {
 		if channelName[0] == '@' {
-			if result := <-a.Srv.Store.User().GetByUsername(channelName[1:]); result.Err != nil {
+			if result, err := a.Srv.Store.User().GetByUsername(channelName[1:]); err != nil {
-				return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.user.app_error", nil, "err="+result.Err.Message, http.StatusBadRequest)
+				return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.user.app_error", nil, "err="+err.Message, http.StatusBadRequest)
 			} else {
-				if ch, err := a.GetOrCreateDirectChannel(hook.UserId, result.Data.(*model.User).Id); err != nil {
+				if ch, err := a.GetOrCreateDirectChannel(hook.UserId, result.Id); err != nil {
 					return err
 				} else {
 					channel = ch

cmd/mattermost/commands/userargs.go

@@ -21,8 +21,9 @@ func getUserFromUserArg(a *app.App, userArg string) *model.User {
 	user, _ := a.Srv.Store.User().GetByEmail(userArg)
 
 	if user == nil {
-		if result := <-a.Srv.Store.User().GetByUsername(userArg); result.Err == nil {
+		var err *model.AppError
-			user = result.Data.(*model.User)
+		if user, err = a.Srv.Store.User().GetByUsername(userArg); err == nil {
+			return user
 		}
 	}
 

store/sqlstore/user_store.go

@@ -1009,24 +1009,20 @@ func (us SqlUserStore) GetAllUsingAuthService(authService string) ([]*model.User
 	return users, nil
 }
 
-func (us SqlUserStore) GetByUsername(username string) store.StoreChannel {
+func (us SqlUserStore) GetByUsername(username string) (*model.User, *model.AppError) {
-	return store.Do(func(result *store.StoreResult) {
+	query := us.usersQuery.Where("u.Username = ?", username)
-		query := us.usersQuery.Where("u.Username = ?", username)
 
-		queryString, args, err := query.ToSql()
+	queryString, args, err := query.ToSql()
-		if err != nil {
+	if err != nil {
-			result.Err = model.NewAppError("SqlUserStore.GetByUsername", "store.sql_user.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlUserStore.GetByUsername", "store.sql_user.app_error", nil, err.Error(), http.StatusInternalServerError)
-			return
+	}
-		}
 
-		user := model.User{}
+	var user *model.User
-		if err := us.GetReplica().SelectOne(&user, queryString, args...); err != nil {
+	if err := us.GetReplica().SelectOne(&user, queryString, args...); err != nil {
-			result.Err = model.NewAppError("SqlUserStore.GetByUsername", "store.sql_user.get_by_username.app_error", nil, err.Error()+" -- "+queryString, http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlUserStore.GetByUsername", "store.sql_user.get_by_username.app_error", nil, err.Error()+" -- "+queryString, http.StatusInternalServerError)
-			return
+	}
-		}
 
-		result.Data = &user
+	return user, nil
-	})
 }
 
 func (us SqlUserStore) GetForLogin(loginId string, allowSignInWithUsername, allowSignInWithEmail bool) (*model.User, *model.AppError) {

store/store.go

@@ -277,7 +277,7 @@ type UserStore interface {
 	GetByEmail(email string) (*model.User, *model.AppError)
 	GetByAuth(authData *string, authService string) (*model.User, *model.AppError)
 	GetAllUsingAuthService(authService string) ([]*model.User, *model.AppError)
-	GetByUsername(username string) StoreChannel
+	GetByUsername(username string) (*model.User, *model.AppError)
 	GetForLogin(loginId string, allowSignInWithUsername, allowSignInWithEmail bool) (*model.User, *model.AppError)
 	VerifyEmail(userId, email string) (string, *model.AppError)
 	GetEtagForAllProfiles() string

store/storetest/mocks/UserStore.go

@@ -350,19 +350,28 @@ func (_m *UserStore) GetByEmail(email string) (*model.User, *model.AppError) {
 }
 
 // GetByUsername provides a mock function with given fields: username
-func (_m *UserStore) GetByUsername(username string) store.StoreChannel {
+func (_m *UserStore) GetByUsername(username string) (*model.User, *model.AppError) {
 	ret := _m.Called(username)
 
-	var r0 store.StoreChannel
+	var r0 *model.User
-	if rf, ok := ret.Get(0).(func(string) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(string) *model.User); ok {
 		r0 = rf(username)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.User)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+		r1 = rf(username)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // GetChannelGroupUsers provides a mock function with given fields: channelID

store/storetest/user_store.go

@@ -1671,33 +1671,33 @@ func testUserStoreGetByUsername(t *testing.T, ss store.Store) {
 	defer func() { require.Nil(t, ss.Bot().PermanentDelete(u3.Id)) }()
 
 	t.Run("get u1 by username", func(t *testing.T) {
-		result := <-ss.User().GetByUsername(u1.Username)
+		result, err := ss.User().GetByUsername(u1.Username)
-		require.Nil(t, result.Err)
+		require.Nil(t, err)
-		assert.Equal(t, u1, result.Data.(*model.User))
+		assert.Equal(t, u1, result)
 	})
 
 	t.Run("get u2 by username", func(t *testing.T) {
-		result := <-ss.User().GetByUsername(u2.Username)
+		result, err := ss.User().GetByUsername(u2.Username)
-		require.Nil(t, result.Err)
+		require.Nil(t, err)
-		assert.Equal(t, u2, result.Data.(*model.User))
+		assert.Equal(t, u2, result)
 	})
 
 	t.Run("get u3 by username", func(t *testing.T) {
-		result := <-ss.User().GetByUsername(u3.Username)
+		result, err := ss.User().GetByUsername(u3.Username)
-		require.Nil(t, result.Err)
+		require.Nil(t, err)
-		assert.Equal(t, u3, result.Data.(*model.User))
+		assert.Equal(t, u3, result)
 	})
 
 	t.Run("get by empty username", func(t *testing.T) {
-		result := <-ss.User().GetByUsername("")
+		_, err := ss.User().GetByUsername("")
-		require.NotNil(t, result.Err)
+		require.NotNil(t, err)
-		require.Equal(t, result.Err.Id, "store.sql_user.get_by_username.app_error")
+		require.Equal(t, err.Id, "store.sql_user.get_by_username.app_error")
 	})
 
 	t.Run("get by unknown", func(t *testing.T) {
-		result := <-ss.User().GetByUsername("unknown")
+		_, err := ss.User().GetByUsername("unknown")
-		require.NotNil(t, result.Err)
+		require.NotNil(t, err)
-		require.Equal(t, result.Err.Id, "store.sql_user.get_by_username.app_error")
+		require.Equal(t, err.Id, "store.sql_user.get_by_username.app_error")
 	})
 }
 
@@ -3611,21 +3611,21 @@ func testUserStoreClearAllCustomRoleAssignments(t *testing.T, ss store.Store) {
 
 	require.Nil(t, ss.User().ClearAllCustomRoleAssignments())
 
-	r1 := <-ss.User().GetByUsername(u1.Username)
+	r1, err := ss.User().GetByUsername(u1.Username)
-	require.Nil(t, r1.Err)
+	require.Nil(t, err)
-	assert.Equal(t, u1.Roles, r1.Data.(*model.User).Roles)
+	assert.Equal(t, u1.Roles, r1.Roles)
 
-	r2 := <-ss.User().GetByUsername(u2.Username)
+	r2, err1 := ss.User().GetByUsername(u2.Username)
-	require.Nil(t, r2.Err)
+	require.Nil(t, err1)
-	assert.Equal(t, "system_user system_admin", r2.Data.(*model.User).Roles)
+	assert.Equal(t, "system_user system_admin", r2.Roles)
 
-	r3 := <-ss.User().GetByUsername(u3.Username)
+	r3, err2 := ss.User().GetByUsername(u3.Username)
-	require.Nil(t, r3.Err)
+	require.Nil(t, err2)
-	assert.Equal(t, u3.Roles, r3.Data.(*model.User).Roles)
+	assert.Equal(t, u3.Roles, r3.Roles)
 
-	r4 := <-ss.User().GetByUsername(u4.Username)
+	r4, err3 := ss.User().GetByUsername(u4.Username)
-	require.Nil(t, r4.Err)
+	require.Nil(t, err3)
-	assert.Equal(t, "", r4.Data.(*model.User).Roles)
+	assert.Equal(t, "", r4.Roles)
 }
 
 func testUserStoreGetAllAfter(t *testing.T, ss store.Store) {