Merge branch 'master' into mark-as-unread

store/localcachelayer/role_layer.go

@@ -55,11 +55,10 @@ func (s LocalCacheRoleStore) GetByNames(names []string) ([]*model.Role, *model.A
 
 	roles, _ := s.RoleStore.GetByNames(rolesToQuery)
 
-	if roles != nil {
-		for _, role := range roles {
-			s.rootStore.doStandardAddToCache(s.rootStore.roleCache, role.Name, role)
-		}
+	for _, role := range roles {
+		s.rootStore.doStandardAddToCache(s.rootStore.roleCache, role.Name, role)
 	}
+
 	return append(foundRoles, roles...), nil
 }
 

store/sqlstore/channel_store.go

@@ -1790,7 +1790,7 @@ func (s SqlChannelStore) RemoveAllDeactivatedMembers(channelId string) *model.Ap
 
 func (s SqlChannelStore) PermanentDeleteMembersByUser(userId string) *model.AppError {
 	if _, err := s.GetMaster().Exec("DELETE FROM ChannelMembers WHERE UserId = :UserId", map[string]interface{}{"UserId": userId}); err != nil {
-		return model.NewAppError("SqlChannelStore.RemoveMember", "store.sql_channel.permanent_delete_members_by_user.app_error", nil, "user_id="+userId+", "+err.Error(), http.StatusInternalServerError)
+		return model.NewAppError("SqlChannelStore.ChannelPermanentDeleteMembersByUser", "store.sql_channel.permanent_delete_members_by_user.app_error", nil, "user_id="+userId+", "+err.Error(), http.StatusInternalServerError)
 	}
 	return nil
 }

store/sqlstore/group_store.go

@@ -123,6 +123,18 @@ func (s *SqlGroupStore) Get(groupId string) (*model.Group, *model.AppError) {
 	return group, nil
 }
 
+func (s *SqlGroupStore) GetByName(name string) (*model.Group, *model.AppError) {
+	var group *model.Group
+	if err := s.GetReplica().SelectOne(&group, "SELECT * from UserGroups WHERE Name = :Name", map[string]interface{}{"Name": name}); err != nil {
+		if err == sql.ErrNoRows {
+			return nil, model.NewAppError("SqlGroupStore.GroupGetByName", "store.sql_group.no_rows", nil, err.Error(), http.StatusNotFound)
+		}
+		return nil, model.NewAppError("SqlGroupStore.GroupGetByName", "store.select_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+
+	return group, nil
+}
+
 func (s *SqlGroupStore) GetByIDs(groupIDs []string) ([]*model.Group, *model.AppError) {
 	var groups []*model.Group
 	query := s.getQueryBuilder().Select("*").From("UserGroups").Where(sq.Eq{"Id": groupIDs})
@@ -158,6 +170,26 @@ func (s *SqlGroupStore) GetAllBySource(groupSource model.GroupSource) ([]*model.
 	return groups, nil
 }
 
+func (s *SqlGroupStore) GetByUser(userId string) ([]*model.Group, *model.AppError) {
+	var groups []*model.Group
+
+	query := `
+		SELECT
+			UserGroups.*
+		FROM
+			GroupMembers
+			JOIN UserGroups ON UserGroups.Id = GroupMembers.GroupId
+		WHERE
+			GroupMembers.DeleteAt = 0
+			AND UserId = :UserId`
+
+	if _, err := s.GetReplica().Select(&groups, query, map[string]interface{}{"UserId": userId}); err != nil {
+		return nil, model.NewAppError("SqlGroupStore.GetByUser", "store.select_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+
+	return groups, nil
+}
+
 func (s *SqlGroupStore) Update(group *model.Group) (*model.Group, *model.AppError) {
 	var retrievedGroup *model.Group
 	if err := s.GetMaster().SelectOne(&retrievedGroup, "SELECT * FROM UserGroups WHERE Id = :Id", map[string]interface{}{"Id": group.Id}); err != nil {
@@ -341,6 +373,13 @@ func (s *SqlGroupStore) DeleteMember(groupID string, userID string) (*model.Grou
 	return retrievedMember, nil
 }
 
+func (s *SqlGroupStore) PermanentDeleteMembersByUser(userId string) *model.AppError {
+	if _, err := s.GetMaster().Exec("DELETE FROM GroupMembers WHERE UserId = :UserId", map[string]interface{}{"UserId": userId}); err != nil {
+		return model.NewAppError("SqlGroupStore.GroupPermanentDeleteMembersByUser", "store.sql_group.permanent_delete_members_by_user.app_error", map[string]interface{}{"UserId": userId}, "", http.StatusInternalServerError)
+	}
+	return nil
+}
+
 func (s *SqlGroupStore) CreateGroupSyncable(groupSyncable *model.GroupSyncable) (*model.GroupSyncable, *model.AppError) {
 	if err := groupSyncable.IsValid(); err != nil {
 		return nil, err

store/sqlstore/integrity_test.go

@@ -14,10 +14,10 @@ import (
 
 func createAudit(ss store.Store, userId, sessionId string) *model.Audit {
 	audit := model.Audit{
-		UserId: userId,
+		UserId:    userId,
 		SessionId: sessionId,
 		IpAddress: "ipaddress",
-		Action: "Action",
+		Action:    "Action",
 	}
 	ss.Audit().Save(&audit)
 	return &audit
@@ -46,7 +46,7 @@ func createChannelWithSchemeId(ss store.Store, schemeId *string) *model.Channel
 	return c
 }
 
-func createCommand(ss store.Store, userId, teamId string) * model.Command {
+func createCommand(ss store.Store, userId, teamId string) *model.Command {
 	m := model.Command{}
 	m.CreatorId = userId
 	m.Method = model.COMMAND_METHOD_POST
@@ -75,19 +75,15 @@ func createChannelMemberHistory(ss store.Store, channelId, userId string) *model
 }
 
 func createChannelWithTeamId(ss store.Store, id string) *model.Channel {
-	return createChannel(ss, id, model.NewId());
+	return createChannel(ss, id, model.NewId())
 }
 
 func createChannelWithCreatorId(ss store.Store, id string) *model.Channel {
-	return createChannel(ss, model.NewId(), id);
+	return createChannel(ss, model.NewId(), id)
 }
 
 func createChannelMemberWithChannelId(ss store.Store, id string) *model.ChannelMember {
-	return createChannelMember(ss, id, model.NewId());
-}
-
-func createChannelMemberWithUserId(ss store.Store, id string) *model.ChannelMember {
-	return createChannelMember(ss, model.NewId(), id);
+	return createChannelMember(ss, id, model.NewId())
 }
 
 func createCommandWebhook(ss store.Store, commandId, userId, channelId string) *model.CommandWebhook {
@@ -192,20 +188,20 @@ func createPost(ss store.Store, channelId, userId, rootId, parentId string) *mod
 }
 
 func createPostWithChannelId(ss store.Store, id string) *model.Post {
-	return createPost(ss, id, model.NewId(), "", "");
+	return createPost(ss, id, model.NewId(), "", "")
 }
 
 func createPostWithUserId(ss store.Store, id string) *model.Post {
-	return createPost(ss, model.NewId(), id, "", "");
+	return createPost(ss, model.NewId(), id, "", "")
 }
 
 func createPreferences(ss store.Store, userId string) *model.Preferences {
 	preferences := model.Preferences{
 		{
-			UserId: userId,
-			Name: model.NewId(),
+			UserId:   userId,
+			Name:     model.NewId(),
 			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW,
-			Value: "somevalue",
+			Value:    "somevalue",
 		},
 	}
 	ss.Preference().Save(&preferences)
@@ -369,10 +365,10 @@ func TestCheckParentChildIntegrity(t *testing.T) {
 		supplier := ss.(*store.LayeredStore).DatabaseLayer.(*SqlSupplier)
 		t.Run("should receive an error", func(t *testing.T) {
 			config := relationalCheckConfig{
-				parentName: "NotValid",
+				parentName:   "NotValid",
 				parentIdAttr: "NotValid",
-				childName: "NotValid",
-				childIdAttr: "NotValid",
+				childName:    "NotValid",
+				childIdAttr:  "NotValid",
 			}
 			result := checkParentChildIntegrity(supplier, config)
 			require.NotNil(t, result.Err)
@@ -402,7 +398,7 @@ func TestCheckChannelsCommandWebhooksIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: channelId,
-				ChildId: cwh.Id,
+				ChildId:  cwh.Id,
 			}, data.Records[0])
 			dbmap.Delete(cwh)
 		})
@@ -488,7 +484,7 @@ func TestCheckChannelsIncomingWebhooksIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: channelId,
-				ChildId: wh.Id,
+				ChildId:  wh.Id,
 			}, data.Records[0])
 			dbmap.Delete(wh)
 		})
@@ -518,7 +514,7 @@ func TestCheckChannelsOutgoingWebhooksIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: channelId,
-				ChildId: wh.Id,
+				ChildId:  wh.Id,
 			}, data.Records[0])
 			dbmap.Delete(wh)
 		})
@@ -545,7 +541,7 @@ func TestCheckChannelsPostsIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: post.ChannelId,
-				ChildId: post.Id,
+				ChildId:  post.Id,
 			}, data.Records[0])
 			dbmap.Delete(post)
 		})
