diff --git a/app/helper_test.go b/app/helper_test.go
index af451bd9c5..ac9d7dd9a9 100644
--- a/app/helper_test.go
+++ b/app/helper_test.go
@@ -188,42 +188,42 @@ var userCache struct {
 	BasicUser2      *model.User
 }
 
-func (me *TestHelper) InitBasic() *TestHelper {
+func (th *TestHelper) InitBasic() *TestHelper {
 	// create users once and cache them because password hashing is slow
 	initBasicOnce.Do(func() {
-		me.SystemAdminUser = me.CreateUser()
-		me.App.UpdateUserRoles(me.SystemAdminUser.Id, model.SYSTEM_USER_ROLE_ID+" "+model.SYSTEM_ADMIN_ROLE_ID, false)
-		me.SystemAdminUser, _ = me.App.GetUser(me.SystemAdminUser.Id)
-		userCache.SystemAdminUser = me.SystemAdminUser.DeepCopy()
+		th.SystemAdminUser = th.CreateUser()
+		th.App.UpdateUserRoles(th.SystemAdminUser.Id, model.SYSTEM_USER_ROLE_ID+" "+model.SYSTEM_ADMIN_ROLE_ID, false)
+		th.SystemAdminUser, _ = th.App.GetUser(th.SystemAdminUser.Id)
+		userCache.SystemAdminUser = th.SystemAdminUser.DeepCopy()
 
-		me.BasicUser = me.CreateUser()
-		me.BasicUser, _ = me.App.GetUser(me.BasicUser.Id)
-		userCache.BasicUser = me.BasicUser.DeepCopy()
+		th.BasicUser = th.CreateUser()
+		th.BasicUser, _ = th.App.GetUser(th.BasicUser.Id)
+		userCache.BasicUser = th.BasicUser.DeepCopy()
 
-		me.BasicUser2 = me.CreateUser()
-		me.BasicUser2, _ = me.App.GetUser(me.BasicUser2.Id)
-		userCache.BasicUser2 = me.BasicUser2.DeepCopy()
+		th.BasicUser2 = th.CreateUser()
+		th.BasicUser2, _ = th.App.GetUser(th.BasicUser2.Id)
+		userCache.BasicUser2 = th.BasicUser2.DeepCopy()
 	})
 	// restore cached users
-	me.SystemAdminUser = userCache.SystemAdminUser.DeepCopy()
-	me.BasicUser = userCache.BasicUser.DeepCopy()
-	me.BasicUser2 = userCache.BasicUser2.DeepCopy()
-	mainHelper.GetSQLSupplier().GetMaster().Insert(me.SystemAdminUser, me.BasicUser, me.BasicUser2)
+	th.SystemAdminUser = userCache.SystemAdminUser.DeepCopy()
+	th.BasicUser = userCache.BasicUser.DeepCopy()
+	th.BasicUser2 = userCache.BasicUser2.DeepCopy()
+	mainHelper.GetSQLSupplier().GetMaster().Insert(th.SystemAdminUser, th.BasicUser, th.BasicUser2)
 
-	me.BasicTeam = me.CreateTeam()
+	th.BasicTeam = th.CreateTeam()
 
-	me.LinkUserToTeam(me.BasicUser, me.BasicTeam)
-	me.LinkUserToTeam(me.BasicUser2, me.BasicTeam)
-	me.BasicChannel = me.CreateChannel(me.BasicTeam)
-	me.BasicPost = me.CreatePost(me.BasicChannel)
-	return me
+	th.LinkUserToTeam(th.BasicUser, th.BasicTeam)
+	th.LinkUserToTeam(th.BasicUser2, th.BasicTeam)
+	th.BasicChannel = th.CreateChannel(th.BasicTeam)
+	th.BasicPost = th.CreatePost(th.BasicChannel)
+	return th
 }
 
-func (me *TestHelper) MakeEmail() string {
+func (*TestHelper) MakeEmail() string {
 	return "success_" + model.NewId() + "@simulator.amazonses.com"
 }
 
-func (me *TestHelper) CreateTeam() *model.Team {
+func (th *TestHelper) CreateTeam() *model.Team {
 	id := model.NewId()
 	team := &model.Team{
 		DisplayName: "dn_" + id,
@@ -234,7 +234,7 @@ func (me *TestHelper) CreateTeam() *model.Team {
 
 	utils.DisableDebugLogForTest()
 	var err *model.AppError
-	if team, err = me.App.CreateTeam(team); err != nil {
+	if team, err = th.App.CreateTeam(team); err != nil {
 		mlog.Error(err.Error())
 
 		time.Sleep(time.Second)
@@ -244,15 +244,15 @@ func (me *TestHelper) CreateTeam() *model.Team {
 	return team
 }
 
-func (me *TestHelper) CreateUser() *model.User {
-	return me.CreateUserOrGuest(false)
+func (th *TestHelper) CreateUser() *model.User {
+	return th.CreateUserOrGuest(false)
 }
 
-func (me *TestHelper) CreateGuest() *model.User {
-	return me.CreateUserOrGuest(true)
+func (th *TestHelper) CreateGuest() *model.User {
+	return th.CreateUserOrGuest(true)
 }
 
-func (me *TestHelper) CreateUserOrGuest(guest bool) *model.User {
+func (th *TestHelper) CreateUserOrGuest(guest bool) *model.User {
 	id := model.NewId()
 
 	user := &model.User{
@@ -266,14 +266,14 @@ func (me *TestHelper) CreateUserOrGuest(guest bool) *model.User {
 	utils.DisableDebugLogForTest()
 	var err *model.AppError
 	if guest {
-		if user, err = me.App.CreateGuest(user); err != nil {
+		if user, err = th.App.CreateGuest(user); err != nil {
 			mlog.Error(err.Error())
 
 			time.Sleep(time.Second)
 			panic(err)
 		}
 	} else {
-		if user, err = me.App.CreateUser(user); err != nil {
+		if user, err = th.App.CreateUser(user); err != nil {
 			mlog.Error(err.Error())
 
 			time.Sleep(time.Second)
@@ -284,37 +284,37 @@ func (me *TestHelper) CreateUserOrGuest(guest bool) *model.User {
 	return user
 }
 
-func (me *TestHelper) CreateBot() *model.Bot {
+func (th *TestHelper) CreateBot() *model.Bot {
 	id := model.NewId()
 
 	bot := &model.Bot{
 		Username:    "bot" + id,
 		DisplayName: "a bot",
 		Description: "bot",
-		OwnerId:     me.BasicUser.Id,
+		OwnerId:     th.BasicUser.Id,
 	}
 
-	me.App.Log().SetConsoleLevel(mlog.LevelError)
-	bot, err := me.App.CreateBot(bot)
+	th.App.Log().SetConsoleLevel(mlog.LevelError)
+	bot, err := th.App.CreateBot(bot)
 	if err != nil {
 		mlog.Error(err.Error())
 
 		time.Sleep(time.Second)
 		panic(err)
 	}
-	me.App.Log().SetConsoleLevel(mlog.LevelDebug)
+	th.App.Log().SetConsoleLevel(mlog.LevelDebug)
 	return bot
 }
 
-func (me *TestHelper) CreateChannel(team *model.Team) *model.Channel {
-	return me.createChannel(team, model.CHANNEL_OPEN)
+func (th *TestHelper) CreateChannel(team *model.Team) *model.Channel {
+	return th.createChannel(team, model.CHANNEL_OPEN)
 }
 
-func (me *TestHelper) CreatePrivateChannel(team *model.Team) *model.Channel {
-	return me.createChannel(team, model.CHANNEL_PRIVATE)
+func (th *TestHelper) CreatePrivateChannel(team *model.Team) *model.Channel {
+	return th.createChannel(team, model.CHANNEL_PRIVATE)
 }
 
-func (me *TestHelper) createChannel(team *model.Team, channelType string) *model.Channel {
+func (th *TestHelper) createChannel(team *model.Team, channelType string) *model.Channel {
 	id := model.NewId()
 
 	channel := &model.Channel{
@@ -322,12 +322,12 @@ func (me *TestHelper) createChannel(team *model.Team, channelType string) *model
 		Name:        "name_" + id,
 		Type:        channelType,
 		TeamId:      team.Id,
-		CreatorId:   me.BasicUser.Id,
+		CreatorId:   th.BasicUser.Id,
 	}
 
 	utils.DisableDebugLogForTest()
 	var err *model.AppError
-	if channel, err = me.App.CreateChannel(channel, true); err != nil {
+	if channel, err = th.App.CreateChannel(channel, true); err != nil {
 		mlog.Error(err.Error())
 
 		time.Sleep(time.Second)
@@ -337,11 +337,11 @@ func (me *TestHelper) createChannel(team *model.Team, channelType string) *model
 	return channel
 }
 
-func (me *TestHelper) CreateDmChannel(user *model.User) *model.Channel {
+func (th *TestHelper) CreateDmChannel(user *model.User) *model.Channel {
 	utils.DisableDebugLogForTest()
 	var err *model.AppError
 	var channel *model.Channel
-	if channel, err = me.App.GetOrCreateDirectChannel(me.BasicUser.Id, user.Id); err != nil {
+	if channel, err = th.App.GetOrCreateDirectChannel(th.BasicUser.Id, user.Id); err != nil {
 		mlog.Error(err.Error())
 
 		time.Sleep(time.Second)
@@ -351,11 +351,11 @@ func (me *TestHelper) CreateDmChannel(user *model.User) *model.Channel {
 	return channel
 }
 
-func (me *TestHelper) CreateGroupChannel(user1 *model.User, user2 *model.User) *model.Channel {
+func (th *TestHelper) CreateGroupChannel(user1 *model.User, user2 *model.User) *model.Channel {
 	utils.DisableDebugLogForTest()
 	var err *model.AppError
 	var channel *model.Channel
-	if channel, err = me.App.CreateGroupChannel([]string{me.BasicUser.Id, user1.Id, user2.Id}, me.BasicUser.Id); err != nil {
+	if channel, err = th.App.CreateGroupChannel([]string{th.BasicUser.Id, user1.Id, user2.Id}, th.BasicUser.Id); err != nil {
 		mlog.Error(err.Error())
 
 		time.Sleep(time.Second)
@@ -365,11 +365,11 @@ func (me *TestHelper) CreateGroupChannel(user1 *model.User, user2 *model.User) *
 	return channel
 }
 
-func (me *TestHelper) CreatePost(channel *model.Channel) *model.Post {
+func (th *TestHelper) CreatePost(channel *model.Channel) *model.Post {
 	id := model.NewId()
 
 	post := &model.Post{
-		UserId:    me.BasicUser.Id,
+		UserId:    th.BasicUser.Id,
 		ChannelId: channel.Id,
 		Message:   "message_" + id,
 		CreateAt:  model.GetMillis() - 10000,
@@ -377,7 +377,7 @@ func (me *TestHelper) CreatePost(channel *model.Channel) *model.Post {
 
 	utils.DisableDebugLogForTest()
 	var err *model.AppError
-	if post, err = me.App.CreatePost(post, channel, false, true); err != nil {
+	if post, err = th.App.CreatePost(post, channel, false, true); err != nil {
 		mlog.Error(err.Error())
 
 		time.Sleep(time.Second)
@@ -387,9 +387,9 @@ func (me *TestHelper) CreatePost(channel *model.Channel) *model.Post {
 	return post
 }
 
-func (me *TestHelper) CreateMessagePost(channel *model.Channel, message string) *model.Post {
+func (th *TestHelper) CreateMessagePost(channel *model.Channel, message string) *model.Post {
 	post := &model.Post{
-		UserId:    me.BasicUser.Id,
+		UserId:    th.BasicUser.Id,
 		ChannelId: channel.Id,
 		Message:   message,
 		CreateAt:  model.GetMillis() - 10000,
@@ -397,7 +397,7 @@ func (me *TestHelper) CreateMessagePost(channel *model.Channel, message string)
 
 	utils.DisableDebugLogForTest()
 	var err *model.AppError
-	if post, err = me.App.CreatePost(post, channel, false, true); err != nil {
+	if post, err = th.App.CreatePost(post, channel, false, true); err != nil {
 		mlog.Error(err.Error())
 
 		time.Sleep(time.Second)
@@ -407,10 +407,10 @@ func (me *TestHelper) CreateMessagePost(channel *model.Channel, message string)
 	return post
 }
 
-func (me *TestHelper) LinkUserToTeam(user *model.User, team *model.Team) {
+func (th *TestHelper) LinkUserToTeam(user *model.User, team *model.Team) {
 	utils.DisableDebugLogForTest()
 
-	err := me.App.JoinUserToTeam(team, user, "")
+	err := th.App.JoinUserToTeam(team, user, "")
 	if err != nil {
 		mlog.Error(err.Error())
 
@@ -421,10 +421,10 @@ func (me *TestHelper) LinkUserToTeam(user *model.User, team *model.Team) {
 	utils.EnableDebugLogForTest()
 }
 
-func (me *TestHelper) RemoveUserFromTeam(user *model.User, team *model.Team) {
+func (th *TestHelper) RemoveUserFromTeam(user *model.User, team *model.Team) {
 	utils.DisableDebugLogForTest()
 
-	err := me.App.RemoveUserFromTeam(team.Id, user.Id, "")
+	err := th.App.RemoveUserFromTeam(team.Id, user.Id, "")
 	if err != nil {
 		mlog.Error(err.Error())
 
@@ -435,10 +435,10 @@ func (me *TestHelper) RemoveUserFromTeam(user *model.User, team *model.Team) {
 	utils.EnableDebugLogForTest()
 }
 
-func (me *TestHelper) AddUserToChannel(user *model.User, channel *model.Channel) *model.ChannelMember {
+func (th *TestHelper) AddUserToChannel(user *model.User, channel *model.Channel) *model.ChannelMember {
 	utils.DisableDebugLogForTest()
 
-	member, err := me.App.AddUserToChannel(user, channel)
+	member, err := th.App.AddUserToChannel(user, channel)
 	if err != nil {
 		mlog.Error(err.Error())
 
@@ -451,15 +451,15 @@ func (me *TestHelper) AddUserToChannel(user *model.User, channel *model.Channel)
 	return member
 }
 
-func (me *TestHelper) CreateRole(roleName string) *model.Role {
-	role, _ := me.App.CreateRole(&model.Role{Name: roleName, DisplayName: roleName, Description: roleName, Permissions: []string{}})
+func (th *TestHelper) CreateRole(roleName string) *model.Role {
+	role, _ := th.App.CreateRole(&model.Role{Name: roleName, DisplayName: roleName, Description: roleName, Permissions: []string{}})
 	return role
 }
 
-func (me *TestHelper) CreateScheme() (*model.Scheme, []*model.Role) {
+func (th *TestHelper) CreateScheme() (*model.Scheme, []*model.Role) {
 	utils.DisableDebugLogForTest()
 
-	scheme, err := me.App.CreateScheme(&model.Scheme{
+	scheme, err := th.App.CreateScheme(&model.Scheme{
 		DisplayName: "Test Scheme Display Name",
 		Name:        model.NewId(),
 		Description: "Test scheme description",
@@ -480,7 +480,7 @@ func (me *TestHelper) CreateScheme() (*model.Scheme, []*model.Role) {
 
 	var roles []*model.Role
 	for _, roleName := range roleNames {
-		role, err := me.App.GetRoleByName(roleName)
+		role, err := th.App.GetRoleByName(roleName)
 		if err != nil {
 			panic(err)
 		}
@@ -492,7 +492,7 @@ func (me *TestHelper) CreateScheme() (*model.Scheme, []*model.Role) {
 	return scheme, roles
 }
 
-func (me *TestHelper) CreateGroup() *model.Group {
+func (th *TestHelper) CreateGroup() *model.Group {
 	id := model.NewId()
 	group := &model.Group{
 		DisplayName: "dn_" + id,
@@ -504,7 +504,7 @@ func (me *TestHelper) CreateGroup() *model.Group {
 
 	utils.DisableDebugLogForTest()
 	var err *model.AppError
-	if group, err = me.App.CreateGroup(group); err != nil {
+	if group, err = th.App.CreateGroup(group); err != nil {
 		mlog.Error(err.Error())
 
 		time.Sleep(time.Second)
@@ -514,11 +514,11 @@ func (me *TestHelper) CreateGroup() *model.Group {
 	return group
 }
 
-func (me *TestHelper) CreateEmoji() *model.Emoji {
+func (th *TestHelper) CreateEmoji() *model.Emoji {
 	utils.DisableDebugLogForTest()
 
-	emoji, err := me.App.Srv().Store.Emoji().Save(&model.Emoji{
-		CreatorId: me.BasicUser.Id,
+	emoji, err := th.App.Srv().Store.Emoji().Save(&model.Emoji{
+		CreatorId: th.BasicUser.Id,
 		Name:      model.NewRandomString(10),
 	})
 	if err != nil {
@@ -530,10 +530,10 @@ func (me *TestHelper) CreateEmoji() *model.Emoji {
 	return emoji
 }
 
-func (me *TestHelper) AddReactionToPost(post *model.Post, user *model.User, emojiName string) *model.Reaction {
+func (th *TestHelper) AddReactionToPost(post *model.Post, user *model.User, emojiName string) *model.Reaction {
 	utils.DisableDebugLogForTest()
 
-	reaction, err := me.App.SaveReactionForPost(&model.Reaction{
+	reaction, err := th.App.SaveReactionForPost(&model.Reaction{
 		UserId:    user.Id,
 		PostId:    post.Id,
 		EmojiName: emojiName,
@@ -547,10 +547,10 @@ func (me *TestHelper) AddReactionToPost(post *model.Post, user *model.User, emoj
 	return reaction
 }
 
-func (me *TestHelper) ShutdownApp() {
+func (th *TestHelper) ShutdownApp() {
 	done := make(chan bool)
 	go func() {
-		me.Server.Shutdown()
+		th.Server.Shutdown()
 		close(done)
 	}()
 
@@ -563,22 +563,22 @@ func (me *TestHelper) ShutdownApp() {
 	}
 }
 
-func (me *TestHelper) TearDown() {
-	if me.IncludeCacheLayer {
+func (th *TestHelper) TearDown() {
+	if th.IncludeCacheLayer {
 		// Clean all the caches
-		me.App.Srv().InvalidateAllCaches()
+		th.App.Srv().InvalidateAllCaches()
 	}
-	me.ShutdownApp()
-	if me.tempWorkspace != "" {
-		os.RemoveAll(me.tempWorkspace)
+	th.ShutdownApp()
+	if th.tempWorkspace != "" {
+		os.RemoveAll(th.tempWorkspace)
 	}
 }
 
-func (me *TestHelper) GetSqlSupplier() *sqlstore.SqlSupplier {
+func (*TestHelper) GetSqlSupplier() *sqlstore.SqlSupplier {
 	return mainHelper.GetSQLSupplier()
 }
 
-func (me *TestHelper) ResetRoleMigration() {
+func (*TestHelper) ResetRoleMigration() {
 	sqlSupplier := mainHelper.GetSQLSupplier()
 	if _, err := sqlSupplier.GetMaster().Exec("DELETE from Roles"); err != nil {
 		panic(err)
@@ -591,7 +591,7 @@ func (me *TestHelper) ResetRoleMigration() {
 	}
 }
 
-func (me *TestHelper) ResetEmojisMigration() {
+func (*TestHelper) ResetEmojisMigration() {
 	sqlSupplier := mainHelper.GetSQLSupplier()
 	if _, err := sqlSupplier.GetMaster().Exec("UPDATE Roles SET Permissions=REPLACE(Permissions, ' create_emojis', '') WHERE builtin=True"); err != nil {
 		panic(err)
@@ -612,58 +612,58 @@ func (me *TestHelper) ResetEmojisMigration() {
 	}
 }
 
-func (me *TestHelper) CheckTeamCount(t *testing.T, expected int64) {
-	teamCount, err := me.App.Srv().Store.Team().AnalyticsTeamCount(false)
+func (th *TestHelper) CheckTeamCount(t *testing.T, expected int64) {
+	teamCount, err := th.App.Srv().Store.Team().AnalyticsTeamCount(false)
 	require.Nil(t, err, "Failed to get team count.")
 	require.Equalf(t, teamCount, expected, "Unexpected number of teams. Expected: %v, found: %v", expected, teamCount)
 }
 
-func (me *TestHelper) CheckChannelsCount(t *testing.T, expected int64) {
-	count, err := me.App.Srv().Store.Channel().AnalyticsTypeCount("", model.CHANNEL_OPEN)
+func (th *TestHelper) CheckChannelsCount(t *testing.T, expected int64) {
+	count, err := th.App.Srv().Store.Channel().AnalyticsTypeCount("", model.CHANNEL_OPEN)
 	require.Nilf(t, err, "Failed to get channel count.")
 	require.Equalf(t, count, expected, "Unexpected number of channels. Expected: %v, found: %v", expected, count)
 }
 
-func (me *TestHelper) SetupTeamScheme() *model.Scheme {
+func (th *TestHelper) SetupTeamScheme() *model.Scheme {
 	scheme := model.Scheme{
 		Name:        model.NewId(),
 		DisplayName: model.NewId(),
 		Scope:       model.SCHEME_SCOPE_TEAM,
 	}
 
-	if scheme, err := me.App.CreateScheme(&scheme); err == nil {
+	if scheme, err := th.App.CreateScheme(&scheme); err == nil {
 		return scheme
 	} else {
 		panic(err)
 	}
 }
 
-func (me *TestHelper) SetupChannelScheme() *model.Scheme {
+func (th *TestHelper) SetupChannelScheme() *model.Scheme {
 	scheme := model.Scheme{
 		Name:        model.NewId(),
 		DisplayName: model.NewId(),
 		Scope:       model.SCHEME_SCOPE_CHANNEL,
 	}
 
-	if scheme, err := me.App.CreateScheme(&scheme); err == nil {
+	if scheme, err := th.App.CreateScheme(&scheme); err == nil {
 		return scheme
 	} else {
 		panic(err)
 	}
 }
 
-func (me *TestHelper) SetupPluginAPI() *PluginAPI {
+func (th *TestHelper) SetupPluginAPI() *PluginAPI {
 	manifest := &model.Manifest{
 		Id: "pluginid",
 	}
 
-	return NewPluginAPI(me.App, manifest)
+	return NewPluginAPI(th.App, manifest)
 }
 
-func (me *TestHelper) RemovePermissionFromRole(permission string, roleName string) {
+func (th *TestHelper) RemovePermissionFromRole(permission string, roleName string) {
 	utils.DisableDebugLogForTest()
 
-	role, err1 := me.App.GetRoleByName(roleName)
+	role, err1 := th.App.GetRoleByName(roleName)
 	if err1 != nil {
 		utils.EnableDebugLogForTest()
 		panic(err1)
@@ -683,7 +683,7 @@ func (me *TestHelper) RemovePermissionFromRole(permission string, roleName strin
 
 	role.Permissions = newPermissions
 
-	_, err2 := me.App.UpdateRole(role)
+	_, err2 := th.App.UpdateRole(role)
 	if err2 != nil {
 		utils.EnableDebugLogForTest()
 		panic(err2)
@@ -692,10 +692,10 @@ func (me *TestHelper) RemovePermissionFromRole(permission string, roleName strin
 	utils.EnableDebugLogForTest()
 }
 
-func (me *TestHelper) AddPermissionToRole(permission string, roleName string) {
+func (th *TestHelper) AddPermissionToRole(permission string, roleName string) {
 	utils.DisableDebugLogForTest()
 
-	role, err1 := me.App.GetRoleByName(roleName)
+	role, err1 := th.App.GetRoleByName(roleName)
 	if err1 != nil {
 		utils.EnableDebugLogForTest()
 		panic(err1)
@@ -710,7 +710,7 @@ func (me *TestHelper) AddPermissionToRole(permission string, roleName string) {
 
 	role.Permissions = append(role.Permissions, permission)
 
-	_, err2 := me.App.UpdateRole(role)
+	_, err2 := th.App.UpdateRole(role)
 	if err2 != nil {
 		utils.EnableDebugLogForTest()
 		panic(err2)