Merge branch 'master' into mark-as-unread

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)