@@ -573,7 +569,7 @@ func TestCheckCommandsCommandWebhooksIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: commandId,
-				ChildId: cwh.Id,
+				ChildId:  cwh.Id,
 			}, data.Records[0])
 			dbmap.Delete(cwh)
 		})
@@ -631,7 +627,7 @@ func TestCheckPostsPostsParentIdIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: parentId,
-				ChildId: post.Id,
+				ChildId:  post.Id,
 			}, data.Records[0])
 			dbmap.Delete(root)
 			dbmap.Delete(post)
@@ -662,7 +658,7 @@ func TestCheckPostsPostsRootIdIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: rootId,
-				ChildId: post.Id,
+				ChildId:  post.Id,
 			}, data.Records[0])
 			dbmap.Delete(post)
 		})
@@ -720,7 +716,7 @@ func TestCheckSchemesChannelsIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: schemeId,
-				ChildId: channel.Id,
+				ChildId:  channel.Id,
 			}, data.Records[0])
 			dbmap.Delete(channel)
 		})
@@ -751,7 +747,7 @@ func TestCheckSchemesTeamsIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: schemeId,
-				ChildId: team.Id,
+				ChildId:  team.Id,
 			}, data.Records[0])
 			dbmap.Delete(team)
 		})
@@ -782,7 +778,7 @@ func TestCheckSessionsAuditsIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: sessionId,
-				ChildId: audit.Id,
+				ChildId:  audit.Id,
 			}, data.Records[0])
 			ss.Audit().PermanentDeleteByUser(userId)
 		})
@@ -809,7 +805,7 @@ func TestCheckTeamsChannelsIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: channel.TeamId,
-				ChildId: channel.Id,
+				ChildId:  channel.Id,
 			}, data.Records[0])
 			dbmap.Delete(channel)
 		})
@@ -837,7 +833,7 @@ func TestCheckTeamsCommandsIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: teamId,
-				ChildId: cmd.Id,
+				ChildId:  cmd.Id,
 			}, data.Records[0])
 			dbmap.Delete(cmd)
 		})
@@ -865,7 +861,7 @@ func TestCheckTeamsIncomingWebhooksIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: teamId,
-				ChildId: wh.Id,
+				ChildId:  wh.Id,
 			}, data.Records[0])
 			dbmap.Delete(wh)
 		})
@@ -893,7 +889,7 @@ func TestCheckTeamsOutgoingWebhooksIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: teamId,
-				ChildId: wh.Id,
+				ChildId:  wh.Id,
 			}, data.Records[0])
 			dbmap.Delete(wh)
 		})
@@ -951,7 +947,7 @@ func TestCheckUsersAuditsIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: userId,
-				ChildId: audit.Id,
+				ChildId:  audit.Id,
 			}, data.Records[0])
 			ss.Audit().PermanentDeleteByUser(userId)
 		})
@@ -979,7 +975,7 @@ func TestCheckUsersCommandWebhooksIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: userId,
-				ChildId: cwh.Id,
+				ChildId:  cwh.Id,
 			}, data.Records[0])
 			dbmap.Delete(cwh)
 		})
@@ -1006,7 +1002,7 @@ func TestCheckUsersChannelsIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: channel.CreatorId,
-				ChildId: channel.Id,
+				ChildId:  channel.Id,
 			}, data.Records[0])
 			dbmap.Delete(channel)
 		})
@@ -1094,7 +1090,7 @@ func TestCheckUsersCommandsIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: userId,
-				ChildId: cmd.Id,
+				ChildId:  cmd.Id,
 			}, data.Records[0])
 			dbmap.Delete(cmd)
 		})
@@ -1124,7 +1120,7 @@ func TestCheckUsersCompliancesIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: userId,
-				ChildId: compliance.Id,
+				ChildId:  compliance.Id,
 			}, data.Records[0])
 			dbmap.Delete(compliance)
 		})
@@ -1154,7 +1150,7 @@ func TestCheckUsersEmojiIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: userId,
-				ChildId: emoji.Id,
+				ChildId:  emoji.Id,
 			}, data.Records[0])
 			dbmap.Delete(emoji)
 		})
@@ -1211,7 +1207,7 @@ func TestCheckUsersIncomingWebhooksIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: userId,
-				ChildId: wh.Id,
+				ChildId:  wh.Id,
 			}, data.Records[0])
 			dbmap.Delete(wh)
 		})
@@ -1241,7 +1237,7 @@ func TestCheckUsersOAuthAccessDataIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: userId,
-				ChildId: ad.Token,
+				ChildId:  ad.Token,
 			}, data.Records[0])
 			ss.OAuth().RemoveAccessData(ad.Token)
 		})
@@ -1271,7 +1267,7 @@ func TestCheckUsersOAuthAppsIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: userId,
-				ChildId: app.Id,
+				ChildId:  app.Id,
 			}, data.Records[0])
 			ss.OAuth().DeleteApp(app.Id)
 		})
@@ -1301,7 +1297,7 @@ func TestCheckUsersOAuthAuthDataIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: userId,
-				ChildId: ad.Code,
+				ChildId:  ad.Code,
 			}, data.Records[0])
 			ss.OAuth().RemoveAuthData(ad.Code)
 		})
@@ -1329,7 +1325,7 @@ func TestCheckUsersOutgoingWebhooksIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: userId,
-				ChildId: wh.Id,
+				ChildId:  wh.Id,
 			}, data.Records[0])
 			dbmap.Delete(wh)
 		})
@@ -1356,7 +1352,7 @@ func TestCheckUsersPostsIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: post.UserId,
-				ChildId: post.Id,
+				ChildId:  post.Id,
 			}, data.Records[0])
 			dbmap.Delete(post)
 		})
@@ -1442,7 +1438,7 @@ func TestCheckUsersSessionsIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: userId,
-				ChildId: session.Id,
+				ChildId:  session.Id,
 			}, data.Records[0])
 			dbmap.Delete(session)
 		})
@@ -1531,7 +1527,7 @@ func TestCheckUsersUserAccessTokensIntegrity(t *testing.T) {
 			require.Len(t, data.Records, 1)
 			require.Equal(t, store.OrphanedRecord{
 				ParentId: userId,
-				ChildId: uat.Id,
+				ChildId:  uat.Id,
 			}, data.Records[0])
 			ss.UserAccessToken().Delete(uat.Id)
 		})

store/sqlstore/post_store.go

@@ -1346,7 +1346,6 @@ func (s *SqlPostStore) GetOldest() (*model.Post, *model.AppError) {
 }
 
 func (s *SqlPostStore) determineMaxPostSize() int {
-	var maxPostSize int = model.POST_MESSAGE_MAX_RUNES_V1
 	var maxPostSizeBytes int32
 
 	if s.DriverName() == model.DATABASE_DRIVER_POSTGRES {
@@ -1384,7 +1383,7 @@ func (s *SqlPostStore) determineMaxPostSize() int {
 	}
 
 	// Assume a worst-case representation of four bytes per rune.
-	maxPostSize = int(maxPostSizeBytes) / 4
+	maxPostSize := int(maxPostSizeBytes) / 4
 
 	// To maintain backwards compatibility, don't yield a maximum post
 	// size smaller than the previous limit, even though it wasn't

store/sqlstore/supplier.go

@@ -699,7 +699,7 @@ func (ss *SqlSupplier) AlterColumnDefaultIfExists(tableName string, columnName s
 		return false
 	}
 
-	var defaultValue = ""
+	var defaultValue string
 	if ss.DriverName() == model.DATABASE_DRIVER_MYSQL {
 		// Some column types in MySQL cannot have defaults, so don't try to configure anything.
 		if mySqlColDefault == nil {

store/sqlstore/upgrade.go

@@ -4,7 +4,6 @@
 package sqlstore
 
 import (
-	"database/sql"
 	"encoding/json"
 	"os"
 	"strings"
@@ -602,33 +601,6 @@ func UpgradeDatabaseToVersion57(sqlStore SqlStore) {
 	}
 }
 
-func getRole(sqlStore SqlStore, name string) (*model.Role, error) {
-	var dbRole Role
-
-	if err := sqlStore.GetReplica().SelectOne(&dbRole, "SELECT * from Roles WHERE Name = :Name", map[string]interface{}{"Name": name}); err != nil {
-		if err == sql.ErrNoRows {
-			return nil, errors.Wrapf(err, "failed to find role %s", name)
-		} else {
-			return nil, errors.Wrapf(err, "failed to query role %s", name)
-		}
-	}
-
-	return dbRole.ToModel(), nil
-}
-
-func saveRole(sqlStore SqlStore, role *model.Role) error {
-	dbRole := NewRoleFromModel(role)
-
-	dbRole.UpdateAt = model.GetMillis()
-	if rowsChanged, err := sqlStore.GetMaster().Update(dbRole); err != nil {
-		return errors.Wrap(err, "failed to update role")
-	} else if rowsChanged != 1 {
-		return errors.New("found no role to update")
-	}
-
-	return nil
-}
-
 func UpgradeDatabaseToVersion58(sqlStore SqlStore) {
 	if shouldPerformUpgrade(sqlStore, VERSION_5_7_0, VERSION_5_8_0) {
 		// idx_channels_txt was removed in `UpgradeDatabaseToVersion50`, but merged as part of

store/sqlstore/user_store.go

@@ -1267,7 +1267,7 @@ func generateSearchQuery(query sq.SelectBuilder, terms []string, fields []string
 func (us SqlUserStore) performSearch(query sq.SelectBuilder, term string, options *model.UserSearchOptions) ([]*model.User, *model.AppError) {
 	term = sanitizeSearchTerm(term, "*")
 
-	searchType := USER_SEARCH_TYPE_NAMES_NO_FULL_NAME
+	var searchType []string
 	if options.AllowEmails {
 		if options.AllowFullNames {
 			searchType = USER_SEARCH_TYPE_ALL
@@ -1359,8 +1359,7 @@ func (us SqlUserStore) GetProfilesNotInTeam(teamId string, groupConstrained bool
 }
 
 func (us SqlUserStore) GetEtagForProfilesNotInTeam(teamId string) string {
-	var querystr string
-	querystr = `
+	querystr := `
 		SELECT
 			CONCAT(MAX(UpdateAt), '.', COUNT(Id)) as etag
 		FROM

store/store.go

@@ -574,9 +574,11 @@ type UserTermsOfServiceStore interface {
 type GroupStore interface {
 	Create(group *model.Group) (*model.Group, *model.AppError)
 	Get(groupID string) (*model.Group, *model.AppError)
+	GetByName(name string) (*model.Group, *model.AppError)
 	GetByIDs(groupIDs []string) ([]*model.Group, *model.AppError)
 	GetByRemoteID(remoteID string, groupSource model.GroupSource) (*model.Group, *model.AppError)
 	GetAllBySource(groupSource model.GroupSource) ([]*model.Group, *model.AppError)
+	GetByUser(userId string) ([]*model.Group, *model.AppError)
 	Update(group *model.Group) (*model.Group, *model.AppError)
 	Delete(groupID string) (*model.Group, *model.AppError)
 
@@ -585,6 +587,7 @@ type GroupStore interface {
 	GetMemberCount(groupID string) (int64, *model.AppError)
 	UpsertMember(groupID string, userID string) (*model.GroupMember, *model.AppError)
 	DeleteMember(groupID string, userID string) (*model.GroupMember, *model.AppError)
+	PermanentDeleteMembersByUser(userId string) *model.AppError
 
 	CreateGroupSyncable(groupSyncable *model.GroupSyncable) (*model.GroupSyncable, *model.AppError)
 	GetGroupSyncable(groupID string, syncableID string, syncableType model.GroupSyncableType) (*model.GroupSyncable, *model.AppError)

store/storetest/bot_store.go

@@ -175,13 +175,13 @@ func testBotStoreGetAll(t *testing.T, ss store.Store) {
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
-	if _, err := ss.User().Save(&deletedUser); err != nil {
-		t.Fatal("couldn't save user", err)
-	}
+	_, err1 := ss.User().Save(&deletedUser)
+	require.Nil(t, err1, "couldn't save user")
+
 	deletedUser.DeleteAt = model.GetMillis()
-	if _, err := ss.User().Update(&deletedUser, true); err != nil {
-		t.Fatal("couldn't delete user", err)
-	}
+	_, err2 := ss.User().Update(&deletedUser, true)
+	require.Nil(t, err2, "couldn't delete user")
+
 	defer func() { require.Nil(t, ss.User().PermanentDelete(deletedUser.Id)) }()
 	ob5, _ := makeBotWithUser(t, ss, &model.Bot{
 		Username:    "ob5",

store/storetest/command_webhook_store.go

@@ -4,14 +4,13 @@
 package storetest
 
 import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
 	"net/http"
+	"testing"
 
 	"github.com/mattermost/mattermost-server/model"
 	"github.com/mattermost/mattermost-server/store"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCommandWebhookStore(t *testing.T, ss store.Store) {
@@ -29,17 +28,12 @@ func testCommandWebhookStore(t *testing.T, ss store.Store) {
 	require.Nil(t, err)
 
 	var r1 *model.CommandWebhook
-	if r1, err = cws.Get(h1.Id); err != nil {
-		t.Fatal(err)
-	} else {
-		if *r1 != *h1 {
-			t.Fatal("invalid returned webhook")
-		}
-	}
+	r1, err = cws.Get(h1.Id)
+	require.Nil(t, err)
+	assert.Equal(t, *r1, *h1, "invalid returned webhook")
 
-	if _, err = cws.Get("123"); err.StatusCode != http.StatusNotFound {
-		t.Fatal("Should have set the status as not found for missing id")
-	}
+	_, err = cws.Get("123")
+	assert.Equal(t, err.StatusCode, http.StatusNotFound, "Should have set the status as not found for missing id")
 
 	h2 := &model.CommandWebhook{}
 	h2.CreateAt = model.GetMillis() - 2*model.COMMAND_WEBHOOK_LIFETIME
@@ -49,25 +43,22 @@ func testCommandWebhookStore(t *testing.T, ss store.Store) {
 	h2, err = cws.Save(h2)
 	require.Nil(t, err)
 
-	if _, err := cws.Get(h2.Id); err == nil || err.StatusCode != http.StatusNotFound {
-		t.Fatal("Should have set the status as not found for expired webhook")
-	}
+	_, err = cws.Get(h2.Id)
+	require.NotNil(t, err, "Should have set the status as not found for expired webhook")
+	assert.Equal(t, err.StatusCode, http.StatusNotFound, "Should have set the status as not found for expired webhook")
 
 	cws.Cleanup()
 
-	if _, err := cws.Get(h1.Id); err != nil {
-		t.Fatal("Should have no error getting unexpired webhook")
-	}
+	_, err = cws.Get(h1.Id)
+	require.Nil(t, err, "Should have no error getting unexpired webhook")
 
-	if _, err := cws.Get(h2.Id); err.StatusCode != http.StatusNotFound {
-		t.Fatal("Should have set the status as not found for expired webhook")
-	}
+	_, err = cws.Get(h2.Id)
+	assert.Equal(t, err.StatusCode, http.StatusNotFound, "Should have set the status as not found for expired webhook")
 
-	if err := cws.TryUse(h1.Id, 1); err != nil {
-		t.Fatal("Should be able to use webhook once")
-	}
+	err = cws.TryUse(h1.Id, 1)
+	require.Nil(t, err, "Should be able to use webhook once")
 
-	if err := cws.TryUse(h1.Id, 1); err == nil || err.StatusCode != http.StatusBadRequest {
-		t.Fatal("Should be able to use webhook once")
-	}
+	err = cws.TryUse(h1.Id, 1)
+	require.NotNil(t, err, "Should be able to use webhook once")
+	assert.Equal(t, err.StatusCode, http.StatusBadRequest, "Should be able to use webhook once")
 }

store/storetest/group_store.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/mattermost/mattermost-server/model"
@@ -20,9 +21,11 @@ import (
 func TestGroupStore(t *testing.T, ss store.Store) {
 	t.Run("Create", func(t *testing.T) { testGroupStoreCreate(t, ss) })
 	t.Run("Get", func(t *testing.T) { testGroupStoreGet(t, ss) })
+	t.Run("GetByName", func(t *testing.T) { testGroupStoreGetByName(t, ss) })
 	t.Run("GetByIDs", func(t *testing.T) { testGroupStoreGetByIDs(t, ss) })
 	t.Run("GetByRemoteID", func(t *testing.T) { testGroupStoreGetByRemoteID(t, ss) })
 	t.Run("GetAllBySource", func(t *testing.T) { testGroupStoreGetAllByType(t, ss) })
+	t.Run("GetByUser", func(t *testing.T) { testGroupStoreGetByUser(t, ss) })
 	t.Run("Update", func(t *testing.T) { testGroupStoreUpdate(t, ss) })
 	t.Run("Delete", func(t *testing.T) { testGroupStoreDelete(t, ss) })
 
@@ -30,6 +33,7 @@ func TestGroupStore(t *testing.T, ss store.Store) {
 	t.Run("GetMemberUsersPage", func(t *testing.T) { testGroupGetMemberUsersPage(t, ss) })
 	t.Run("UpsertMember", func(t *testing.T) { testUpsertMember(t, ss) })
 	t.Run("DeleteMember", func(t *testing.T) { testGroupDeleteMember(t, ss) })
+	t.Run("PermanentDeleteMembersByUser", func(t *testing.T) { testGroupPermanentDeleteMembersByUser(t, ss) })
 
 	t.Run("CreateGroupSyncable", func(t *testing.T) { testCreateGroupSyncable(t, ss) })
 	t.Run("GetGroupSyncable", func(t *testing.T) { testGetGroupSyncable(t, ss) })
@@ -181,6 +185,37 @@ func testGroupStoreGet(t *testing.T, ss store.Store) {
 	require.Equal(t, err.Id, "store.sql_group.no_rows")
 }
 
+func testGroupStoreGetByName(t *testing.T, ss store.Store) {
+	// Create a group
+	g1 := &model.Group{
+		Name:        model.NewId(),
+		DisplayName: model.NewId(),
+		Description: model.NewId(),
+		Source:      model.GroupSourceLdap,
+		RemoteId:    model.NewId(),
+	}
+	d1, err := ss.Group().Create(g1)
+	require.Nil(t, err)
+	require.Len(t, d1.Id, 26)
+
+	// Get the group
+	d2, err := ss.Group().GetByName(d1.Name)
+	require.Nil(t, err)
+	require.Equal(t, d1.Id, d2.Id)
+	require.Equal(t, d1.Name, d2.Name)
+	require.Equal(t, d1.DisplayName, d2.DisplayName)
+	require.Equal(t, d1.Description, d2.Description)
+	require.Equal(t, d1.RemoteId, d2.RemoteId)
+	require.Equal(t, d1.CreateAt, d2.CreateAt)
+	require.Equal(t, d1.UpdateAt, d2.UpdateAt)
+	require.Equal(t, d1.DeleteAt, d2.DeleteAt)
+
+	// Get an invalid group
+	_, err = ss.Group().GetByName(model.NewId())
+	require.NotNil(t, err)
+	require.Equal(t, err.Id, "store.sql_group.no_rows")
+}
+
 func testGroupStoreGetByIDs(t *testing.T, ss store.Store) {
 	var group1 *model.Group
 	var group2 *model.Group
@@ -280,6 +315,76 @@ func testGroupStoreGetAllByType(t *testing.T, ss store.Store) {
 	}
 }
 
+func testGroupStoreGetByUser(t *testing.T, ss store.Store) {
+	// Save a group
+	g1 := &model.Group{
+		Name:        model.NewId(),
+		DisplayName: model.NewId(),
+		Description: model.NewId(),
+		Source:      model.GroupSourceLdap,
+		RemoteId:    model.NewId(),
+	}
+	g1, err := ss.Group().Create(g1)
+	require.Nil(t, err)
+
+	g2 := &model.Group{
+		Name:        model.NewId(),
+		DisplayName: model.NewId(),
+		Description: model.NewId(),
+		Source:      model.GroupSourceLdap,
+		RemoteId:    model.NewId(),
+	}
+	g2, err = ss.Group().Create(g2)
+	require.Nil(t, err)
+
+	u1 := &model.User{
+		Email:    MakeEmail(),
+		Username: model.NewId(),
+	}
+	u1, err = ss.User().Save(u1)
+	require.Nil(t, err)
+
+	_, err = ss.Group().UpsertMember(g1.Id, u1.Id)
+	require.Nil(t, err)
+	_, err = ss.Group().UpsertMember(g2.Id, u1.Id)
+	require.Nil(t, err)
+
+	u2 := &model.User{
+		Email:    MakeEmail(),
+		Username: model.NewId(),
+	}
+	u2, err = ss.User().Save(u2)
+	require.Nil(t, err)
+
+	_, err = ss.Group().UpsertMember(g2.Id, u2.Id)
+	require.Nil(t, err)
+
+	groups, err := ss.Group().GetByUser(u1.Id)
+	require.Nil(t, err)
+	assert.Equal(t, 2, len(groups))
+	found1 := false
+	found2 := false
+	for _, g := range groups {
+		if g.Id == g1.Id {
+			found1 = true
+		}
+		if g.Id == g2.Id {
+			found2 = true
+		}
+	}
+	assert.True(t, found1)
+	assert.True(t, found2)
+
+	groups, err = ss.Group().GetByUser(u2.Id)
+	require.Nil(t, err)
+	require.Equal(t, 1, len(groups))
+	assert.Equal(t, g2.Id, groups[0].Id)
+
+	groups, err = ss.Group().GetByUser(model.NewId())
+	require.Nil(t, err)
+	assert.Equal(t, 0, len(groups))
+}
+
 func testGroupStoreUpdate(t *testing.T, ss store.Store) {
 	// Save a new group
 	g1 := &model.Group{
@@ -658,6 +763,42 @@ func testGroupDeleteMember(t *testing.T, ss store.Store) {
 	require.Equal(t, err.Id, "store.sql_group.no_rows")
 }
 
+func testGroupPermanentDeleteMembersByUser(t *testing.T, ss store.Store) {
+	var g *model.Group
+	var groups []*model.Group
+	numberOfGroups := 5
+
+	for i := 0; i < numberOfGroups; i++ {
+		g = &model.Group{
+			Name:        model.NewId(),
+			DisplayName: model.NewId(),
+			Source:      model.GroupSourceLdap,
+			RemoteId:    model.NewId(),
+		}
+		group, err := ss.Group().Create(g)
+		groups = append(groups, group)
+		require.Nil(t, err)
+	}
+
+	// Create user
+	u1 := &model.User{
+		Email:    MakeEmail(),
+		Username: model.NewId(),
+	}
+	user, err := ss.User().Save(u1)
+	require.Nil(t, err)
+
+	// Create members
+	for _, group := range groups {
+		_, err = ss.Group().UpsertMember(group.Id, user.Id)
+		require.Nil(t, err)
+	}
+
+	// Happy path
+	err = ss.Group().PermanentDeleteMembersByUser(user.Id)
+	require.Nil(t, err)
+}
+
 func testCreateGroupSyncable(t *testing.T, ss store.Store) {
 	// Invalid GroupID
 	_, err := ss.Group().CreateGroupSyncable(model.NewGroupTeam("x", model.NewId(), false))
@@ -897,7 +1038,7 @@ func testDeleteGroupSyncable(t *testing.T, ss store.Store) {
 	require.Equal(t, err.Id, "store.sql_group.no_rows")
 
 	// Non-existent Team
-	_, err = ss.Group().DeleteGroupSyncable(groupTeam.GroupId, string(model.NewId()), model.GroupSyncableTypeTeam)
+	_, err = ss.Group().DeleteGroupSyncable(groupTeam.GroupId, model.NewId(), model.GroupSyncableTypeTeam)
 	require.Equal(t, err.Id, "store.sql_group.no_rows")
 
 	// Happy path...
@@ -1654,10 +1795,10 @@ func testGetGroupsByChannel(t *testing.T, ss store.Store) {
 	_, err = ss.User().Update(user2, true)
 	require.Nil(t, err)
 
-	group1WithMemberCount := model.Group(*group1)
+	group1WithMemberCount := *group1
 	group1WithMemberCount.MemberCount = model.NewInt(1)
 
-	group2WithMemberCount := model.Group(*group2)
+	group2WithMemberCount := *group2
 	group2WithMemberCount.MemberCount = model.NewInt(0)
 
 	testCases := []struct {
@@ -1868,10 +2009,10 @@ func testGetGroupsByTeam(t *testing.T, ss store.Store) {
 	_, err = ss.User().Update(user2, true)
 	require.Nil(t, err)
 
-	group1WithMemberCount := model.Group(*group1)
+	group1WithMemberCount := *group1
 	group1WithMemberCount.MemberCount = model.NewInt(1)
 
-	group2WithMemberCount := model.Group(*group2)
+	group2WithMemberCount := *group2
 	group2WithMemberCount.MemberCount = model.NewInt(0)
 
 	testCases := []struct {

store/storetest/mocks/GroupStore.go

@@ -406,6 +406,31 @@ func (_m *GroupStore) GetByIDs(groupIDs []string) ([]*model.Group, *model.AppErr
 	return r0, r1
 }
 
+// GetByName provides a mock function with given fields: name
+func (_m *GroupStore) GetByName(name string) (*model.Group, *model.AppError) {
+	ret := _m.Called(name)
+
+	var r0 *model.Group
+	if rf, ok := ret.Get(0).(func(string) *model.Group); ok {
+		r0 = rf(name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Group)
+		}
+	}
+
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+		r1 = rf(name)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
+}
+
 // GetByRemoteID provides a mock function with given fields: remoteID, groupSource
 func (_m *GroupStore) GetByRemoteID(remoteID string, groupSource model.GroupSource) (*model.Group, *model.AppError) {
 	ret := _m.Called(remoteID, groupSource)
@@ -431,6 +456,31 @@ func (_m *GroupStore) GetByRemoteID(remoteID string, groupSource model.GroupSour
 	return r0, r1
 }
 
+// GetByUser provides a mock function with given fields: userId
+func (_m *GroupStore) GetByUser(userId string) ([]*model.Group, *model.AppError) {
+	ret := _m.Called(userId)
+
+	var r0 []*model.Group
+	if rf, ok := ret.Get(0).(func(string) []*model.Group); ok {
+		r0 = rf(userId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Group)
+		}
+	}
+
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+		r1 = rf(userId)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
+}
+
 // GetGroupSyncable provides a mock function with given fields: groupID, syncableID, syncableType
 func (_m *GroupStore) GetGroupSyncable(groupID string, syncableID string, syncableType model.GroupSyncableType) (*model.GroupSyncable, *model.AppError) {
 	ret := _m.Called(groupID, syncableID, syncableType)
@@ -604,6 +654,22 @@ func (_m *GroupStore) GetMemberUsersPage(groupID string, page int, perPage int)
 	return r0, r1
 }
 
+// PermanentDeleteMembersByUser provides a mock function with given fields: userId
+func (_m *GroupStore) PermanentDeleteMembersByUser(userId string) *model.AppError {
+	ret := _m.Called(userId)
+
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
+		r0 = rf(userId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AppError)
+		}
+	}
+
+	return r0
+}
+
 // TeamMembersMinusGroupMembers provides a mock function with given fields: teamID, groupIDs, page, perPage
 func (_m *GroupStore) TeamMembersMinusGroupMembers(teamID string, groupIDs []string, page int, perPage int) ([]*model.UserWithGroups, *model.AppError) {
 	ret := _m.Called(teamID, groupIDs, page, perPage)

store/storetest/oauth_store.go

@@ -213,7 +213,7 @@ func testOAuthStoreRemoveAccessData(t *testing.T, ss store.Store) {
 	require.Nil(t, result, "did not delete access token")
 }
 
-func testOAuthStoreRemoveAllAccessData(t *testing.T, ss store.Store) {
+func TestOAuthStoreRemoveAllAccessData(t *testing.T, ss store.Store) {
 	a1 := model.AccessData{}
 	a1.ClientId = model.NewId()
 	a1.UserId = model.NewId()

store/storetest/preference_store.go

@@ -42,26 +42,22 @@ func testPreferenceSave(t *testing.T, ss store.Store) {
 			Value:    "value1b",
 		},
 	}
-	if err := ss.Preference().Save(&preferences); err != nil {
-		t.Fatal("saving preference returned error")
-	}
+	err := ss.Preference().Save(&preferences)
+	require.Nil(t, err, "saving preference returned error")
 
 	for _, preference := range preferences {
-		if data, _ := ss.Preference().Get(preference.UserId, preference.Category, preference.Name); preference.ToJson() != data.ToJson() {
-			t.Fatal("got incorrect preference after first Save")
-		}
+		data, _ := ss.Preference().Get(preference.UserId, preference.Category, preference.Name)
+		require.Equal(t, data.ToJson(), preference.ToJson(), "got incorrect preference after first Save")
 	}
 
 	preferences[0].Value = "value2a"
 	preferences[1].Value = "value2b"
-	if err := ss.Preference().Save(&preferences); err != nil {
-		t.Fatal("saving preference returned error")
-	}
+	err = ss.Preference().Save(&preferences)
+	require.Nil(t, err, "saving preference returned error")
 
 	for _, preference := range preferences {
-		if data, _ := ss.Preference().Get(preference.UserId, preference.Category, preference.Name); preference.ToJson() != data.ToJson() {
-			t.Fatal("got incorrect preference after second Save")
-		}
+		data, _ := ss.Preference().Get(preference.UserId, preference.Category, preference.Name)
+		require.Equal(t, data.ToJson(), preference.ToJson(), "got incorrect preference after second Save")
 	}
 }
 
@@ -96,16 +92,13 @@ func testPreferenceGet(t *testing.T, ss store.Store) {
 	err := ss.Preference().Save(&preferences)
 	require.Nil(t, err)
 
-	if data, err := ss.Preference().Get(userId, category, name); err != nil {
-		t.Fatal(err)
-	} else if data.ToJson() != preferences[0].ToJson() {
-		t.Fatal("got incorrect preference")
-	}
+	data, err := ss.Preference().Get(userId, category, name)
+	require.Nil(t, err)
+	require.Equal(t, preferences[0].ToJson(), data.ToJson(), "got incorrect preference")
 
 	// make sure getting a missing preference fails
-	if _, err := ss.Preference().Get(model.NewId(), model.NewId(), model.NewId()); err == nil {
-		t.Fatal("no error on getting a missing preference")
-	}
+	_, err = ss.Preference().Get(model.NewId(), model.NewId(), model.NewId())
+	require.NotNil(t, err, "no error on getting a missing preference")
 }
 
 func testPreferenceGetCategory(t *testing.T, ss store.Store) {
@@ -142,20 +135,19 @@ func testPreferenceGetCategory(t *testing.T, ss store.Store) {
 	err := ss.Preference().Save(&preferences)
 	require.Nil(t, err)
 
-	if preferencesByCategory, err := ss.Preference().GetCategory(userId, category); err != nil {
-		t.Fatal(err)
-	} else if len(preferencesByCategory) != 2 {
-		t.Fatal("got the wrong number of preferences")
-	} else if !((preferencesByCategory[0] == preferences[0] && preferencesByCategory[1] == preferences[1]) || (preferencesByCategory[0] == preferences[1] && preferencesByCategory[1] == preferences[0])) {
-		t.Fatal("got incorrect preferences")
-	}
+	preferencesByCategory, err := ss.Preference().GetCategory(userId, category)
+	require.Nil(t, err)
+	require.Equal(t, 2, len(preferencesByCategory), "got the wrong number of preferences")
+	require.True(
+		t,
+		((preferencesByCategory[0] == preferences[0] && preferencesByCategory[1] == preferences[1]) || (preferencesByCategory[0] == preferences[1] && preferencesByCategory[1] == preferences[0])),
+		"got incorrect preferences",
+	)
 
 	// make sure getting a missing preference category doesn't fail
-	if preferencesByCategory, err := ss.Preference().GetCategory(model.NewId(), model.NewId()); err != nil {
-		t.Fatal(err)
-	} else if len(preferencesByCategory) != 0 {
-		t.Fatal("shouldn't have got any preferences")
-	}
+	preferencesByCategory, err = ss.Preference().GetCategory(model.NewId(), model.NewId())
+	require.Nil(t, err)
+	require.Equal(t, 0, len(preferencesByCategory), "shouldn't have got any preferences")
 }
 
 func testPreferenceGetAll(t *testing.T, ss store.Store) {
@@ -192,17 +184,14 @@ func testPreferenceGetAll(t *testing.T, ss store.Store) {
 	err := ss.Preference().Save(&preferences)
 	require.Nil(t, err)
 
-	if result, err := ss.Preference().GetAll(userId); err != nil {
-		t.Fatal(err)
-	} else if len(result) != 3 {
-		t.Fatal("got the wrong number of preferences")
-	} else {
-		for i := 0; i < 3; i++ {
-			if result[0] != preferences[i] && result[1] != preferences[i] && result[2] != preferences[i] {
-				t.Fatal("got incorrect preferences")
-			}
-		}
+	result, err := ss.Preference().GetAll(userId)
+	require.Nil(t, err)
+	require.Equal(t, 3, len(result), "got the wrong number of preferences")
+
+	for i := 0; i < 3; i++ {
+		assert.Falsef(t, result[0] != preferences[i] && result[1] != preferences[i] && result[2] != preferences[i], "got incorrect preferences")
 	}
+
 }
 
 func testPreferenceDeleteByUser(t *testing.T, ss store.Store) {
@@ -239,9 +228,8 @@ func testPreferenceDeleteByUser(t *testing.T, ss store.Store) {
 	err := ss.Preference().Save(&preferences)
 	require.Nil(t, err)
 
-	if err := ss.Preference().PermanentDeleteByUser(userId); err != nil {
-		t.Fatal(err)
-	}
+	err = ss.Preference().PermanentDeleteByUser(userId)
+	require.Nil(t, err)
 }
 
 func testPreferenceDelete(t *testing.T, ss store.Store) {
@@ -259,13 +247,11 @@ func testPreferenceDelete(t *testing.T, ss store.Store) {
 	require.Nil(t, err)
 	assert.Len(t, preferences, 1, "should've returned 1 preference")
 
-	if err = ss.Preference().Delete(preference.UserId, preference.Category, preference.Name); err != nil {
-		t.Fatal(err)
-	}
+	err = ss.Preference().Delete(preference.UserId, preference.Category, preference.Name)
+	require.Nil(t, err)
 	preferences, err = ss.Preference().GetAll(preference.UserId)
 	require.Nil(t, err)
 	assert.Len(t, preferences, 0, "should've returned no preferences")
-
 }
 
 func testPreferenceDeleteCategory(t *testing.T, ss store.Store) {
@@ -293,9 +279,8 @@ func testPreferenceDeleteCategory(t *testing.T, ss store.Store) {
 	require.Nil(t, err)
 	assert.Len(t, preferences, 2, "should've returned 2 preferences")
 
-	if err = ss.Preference().DeleteCategory(userId, category); err != nil {
-		t.Fatal(err)
-	}
+	err = ss.Preference().DeleteCategory(userId, category)
+	require.Nil(t, err)
 
 	preferences, err = ss.Preference().GetAll(userId)
 	require.Nil(t, err)
@@ -333,9 +318,8 @@ func testPreferenceDeleteCategoryAndName(t *testing.T, ss store.Store) {
 	require.Nil(t, err)
 	assert.Len(t, preferences, 1, "should've returned 1 preference")
 
-	if err = ss.Preference().DeleteCategoryAndName(category, name); err != nil {
-		t.Fatal(err)
-	}
+	err = ss.Preference().DeleteCategoryAndName(category, name)
+	require.Nil(t, err)
 
 	preferences, err = ss.Preference().GetAll(userId)
 	require.Nil(t, err)

store/storetest/terms_of_service_store.go

@@ -30,13 +30,9 @@ func testSaveTermsOfService(t *testing.T, ss store.Store) {
 	savedTermsOfService, err := ss.TermsOfService().Save(termsOfService)
 	require.Nil(t, err)
 
-	if len(savedTermsOfService.Id) != 26 {
-		t.Fatal("Id should have been populated")
-	}
+	require.Len(t, savedTermsOfService.Id, 26, "Id should have been populated")
 
-	if savedTermsOfService.CreateAt == 0 {
-		t.Fatal("Create at should have been populated")
-	}
+	require.NotEqual(t, savedTermsOfService.CreateAt, 0, "Create at should have been populated")
 }
 
 func testGetLatestTermsOfService(t *testing.T, ss store.Store) {

store/storetest/user_access_token_store.go

@@ -31,49 +31,36 @@ func testUserAccessTokenSaveGetDelete(t *testing.T, ss store.Store) {
 	s1, err := ss.Session().Save(s1)
 	require.Nil(t, err)
 
-	if _, err = ss.UserAccessToken().Save(uat); err != nil {
-		t.Fatal(err)
-	}
+	_, err = ss.UserAccessToken().Save(uat)
+	require.Nil(t, err)
 
-	if result, terr := ss.UserAccessToken().Get(uat.Id); terr != nil {
-		t.Fatal(terr)
-	} else if result.Token != uat.Token {
-		t.Fatal("received incorrect token after save")
-	}
+	result, terr := ss.UserAccessToken().Get(uat.Id)
+	require.Nil(t, terr)
+	require.Equal(t, result.Token, uat.Token, "received incorrect token after save")
 
-	if received, err2 := ss.UserAccessToken().GetByToken(uat.Token); err2 != nil {
-		t.Fatal(err2)
-	} else if received.Token != uat.Token {
-		t.Fatal("received incorrect token after save")
-	}
+	received, err2 := ss.UserAccessToken().GetByToken(uat.Token)
+	require.Nil(t, err2)
+	require.Equal(t, received.Token, uat.Token, "received incorrect token after save")
 
-	if _, err = ss.UserAccessToken().GetByToken("notarealtoken"); err == nil {
-		t.Fatal("should have failed on bad token")
-	}
+	_, err = ss.UserAccessToken().GetByToken("notarealtoken")
+	require.NotNil(t, err, "should have failed on bad token")
 
-	if received, err2 := ss.UserAccessToken().GetByUser(uat.UserId, 0, 100); err2 != nil {
-		t.Fatal(err2)
-	} else if len(received) != 1 {
-		t.Fatal("received incorrect number of tokens after save")
-	}
+	received2, err2 := ss.UserAccessToken().GetByUser(uat.UserId, 0, 100)
+	require.Nil(t, err2)
+	require.Equal(t, 1, len(received2), "received incorrect number of tokens after save")
 
-	if result, appError := ss.UserAccessToken().GetAll(0, 100); appError != nil {
-		t.Fatal(appError)
-	} else if len(result) != 1 {
-		t.Fatal("received incorrect number of tokens after save")
-	}
+	result2, appError := ss.UserAccessToken().GetAll(0, 100)
+	require.Nil(t, appError)
+	require.Equal(t, 1, len(result2), "received incorrect number of tokens after save")
 
-	if err = ss.UserAccessToken().Delete(uat.Id); err != nil {
-		t.Fatal(err)
-	}
+	err = ss.UserAccessToken().Delete(uat.Id)
+	require.Nil(t, err)
 
-	if _, err = ss.Session().Get(s1.Token); err == nil {
-		t.Fatal("should error - session should be deleted")
-	}
+	_, err = ss.Session().Get(s1.Token)
+	require.NotNil(t, err, "should error - session should be deleted")
 
-	if _, err = ss.UserAccessToken().GetByToken(s1.Token); err == nil {
-		t.Fatal("should error - access token should be deleted")
-	}
+	_, err = ss.UserAccessToken().GetByToken(s1.Token)
+	require.NotNil(t, err, "should error - access token should be deleted")
 
 	s2 := &model.Session{}
 	s2.UserId = uat.UserId
@@ -82,21 +69,17 @@ func testUserAccessTokenSaveGetDelete(t *testing.T, ss store.Store) {
 	s2, err = ss.Session().Save(s2)
 	require.Nil(t, err)
 
-	if _, err = ss.UserAccessToken().Save(uat); err != nil {
-		t.Fatal(err)
-	}
+	_, err = ss.UserAccessToken().Save(uat)
+	require.Nil(t, err)
 
-	if err := ss.UserAccessToken().DeleteAllForUser(uat.UserId); err != nil {
-		t.Fatal(err)
-	}
+	err = ss.UserAccessToken().DeleteAllForUser(uat.UserId)
+	require.Nil(t, err)
 
-	if _, err := ss.Session().Get(s2.Token); err == nil {
-		t.Fatal("should error - session should be deleted")
-	}
+	_, err = ss.Session().Get(s2.Token)
+	require.NotNil(t, err, "should error - session should be deleted")
 
-	if _, err := ss.UserAccessToken().GetByToken(s2.Token); err == nil {
-		t.Fatal("should error - access token should be deleted")
-	}
+	_, err = ss.UserAccessToken().GetByToken(s2.Token)
+	require.NotNil(t, err, "should error - access token should be deleted")
 }
 
 func testUserAccessTokenDisableEnable(t *testing.T, ss store.Store) {
@@ -113,17 +96,14 @@ func testUserAccessTokenDisableEnable(t *testing.T, ss store.Store) {
 	s1, err := ss.Session().Save(s1)
 	require.Nil(t, err)
 
-	if _, err = ss.UserAccessToken().Save(uat); err != nil {
-		t.Fatal(err)
-	}
+	_, err = ss.UserAccessToken().Save(uat)
+	require.Nil(t, err)
 
-	if err = ss.UserAccessToken().UpdateTokenDisable(uat.Id); err != nil {
-		t.Fatal(err)
-	}
+	err = ss.UserAccessToken().UpdateTokenDisable(uat.Id)
+	require.Nil(t, err)
 
-	if _, err = ss.Session().Get(s1.Token); err == nil {
-		t.Fatal("should error - session should be deleted")
-	}
+	_, err = ss.Session().Get(s1.Token)
+	require.NotNil(t, err, "should error - session should be deleted")
 
 	s2 := &model.Session{}
 	s2.UserId = uat.UserId
@@ -132,9 +112,8 @@ func testUserAccessTokenDisableEnable(t *testing.T, ss store.Store) {
 	s2, err = ss.Session().Save(s2)
 	require.Nil(t, err)
 
-	if err = ss.UserAccessToken().UpdateTokenEnable(uat.Id); err != nil {
-		t.Fatal(err)
-	}
+	err = ss.UserAccessToken().UpdateTokenEnable(uat.Id)
+	require.Nil(t, err)
 }
 
 func testUserAccessTokenSearch(t *testing.T, ss store.Store) {
@@ -158,25 +137,19 @@ func testUserAccessTokenSearch(t *testing.T, ss store.Store) {
 	s1, err = ss.Session().Save(s1)
 	require.Nil(t, err)
 
-	if _, err = ss.UserAccessToken().Save(uat); err != nil {
-		t.Fatal(err)
-	}
+	_, err = ss.UserAccessToken().Save(uat)
+	require.Nil(t, err)
 
-	if received, err := ss.UserAccessToken().Search(uat.Id); err != nil {
-		t.Fatal(err)
-	} else if len(received) != 1 {
-		t.Fatal("received incorrect number of tokens after search")
-	}
+	received, err := ss.UserAccessToken().Search(uat.Id)
+	require.Nil(t, err)
 
-	if received, err := ss.UserAccessToken().Search(uat.UserId); err != nil {
-		t.Fatal(err)
-	} else if len(received) != 1 {
-		t.Fatal("received incorrect number of tokens after search")
-	}
+	require.Equal(t, 1, len(received), "received incorrect number of tokens after search")
 
-	if received, err := ss.UserAccessToken().Search(u1.Username); err != nil {
-		t.Fatal(err)
-	} else if len(received) != 1 {
-		t.Fatal("received incorrect number of tokens after search")
-	}
+	received, err = ss.UserAccessToken().Search(uat.UserId)
+	require.Nil(t, err)
+	require.Equal(t, 1, len(received), "received incorrect number of tokens after search")
+
+	received, err = ss.UserAccessToken().Search(u1.Username)
+	require.Nil(t, err)
+	require.Equal(t, 1, len(received), "received incorrect number of tokens after search")
 }

store/storetest/webhook_store.go

@@ -228,7 +228,7 @@ func TestWebhookStoreGetIncomingByTeamByUser(t *testing.T, ss store.Store) {
 	})
 }
 
-func testWebhookStoreGetIncomingByChannel(t *testing.T, ss store.Store) {
+func TestWebhookStoreGetIncomingByChannel(t *testing.T, ss store.Store) {
 	o1 := buildIncomingWebhook()
 
 	o1, err := ss.Webhook().SaveIncoming(o1)

store/timer_layer.go

@@ -2776,6 +2776,23 @@ func (s *TimerLayerGroupStore) GetByIDs(groupIDs []string) ([]*model.Group, *mod
 	return resultVar0, resultVar1
 }
 
+func (s *TimerLayerGroupStore) GetByName(name string) (*model.Group, *model.AppError) {
+	start := timemodule.Now()
+
+	resultVar0, resultVar1 := s.GroupStore.GetByName(name)
+
+	t := timemodule.Now()
+	elapsed := t.Sub(start)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if resultVar1 == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetByName", success, float64(elapsed))
+	}
+	return resultVar0, resultVar1
+}
+
 func (s *TimerLayerGroupStore) GetByRemoteID(remoteID string, groupSource model.GroupSource) (*model.Group, *model.AppError) {
 	start := timemodule.Now()
 
@@ -2792,6 +2809,23 @@ func (s *TimerLayerGroupStore) GetByRemoteID(remoteID string, groupSource model.
 	return resultVar0, resultVar1
 }
 
+func (s *TimerLayerGroupStore) GetByUser(userId string) ([]*model.Group, *model.AppError) {
+	start := timemodule.Now()
+
+	resultVar0, resultVar1 := s.GroupStore.GetByUser(userId)
+
+	t := timemodule.Now()
+	elapsed := t.Sub(start)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if resultVar1 == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetByUser", success, float64(elapsed))
+	}
+	return resultVar0, resultVar1
+}
+
 func (s *TimerLayerGroupStore) GetGroupSyncable(groupID string, syncableID string, syncableType model.GroupSyncableType) (*model.GroupSyncable, *model.AppError) {
 	start := timemodule.Now()