Replacing require.nil in app layer (#16905)

* Replacing require.nil in app layer

* Fixing some tests

* Fixing tests

* Reverting the error correction, defering it for another PR

* Fixing golangci-lint errors

Co-authored-by: Mattermod <mattermod@users.noreply.github.com>

app/app_test.go

@@ -484,18 +484,18 @@ func TestDBHealthCheckWriteAndDelete(t *testing.T) {
 	assert.Equal(t, expectedKey, th.App.dbHealthCheckKey())
 
 	_, err := th.App.Srv().Store.System().GetByName(expectedKey)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	err = th.App.DBHealthCheckWrite()
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	systemVal, err := th.App.Srv().Store.System().GetByName(expectedKey)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.NotNil(t, systemVal)
 
 	err = th.App.DBHealthCheckDelete()
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	_, err = th.App.Srv().Store.System().GetByName(expectedKey)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }

app/bot_test.go

@@ -778,7 +778,7 @@ func TestSetBotIconImage(t *testing.T) {
 		defer svgFile.Close()
 
 		expectedData, fileErr := ioutil.ReadAll(svgFile)
-		require.Nil(t, fileErr)
+		require.NoError(t, fileErr)
 		require.NotNil(t, expectedData)
 
 		bot, err := th.App.ConvertUserToBot(&model.User{
@@ -830,7 +830,7 @@ func TestGetBotIconImage(t *testing.T) {
 		defer svgFile.Close()
 
 		expectedData, fileErr := ioutil.ReadAll(svgFile)
-		require.Nil(t, fileErr)
+		require.NoError(t, fileErr)
 		require.NotNil(t, expectedData)
 
 		bot, err := th.App.ConvertUserToBot(&model.User{
@@ -877,7 +877,7 @@ func TestDeleteBotIconImage(t *testing.T) {
 		defer svgFile.Close()
 
 		expectedData, fileErr := ioutil.ReadAll(svgFile)
-		require.Nil(t, fileErr)
+		require.NoError(t, fileErr)
 		require.NotNil(t, expectedData)
 
 		bot, err := th.App.ConvertUserToBot(&model.User{

app/channel_category_test.go

@@ -110,10 +110,10 @@ func TestGetSidebarCategories(t *testing.T) {
 			UserId:     th.BasicUser.Id,
 			SchemeUser: true,
 		}, 100)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
-		categories, err := th.App.GetSidebarCategories(th.BasicUser.Id, team.Id)
-		assert.Nil(t, err)
+		categories, appErr := th.App.GetSidebarCategories(th.BasicUser.Id, team.Id)
+		assert.Nil(t, appErr)
 		assert.Len(t, categories.Categories, 3)
 	})
 
@@ -124,10 +124,10 @@ func TestGetSidebarCategories(t *testing.T) {
 		// Temporarily renaming a table to force a DB error.
 		sqlStore := mainHelper.GetSQLStore()
 		_, err := sqlStore.GetMaster().Exec("ALTER TABLE SidebarCategories RENAME TO SidebarCategoriesTest")
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer func() {
 			_, err := sqlStore.GetMaster().Exec("ALTER TABLE SidebarCategoriesTest RENAME TO SidebarCategories")
-			require.Nil(t, err)
+			require.NoError(t, err)
 		}()
 
 		categories, appErr := th.App.GetSidebarCategories(th.BasicUser.Id, th.BasicTeam.Id)

app/channel_test.go

@@ -134,7 +134,7 @@ func TestMoveChannel(t *testing.T) {
 		require.Nil(t, err)
 
 		err = th.App.MoveChannel(targetTeam, channel1, th.BasicUser)
-		require.Error(t, err, "Should have failed due to mismatched members.")
+		require.NotNil(t, err, "Should have failed due to mismatched members.")
 
 		_, err = th.App.AddUserToTeam(targetTeam.Id, th.BasicUser2.Id, "")
 		require.Nil(t, err)
@@ -160,7 +160,7 @@ func TestMoveChannel(t *testing.T) {
 		require.Nil(t, err)
 
 		err = th.App.MoveChannel(targetTeam, channel2, th.BasicUser)
-		require.Error(t, err, "Should have failed due to mismatched deacivated member.")
+		require.NotNil(t, err, "Should have failed due to mismatched deacivated member.")
 
 		// Test moving a channel with no members.
 		channel3 := &model.Channel{
@@ -265,10 +265,10 @@ func TestJoinDefaultChannelsCreatesChannelMemberHistoryRecordTownSquare(t *testi
 
 	// figure out the initial number of users in town square
 	channel, err := th.App.Srv().Store.Channel().GetByName(th.BasicTeam.Id, "town-square", true)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	townSquareChannelId := channel.Id
 	users, nErr := th.App.Srv().Store.ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, townSquareChannelId)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	initialNumTownSquareUsers := len(users)
 
 	// create a new user that joins the default channels
@@ -277,7 +277,7 @@ func TestJoinDefaultChannelsCreatesChannelMemberHistoryRecordTownSquare(t *testi
 
 	// there should be a ChannelMemberHistory record for the user
 	histories, nErr := th.App.Srv().Store.ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, townSquareChannelId)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, histories, initialNumTownSquareUsers+1)
 
 	found := false
@@ -296,10 +296,10 @@ func TestJoinDefaultChannelsCreatesChannelMemberHistoryRecordOffTopic(t *testing
 
 	// figure out the initial number of users in off-topic
 	channel, err := th.App.Srv().Store.Channel().GetByName(th.BasicTeam.Id, "off-topic", true)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	offTopicChannelId := channel.Id
 	users, nErr := th.App.Srv().Store.ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, offTopicChannelId)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	initialNumTownSquareUsers := len(users)
 
 	// create a new user that joins the default channels
@@ -308,7 +308,7 @@ func TestJoinDefaultChannelsCreatesChannelMemberHistoryRecordOffTopic(t *testing
 
 	// there should be a ChannelMemberHistory record for the user
 	histories, nErr := th.App.Srv().Store.ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, offTopicChannelId)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, histories, initialNumTownSquareUsers+1)
 
 	found := false
@@ -353,7 +353,7 @@ func TestCreateChannelPublicCreatesChannelMemberHistoryRecord(t *testing.T) {
 
 	// there should be a ChannelMemberHistory record for the user
 	histories, err := th.App.Srv().Store.ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, publicChannel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, histories, 1)
 	assert.Equal(t, th.BasicUser.Id, histories[0].UserId)
 	assert.Equal(t, publicChannel.Id, histories[0].ChannelId)
@@ -368,7 +368,7 @@ func TestCreateChannelPrivateCreatesChannelMemberHistoryRecord(t *testing.T) {
 
 	// there should be a ChannelMemberHistory record for the user
 	histories, err := th.App.Srv().Store.ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, privateChannel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, histories, 1)
 	assert.Equal(t, th.BasicUser.Id, histories[0].UserId)
 	assert.Equal(t, privateChannel.Id, histories[0].ChannelId)
@@ -412,7 +412,7 @@ func TestCreateGroupChannelCreatesChannelMemberHistoryRecord(t *testing.T) {
 
 	require.Nil(t, err, "Failed to create group channel.")
 	histories, nErr := th.App.Srv().Store.ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, channel.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, histories, 3)
 
 	channelMemberHistoryUserIds := make([]string, 0)
@@ -437,7 +437,7 @@ func TestCreateDirectChannelCreatesChannelMemberHistoryRecord(t *testing.T) {
 	require.Nil(t, err, "Failed to create direct channel.")
 
 	histories, nErr := th.App.Srv().Store.ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, channel.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, histories, 2)
 
 	historyId0 := histories[0].UserId
@@ -465,7 +465,7 @@ func TestGetDirectChannelCreatesChannelMemberHistoryRecord(t *testing.T) {
 
 	// there should be a ChannelMemberHistory record for both users
 	histories, nErr := th.App.Srv().Store.ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, channel.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, histories, 2)
 
 	historyId0 := histories[0].UserId
@@ -500,7 +500,7 @@ func TestAddUserToChannelCreatesChannelMemberHistoryRecord(t *testing.T) {
 
 	// there should be a ChannelMemberHistory record for the user
 	histories, nErr := th.App.Srv().Store.ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, channel.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, histories, 2)
 	channelMemberHistoryUserIds := make([]string, 0)
 	for _, history := range histories {
@@ -588,7 +588,7 @@ func TestAddChannelMemberNoUserRequestor(t *testing.T) {
 
 	// there should be a ChannelMemberHistory record for the user
 	histories, nErr := th.App.Srv().Store.ChannelMemberHistory().GetUsersInChannelDuring(model.GetMillis()-100, model.GetMillis()+100, channel.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, histories, 2)
 	channelMemberHistoryUserIds := make([]string, 0)
 	for _, history := range histories {
@@ -598,7 +598,7 @@ func TestAddChannelMemberNoUserRequestor(t *testing.T) {
 	assert.Equal(t, groupUserIds, channelMemberHistoryUserIds)
 
 	postList, nErr := th.App.Srv().Store.Post().GetPosts(model.GetPostsOptions{ChannelId: channel.Id, Page: 0, PerPage: 1}, false)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	if assert.Len(t, postList.Order, 1) {
 		post := postList.Posts[postList.Order[0]]

app/config_test.go

@@ -151,7 +151,7 @@ func TestEnsureInstallationDate(t *testing.T) {
 				assert.NoError(t, err)
 
 				data, err := th.App.Srv().Store.System().GetByName(model.SYSTEM_INSTALLATION_DATE_KEY)
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 				value, _ := strconv.ParseInt(data.Value, 10, 64)
 				assert.True(t, *tc.ExpectedInstallationDate <= value && *tc.ExpectedInstallationDate+1000 >= value)
 			}

app/email_batching_test.go

@@ -90,10 +90,10 @@ func TestCheckPendingNotifications(t *testing.T) {
 	}
 
 	channelMember, err := th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	channelMember.LastViewedAt = 9999999
 	_, err = th.App.Srv().Store.Channel().UpdateMember(channelMember)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	nErr := th.App.Srv().Store.Preference().Save(&model.Preferences{{
 		UserId:   th.BasicUser.Id,
@@ -101,7 +101,7 @@ func TestCheckPendingNotifications(t *testing.T) {
 		Name:     model.PREFERENCE_NAME_EMAIL_INTERVAL,
 		Value:    "60",
 	}})
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// test that notifications aren't sent before interval
 	job.checkPendingNotifications(time.Unix(10001, 0), func(string, []*batchedNotification) {})
@@ -111,10 +111,10 @@ func TestCheckPendingNotifications(t *testing.T) {
 
 	// test that notifications are cleared if the user has acted
 	channelMember, err = th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	channelMember.LastViewedAt = 10001000
 	_, err = th.App.Srv().Store.Channel().UpdateMember(channelMember)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// We reset the interval to something shorter
 	nErr = th.App.Srv().Store.Preference().Save(&model.Preferences{{
@@ -123,7 +123,7 @@ func TestCheckPendingNotifications(t *testing.T) {
 		Name:     model.PREFERENCE_NAME_EMAIL_INTERVAL,
 		Value:    "10",
 	}})
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	var wasCalled int32
 	job.checkPendingNotifications(time.Unix(10050, 0), func(string, []*batchedNotification) {
@@ -209,10 +209,10 @@ func TestCheckPendingNotificationsDefaultInterval(t *testing.T) {
 
 	// bypasses recent user activity check
 	channelMember, err := th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	channelMember.LastViewedAt = 9999000
 	_, err = th.App.Srv().Store.Channel().UpdateMember(channelMember)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	job.pendingNotifications[th.BasicUser.Id] = []*batchedNotification{
 		{
@@ -247,10 +247,10 @@ func TestCheckPendingNotificationsCantParseInterval(t *testing.T) {
 
 	// bypasses recent user activity check
 	channelMember, err := th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	channelMember.LastViewedAt = 9999000
 	_, err = th.App.Srv().Store.Channel().UpdateMember(channelMember)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// preference value is not an integer, so we'll fall back to the default 15min value
 	nErr := th.App.Srv().Store.Preference().Save(&model.Preferences{{
@@ -259,7 +259,7 @@ func TestCheckPendingNotificationsCantParseInterval(t *testing.T) {
 		Name:     model.PREFERENCE_NAME_EMAIL_INTERVAL,
 		Value:    "notAnIntegerValue",
 	}})
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	job.pendingNotifications[th.BasicUser.Id] = []*batchedNotification{
 		{

app/export_test.go

@@ -94,11 +94,11 @@ func TestExportUserChannels(t *testing.T) {
 	var preferences model.Preferences
 	preferences = append(preferences, preference)
 	err := th.App.Srv().Store.Preference().Save(&preferences)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	th.App.UpdateChannelMemberNotifyProps(notifyProps, channel.Id, user.Id)
-	exportData, err := th.App.buildUserChannelMemberships(user.Id, team.Id)
-	require.Nil(t, err)
+	exportData, appErr := th.App.buildUserChannelMemberships(user.Id, team.Id)
+	require.Nil(t, appErr)
 	assert.Equal(t, len(*exportData), 3)
 	for _, data := range *exportData {
 		if *data.Name == channelName {
@@ -142,7 +142,7 @@ func TestCopyEmojiImages(t *testing.T) {
 	defer os.RemoveAll(filePath)
 
 	copyError := th.App.copyEmojiImages(emoji.Id, emojiImagePath, pathToDir)
-	require.Nil(t, copyError)
+	require.NoError(t, copyError)
 
 	_, err = os.Stat(pathToDir + "/" + emoji.Id + "/image")
 	require.False(t, os.IsNotExist(err), "File should exist ")
@@ -155,17 +155,17 @@ func TestExportCustomEmoji(t *testing.T) {
 	filePath := "../demo.json"
 
 	fileWriter, err := os.Create(filePath)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer os.Remove(filePath)
 
 	dirNameToExportEmoji := "exported_emoji_test"
 	defer os.RemoveAll("../" + dirNameToExportEmoji)
 
 	outPath, err := filepath.Abs(filePath)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
-	_, err = th.App.exportCustomEmoji(fileWriter, outPath, dirNameToExportEmoji, false)
-	require.Nil(t, err, "should not have failed")
+	_, appErr := th.App.exportCustomEmoji(fileWriter, outPath, dirNameToExportEmoji, false)
+	require.Nil(t, appErr, "should not have failed")
 }
 
 func TestExportAllUsers(t *testing.T) {
@@ -228,7 +228,7 @@ func TestExportDMChannel(t *testing.T) {
 	require.Nil(t, err)
 
 	channels, nErr := th1.App.Srv().Store.Channel().GetAllDirectChannelsForExportAfter(1000, "00000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, 1, len(channels))
 
 	th1.TearDown()
@@ -237,7 +237,7 @@ func TestExportDMChannel(t *testing.T) {
 	defer th2.TearDown()
 
 	channels, nErr = th2.App.Srv().Store.Channel().GetAllDirectChannelsForExportAfter(1000, "00000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, 0, len(channels))
 
 	// import the exported channel
@@ -247,7 +247,7 @@ func TestExportDMChannel(t *testing.T) {
 
 	// Ensure the Members of the imported DM channel is the same was from the exported
 	channels, nErr = th2.App.Srv().Store.Channel().GetAllDirectChannelsForExportAfter(1000, "00000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, 1, len(channels))
 	assert.ElementsMatch(t, []string{th1.BasicUser.Username, th1.BasicUser2.Username}, *channels[0].Members)
 }
@@ -264,14 +264,14 @@ func TestExportDMChannelToSelf(t *testing.T) {
 	require.Nil(t, err)
 
 	channels, nErr := th1.App.Srv().Store.Channel().GetAllDirectChannelsForExportAfter(1000, "00000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, 1, len(channels))
 
 	th2 := Setup(t)
 	defer th2.TearDown()
 
 	channels, nErr = th2.App.Srv().Store.Channel().GetAllDirectChannelsForExportAfter(1000, "00000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, 0, len(channels))
 
 	// import the exported channel
@@ -280,7 +280,7 @@ func TestExportDMChannelToSelf(t *testing.T) {
 	assert.Equal(t, 0, i)
 
 	channels, nErr = th2.App.Srv().Store.Channel().GetAllDirectChannelsForExportAfter(1000, "00000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, 1, len(channels))
 	assert.Equal(t, 1, len((*channels[0].Members)))
 	assert.Equal(t, th1.BasicUser.Username, (*channels[0].Members)[0])
@@ -302,7 +302,7 @@ func TestExportGMChannel(t *testing.T) {
 	require.Nil(t, err)
 
 	channels, nErr := th1.App.Srv().Store.Channel().GetAllDirectChannelsForExportAfter(1000, "00000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, 1, len(channels))
 
 	th1.TearDown()
@@ -311,7 +311,7 @@ func TestExportGMChannel(t *testing.T) {
 	defer th2.TearDown()
 
 	channels, nErr = th2.App.Srv().Store.Channel().GetAllDirectChannelsForExportAfter(1000, "00000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, 0, len(channels))
 }
 
@@ -334,7 +334,7 @@ func TestExportGMandDMChannels(t *testing.T) {
 	require.Nil(t, err)
 
 	channels, nErr := th1.App.Srv().Store.Channel().GetAllDirectChannelsForExportAfter(1000, "00000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, 2, len(channels))
 
 	th1.TearDown()
@@ -343,7 +343,7 @@ func TestExportGMandDMChannels(t *testing.T) {
 	defer th2.TearDown()
 
 	channels, nErr = th2.App.Srv().Store.Channel().GetAllDirectChannelsForExportAfter(1000, "00000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, 0, len(channels))
 
 	// import the exported channel
@@ -353,7 +353,7 @@ func TestExportGMandDMChannels(t *testing.T) {
 
 	// Ensure the Members of the imported GM channel is the same was from the exported
 	channels, nErr = th2.App.Srv().Store.Channel().GetAllDirectChannelsForExportAfter(1000, "00000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// Adding some deteminism so its possible to assert on slice index
 	sort.Slice(channels, func(i, j int) bool { return channels[i].Type > channels[j].Type })
@@ -409,12 +409,12 @@ func TestExportDMandGMPost(t *testing.T) {
 	th1.App.CreatePost(p4, gmChannel, false, true)
 
 	posts, err := th1.App.Srv().Store.Post().GetDirectPostParentsForExportAfter(1000, "0000000")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 4, len(posts))
 
 	var b bytes.Buffer
-	err = th1.App.BulkExport(&b, "somePath", BulkExportOpts{})
-	require.Nil(t, err)
+	appErr := th1.App.BulkExport(&b, "somePath", BulkExportOpts{})
+	require.Nil(t, appErr)
 
 	th1.TearDown()
 
@@ -422,16 +422,16 @@ func TestExportDMandGMPost(t *testing.T) {
 	defer th2.TearDown()
 
 	posts, err = th2.App.Srv().Store.Post().GetDirectPostParentsForExportAfter(1000, "0000000")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, len(posts))
 
 	// import the exported posts
-	err, i := th2.App.BulkImport(&b, false, 5)
-	assert.Nil(t, err)
+	appErr, i := th2.App.BulkImport(&b, false, 5)
+	assert.Nil(t, appErr)
 	assert.Equal(t, 0, i)
 
 	posts, err = th2.App.Srv().Store.Post().GetDirectPostParentsForExportAfter(1000, "0000000")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// Adding some deteminism so its possible to assert on slice index
 	sort.Slice(posts, func(i, j int) bool { return posts[i].Message > posts[j].Message })
@@ -482,14 +482,14 @@ func TestExportPostWithProps(t *testing.T) {
 	th1.App.CreatePost(p2, gmChannel, false, true)
 
 	posts, err := th1.App.Srv().Store.Post().GetDirectPostParentsForExportAfter(1000, "0000000")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, posts, 2)
 	require.NotEmpty(t, posts[0].Props)
 	require.NotEmpty(t, posts[1].Props)
 
 	var b bytes.Buffer
-	err = th1.App.BulkExport(&b, "somePath", BulkExportOpts{})
-	require.Nil(t, err)
+	appErr := th1.App.BulkExport(&b, "somePath", BulkExportOpts{})
+	require.Nil(t, appErr)
 
 	th1.TearDown()
 
@@ -497,16 +497,16 @@ func TestExportPostWithProps(t *testing.T) {
 	defer th2.TearDown()
 
 	posts, err = th2.App.Srv().Store.Post().GetDirectPostParentsForExportAfter(1000, "0000000")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, posts, 0)
 
 	// import the exported posts
-	err, i := th2.App.BulkImport(&b, false, 5)
-	assert.Nil(t, err)
+	appErr, i := th2.App.BulkImport(&b, false, 5)
+	assert.Nil(t, appErr)
 	assert.Equal(t, 0, i)
 
 	posts, err = th2.App.Srv().Store.Post().GetDirectPostParentsForExportAfter(1000, "0000000")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// Adding some determinism so its possible to assert on slice index
 	sort.Slice(posts, func(i, j int) bool { return posts[i].Message > posts[j].Message })
@@ -530,7 +530,7 @@ func TestExportDMPostWithSelf(t *testing.T) {
 	require.Nil(t, err)
 
 	posts, nErr := th1.App.Srv().Store.Post().GetDirectPostParentsForExportAfter(1000, "0000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, 1, len(posts))
 
 	th1.TearDown()
@@ -539,7 +539,7 @@ func TestExportDMPostWithSelf(t *testing.T) {
 	defer th2.TearDown()
 
 	posts, nErr = th2.App.Srv().Store.Post().GetDirectPostParentsForExportAfter(1000, "0000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, 0, len(posts))
 
 	// import the exported posts
@@ -548,7 +548,7 @@ func TestExportDMPostWithSelf(t *testing.T) {
 	assert.Equal(t, 0, i)
 
 	posts, nErr = th2.App.Srv().Store.Post().GetDirectPostParentsForExportAfter(1000, "0000000")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, 1, len(posts))
 	assert.Equal(t, 1, len((*posts[0].ChannelMembers)))
 	assert.Equal(t, th1.BasicUser.Username, (*posts[0].ChannelMembers)[0])
@@ -559,23 +559,23 @@ func TestBulkExport(t *testing.T) {
 	testsDir, _ := fileutils.FindDir("tests")
 
 	dir, err := ioutil.TempDir("", "import_test")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer os.RemoveAll(dir)
 
 	extractImportFile := func(filePath string) *os.File {
 		importFile, err2 := os.Open(filePath)
-		require.Nil(t, err2)
+		require.NoError(t, err2)
 		defer importFile.Close()
 
 		info, err2 := importFile.Stat()
-		require.Nil(t, err2)
+		require.NoError(t, err2)
 
 		paths, err2 := utils.UnzipToPath(importFile, info.Size(), dir)
-		require.Nil(t, err2)
+		require.NoError(t, err2)
 		require.NotEmpty(t, paths)
 
 		jsonFile, err2 := os.Open(filepath.Join(dir, "import.jsonl"))
-		require.Nil(t, err2)
+		require.NoError(t, err2)
 
 		return jsonFile
 	}
@@ -583,19 +583,19 @@ func TestBulkExport(t *testing.T) {
 	jsonFile := extractImportFile(filepath.Join(testsDir, "import_test.zip"))
 	defer jsonFile.Close()
 
-	err, _ = th.App.BulkImportWithPath(jsonFile, false, 1, dir)
-	require.Nil(t, err)
+	appErr, _ := th.App.BulkImportWithPath(jsonFile, false, 1, dir)
+	require.Nil(t, appErr)
 
 	exportFile, err := os.Create(filepath.Join(dir, "export.zip"))
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer exportFile.Close()
 
 	opts := BulkExportOpts{
 		IncludeAttachments: true,
 		CreateArchive:      true,
 	}
-	err = th.App.BulkExport(exportFile, dir, opts)
-	require.Nil(t, err)
+	appErr = th.App.BulkExport(exportFile, dir, opts)
+	require.Nil(t, appErr)
 
 	th.TearDown()
 	th = Setup(t)
@@ -604,6 +604,6 @@ func TestBulkExport(t *testing.T) {
 	jsonFile = extractImportFile(filepath.Join(dir, "export.zip"))
 	defer jsonFile.Close()
 
-	err, _ = th.App.BulkImportWithPath(jsonFile, false, 1, filepath.Join(dir, "data"))
-	require.Nil(t, err)
+	appErr, _ = th.App.BulkImportWithPath(jsonFile, false, 1, filepath.Join(dir, "data"))
+	require.Nil(t, appErr)
 }

app/file_test.go

@@ -99,7 +99,7 @@ func TestUploadFile(t *testing.T) {
 	data := []byte("abcd")
 
 	info1, err := th.App.UploadFile(data, "wrong", filename)
-	require.Error(t, err, "Wrong Channel ID.")
+	require.NotNil(t, err, "Wrong Channel ID.")
 	require.Nil(t, info1, "Channel ID does not exist.")
 
 	info1, err = th.App.UploadFile(data, "", filename)
@@ -253,7 +253,7 @@ func TestMigrateFilenamesToFileInfos(t *testing.T) {
 
 	path, _ := fileutils.FindDir("tests")
 	file, fileErr := os.Open(filepath.Join(path, "test.png"))
-	require.Nil(t, fileErr)
+	require.NoError(t, fileErr)
 	defer file.Close()
 
 	fileId := model.NewId()
@@ -281,13 +281,13 @@ func TestCreateZipFileAndAddFiles(t *testing.T) {
 	mockBackend.On("WriteFile", mock.Anything, "directory-to-heaven/zip-file-name-to-heaven.zip").Return(int64(666), errors.New("Only those who dare to fail greatly can ever achieve greatly"))
 
 	err := th.App.CreateZipFileAndAddFiles(&mockBackend, []model.FileData{}, "zip-file-name-to-heaven.zip", "directory-to-heaven")
-	require.NotNil(t, err)
+	require.Error(t, err)
 	require.Equal(t, err.Error(), "Only those who dare to fail greatly can ever achieve greatly")
 
 	mockBackend = mocks.FileBackend{}
 	mockBackend.On("WriteFile", mock.Anything, "directory-to-heaven/zip-file-name-to-heaven.zip").Return(int64(666), nil)
 	err = th.App.CreateZipFileAndAddFiles(&mockBackend, []model.FileData{}, "zip-file-name-to-heaven.zip", "directory-to-heaven")
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func TestCopyFileInfos(t *testing.T) {

app/helper_test.go

@@ -566,13 +566,13 @@ func (*TestHelper) ResetEmojisMigration() {
 
 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.NoError(t, err, "Failed to get team count.")
 	require.Equalf(t, teamCount, expected, "Unexpected number of teams. Expected: %v, found: %v", expected, teamCount)
 }
 
 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.NoError(t, err, "Failed to get channel count.")
 	require.Equalf(t, count, expected, "Unexpected number of channels. Expected: %v, found: %v", expected, count)
 }
 

app/import_test.go

@@ -38,7 +38,7 @@ func ptrBool(b bool) *bool {
 
 func checkPreference(t *testing.T, a *App, userID string, category string, name string, value string) {
 	preferences, err := a.Srv().Store.Preference().GetCategory(userID, category)
-	require.Nilf(t, err, "Failed to get preferences for user %v with category %v", userID, category)
+	require.NoErrorf(t, err, "Failed to get preferences for user %v with category %v", userID, category)
 	found := false
 	for _, preference := range preferences {
 		if preference.Name == name {
@@ -66,14 +66,14 @@ func checkNoError(t *testing.T, err *model.AppError) {
 
 func AssertAllPostsCount(t *testing.T, a *App, initialCount int64, change int64, teamName string) {
 	result, err := a.Srv().Store.Post().AnalyticsPostCount(teamName, false, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, initialCount+change, result, "Did not find the expected number of posts.")
 }
 
 func AssertChannelCount(t *testing.T, a *App, channelType string, expectedCount int64) {
 	count, err := a.Srv().Store.Channel().AnalyticsTypeCount("", channelType)
 	require.Equalf(t, expectedCount, count, "Channel count of type: %v. Expected: %v, Got: %v", channelType, expectedCount, count)
-	require.Nil(t, err, "Failed to get channel count.")
+	require.NoError(t, err, "Failed to get channel count.")
 }
 
 func TestImportImportLine(t *testing.T) {
@@ -251,7 +251,7 @@ func TestImportProcessImportDataFileVersionLine(t *testing.T) {
 
 func GetAttachments(userID string, th *TestHelper, t *testing.T) []*model.FileInfo {
 	fileInfos, err := th.App.Srv().Store.FileInfo().GetForUser(userID)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	return fileInfos
 }
 
@@ -260,7 +260,7 @@ func AssertFileIdsInPost(files []*model.FileInfo, th *TestHelper, t *testing.T)
 	require.NotNil(t, postId)
 
 	posts, err := th.App.Srv().Store.Post().GetPostsByIds([]string{postId})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	require.Len(t, posts, 1)
 	for _, file := range files {
@@ -364,21 +364,21 @@ func BenchmarkBulkImport(b *testing.B) {
 	testsDir, _ := fileutils.FindDir("tests")
 
 	importFile, err := os.Open(testsDir + "/import_test.zip")
-	require.Nil(b, err)
+	require.NoError(b, err)
 	defer importFile.Close()
 
 	info, err := importFile.Stat()
-	require.Nil(b, err)
+	require.NoError(b, err)
 
 	dir, err := ioutil.TempDir("", "testimport")
-	require.Nil(b, err)
+	require.NoError(b, err)
 	defer os.RemoveAll(dir)
 
 	_, err = utils.UnzipToPath(importFile, info.Size(), dir)
-	require.Nil(b, err)
+	require.NoError(b, err)
 
 	jsonFile, err := os.Open(dir + "/import.jsonl")
-	require.Nil(b, err)
+	require.NoError(b, err)
 	defer jsonFile.Close()
 
 	b.ResetTimer()

app/integration_action_test.go

@@ -420,7 +420,7 @@ func TestPostActionProps(t *testing.T) {
 	assert.True(t, len(clientTriggerId) == 26)
 
 	newPost, nErr := th.App.Srv().Store.Post().GetSingle(post.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	assert.True(t, newPost.IsPinned)
 	assert.False(t, newPost.HasReactions)
@@ -453,7 +453,7 @@ func TestSubmitInteractiveDialog(t *testing.T) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		var request model.SubmitDialogRequest
 		err := json.NewDecoder(r.Body).Decode(&request)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, request)
 
 		assert.Equal(t, request.URL, "")
@@ -509,7 +509,7 @@ func TestSubmitInteractiveDialog(t *testing.T) {
 		`, `{"id": "myplugin", "backend": {"executable": "backend.exe"}}`, "myplugin", th.App)
 
 	hooks, err2 := th.App.GetPluginsEnvironment().HooksForPlugin("myplugin")
-	require.Nil(t, err2)
+	require.NoError(t, err2)
 	require.NotNil(t, hooks)
 
 	submit.URL = ts.URL
@@ -791,7 +791,7 @@ func TestPostActionRelativePluginURL(t *testing.T) {
 		`, `{"id": "myplugin", "backend": {"executable": "backend.exe"}}`, "myplugin", th.App)
 
 	hooks, err2 := th.App.GetPluginsEnvironment().HooksForPlugin("myplugin")
-	require.Nil(t, err2)
+	require.NoError(t, err2)
 	require.NotNil(t, hooks)
 
 	t.Run("invalid relative URL", func(t *testing.T) {
@@ -1010,7 +1010,7 @@ func TestDoPluginRequest(t *testing.T) {
 		`, `{"id": "myplugin", "backend": {"executable": "backend.exe"}}`, "myplugin", th.App)
 
 	hooks, err2 := th.App.GetPluginsEnvironment().HooksForPlugin("myplugin")
-	require.Nil(t, err2)
+	require.NoError(t, err2)
 	require.NotNil(t, hooks)
 
 	resp, err := th.App.doPluginRequest("GET", "/plugins/myplugin", nil, nil)

app/job_test.go

@@ -20,12 +20,12 @@ func TestGetJob(t *testing.T) {
 		Status: model.NewId(),
 	}
 	_, err := th.App.Srv().Store.Job().Save(status)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	defer th.App.Srv().Store.Job().Delete(status.Id)
 
-	received, err := th.App.GetJob(status.Id)
-	require.Nil(t, err)
+	received, appErr := th.App.GetJob(status.Id)
+	require.Nil(t, appErr)
 	require.Equal(t, status, received, "incorrect job status received")
 }
 
@@ -55,7 +55,7 @@ func TestGetJobByType(t *testing.T) {
 
 	for _, status := range statuses {
 		_, err := th.App.Srv().Store.Job().Save(status)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer th.App.Srv().Store.Job().Delete(status.Id)
 	}
 

app/login_test.go

@@ -56,17 +56,17 @@ func TestCWSLogin(t *testing.T) {
 		require.NotNil(t, user)
 		require.Equal(t, th.BasicUser.Username, user.Username)
 		_, apperr := th.App.Srv().Store.Token().GetByToken(token.Token)
-		require.Nil(t, apperr)
+		require.NoError(t, apperr)
 		th.App.DeleteToken(token)
 	})
 
 	t.Run("Should not authenticate the user when CWS token was used", func(t *testing.T) {
 		token := model.NewToken(TokenTypeCWSAccess, "")
 		os.Setenv("CWS_CLOUD_TOKEN", token.Token)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		defer th.App.DeleteToken(token)
 		user, err := th.App.AuthenticateUserForLogin("", th.BasicUser.Username, "", "", token.Token, false)
-		require.Error(t, err)
+		require.NotNil(t, err)
 		require.Nil(t, user)
 	})
 }

app/notification_push_test.go

@@ -1244,7 +1244,7 @@ func TestSendAckToPushProxy(t *testing.T) {
 		NotificationType: model.PUSH_TYPE_MESSAGE,
 	}
 	err := th.App.SendAckToPushProxy(ack)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	// Server side verification.
 	// We verify that 1 request has been sent, and also check the message contents.
 	require.Equal(t, 1, handler.numReqs())

app/notification_test.go

@@ -80,7 +80,7 @@ func TestSendNotifications(t *testing.T) {
 				Props:     model.StringInterface{"from_webhook": "true", "override_username": "a bot"},
 			}
 
-			rootPost, appErr := th.App.CreatePostMissingChannel(rootPost, false)
+			rootPost, appErr = th.App.CreatePostMissingChannel(rootPost, false)
 			require.Nil(t, appErr)
 
 			childPost := &model.Post{
@@ -97,20 +97,20 @@ func TestSendNotifications(t *testing.T) {
 				Posts: map[string]*model.Post{rootPost.Id: rootPost, childPost.Id: childPost},
 			}
 			mentions, err = th.App.SendNotifications(childPost, th.BasicTeam, th.BasicChannel, th.BasicUser2, &postList, true)
-			require.Nil(t, err)
+			require.NoError(t, err)
 			require.False(t, utils.StringInSlice(user.Id, mentions))
 		}
 
 		th.BasicUser.NotifyProps[model.COMMENTS_NOTIFY_PROP] = model.COMMENTS_NOTIFY_ANY
-		th.BasicUser, err = th.App.UpdateUser(th.BasicUser, false)
-		require.Nil(t, err)
+		th.BasicUser, appErr = th.App.UpdateUser(th.BasicUser, false)
+		require.Nil(t, appErr)
 		t.Run("user wants notifications on all comments", func(t *testing.T) {
 			testUserNotNotified(t, th.BasicUser)
 		})
 
 		th.BasicUser.NotifyProps[model.COMMENTS_NOTIFY_PROP] = model.COMMENTS_NOTIFY_ROOT
-		th.BasicUser, err = th.App.UpdateUser(th.BasicUser, false)
-		require.Nil(t, err)
+		th.BasicUser, appErr = th.App.UpdateUser(th.BasicUser, false)
+		require.Nil(t, appErr)
 		t.Run("user wants notifications on root comment", func(t *testing.T) {
 			testUserNotNotified(t, th.BasicUser)
 		})
@@ -143,7 +143,7 @@ func TestSendNotificationsWithManyUsers(t *testing.T) {
 		for i, user := range users {
 			t.Run(fmt.Sprintf("user-%d", i+1), func(t *testing.T) {
 				channelUnread, appErr2 := th.Server.Store.Channel().GetChannelUnread(th.BasicChannel.Id, user.Id)
-				require.Nil(t, appErr2)
+				require.NoError(t, appErr2)
 				assert.Equal(t, int64(1), channelUnread.MentionCount)
 			})
 		}
@@ -163,7 +163,7 @@ func TestSendNotificationsWithManyUsers(t *testing.T) {
 		for i, user := range users {
 			t.Run(fmt.Sprintf("user-%d", i+1), func(t *testing.T) {
 				channelUnread, appErr2 := th.Server.Store.Channel().GetChannelUnread(th.BasicChannel.Id, user.Id)
-				require.Nil(t, appErr2)
+				require.NoError(t, appErr2)
 				assert.Equal(t, int64(2), channelUnread.MentionCount)
 			})
 		}
@@ -185,7 +185,7 @@ func TestSendOutOfChannelMentions(t *testing.T) {
 
 		sent, err := th.App.sendOutOfChannelMentions(user1, post, channel, potentialMentions)
 
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		assert.True(t, sent)
 	})
 
@@ -195,7 +195,7 @@ func TestSendOutOfChannelMentions(t *testing.T) {
 
 		sent, err := th.App.sendOutOfChannelMentions(user1, post, channel, potentialMentions)
 
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		assert.False(t, sent)
 	})
 }
@@ -226,7 +226,7 @@ func TestFilterOutOfChannelMentions(t *testing.T) {
 
 		outOfChannelUsers, outOfGroupUsers, err := th.App.filterOutOfChannelMentions(user1, post, channel, potentialMentions)
 
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		assert.Len(t, outOfChannelUsers, 2)
 		assert.True(t, (outOfChannelUsers[0].Id == user2.Id || outOfChannelUsers[1].Id == user2.Id))
 		assert.True(t, (outOfChannelUsers[0].Id == user3.Id || outOfChannelUsers[1].Id == user3.Id))
@@ -239,7 +239,7 @@ func TestFilterOutOfChannelMentions(t *testing.T) {
 
 		outOfChannelUsers, outOfGroupUsers, err := th.App.filterOutOfChannelMentions(guest, post, channel, potentialMentions)
 
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Len(t, outOfChannelUsers, 1)
 		assert.Equal(t, user4.Id, outOfChannelUsers[0].Id)
 		assert.Nil(t, outOfGroupUsers)
@@ -253,7 +253,7 @@ func TestFilterOutOfChannelMentions(t *testing.T) {
 
 		outOfChannelUsers, outOfGroupUsers, err := th.App.filterOutOfChannelMentions(user1, post, channel, potentialMentions)
 
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		assert.Nil(t, outOfChannelUsers)
 		assert.Nil(t, outOfGroupUsers)
 	})
@@ -267,7 +267,7 @@ func TestFilterOutOfChannelMentions(t *testing.T) {
 
 		outOfChannelUsers, outOfGroupUsers, err := th.App.filterOutOfChannelMentions(user1, post, directChannel, potentialMentions)
 
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		assert.Nil(t, outOfChannelUsers)
 		assert.Nil(t, outOfGroupUsers)
 	})
@@ -281,7 +281,7 @@ func TestFilterOutOfChannelMentions(t *testing.T) {
 
 		outOfChannelUsers, outOfGroupUsers, err := th.App.filterOutOfChannelMentions(user1, post, groupChannel, potentialMentions)
 
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		assert.Nil(t, outOfChannelUsers)
 		assert.Nil(t, outOfGroupUsers)
 	})
@@ -296,7 +296,7 @@ func TestFilterOutOfChannelMentions(t *testing.T) {
 
 		outOfChannelUsers, outOfGroupUsers, err := th.App.filterOutOfChannelMentions(user1, post, channel, potentialMentions)
 
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		assert.Nil(t, outOfChannelUsers)
 		assert.Nil(t, outOfGroupUsers)
 	})
@@ -310,7 +310,7 @@ func TestFilterOutOfChannelMentions(t *testing.T) {
 
 		outOfChannelUsers, outOfGroupUsers, err := th.App.filterOutOfChannelMentions(user1, post, channel, potentialMentions)
 
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		assert.Nil(t, outOfChannelUsers)
 		assert.Nil(t, outOfGroupUsers)
 	})
@@ -321,7 +321,7 @@ func TestFilterOutOfChannelMentions(t *testing.T) {
 
 		outOfChannelUsers, outOfGroupUsers, err := th.App.filterOutOfChannelMentions(user1, post, channel, potentialMentions)
 
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		assert.Nil(t, outOfChannelUsers)
 		assert.Nil(t, outOfGroupUsers)
 	})
@@ -355,7 +355,7 @@ func TestFilterOutOfChannelMentions(t *testing.T) {
 
 		outOfChannelUsers, outOfGroupUsers, err := th.App.filterOutOfChannelMentions(user1, post, constrainedChannel, potentialMentions)
 
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		assert.Len(t, outOfChannelUsers, 1)
 		assert.Equal(t, nonChannelMember.Id, outOfChannelUsers[0].Id)
 		assert.Len(t, outOfGroupUsers, 1)
@@ -2519,7 +2519,7 @@ func TestGetGroupsAllowedForReferenceInChannel(t *testing.T) {
 
 	t.Run("should return empty map when no groups with allow reference", func(t *testing.T) {
 		groupsMap, nErr := th.App.getGroupsAllowedForReferenceInChannel(channel, team)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 		require.Len(t, groupsMap, 0)
 	})
 
@@ -2530,7 +2530,7 @@ func TestGetGroupsAllowedForReferenceInChannel(t *testing.T) {
 	group2 := th.CreateGroup()
 	t.Run("should only return groups with allow reference", func(t *testing.T) {
 		groupsMap, nErr := th.App.getGroupsAllowedForReferenceInChannel(channel, team)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 		require.Len(t, groupsMap, 1)
 		require.Nil(t, groupsMap[*group2.Name])
 		require.Equal(t, groupsMap[*group1.Name], group1)
@@ -2554,7 +2554,7 @@ func TestGetGroupsAllowedForReferenceInChannel(t *testing.T) {
 
 	t.Run("should return only groups synced to channel if channel is group constrained", func(t *testing.T) {
 		groupsMap, nErr := th.App.getGroupsAllowedForReferenceInChannel(constrainedChannel, team)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 		require.Len(t, groupsMap, 1)
 		require.Nil(t, groupsMap[*group2.Name])
 		require.Equal(t, groupsMap[*group1.Name], group1)
@@ -2579,7 +2579,7 @@ func TestGetGroupsAllowedForReferenceInChannel(t *testing.T) {
 
 	t.Run("should return union of groups synced to team and any channels if team is group constrained", func(t *testing.T) {
 		groupsMap, nErr := th.App.getGroupsAllowedForReferenceInChannel(channel, team)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 		require.Len(t, groupsMap, 2)
 		require.Nil(t, groupsMap[*group3.Name])
 		require.Equal(t, groupsMap[*group2.Name], group2)
@@ -2588,7 +2588,7 @@ func TestGetGroupsAllowedForReferenceInChannel(t *testing.T) {
 
 	t.Run("should return only subset of groups synced to channel for group constrained channel when team is also group constrained", func(t *testing.T) {
 		groupsMap, nErr := th.App.getGroupsAllowedForReferenceInChannel(constrainedChannel, team)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 		require.Len(t, groupsMap, 1)
 		require.Nil(t, groupsMap[*group3.Name])
 		require.Nil(t, groupsMap[*group2.Name])
@@ -2601,7 +2601,7 @@ func TestGetGroupsAllowedForReferenceInChannel(t *testing.T) {
 
 	t.Run("should return all groups when team and channel are not group constrained", func(t *testing.T) {
 		groupsMap, nErr := th.App.getGroupsAllowedForReferenceInChannel(channel, team)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 		require.Len(t, groupsMap, 3)
 		require.Equal(t, groupsMap[*group1.Name], group1)
 		require.Equal(t, groupsMap[*group2.Name], group2)

app/oauth_test.go

@@ -92,7 +92,7 @@ func TestOAuthRevokeAccessToken(t *testing.T) {
 	accessData.ExpiresAt = session.ExpiresAt
 
 	_, nErr := th.App.Srv().Store.OAuth().SaveAccessData(accessData)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	err = th.App.RevokeAccessToken(accessData.Token)
 	require.Nil(t, err)
@@ -132,7 +132,7 @@ func TestOAuthDeleteApp(t *testing.T) {
 	accessData.ExpiresAt = session.ExpiresAt
 
 	_, nErr := th.App.Srv().Store.OAuth().SaveAccessData(accessData)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	err = th.App.DeleteOAuthApp(a1.Id)
 	require.Nil(t, err)
@@ -227,7 +227,7 @@ func TestAuthorizeOAuthUser(t *testing.T) {
 		defer th.TearDown()
 
 		token := model.NewToken("invalid", "")
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 
 		state := makeState(token)
 
@@ -509,7 +509,7 @@ func TestAuthorizeOAuthUser(t *testing.T) {
 
 				require.NotNil(t, body)
 				bodyBytes, bodyErr := ioutil.ReadAll(body)
-				require.Nil(t, bodyErr)
+				require.NoError(t, bodyErr)
 				assert.Equal(t, userData, string(bodyBytes))
 
 				assert.Equal(t, stateProps["team_id"], receivedTeamId)

app/opengraph_test.go

@@ -110,7 +110,7 @@ func TestMakeOpenGraphURLsAbsolute(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			og := opengraph.NewOpenGraph()
 			err := og.ProcessHTML(strings.NewReader(tc.HTML))
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			makeOpenGraphURLsAbsolute(og, tc.RequestURL)
 

app/plugin_api_test.go

@@ -25,6 +25,7 @@ import (
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
+	goi18n "github.com/mattermost/go-i18n/i18n"
 	"github.com/mattermost/mattermost-server/v5/einterfaces/mocks"
 	"github.com/mattermost/mattermost-server/v5/model"
 	"github.com/mattermost/mattermost-server/v5/plugin"
@@ -98,7 +99,7 @@ func setupMultiPluginApiTest(t *testing.T, pluginCodes []string, pluginManifests
 
 		ioutil.WriteFile(filepath.Join(pluginDir, pluginId, "plugin.json"), []byte(pluginManifests[i]), 0600)
 		manifest, activated, reterr := env.Activate(pluginId)
-		require.Nil(t, reterr)
+		require.NoError(t, reterr)
 		require.NotNil(t, manifest)
 		require.True(t, activated)
 
@@ -772,7 +773,7 @@ func TestPluginAPIGetPlugins(t *testing.T) {
 		ioutil.WriteFile(filepath.Join(pluginDir, pluginID, "plugin.json"), []byte(fmt.Sprintf(`{"id": "%s", "server": {"executable": "backend.exe"}}`, pluginID)), 0600)
 		manifest, activated, reterr := env.Activate(pluginID)
 
-		require.Nil(t, reterr)
+		require.NoError(t, reterr)
 		require.NotNil(t, manifest)
 		require.True(t, activated)
 		pluginManifests = append(pluginManifests, manifest)
@@ -784,8 +785,8 @@ func TestPluginAPIGetPlugins(t *testing.T) {
 	require.True(t, success)
 
 	// check existing user first
-	plugins, err := api.GetPlugins()
-	assert.Nil(t, err)
+	plugins, appErr := api.GetPlugins()
+	assert.Nil(t, appErr)
 	assert.NotEmpty(t, plugins)
 	assert.Equal(t, pluginManifests, plugins)
 }
@@ -799,23 +800,23 @@ func TestPluginAPIInstallPlugin(t *testing.T) {
 	tarData, err := ioutil.ReadFile(filepath.Join(path, "testplugin.tar.gz"))
 	require.NoError(t, err)
 
-	_, err = api.InstallPlugin(bytes.NewReader(tarData), true)
-	assert.NotNil(t, err, "should not allow upload if upload disabled")
-	assert.Equal(t, err.Error(), "installPlugin: Plugins and/or plugin uploads have been disabled., ")
+	_, appErr := api.InstallPlugin(bytes.NewReader(tarData), true)
+	assert.NotNil(t, appErr, "should not allow upload if upload disabled")
+	assert.Equal(t, appErr.Error(), "installPlugin: Plugins and/or plugin uploads have been disabled., ")
 
 	th.App.UpdateConfig(func(cfg *model.Config) {
 		*cfg.PluginSettings.Enable = true
 		*cfg.PluginSettings.EnableUploads = true
 	})
 
-	manifest, err := api.InstallPlugin(bytes.NewReader(tarData), true)
+	manifest, appErr := api.InstallPlugin(bytes.NewReader(tarData), true)
 	defer os.RemoveAll("plugins/testplugin")
-	require.Nil(t, err)
+	require.Nil(t, appErr)
 	assert.Equal(t, "testplugin", manifest.Id)
 
 	// Successfully installed
-	pluginsResp, err := api.GetPlugins()
-	require.Nil(t, err)
+	pluginsResp, appErr := api.GetPlugins()
+	require.Nil(t, appErr)
 
 	found := false
 	for _, m := range pluginsResp {
@@ -854,7 +855,7 @@ func TestInstallPlugin(t *testing.T) {
 
 		ioutil.WriteFile(filepath.Join(pluginDir, pluginID, "plugin.json"), []byte(pluginManifest), 0600)
 		manifest, activated, reterr := env.Activate(pluginID)
-		require.Nil(t, reterr)
+		require.NoError(t, reterr)
 		require.NotNil(t, manifest)
 		require.True(t, activated)
 
@@ -960,23 +961,23 @@ func TestPluginAPIGetTeamIcon(t *testing.T) {
 	img.Set(2, 3, color.RGBA{255, 0, 0, 255})
 	buf := new(bytes.Buffer)
 	err := png.Encode(buf, img)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	dataBytes := buf.Bytes()
 	fileReader := bytes.NewReader(dataBytes)
 
 	// Set the Team Icon
-	err = th.App.SetTeamIconFromFile(th.BasicTeam, fileReader)
-	require.Nil(t, err)
+	appErr := th.App.SetTeamIconFromFile(th.BasicTeam, fileReader)
+	require.Nil(t, appErr)
 
 	// Get the team icon to check
-	teamIcon, err := api.GetTeamIcon(th.BasicTeam.Id)
-	require.Nil(t, err)
+	teamIcon, appErr := api.GetTeamIcon(th.BasicTeam.Id)
+	require.Nil(t, appErr)
 	require.NotEmpty(t, teamIcon)
 
 	colorful := color.NRGBA{255, 0, 0, 255}
 	byteReader := bytes.NewReader(teamIcon)
 	img2, _, err2 := image.Decode(byteReader)
-	require.Nil(t, err2)
+	require.NoError(t, err2)
 	require.Equal(t, img2.At(2, 3), colorful)
 }
 
@@ -991,22 +992,22 @@ func TestPluginAPISetTeamIcon(t *testing.T) {
 	img.Set(2, 3, color.RGBA{255, 0, 0, 255})
 	buf := new(bytes.Buffer)
 	err := png.Encode(buf, img)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	dataBytes := buf.Bytes()
 
 	// Set the user profile image
-	err = api.SetTeamIcon(th.BasicTeam.Id, dataBytes)
-	require.Nil(t, err)
+	appErr := api.SetTeamIcon(th.BasicTeam.Id, dataBytes)
+	require.Nil(t, appErr)
 
 	// Get the user profile image to check
-	teamIcon, err := api.GetTeamIcon(th.BasicTeam.Id)
-	require.Nil(t, err)
+	teamIcon, appErr := api.GetTeamIcon(th.BasicTeam.Id)
+	require.Nil(t, appErr)
 	require.NotEmpty(t, teamIcon)
 
 	colorful := color.NRGBA{255, 0, 0, 255}
 	byteReader := bytes.NewReader(teamIcon)
 	img2, _, err2 := image.Decode(byteReader)
-	require.Nil(t, err2)
+	require.NoError(t, err2)
 	require.Equal(t, img2.At(2, 3), colorful)
 }
 
@@ -1022,7 +1023,7 @@ func TestPluginAPIRemoveTeamIcon(t *testing.T) {
 	img.Set(2, 3, color.RGBA{255, 0, 0, 255})
 	buf := new(bytes.Buffer)
 	err1 := png.Encode(buf, img)
-	require.Nil(t, err1)
+	require.NoError(t, err1)
 	dataBytes := buf.Bytes()
 	fileReader := bytes.NewReader(dataBytes)
 
@@ -1656,8 +1657,8 @@ func TestPluginHTTPUpgradeWebSocket(t *testing.T) {
 	require.NotEmpty(t, pluginID)
 
 	reqURL := fmt.Sprintf("ws://localhost:%d/plugins/%s", th.Server.ListenAddr.Port, pluginID)
-	wsc, err := model.NewWebSocketClient(reqURL, "")
-	require.Nil(t, err)
+	wsc, appErr := model.NewWebSocketClient(reqURL, "")
+	require.Nil(t, appErr)
 	require.NotNil(t, wsc)
 
 	wsc.Listen()
@@ -1680,24 +1681,54 @@ func TestPluginHTTPUpgradeWebSocket(t *testing.T) {
 	}
 }
 
+type MockSlashCommandProvider struct {
+	Args    *model.CommandArgs
+	Message string
+}
+
+func (*MockSlashCommandProvider) GetTrigger() string {
+	return "mock"
+}
+func (*MockSlashCommandProvider) GetCommand(a *App, T goi18n.TranslateFunc) *model.Command {
+	return &model.Command{
+		Trigger:          "mock",
+		AutoComplete:     true,
+		AutoCompleteDesc: "mock",
+		AutoCompleteHint: "mock",
+		DisplayName:      "mock",
+	}
+}
+func (mscp *MockSlashCommandProvider) DoCommand(a *App, args *model.CommandArgs, message string) *model.CommandResponse {
+	mscp.Args = args
+	mscp.Message = message
+	return &model.CommandResponse{
+		Text:         "mock",
+		ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL,
+	}
+}
+
 func TestPluginExecuteSlashCommand(t *testing.T) {
 	th := Setup(t).InitBasic()
 	defer th.TearDown()
 	api := th.SetupPluginAPI()
 
+	slashCommandMock := &MockSlashCommandProvider{}
+	RegisterCommandProvider(slashCommandMock)
+
 	newUser := th.CreateUser()
 	th.LinkUserToTeam(newUser, th.BasicTeam)
 
 	t.Run("run invite command", func(t *testing.T) {
-		_, err := api.ExecuteSlashCommand(&model.CommandArgs{
-			Command:   "/invite @" + newUser.Username,
+		args := &model.CommandArgs{
+			Command:   "/mock @" + newUser.Username,
 			TeamId:    th.BasicTeam.Id,
 			UserId:    th.BasicUser.Id,
 			ChannelId: th.BasicChannel.Id,
-		})
+		}
+		_, err := api.ExecuteSlashCommand(args)
 		require.NoError(t, err)
-		_, err2 := th.App.GetChannelMember(th.BasicChannel.Id, newUser.Id)
-		require.Nil(t, err2)
+		require.Equal(t, args, slashCommandMock.Args)
+		require.Equal(t, "@"+newUser.Username, slashCommandMock.Message)
 	})
 }
 
@@ -1755,7 +1786,7 @@ func TestPluginAPICreateCommandAndListCommands(t *testing.T) {
 
 	foundCommand := func(listXCommand func(teamID string) ([]*model.Command, error)) bool {
 		cmds, appErr := listXCommand(th.BasicTeam.Id)
-		require.Nil(t, appErr)
+		require.NoError(t, appErr)
 
 		for _, cmd := range cmds {
 			if cmd.Trigger == "testcmd" {
@@ -1775,10 +1806,10 @@ func TestPluginAPICreateCommandAndListCommands(t *testing.T) {
 	}
 
 	cmd, appErr := api.CreateCommand(cmd)
-	require.Nil(t, appErr)
+	require.NoError(t, appErr)
 
 	newCmd, appErr := api.GetCommand(cmd.Id)
-	require.Nil(t, appErr)
+	require.NoError(t, appErr)
 	require.Equal(t, "pluginid", newCmd.PluginId)
 	require.Equal(t, "", newCmd.CreatorId)
 	require.True(t, foundCommand(api.ListCommands))
@@ -1799,17 +1830,17 @@ func TestPluginAPIUpdateCommand(t *testing.T) {
 	}
 
 	cmd, appErr := api.CreateCommand(cmd)
-	require.Nil(t, appErr)
+	require.NoError(t, appErr)
 
 	newCmd, appErr := api.GetCommand(cmd.Id)
-	require.Nil(t, appErr)
+	require.NoError(t, appErr)
 	require.Equal(t, "pluginid", newCmd.PluginId)
 	require.Equal(t, "", newCmd.CreatorId)
 
 	newCmd.Trigger = "NewTrigger"
 	newCmd.PluginId = "CannotChangeMe"
 	newCmd2, appErr := api.UpdateCommand(newCmd.Id, newCmd)
-	require.Nil(t, appErr)
+	require.NoError(t, appErr)
 	require.Equal(t, "pluginid", newCmd2.PluginId)
 	require.Equal(t, "newtrigger", newCmd2.Trigger)
 
@@ -1819,7 +1850,7 @@ func TestPluginAPIUpdateCommand(t *testing.T) {
 	newCmd2.Trigger = "anotherNewTrigger"
 	newCmd2.TeamId = team1.Id
 	newCmd3, appErr := api.UpdateCommand(newCmd2.Id, newCmd2)
-	require.Nil(t, appErr)
+	require.NoError(t, appErr)
 	require.Equal(t, "pluginid", newCmd3.PluginId)
 	require.Equal(t, "anothernewtrigger", newCmd3.Trigger)
 	require.Equal(t, team1.Id, newCmd3.TeamId)
@@ -1827,7 +1858,7 @@ func TestPluginAPIUpdateCommand(t *testing.T) {
 	newCmd3.Trigger = "anotherNewTriggerAgain"
 	newCmd3.TeamId = ""
 	newCmd4, appErr := api.UpdateCommand(newCmd2.Id, newCmd2)
-	require.Nil(t, appErr)
+	require.NoError(t, appErr)
 	require.Equal(t, "anothernewtriggeragain", newCmd4.Trigger)
 	require.Equal(t, team1.Id, newCmd4.TeamId)
 

app/plugin_health_check_test.go

@@ -50,7 +50,7 @@ func TestHealthCheckJob(t *testing.T) {
 
 	// First health check
 	hooks, err := env.HooksForPlugin(id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	hooks.MessageWillBePosted(&plugin.Context{}, &model.Post{})
 	job.CheckPlugin(id)
 	bundles = env.Active()
@@ -60,7 +60,7 @@ func TestHealthCheckJob(t *testing.T) {
 
 	// Second health check
 	hooks, err = env.HooksForPlugin(id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	hooks.MessageWillBePosted(&plugin.Context{}, &model.Post{})
 	job.CheckPlugin(id)
 	bundles = env.Active()
@@ -70,7 +70,7 @@ func TestHealthCheckJob(t *testing.T) {
 
 	// Third health check, plugin should be deactivated by the job
 	hooks, err = env.HooksForPlugin(id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	hooks.MessageWillBePosted(&plugin.Context{}, &model.Post{})
 	job.CheckPlugin(id)
 	bundles = env.Active()

app/plugin_hooks_test.go

@@ -182,7 +182,7 @@ func TestHookMessageWillBePosted(t *testing.T) {
 
 		assert.Equal(t, "message", post.Message)
 		retrievedPost, errSingle := th.App.Srv().Store.Post().GetSingle(post.Id)
-		require.Nil(t, errSingle)
+		require.NoError(t, errSingle)
 		assert.Equal(t, "message", retrievedPost.Message)
 	})
 
@@ -226,7 +226,7 @@ func TestHookMessageWillBePosted(t *testing.T) {
 
 		assert.Equal(t, "message_fromplugin", post.Message)
 		retrievedPost, errSingle := th.App.Srv().Store.Post().GetSingle(post.Id)
-		require.Nil(t, errSingle)
+		require.NoError(t, errSingle)
 		assert.Equal(t, "message_fromplugin", retrievedPost.Message)
 	})
 
@@ -863,7 +863,7 @@ func TestErrorString(t *testing.T) {
 		defer tearDown()
 
 		require.Len(t, activationErrors, 1)
-		require.NotNil(t, activationErrors[0])
+		require.Error(t, activationErrors[0])
 		require.Contains(t, activationErrors[0].Error(), "simulate failure")
 	})
 
@@ -893,7 +893,7 @@ func TestErrorString(t *testing.T) {
 		defer tearDown()
 
 		require.Len(t, activationErrors, 1)
-		require.NotNil(t, activationErrors[0])
+		require.Error(t, activationErrors[0])
 
 		cause := errors.Cause(activationErrors[0])
 		require.IsType(t, &model.AppError{}, cause)

app/plugin_install_test.go

@@ -128,7 +128,7 @@ func TestInstallPluginLocally(t *testing.T) {
 		pluginsEnvironment := th.App.GetPluginsEnvironment()
 		require.NotNil(t, pluginsEnvironment)
 		bundleInfos, err := pluginsEnvironment.Available()
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		for _, bundleInfo := range bundleInfos {
 			err := th.App.removePluginLocally(bundleInfo.Manifest.Id)
@@ -140,7 +140,7 @@ func TestInstallPluginLocally(t *testing.T) {
 		pluginsEnvironment := th.App.GetPluginsEnvironment()
 		require.NotNil(t, pluginsEnvironment)
 		bundleInfos, err := pluginsEnvironment.Available()
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		sort.Sort(byBundleInfoId(bundleInfos))
 
@@ -281,7 +281,7 @@ func TestInstallPluginAlreadyActive(t *testing.T) {
 	pluginsEnvironment := th.App.GetPluginsEnvironment()
 	require.NotNil(t, pluginsEnvironment)
 	bundleInfos, err := pluginsEnvironment.Available()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.NotEmpty(t, bundleInfos)
 	for _, bundleInfo := range bundleInfos {
 		if bundleInfo.Manifest.Id == actualManifest.Id {

app/plugin_signature_test.go

@@ -38,28 +38,28 @@ func TestPluginPublicKeys(t *testing.T) {
 	path, _ := fileutils.FindDir("tests")
 	publicKeyFilename := "test-public-key.plugin.gpg"
 	publicKey, err := ioutil.ReadFile(filepath.Join(path, publicKeyFilename))
-	require.Nil(t, err)
+	require.NoError(t, err)
 	fileReader, err := os.Open(filepath.Join(path, publicKeyFilename))
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer fileReader.Close()
 	th.App.AddPublicKey(publicKeyFilename, fileReader)
-	file, err := th.App.GetPublicKey(publicKeyFilename)
-	require.Nil(t, err)
+	file, appErr := th.App.GetPublicKey(publicKeyFilename)
+	require.Nil(t, appErr)
 	require.Equal(t, publicKey, file)
-	_, err = th.App.GetPublicKey("wrong file name")
-	require.NotNil(t, err)
-	_, err = th.App.GetPublicKey("wrong-file-name.plugin.gpg")
-	require.NotNil(t, err)
+	_, appErr = th.App.GetPublicKey("wrong file name")
+	require.NotNil(t, appErr)
+	_, appErr = th.App.GetPublicKey("wrong-file-name.plugin.gpg")
+	require.NotNil(t, appErr)
 
-	err = th.App.DeletePublicKey("wrong file name")
-	require.Nil(t, err)
-	err = th.App.DeletePublicKey("wrong-file-name.plugin.gpg")
-	require.Nil(t, err)
+	appErr = th.App.DeletePublicKey("wrong file name")
+	require.Nil(t, appErr)
+	appErr = th.App.DeletePublicKey("wrong-file-name.plugin.gpg")
+	require.Nil(t, appErr)
 
-	err = th.App.DeletePublicKey(publicKeyFilename)
-	require.Nil(t, err)
-	_, err = th.App.GetPublicKey(publicKeyFilename)
-	require.NotNil(t, err)
+	appErr = th.App.DeletePublicKey(publicKeyFilename)
+	require.Nil(t, appErr)
+	_, appErr = th.App.GetPublicKey(publicKeyFilename)
+	require.NotNil(t, appErr)
 }
 
 func TestVerifySignature(t *testing.T) {
@@ -71,50 +71,50 @@ func TestVerifySignature(t *testing.T) {
 	armoredPublicKeyFilename := "development-public-key.asc"
 	t.Run("verify armored signature and armored public key", func(t *testing.T) {
 		publicKeyFileReader, err := os.Open(filepath.Join(path, armoredPublicKeyFilename))
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer publicKeyFileReader.Close()
 		pluginFileReader, err := os.Open(filepath.Join(path, pluginFilename))
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer pluginFileReader.Close()
 		signatureFileReader, err := os.Open(filepath.Join(path, armoredSignatureFilename))
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer signatureFileReader.Close()
-		require.Nil(t, verifySignature(publicKeyFileReader, pluginFileReader, signatureFileReader))
+		require.NoError(t, verifySignature(publicKeyFileReader, pluginFileReader, signatureFileReader))
 	})
 	t.Run("verify non armored signature and armored public key", func(t *testing.T) {
 		publicKeyFileReader, err := os.Open(filepath.Join(path, armoredPublicKeyFilename))
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer publicKeyFileReader.Close()
 		pluginFileReader, err := os.Open(filepath.Join(path, pluginFilename))
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer pluginFileReader.Close()
 		signatureFileReader, err := os.Open(filepath.Join(path, signatureFilename))
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer signatureFileReader.Close()
-		require.Nil(t, verifySignature(publicKeyFileReader, pluginFileReader, signatureFileReader))
+		require.NoError(t, verifySignature(publicKeyFileReader, pluginFileReader, signatureFileReader))
 	})
 	t.Run("verify armored signature and non armored public key", func(t *testing.T) {
 		publicKeyFileReader, err := os.Open(filepath.Join(path, publicKeyFilename))
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer publicKeyFileReader.Close()
 		pluginFileReader, err := os.Open(filepath.Join(path, pluginFilename))
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer pluginFileReader.Close()
 		armoredSignatureFileReader, err := os.Open(filepath.Join(path, armoredSignatureFilename))
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer armoredSignatureFileReader.Close()
-		require.Nil(t, verifySignature(publicKeyFileReader, pluginFileReader, armoredSignatureFileReader))
+		require.NoError(t, verifySignature(publicKeyFileReader, pluginFileReader, armoredSignatureFileReader))
 	})
 	t.Run("verify non armored signature and non armored public key", func(t *testing.T) {
 		publicKeyFileReader, err := os.Open(filepath.Join(path, publicKeyFilename))
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer publicKeyFileReader.Close()
 		pluginFileReader, err := os.Open(filepath.Join(path, pluginFilename))
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer pluginFileReader.Close()
 		signatureFileReader, err := os.Open(filepath.Join(path, signatureFilename))
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer signatureFileReader.Close()
-		require.Nil(t, verifySignature(publicKeyFileReader, pluginFileReader, signatureFileReader))
+		require.NoError(t, verifySignature(publicKeyFileReader, pluginFileReader, signatureFileReader))
 	})
 }

app/plugin_test.go

@@ -75,7 +75,7 @@ func TestPluginKeyValueStore(t *testing.T) {
 	}
 
 	_, nErr := th.App.Srv().Store.Plugin().SaveOrUpdate(kv)
-	assert.Nil(t, nErr)
+	assert.NoError(t, nErr)
 
 	// Test fetch by keyname (this key does not exist but hashed key will be used for lookup)
 	ret, err = th.App.GetPluginKey(pluginId, "key2")
@@ -535,7 +535,7 @@ func TestPluginSync(t *testing.T) {
 
 				// Check if installed
 				pluginStatus, err := env.Statuses()
-				require.Nil(t, err)
+				require.NoError(t, err)
 				require.Len(t, pluginStatus, 1)
 				require.Equal(t, pluginStatus[0].PluginId, "testplugin")
 			})
@@ -553,7 +553,7 @@ func TestPluginSync(t *testing.T) {
 
 				// Check if removed
 				pluginStatus, err := env.Statuses()
-				require.Nil(t, err)
+				require.NoError(t, err)
 				require.Empty(t, pluginStatus)
 			})
 
@@ -571,7 +571,7 @@ func TestPluginSync(t *testing.T) {
 				appErr = th.App.SyncPlugins()
 				checkNoError(t, appErr)
 				pluginStatus, err := env.Statuses()
-				require.Nil(t, err)
+				require.NoError(t, err)
 				require.Len(t, pluginStatus, 0)
 			})
 
@@ -590,7 +590,7 @@ func TestPluginSync(t *testing.T) {
 				checkNoError(t, appErr)
 
 				pluginStatus, err := env.Statuses()
-				require.Nil(t, err)
+				require.NoError(t, err)
 				require.Len(t, pluginStatus, 0)
 			})
 
@@ -614,7 +614,7 @@ func TestPluginSync(t *testing.T) {
 				checkNoError(t, appErr)
 
 				pluginStatus, err := env.Statuses()
-				require.Nil(t, err)
+				require.NoError(t, err)
 				require.Len(t, pluginStatus, 1)
 				require.Equal(t, pluginStatus[0].PluginId, "testplugin")
 
@@ -657,7 +657,7 @@ func TestSyncPluginsActiveState(t *testing.T) {
 
 	// Verify the plugin was installed and set to deactivated.
 	pluginStatus, err := env.Statuses()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, pluginStatus, 1)
 	require.Equal(t, pluginStatus[0].PluginId, "testplugin")
 	require.Equal(t, pluginStatus[0].State, model.PluginStateNotRunning)
@@ -669,7 +669,7 @@ func TestSyncPluginsActiveState(t *testing.T) {
 
 	// Verify the plugin was activated due to config change.
 	pluginStatus, err = env.Statuses()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, pluginStatus, 1)
 	require.Equal(t, pluginStatus[0].PluginId, "testplugin")
 	require.Equal(t, pluginStatus[0].State, model.PluginStateRunning)
@@ -681,7 +681,7 @@ func TestSyncPluginsActiveState(t *testing.T) {
 
 	// Verify the plugin was deactivated due to config change.
 	pluginStatus, err = env.Statuses()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, pluginStatus, 1)
 	require.Equal(t, pluginStatus[0].PluginId, "testplugin")
 	require.Equal(t, pluginStatus[0].State, model.PluginStateNotRunning)

app/post_metadata_test.go

@@ -78,19 +78,19 @@ func TestPreparePostForClient(t *testing.T) {
 			</html>`))
 		case "/test-image1.png":
 			file, err := testutils.ReadTestFile("test.png")
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			w.Header().Set("Content-Type", "image/png")
 			w.Write(file)
 		case "/test-image2.png":
 			file, err := testutils.ReadTestFile("test-data-graph.png")
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			w.Header().Set("Content-Type", "image/png")
 			w.Write(file)
 		case "/test-image3.png":
 			file, err := testutils.ReadTestFile("qa-data-graph.png")
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			w.Header().Set("Content-Type", "image/png")
 			w.Write(file)
@@ -621,7 +621,7 @@ func testProxyOpenGraphImage(t *testing.T, th *TestHelper, shouldProxy bool) {
 			</html>`))
 		case "/test-image3.png":
 			file, err := testutils.ReadTestFile("qa-data-graph.png")
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			w.Header().Set("Content-Type", "image/png")
 			w.Write(file)
@@ -675,7 +675,7 @@ func TestGetEmbedForPost(t *testing.T) {
 			</html>`))
 		} else if r.URL.Path == "/image.png" {
 			file, err := testutils.ReadTestFile("test.png")
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			w.Header().Set("Content-Type", "image/png")
 			w.Write(file)
@@ -719,7 +719,7 @@ func TestGetEmbedForPost(t *testing.T) {
 			assert.Equal(t, &model.PostEmbed{
 				Type: model.POST_EMBED_MESSAGE_ATTACHMENT,
 			}, embed)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 		})
 
 		t.Run("should return an image embed when the first link is an image", func(t *testing.T) {
@@ -729,7 +729,7 @@ func TestGetEmbedForPost(t *testing.T) {
 				Type: model.POST_EMBED_IMAGE,
 				URL:  imageURL,
 			}, embed)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 		})
 
 		t.Run("should return an image embed when the first link is an image", func(t *testing.T) {
@@ -742,7 +742,7 @@ func TestGetEmbedForPost(t *testing.T) {
 					Title: "Title",
 				},
 			}, embed)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 		})
 
 		t.Run("should return a link embed", func(t *testing.T) {
@@ -752,7 +752,7 @@ func TestGetEmbedForPost(t *testing.T) {
 				Type: model.POST_EMBED_LINK,
 				URL:  otherURL,
 			}, embed)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 		})
 	})
 
@@ -779,28 +779,28 @@ func TestGetEmbedForPost(t *testing.T) {
 			assert.Equal(t, &model.PostEmbed{
 				Type: model.POST_EMBED_MESSAGE_ATTACHMENT,
 			}, embed)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 		})
 
 		t.Run("should not return an opengraph embed", func(t *testing.T) {
 			embed, err := th.App.getEmbedForPost(&model.Post{}, ogURL, false)
 
 			assert.Nil(t, embed)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 		})
 
 		t.Run("should not return an image embed", func(t *testing.T) {
 			embed, err := th.App.getEmbedForPost(&model.Post{}, imageURL, false)
 
 			assert.Nil(t, embed)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 		})
 
 		t.Run("should not return a link embed", func(t *testing.T) {
 			embed, err := th.App.getEmbedForPost(&model.Post{}, otherURL, false)
 
 			assert.Nil(t, embed)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 		})
 	})
 }
@@ -816,7 +816,7 @@ func TestGetImagesForPost(t *testing.T) {
 
 		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			file, err := testutils.ReadTestFile("test.png")
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			w.Header().Set("Content-Type", "image/png")
 			w.Write(file)
@@ -1617,7 +1617,7 @@ func TestGetLinkMetadata(t *testing.T) {
 
 			require.NotNil(t, og)
 			assert.Nil(t, img)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 			assert.Equal(t, title, og.Title)
 		})
 
@@ -1632,7 +1632,7 @@ func TestGetLinkMetadata(t *testing.T) {
 
 			require.NotNil(t, og)
 			assert.Nil(t, img)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 			assert.Equal(t, title, og.Title)
 		})
 
@@ -1649,7 +1649,7 @@ func TestGetLinkMetadata(t *testing.T) {
 
 			assert.Nil(t, og)
 			assert.Nil(t, img)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 		})
 
 		t.Run("should not use cache if timestamp is different", func(t *testing.T) {
@@ -1665,7 +1665,7 @@ func TestGetLinkMetadata(t *testing.T) {
 
 			assert.Nil(t, og)
 			assert.Nil(t, img)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 		})
 	})
 
@@ -1692,7 +1692,7 @@ func TestGetLinkMetadata(t *testing.T) {
 
 			require.NotNil(t, og)
 			assert.Nil(t, img)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 			assert.Equal(t, title, og.Title)
 		})
 
@@ -1709,7 +1709,7 @@ func TestGetLinkMetadata(t *testing.T) {
 
 			require.NotNil(t, og)
 			assert.Nil(t, img)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 			assert.Equal(t, title, og.Title)
 		})
 
@@ -1728,7 +1728,7 @@ func TestGetLinkMetadata(t *testing.T) {
 
 			assert.Nil(t, og)
 			assert.Nil(t, img)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 		})
 
 		t.Run("should not use database if timestamp is different", func(t *testing.T) {
@@ -1746,7 +1746,7 @@ func TestGetLinkMetadata(t *testing.T) {
 
 			assert.Nil(t, og)
 			assert.Nil(t, img)
-			assert.Nil(t, err)
+			assert.NoError(t, err)
 		})
 	})
 
@@ -1767,7 +1767,7 @@ func TestGetLinkMetadata(t *testing.T) {
 
 		assert.NotNil(t, og)
 		assert.Nil(t, img)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 	})
 
 	t.Run("should cache OpenGraph results", func(t *testing.T) {
@@ -1787,7 +1787,7 @@ func TestGetLinkMetadata(t *testing.T) {
 
 		assert.NotNil(t, og)
 		assert.Nil(t, img)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 
 		fromCache, _, ok := getLinkMetadataFromCache(requestURL, timestamp)
 		assert.True(t, ok)
@@ -1815,7 +1815,7 @@ func TestGetLinkMetadata(t *testing.T) {
 
 		assert.Nil(t, og)
 		assert.NotNil(t, img)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 
 		_, fromCache, ok := getLinkMetadataFromCache(requestURL, timestamp)
 		assert.True(t, ok)
@@ -1843,7 +1843,7 @@ func TestGetLinkMetadata(t *testing.T) {
 
 		assert.Nil(t, og)
 		assert.Nil(t, img)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 
 		ogFromCache, imgFromCache, ok := getLinkMetadataFromCache(requestURL, timestamp)
 		assert.True(t, ok)
@@ -1907,7 +1907,7 @@ func TestGetLinkMetadata(t *testing.T) {
 
 		assert.Nil(t, og)
 		assert.Nil(t, img)
-		assert.NotNil(t, err)
+		assert.Error(t, err)
 		assert.True(t, os.IsTimeout(err))
 
 		ogFromCache, imgFromCache, ok := getLinkMetadataFromCache(requestURL, timestamp)
@@ -1935,7 +1935,7 @@ func TestGetLinkMetadata(t *testing.T) {
 		require.False(t, ok, "data should not exist in database")
 
 		_, img, err := th.App.getLinkMetadata(requestURL, timestamp, false)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		_, _, ok = getLinkMetadataFromCache(requestURL, timestamp)
 		require.True(t, ok, "data should now exist in in-memory cache")
@@ -1959,7 +1959,7 @@ func TestGetLinkMetadata(t *testing.T) {
 		og, img, err := th.App.getLinkMetadata(requestURL, timestamp, false)
 		assert.Nil(t, og)
 		assert.Nil(t, img)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 	})
 
 	t.Run("should check in-memory cache for new post", func(t *testing.T) {
@@ -1974,7 +1974,7 @@ func TestGetLinkMetadata(t *testing.T) {
 		og, img, err := th.App.getLinkMetadata(requestURL, timestamp, true)
 		assert.NotNil(t, og)
 		assert.Nil(t, img)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 	})
 
 	t.Run("should skip database cache for new post", func(t *testing.T) {
@@ -1989,7 +1989,7 @@ func TestGetLinkMetadata(t *testing.T) {
 		og, img, err := th.App.getLinkMetadata(requestURL, timestamp, true)
 		assert.Nil(t, og)
 		assert.Nil(t, img)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 	})
 
 	t.Run("should resolve relative URL", func(t *testing.T) {
@@ -2012,7 +2012,7 @@ func TestGetLinkMetadata(t *testing.T) {
 		og, img, err := th.App.getLinkMetadata(requestURL, timestamp, false)
 		assert.Nil(t, og)
 		assert.NotNil(t, img)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 	})
 
 	t.Run("should error on local addresses other than the image proxy", func(t *testing.T) {
@@ -2040,7 +2040,7 @@ func TestGetLinkMetadata(t *testing.T) {
 		og, img, err := th.App.getLinkMetadata(requestURL, timestamp, false)
 		assert.Nil(t, og)
 		assert.Nil(t, img)
-		assert.NotNil(t, err)
+		assert.Error(t, err)
 		assert.IsType(t, &url.Error{}, err)
 		assert.Equal(t, httpservice.AddressForbidden, err.(*url.Error).Err)
 
@@ -2050,7 +2050,7 @@ func TestGetLinkMetadata(t *testing.T) {
 		og, img, err = th.App.getLinkMetadata(requestURL, timestamp, false)
 		assert.Nil(t, og)
 		assert.Nil(t, img)
-		assert.NotNil(t, err)
+		assert.Error(t, err)
 		assert.IsType(t, imageproxy.Error{}, err)
 	})
 
@@ -2064,7 +2064,7 @@ func TestGetLinkMetadata(t *testing.T) {
 		og, img, err := th.App.getLinkMetadata(requestURL, timestamp, true)
 		assert.Nil(t, og)
 		assert.NotNil(t, img)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 	})
 }
 
@@ -2115,7 +2115,7 @@ func TestParseLinkMetadata(t *testing.T) {
 
 	imageURL := "http://example.com/test.png"
 	file, err := testutils.ReadTestFile("test.png")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	ogURL := "https://example.com/hello"
 	html := `
@@ -2137,7 +2137,7 @@ func TestParseLinkMetadata(t *testing.T) {
 
 	t.Run("image", func(t *testing.T) {
 		og, dimensions, err := th.App.parseLinkMetadata(imageURL, makeImageReader(), "image/png")
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 
 		assert.Nil(t, og)
 		assert.Equal(t, &model.PostImage{
@@ -2149,7 +2149,7 @@ func TestParseLinkMetadata(t *testing.T) {
 
 	t.Run("malformed image", func(t *testing.T) {
 		og, dimensions, err := th.App.parseLinkMetadata(imageURL, makeOpenGraphReader(), "image/png")
-		assert.NotNil(t, err)
+		assert.Error(t, err)
 
 		assert.Nil(t, og)
 		assert.Nil(t, dimensions)
@@ -2157,7 +2157,7 @@ func TestParseLinkMetadata(t *testing.T) {
 
 	t.Run("opengraph", func(t *testing.T) {
 		og, dimensions, err := th.App.parseLinkMetadata(ogURL, makeOpenGraphReader(), "text/html; charset=utf-8")
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 
 		assert.NotNil(t, og)
 		assert.Equal(t, og.Title, "Hello, World!")
@@ -2168,7 +2168,7 @@ func TestParseLinkMetadata(t *testing.T) {
 
 	t.Run("malformed opengraph", func(t *testing.T) {
 		og, dimensions, err := th.App.parseLinkMetadata(ogURL, makeImageReader(), "text/html; charset=utf-8")
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 
 		assert.Nil(t, og)
 		assert.Nil(t, dimensions)
@@ -2176,7 +2176,7 @@ func TestParseLinkMetadata(t *testing.T) {
 
 	t.Run("neither", func(t *testing.T) {
 		og, dimensions, err := th.App.parseLinkMetadata("http://example.com/test.wad", strings.NewReader("garbage"), "application/x-doom")
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 
 		assert.Nil(t, og)
 		assert.Nil(t, dimensions)
@@ -2184,7 +2184,7 @@ func TestParseLinkMetadata(t *testing.T) {
 
 	t.Run("svg", func(t *testing.T) {
 		og, dimensions, err := th.App.parseLinkMetadata("http://example.com/image.svg", nil, "image/svg+xml")
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 
 		assert.Nil(t, og)
 		assert.Equal(t, &model.PostImage{
@@ -2227,13 +2227,13 @@ func TestParseImages(t *testing.T) {
 	} {
 		t.Run(name, func(t *testing.T) {
 			file, err := testutils.ReadTestFile(testCase.FileName)
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			result, err := parseImages(bytes.NewReader(file))
 			if testCase.ExpectError {
-				assert.NotNil(t, err)
+				assert.Error(t, err)
 			} else {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 				assert.Equal(t, testCase.Expected, result)
 			}
 		})

app/post_test.go

@@ -137,14 +137,14 @@ func TestCreatePostDeduplicate(t *testing.T) {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			var err error
-			post, err = th.App.CreatePostAsUser(&model.Post{
+			var appErr *model.AppError
+			post, appErr = th.App.CreatePostAsUser(&model.Post{
 				UserId:        th.BasicUser.Id,
 				ChannelId:     th.BasicChannel.Id,
 				Message:       "plugin delayed",
 				PendingPostId: pendingPostId,
 			}, "", true)
-			require.Nil(t, err)
+			require.Nil(t, appErr)
 			require.Equal(t, post.Message, "plugin delayed")
 		}()
 
@@ -200,22 +200,22 @@ func TestAttachFilesToPost(t *testing.T) {
 			CreatorId: th.BasicUser.Id,
 			Path:      "path.txt",
 		})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		info2, err := th.App.Srv().Store.FileInfo().Save(&model.FileInfo{
 			CreatorId: th.BasicUser.Id,
 			Path:      "path.txt",
 		})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		post := th.BasicPost
 		post.FileIds = []string{info1.Id, info2.Id}
 
-		err = th.App.attachFilesToPost(post)
-		assert.Nil(t, err)
+		appErr := th.App.attachFilesToPost(post)
+		assert.Nil(t, appErr)
 
-		infos, err := th.App.GetFileInfosForPost(post.Id, false)
-		assert.Nil(t, err)
+		infos, appErr := th.App.GetFileInfosForPost(post.Id, false)
+		assert.Nil(t, appErr)
 		assert.Len(t, infos, 2)
 	})
 
@@ -228,27 +228,27 @@ func TestAttachFilesToPost(t *testing.T) {
 			Path:      "path.txt",
 			PostId:    model.NewId(),
 		})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		info2, err := th.App.Srv().Store.FileInfo().Save(&model.FileInfo{
 			CreatorId: th.BasicUser.Id,
 			Path:      "path.txt",
 		})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		post := th.BasicPost
 		post.FileIds = []string{info1.Id, info2.Id}
 
-		err = th.App.attachFilesToPost(post)
-		assert.Nil(t, err)
+		appErr := th.App.attachFilesToPost(post)
+		assert.Nil(t, appErr)
 
-		infos, err := th.App.GetFileInfosForPost(post.Id, false)
-		assert.Nil(t, err)
+		infos, appErr := th.App.GetFileInfosForPost(post.Id, false)
+		assert.Nil(t, appErr)
 		assert.Len(t, infos, 1)
 		assert.Equal(t, info2.Id, infos[0].Id)
 
-		updated, err := th.App.GetSinglePost(post.Id)
-		require.Nil(t, err)
+		updated, appErr := th.App.GetSinglePost(post.Id)
+		require.Nil(t, appErr)
 		assert.Len(t, updated.FileIds, 1)
 		assert.Contains(t, updated.FileIds, info2.Id)
 	})
@@ -854,15 +854,15 @@ func TestCreatePostAsUser(t *testing.T) {
 			UserId:    th.BasicUser.Id,
 		}
 
-		channelMemberBefore, appErr := th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
-		require.Nil(t, appErr)
+		channelMemberBefore, err := th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
+		require.NoError(t, err)
 
 		time.Sleep(1 * time.Millisecond)
-		_, appErr = th.App.CreatePostAsUser(post, "", true)
+		_, appErr := th.App.CreatePostAsUser(post, "", true)
 		require.Nil(t, appErr)
 
-		channelMemberAfter, appErr := th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
-		require.Nil(t, appErr)
+		channelMemberAfter, err := th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
+		require.NoError(t, err)
 
 		require.Greater(t, channelMemberAfter.LastViewedAt, channelMemberBefore.LastViewedAt)
 	})
@@ -878,15 +878,15 @@ func TestCreatePostAsUser(t *testing.T) {
 		}
 		post.AddProp("from_webhook", "true")
 
-		channelMemberBefore, appErr := th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
-		require.Nil(t, appErr)
+		channelMemberBefore, err := th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
+		require.NoError(t, err)
 
 		time.Sleep(1 * time.Millisecond)
-		_, appErr = th.App.CreatePostAsUser(post, "", true)
+		_, appErr := th.App.CreatePostAsUser(post, "", true)
 		require.Nil(t, appErr)
 
-		channelMemberAfter, appErr := th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
-		require.Nil(t, appErr)
+		channelMemberAfter, err := th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
+		require.NoError(t, err)
 
 		require.Equal(t, channelMemberAfter.LastViewedAt, channelMemberBefore.LastViewedAt)
 	})
@@ -910,14 +910,14 @@ func TestCreatePostAsUser(t *testing.T) {
 		}
 
 		channelMemberBefore, nErr := th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 
 		time.Sleep(1 * time.Millisecond)
 		_, appErr = th.App.CreatePostAsUser(post, "", true)
 		require.Nil(t, appErr)
 
 		channelMemberAfter, nErr := th.App.Srv().Store.Channel().GetMember(th.BasicChannel.Id, th.BasicUser.Id)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 
 		require.Equal(t, channelMemberAfter.LastViewedAt, channelMemberBefore.LastViewedAt)
 	})
@@ -1893,11 +1893,11 @@ func TestThreadMembership(t *testing.T) {
 
 		// first user should now be part of the thread since they replied to a post
 		memberships, err2 := th.App.GetThreadMembershipsForUser(user1.Id, th.BasicTeam.Id)
-		require.Nil(t, err2)
+		require.NoError(t, err2)
 		require.Len(t, memberships, 1)
 		// second user should also be part of a thread since they were mentioned
 		memberships, err2 = th.App.GetThreadMembershipsForUser(user2.Id, th.BasicTeam.Id)
-		require.Nil(t, err2)
+		require.NoError(t, err2)
 		require.Len(t, memberships, 1)
 
 		post2, err := th.App.CreatePost(&model.Post{
@@ -1917,7 +1917,7 @@ func TestThreadMembership(t *testing.T) {
 
 		// first user should now be part of two threads
 		memberships, err2 = th.App.GetThreadMembershipsForUser(user1.Id, th.BasicTeam.Id)
-		require.Nil(t, err2)
+		require.NoError(t, err2)
 		require.Len(t, memberships, 2)
 	})
 }
@@ -1952,7 +1952,7 @@ func TestCollapsedThreadFetch(t *testing.T) {
 		}, channel, false, true)
 		require.Nil(t, err)
 		thread, nErr := th.App.Srv().Store.Thread().Get(postRoot.Id)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 		require.Len(t, thread.Participants, 2)
 		th.App.MarkChannelAsUnreadFromPost(postRoot.Id, user1.Id)
 		l, err := th.App.GetPostsForChannelAroundLastUnread(channel.Id, user1.Id, 10, 10, true, true, false)

app/product_notices_test.go

@@ -586,8 +586,8 @@ func TestNoticeFetch(t *testing.T) {
 		},
 		Repeatable: nil,
 	}}
-	noticesBytes, appErr := notices.Marshal()
-	require.NoError(t, appErr)
+	noticesBytes, err := notices.Marshal()
+	require.NoError(t, err)
 
 	notices2 := model.ProductNotices{model.ProductNotice{
 		Conditions: model.Conditions{
@@ -602,8 +602,8 @@ func TestNoticeFetch(t *testing.T) {
 		},
 		Repeatable: nil,
 	}}
-	noticesBytes2, appErr := notices2.Marshal()
-	require.NoError(t, appErr)
+	noticesBytes2, err := notices2.Marshal()
+	require.NoError(t, err)
 	server1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if strings.HasSuffix(r.URL.Path, "notices.json") {
 			w.Write(noticesBytes)
@@ -619,7 +619,7 @@ func TestNoticeFetch(t *testing.T) {
 	})
 
 	// fetch fake notices
-	appErr = th.App.UpdateProductNotices()
+	appErr := th.App.UpdateProductNotices()
 	require.Nil(t, appErr)
 
 	// get them for specified user
@@ -638,7 +638,7 @@ func TestNoticeFetch(t *testing.T) {
 
 	// validate views table
 	views, err := th.App.Srv().Store.ProductNotices().GetViews(th.BasicUser.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, views, 1)
 
 	// fetch another set
@@ -657,6 +657,6 @@ func TestNoticeFetch(t *testing.T) {
 
 	// even though UpdateViewedProductNotices was called previously, the table should be empty, since there's cleanup done during UpdateProductNotices
 	views, err = th.App.Srv().Store.ProductNotices().GetViews(th.BasicUser.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, views, 0)
 }

app/role_test.go

@@ -102,15 +102,15 @@ func testPermissionInheritance(t *testing.T, testCallback func(t *testing.T, th
 
 	// Get the truth table from CSV
 	file, e := os.Open("tests/channel-role-has-permission.csv")
-	require.Nil(t, e)
+	require.NoError(t, e)
 	defer file.Close()
 
 	b, e := ioutil.ReadAll(file)
-	require.Nil(t, e)
+	require.NoError(t, e)
 
 	r := csv.NewReader(strings.NewReader(string(b)))
 	records, e := r.ReadAll()
-	require.Nil(t, e)
+	require.NoError(t, e)
 
 	test := func(higherScopedGuest, higherScopedUser, higherScopedAdmin string) {
 		for _, roleNameUnderTest := range []string{higherScopedGuest, higherScopedUser, higherScopedAdmin} {
@@ -121,19 +121,19 @@ func testPermissionInheritance(t *testing.T, testCallback func(t *testing.T, th
 				}
 
 				higherSchemeHasPermission, e := strconv.ParseBool(row[0])
-				require.Nil(t, e)
+				require.NoError(t, e)
 
 				permissionIsModerated, e := strconv.ParseBool(row[1])
-				require.Nil(t, e)
+				require.NoError(t, e)
 
 				channelSchemeHasPermission, e := strconv.ParseBool(row[2])
-				require.Nil(t, e)
+				require.NoError(t, e)
 
 				channelRoleIsChannelAdmin, e := strconv.ParseBool(row[3])
-				require.Nil(t, e)
+				require.NoError(t, e)
 
 				shouldHavePermission, e := strconv.ParseBool(row[4])
-				require.Nil(t, e)
+				require.NoError(t, e)
 
 				// skip some invalid combinations because of the outer loop iterating all 3 channel roles
 				if (channelRoleIsChannelAdmin && roleNameUnderTest != higherScopedAdmin) || (!channelRoleIsChannelAdmin && roleNameUnderTest == higherScopedAdmin) {

app/server_test.go

@@ -191,9 +191,9 @@ func TestGenerateSupportPacket(t *testing.T) {
 
 	d1 := []byte("hello\ngo\n")
 	err := ioutil.WriteFile("mattermost.log", d1, 0777)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	err = ioutil.WriteFile("notifications.log", d1, 0777)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	fileDatas := th.App.GenerateSupportPacket()
 	testFiles := []string{"support_packet.yaml", "plugins.json", "sanitized_config.json", "mattermost.log", "notifications.log"}
@@ -205,9 +205,9 @@ func TestGenerateSupportPacket(t *testing.T) {
 
 	// Remove these two files and ensure that warning.txt file is generated
 	err = os.Remove("notifications.log")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	err = os.Remove("mattermost.log")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	fileDatas = th.App.GenerateSupportPacket()
 	testFiles = []string{"support_packet.yaml", "plugins.json", "sanitized_config.json", "warning.txt"}
 	for i, fileData := range fileDatas {
@@ -246,7 +246,7 @@ func TestGetNotificationsLog(t *testing.T) {
 	d1 := []byte("hello\ngo\n")
 	err := ioutil.WriteFile("notifications.log", d1, 0777)
 	defer os.Remove("notifications.log")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	fileData, warning = th.App.getNotificationsLog()
 	require.NotNil(t, fileData)
@@ -284,7 +284,7 @@ func TestGetMattermostLog(t *testing.T) {
 	d1 := []byte("hello\ngo\n")
 	err := ioutil.WriteFile("mattermost.log", d1, 0777)
 	defer os.Remove("mattermost.log")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	fileData, warning = th.App.getMattermostLog()
 	require.NotNil(t, fileData)

app/session_test.go

@@ -35,20 +35,20 @@ func TestCache(t *testing.T) {
 	th.App.Srv().sessionCache.SetWithExpiry(session2.Token, session2, 5*time.Minute)
 
 	keys, err := th.App.Srv().sessionCache.Keys()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.NotEmpty(t, keys)
 
 	th.App.ClearSessionCacheForUser(session.UserId)
 
 	rkeys, err := th.App.Srv().sessionCache.Keys()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Lenf(t, rkeys, len(keys)-1, "should have one less: %d - %d != 1", len(keys), len(rkeys))
 	require.NotEmpty(t, rkeys)
 
 	th.App.ClearSessionCacheForAllUsers()
 
 	rkeys, err = th.App.Srv().sessionCache.Keys()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Empty(t, rkeys)
 }
 
@@ -73,7 +73,7 @@ func TestGetSessionIdleTimeoutInMinutes(t *testing.T) {
 	// Test regular session, should timeout
 	time := session.LastActivityAt - (1000 * 60 * 6)
 	nErr := th.App.Srv().Store.Session().UpdateLastActivityAt(session.Id, time)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	th.App.ClearSessionCacheForUserSkipClusterSend(session.UserId)
 
 	rsession, err = th.App.GetSession(session.Token)
@@ -91,7 +91,7 @@ func TestGetSessionIdleTimeoutInMinutes(t *testing.T) {
 	session, _ = th.App.CreateSession(session)
 	time = session.LastActivityAt - (1000 * 60 * 6)
 	nErr = th.App.Srv().Store.Session().UpdateLastActivityAt(session.Id, time)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	th.App.ClearSessionCacheForUserSkipClusterSend(session.UserId)
 
 	_, err = th.App.GetSession(session.Token)
@@ -106,7 +106,7 @@ func TestGetSessionIdleTimeoutInMinutes(t *testing.T) {
 	session, _ = th.App.CreateSession(session)
 	time = session.LastActivityAt - (1000 * 60 * 6)
 	nErr = th.App.Srv().Store.Session().UpdateLastActivityAt(session.Id, time)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	th.App.ClearSessionCacheForUserSkipClusterSend(session.UserId)
 
 	_, err = th.App.GetSession(session.Token)
@@ -124,7 +124,7 @@ func TestGetSessionIdleTimeoutInMinutes(t *testing.T) {
 	session, _ = th.App.CreateSession(session)
 	time = session.LastActivityAt - (1000 * 60 * 6)
 	nErr = th.App.Srv().Store.Session().UpdateLastActivityAt(session.Id, time)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	th.App.ClearSessionCacheForUserSkipClusterSend(session.UserId)
 
 	_, err = th.App.GetSession(session.Token)
@@ -343,12 +343,12 @@ func TestApp_ExtendExpiryIfNeeded(t *testing.T) {
 			// check cache was updated
 			var cachedSession *model.Session
 			errGet := th.App.Srv().sessionCache.Get(session.Token, &cachedSession)
-			require.Nil(t, errGet)
+			require.NoError(t, errGet)
 			require.Equal(t, session.ExpiresAt, cachedSession.ExpiresAt)
 
 			// check database was updated.
 			storedSession, nErr := th.App.Srv().Store.Session().Get(session.Token)
-			require.Nil(t, nErr)
+			require.NoError(t, nErr)
 			require.Equal(t, session.ExpiresAt, storedSession.ExpiresAt)
 		})
 	}

app/syncables_test.go

@@ -360,7 +360,7 @@ func TestCreateDefaultMemberships(t *testing.T) {
 		require.Nil(t, err)
 
 		pErr = th.App.CreateDefaultMemberships(0)
-		require.Nil(t, pErr)
+		require.NoError(t, pErr)
 
 		// Ensure only the restricted user was added to both the team and channel
 		cMembersCount, err = th.App.GetChannelMemberCount(restrictedChannel.Id)
@@ -426,7 +426,7 @@ func TestDeleteGroupMemberships(t *testing.T) {
 
 	// run the delete
 	appErr := th.App.DeleteGroupConstrainedMemberships()
-	require.Nil(t, appErr)
+	require.NoError(t, appErr)
 
 	// verify the new member counts
 	tmembers, err = th.App.GetTeamMembers(th.BasicTeam.Id, 0, 100, nil)

app/team_test.go

@@ -205,7 +205,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}),
 		)
 
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		defer th.App.DeleteToken(token)
 
 		_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
@@ -219,7 +219,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 		)
 
 		token.CreateAt = model.GetMillis() - InvitationExpiryTime - 1
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		defer th.App.DeleteToken(token)
 
 		_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
@@ -231,7 +231,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			TokenTypeTeamInvitation,
 			model.MapToJson(map[string]string{"teamId": model.NewId()}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		defer th.App.DeleteToken(token)
 
 		_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
@@ -243,7 +243,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			TokenTypeTeamInvitation,
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		defer th.App.DeleteToken(token)
 
 		_, err := th.App.AddUserToTeamByToken(model.NewId(), token.Token)
@@ -255,12 +255,12 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			TokenTypeTeamInvitation,
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
 		require.Nil(t, err, "Should add user to the team")
 
 		_, nErr := th.App.Srv().Store.Token().GetByToken(token.Token)
-		require.NotNil(t, nErr, "The token must be deleted after be used")
+		require.Error(t, nErr, "The token must be deleted after be used")
 
 		members, err := th.App.GetChannelMembersForUser(th.BasicTeam.Id, ruser.Id)
 		require.Nil(t, err)
@@ -272,7 +272,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			TokenTypeTeamInvitation,
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		_, err := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
 		assert.NotNil(t, err)
 	})
@@ -282,7 +282,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			TokenTypeGuestInvitation,
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id, "channels": th.BasicChannel.Id}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
 		assert.NotNil(t, err)
 	})
@@ -297,7 +297,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			TokenTypeGuestInvitation,
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id, "channels": th.BasicChannel.Id}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		_, err := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
 		require.NotNil(t, err)
 		assert.Equal(t, "api.team.join_user_to_team.allowed_domains.app_error", err.Id)
@@ -317,19 +317,19 @@ func TestAddUserToTeamByToken(t *testing.T) {
 		rguest.Email = "test@restricted.com"
 		_, err := th.App.Srv().Store.User().Update(rguest, false)
 		th.App.InvalidateCacheForUser(rguest.Id)
-		require.Nil(t, err)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
-		_, err = th.App.AddUserToTeamByToken(rguest.Id, token.Token)
-		require.Nil(t, err)
+		require.NoError(t, err)
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
+		_, appErr := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
+		require.Nil(t, appErr)
 		rguest.Email = guestEmail
 		_, err = th.App.Srv().Store.User().Update(rguest, false)
-		require.Nil(t, err)
+		require.NoError(t, err)
 	})
 
 	t.Run("add a guest user even though there are team and system domain restrictions", func(t *testing.T) {
 		th.BasicTeam.AllowedDomains = "restricted-team.com"
 		_, err := th.Server.Store.Team().Update(th.BasicTeam)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		restrictedDomain := *th.App.Config().TeamSettings.RestrictCreationToDomains
 		defer func() {
 			th.App.UpdateConfig(func(cfg *model.Config) { cfg.TeamSettings.RestrictCreationToDomains = &restrictedDomain })
@@ -340,13 +340,13 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id, "channels": th.BasicChannel.Id}),
 		)
 		_, err = th.App.Srv().Store.User().Update(rguest, false)
-		require.Nil(t, err)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
-		_, err = th.App.AddUserToTeamByToken(rguest.Id, token.Token)
-		require.Nil(t, err)
+		require.NoError(t, err)
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
+		_, appErr := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
+		require.Nil(t, appErr)
 		th.BasicTeam.AllowedDomains = ""
 		_, err = th.Server.Store.Team().Update(th.BasicTeam)
-		require.Nil(t, err)
+		require.NoError(t, err)
 	})
 
 	t.Run("valid request from guest invite", func(t *testing.T) {
@@ -354,13 +354,13 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			TokenTypeGuestInvitation,
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id, "channels": th.BasicChannel.Id}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 
 		_, err := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
 		require.Nil(t, err, "Should add user to the team")
 
 		_, nErr := th.App.Srv().Store.Token().GetByToken(token.Token)
-		require.NotNil(t, nErr, "The token must be deleted after be used")
+		require.Error(t, nErr, "The token must be deleted after be used")
 
 		members, err := th.App.GetChannelMembersForUser(th.BasicTeam.Id, rguest.Id)
 		require.Nil(t, err)
@@ -377,7 +377,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			TokenTypeTeamInvitation,
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 
 		_, err = th.App.AddUserToTeamByToken(ruser.Id, token.Token)
 		require.NotNil(t, err, "Should return an error when trying to join a group-constrained team.")
@@ -401,7 +401,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			TokenTypeTeamInvitation,
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 
 		_, err = th.App.AddUserToTeamByToken(ruser.Id, token.Token)
 		require.NotNil(t, err, "Should not add restricted user")
@@ -416,7 +416,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			TokenTypeTeamInvitation,
 			model.MapToJson(map[string]string{"teamId": team.Id}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 
 		_, err := th.App.AddUserToTeamByToken(user.Id, token.Token)
 		require.Nil(t, err)
@@ -1107,7 +1107,7 @@ func TestInvalidateAllEmailInvites(t *testing.T) {
 		Extra:    "",
 	}
 	err := th.App.Srv().Store.Token().Save(&t1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	t2 := model.Token{
 		Token:    "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy",
@@ -1116,7 +1116,7 @@ func TestInvalidateAllEmailInvites(t *testing.T) {
 		Extra:    "",
 	}
 	err = th.App.Srv().Store.Token().Save(&t2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	t3 := model.Token{
 		Token:    "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz",
@@ -1125,19 +1125,19 @@ func TestInvalidateAllEmailInvites(t *testing.T) {
 		Extra:    "",
 	}
 	err = th.App.Srv().Store.Token().Save(&t3)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
-	err = th.App.InvalidateAllEmailInvites()
-	require.Nil(t, err)
+	appErr := th.App.InvalidateAllEmailInvites()
+	require.Nil(t, appErr)
 
 	_, err = th.App.Srv().Store.Token().GetByToken(t1.Token)
-	require.NotNil(t, err)
+	require.Error(t, err)
 
 	_, err = th.App.Srv().Store.Token().GetByToken(t2.Token)
-	require.NotNil(t, err)
+	require.Error(t, err)
 
 	_, err = th.App.Srv().Store.Token().GetByToken(t3.Token)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func TestClearTeamMembersCache(t *testing.T) {

app/upload_test.go

@@ -105,9 +105,8 @@ func TestUploadData(t *testing.T) {
 		FileSize:  8 * 1024 * 1024,
 	}
 
-	var err error
-	us, err = th.App.CreateUploadSession(us)
-	require.Nil(t, err)
+	us, uploadSessionAppErr := th.App.CreateUploadSession(us)
+	require.Nil(t, uploadSessionAppErr)
 	require.NotEmpty(t, us)
 
 	data := make([]byte, us.FileSize)
@@ -120,16 +119,16 @@ func TestUploadData(t *testing.T) {
 			N: 1024 * 1024,
 		}
 
-		ok, err := th.App.FileExists(us.Path)
+		ok, appErr := th.App.FileExists(us.Path)
 		require.False(t, ok)
-		require.Nil(t, err)
+		require.Nil(t, appErr)
 
 		u := *us
 		u.Path = ""
-		info, err := th.App.UploadData(&u, rd)
+		info, appErr := th.App.UploadData(&u, rd)
 		require.Nil(t, info)
-		require.NotNil(t, err)
-		require.NotEqual(t, "app.upload.upload_data.first_part_too_small.app_error", err.Id)
+		require.NotNil(t, appErr)
+		require.NotEqual(t, "app.upload.upload_data.first_part_too_small.app_error", appErr.Id)
 	})
 
 	t.Run("first part too small", func(t *testing.T) {
@@ -138,18 +137,18 @@ func TestUploadData(t *testing.T) {
 			N: 1024 * 1024,
 		}
 
-		ok, err := th.App.FileExists(us.Path)
+		ok, appErr := th.App.FileExists(us.Path)
 		require.False(t, ok)
-		require.Nil(t, err)
+		require.Nil(t, appErr)
 
-		info, err := th.App.UploadData(us, rd)
+		info, appErr := th.App.UploadData(us, rd)
 		require.Nil(t, info)
-		require.NotNil(t, err)
-		require.Equal(t, "app.upload.upload_data.first_part_too_small.app_error", err.Id)
+		require.NotNil(t, appErr)
+		require.Equal(t, "app.upload.upload_data.first_part_too_small.app_error", appErr.Id)
 
-		ok, err = th.App.FileExists(us.Path)
+		ok, appErr = th.App.FileExists(us.Path)
 		require.False(t, ok)
-		require.Nil(t, err)
+		require.Nil(t, appErr)
 	})
 
 	t.Run("resume success", func(t *testing.T) {
@@ -157,73 +156,76 @@ func TestUploadData(t *testing.T) {
 			R: bytes.NewReader(data),
 			N: 5 * 1024 * 1024,
 		}
-		info, err := th.App.UploadData(us, rd)
+		info, appErr := th.App.UploadData(us, rd)
 		require.Nil(t, info)
-		require.Nil(t, err)
+		require.Nil(t, appErr)
 
 		rd = &io.LimitedReader{
 			R: bytes.NewReader(data[5*1024*1024:]),
 			N: 3 * 1024 * 1024,
 		}
-		info, err = th.App.UploadData(us, rd)
-		require.Nil(t, err)
+		info, appErr = th.App.UploadData(us, rd)
+		require.Nil(t, appErr)
 		require.NotEmpty(t, info)
 
-		d, err := th.App.ReadFile(us.Path)
-		require.Nil(t, err)
+		d, appErr := th.App.ReadFile(us.Path)
+		require.Nil(t, appErr)
 		require.Equal(t, data, d)
 	})
 
 	t.Run("all at once success", func(t *testing.T) {
 		us.Id = model.NewId()
-		us, err = th.App.CreateUploadSession(us)
-		require.Nil(t, err)
+		var appErr *model.AppError
+		us, appErr = th.App.CreateUploadSession(us)
+		require.Nil(t, appErr)
 		require.NotEmpty(t, us)
 
-		info, err := th.App.UploadData(us, bytes.NewReader(data))
-		require.Nil(t, err)
+		info, appErr := th.App.UploadData(us, bytes.NewReader(data))
+		require.Nil(t, appErr)
 		require.NotEmpty(t, info)
 
-		d, err := th.App.ReadFile(us.Path)
-		require.Nil(t, err)
+		d, appErr := th.App.ReadFile(us.Path)
+		require.Nil(t, appErr)
 		require.Equal(t, data, d)
 	})
 
 	t.Run("small file success", func(t *testing.T) {
 		us.Id = model.NewId()
 		us.FileSize = 1024 * 1024
-		us, err = th.App.CreateUploadSession(us)
-		require.Nil(t, err)
+		var appErr *model.AppError
+		us, appErr = th.App.CreateUploadSession(us)
+		require.Nil(t, appErr)
 		require.NotEmpty(t, us)
 
 		rd := &io.LimitedReader{
 			R: bytes.NewReader(data),
 			N: 1024 * 1024,
 		}
-		info, err := th.App.UploadData(us, rd)
-		require.Nil(t, err)
+		info, appErr := th.App.UploadData(us, rd)
+		require.Nil(t, appErr)
 		require.NotEmpty(t, info)
 
-		d, err := th.App.ReadFile(us.Path)
-		require.Nil(t, err)
+		d, appErr := th.App.ReadFile(us.Path)
+		require.Nil(t, appErr)
 		require.Equal(t, data[:1024*1024], d)
 	})
 
 	t.Run("image processing", func(t *testing.T) {
 		testDir, _ := fileutils.FindDir("tests")
 		data, err := ioutil.ReadFile(filepath.Join(testDir, "test.png"))
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.NotEmpty(t, data)
 
 		us.Id = model.NewId()
 		us.Filename = "test.png"
 		us.FileSize = int64(len(data))
-		us, err = th.App.CreateUploadSession(us)
-		require.Nil(t, err)
+		var appErr *model.AppError
+		us, appErr = th.App.CreateUploadSession(us)
+		require.Nil(t, appErr)
 		require.NotEmpty(t, us)
 
-		info, err := th.App.UploadData(us, bytes.NewReader(data))
-		require.Nil(t, err)
+		info, appErr := th.App.UploadData(us, bytes.NewReader(data))
+		require.Nil(t, appErr)
 		require.NotEmpty(t, info)
 		require.NotZero(t, info.Width)
 		require.NotZero(t, info.Height)
@@ -245,9 +247,9 @@ func TestUploadDataConcurrent(t *testing.T) {
 		FileSize:  8 * 1024 * 1024,
 	}
 
-	var err error
-	us, err = th.App.CreateUploadSession(us)
-	require.Nil(t, err)
+	var appErr *model.AppError
+	us, appErr = th.App.CreateUploadSession(us)
+	require.Nil(t, appErr)
 	require.NotEmpty(t, us)
 
 	data := make([]byte, us.FileSize)
@@ -303,7 +305,7 @@ func TestUploadDataConcurrent(t *testing.T) {
 	// Verify that only 1 request was able to finish the upload.
 	require.Equal(t, int32(n-1), nErrs)
 
-	d, err := th.App.ReadFile(us.Path)
-	require.Nil(t, err)
+	d, appErr := th.App.ReadFile(us.Path)
+	require.Nil(t, appErr)
 	require.Equal(t, data, d)
 }

app/user_test.go

@@ -102,7 +102,7 @@ func TestCreateProfileImage(t *testing.T) {
 
 	rdr := bytes.NewReader(b)
 	img, _, err2 := image.Decode(rdr)
-	require.Nil(t, err2)
+	require.NoError(t, err2)
 
 	colorful := color.RGBA{116, 49, 196, 255}
 
@@ -133,12 +133,12 @@ func TestAdjustProfileImage(t *testing.T) {
 	defer th.TearDown()
 
 	_, err := th.App.AdjustImage(bytes.NewReader([]byte{}))
-	require.Error(t, err)
+	require.NotNil(t, err)
 
 	// test image isn't the correct dimensions
 	// it should be adjusted
 	testjpg, error := testutils.ReadTestFile("testjpg.jpg")
-	require.Nil(t, error)
+	require.NoError(t, error)
 	adjusted, err := th.App.AdjustImage(bytes.NewReader(testjpg))
 	require.Nil(t, err)
 	assert.True(t, adjusted.Len() > 0)
@@ -448,7 +448,7 @@ func TestUpdateUserEmail(t *testing.T) {
 			IsBot:    true,
 		}
 		_, nErr := th.App.Srv().Store.User().Save(&botuser)
-		assert.Nil(t, nErr)
+		assert.NoError(t, nErr)
 
 		newBotEmail := th.MakeEmail()
 		botuser.Email = newBotEmail
@@ -492,7 +492,7 @@ func TestUpdateUserEmail(t *testing.T) {
 			IsBot:    true,
 		}
 		_, nErr := th.App.Srv().Store.User().Save(&botuser)
-		assert.Nil(t, nErr)
+		assert.NoError(t, nErr)
 
 		newBotEmail := th.MakeEmail()
 		botuser.Email = newBotEmail
@@ -527,7 +527,7 @@ func getGitlabUserPayload(gitlabUser oauthgitlab.GitLabUser, t *testing.T) []byt
 	var payload []byte
 	var err error
 	payload, err = json.Marshal(gitlabUser)
-	require.Nil(t, err, "Serialization of gitlab user to json failed", err)
+	require.NoError(t, err, "Serialization of gitlab user to json failed", err)
 
 	return payload
 }
@@ -696,7 +696,7 @@ func TestCreateUserWithInviteId(t *testing.T) {
 	t.Run("invalid domain", func(t *testing.T) {
 		th.BasicTeam.AllowedDomains = "mattermost.com"
 		_, nErr := th.App.Srv().Store.Team().Update(th.BasicTeam)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 		_, err := th.App.CreateUserWithInviteId(&user, th.BasicTeam.InviteId, "")
 		require.NotNil(t, err)
 		require.Equal(t, "api.team.invite_members.invalid_email.app_error", err.Id)
@@ -719,7 +719,7 @@ func TestCreateUserWithToken(t *testing.T) {
 			TokenTypeVerifyEmail,
 			model.MapToJson(map[string]string{"teamID": th.BasicTeam.Id, "email": user.Email}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		defer th.App.DeleteToken(token)
 		_, err := th.App.CreateUserWithToken(&user, token)
 		require.NotNil(t, err, "Should fail on bad token type")
@@ -731,7 +731,7 @@ func TestCreateUserWithToken(t *testing.T) {
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id, "email": user.Email}),
 		)
 		token.CreateAt = model.GetMillis() - InvitationExpiryTime - 1
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		defer th.App.DeleteToken(token)
 		_, err := th.App.CreateUserWithToken(&user, token)
 		require.NotNil(t, err, "Should fail on expired token")
@@ -742,7 +742,7 @@ func TestCreateUserWithToken(t *testing.T) {
 			TokenTypeTeamInvitation,
 			model.MapToJson(map[string]string{"teamId": model.NewId(), "email": user.Email}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		defer th.App.DeleteToken(token)
 		_, err := th.App.CreateUserWithToken(&user, token)
 		require.NotNil(t, err, "Should fail on bad team id")
@@ -754,14 +754,14 @@ func TestCreateUserWithToken(t *testing.T) {
 			TokenTypeTeamInvitation,
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id, "email": invitationEmail}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		newUser, err := th.App.CreateUserWithToken(&user, token)
 		require.Nil(t, err, "Should add user to the team. err=%v", err)
 		assert.False(t, newUser.IsGuest())
 		require.Equal(t, invitationEmail, newUser.Email, "The user email must be the invitation one")
 
 		_, nErr := th.App.Srv().Store.Token().GetByToken(token.Token)
-		require.NotNil(t, nErr, "The token must be deleted after be used")
+		require.Error(t, nErr, "The token must be deleted after be used")
 
 		members, err := th.App.GetChannelMembersForUser(th.BasicTeam.Id, newUser.Id)
 		require.Nil(t, err)
@@ -774,7 +774,7 @@ func TestCreateUserWithToken(t *testing.T) {
 			TokenTypeGuestInvitation,
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id, "email": invitationEmail, "channels": th.BasicChannel.Id}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		guest := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
 		newGuest, err := th.App.CreateUserWithToken(&guest, token)
 		require.Nil(t, err, "Should add user to the team. err=%v", err)
@@ -782,7 +782,7 @@ func TestCreateUserWithToken(t *testing.T) {
 		assert.True(t, newGuest.IsGuest())
 		require.Equal(t, invitationEmail, newGuest.Email, "The user email must be the invitation one")
 		_, nErr := th.App.Srv().Store.Token().GetByToken(token.Token)
-		require.NotNil(t, nErr, "The token must be deleted after be used")
+		require.Error(t, nErr, "The token must be deleted after be used")
 
 		members, err := th.App.GetChannelMembersForUser(th.BasicTeam.Id, newGuest.Id)
 		require.Nil(t, err)
@@ -808,8 +808,8 @@ func TestCreateUserWithToken(t *testing.T) {
 			TokenTypeGuestInvitation,
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id, "email": grantedInvitationEmail, "channels": th.BasicChannel.Id}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(forbiddenDomainToken))
-		require.Nil(t, th.App.Srv().Store.Token().Save(grantedDomainToken))
+		require.NoError(t, th.App.Srv().Store.Token().Save(forbiddenDomainToken))
+		require.NoError(t, th.App.Srv().Store.Token().Save(grantedDomainToken))
 		guest := model.User{
 			Email:       strings.ToLower(model.NewId()) + "+test@example.com",
 			Nickname:    "Darth Vader",
@@ -827,7 +827,7 @@ func TestCreateUserWithToken(t *testing.T) {
 		assert.True(t, newGuest.IsGuest())
 		require.Equal(t, grantedInvitationEmail, newGuest.Email)
 		_, nErr := th.App.Srv().Store.Token().GetByToken(grantedDomainToken.Token)
-		require.NotNil(t, nErr)
+		require.Error(t, nErr)
 
 		members, err := th.App.GetChannelMembersForUser(th.BasicTeam.Id, newGuest.Id)
 		require.Nil(t, err)
@@ -851,7 +851,7 @@ func TestCreateUserWithToken(t *testing.T) {
 			TokenTypeGuestInvitation,
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id, "email": invitationEmail, "channels": th.BasicChannel.Id}),
 		)
-		require.Nil(t, th.App.Srv().Store.Token().Save(token))
+		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		guest := model.User{
 			Email:       strings.ToLower(model.NewId()) + "+test@example.com",
 			Nickname:    "Darth Vader",
@@ -864,7 +864,7 @@ func TestCreateUserWithToken(t *testing.T) {
 		assert.True(t, newGuest.IsGuest())
 		assert.Equal(t, invitationEmail, newGuest.Email, "The user email must be the invitation one")
 		_, nErr := th.App.Srv().Store.Token().GetByToken(token.Token)
-		require.NotNil(t, nErr)
+		require.Error(t, nErr)
 
 		members, err := th.App.GetChannelMembersForUser(th.BasicTeam.Id, newGuest.Id)
 		require.Nil(t, err)
@@ -895,7 +895,7 @@ func TestPermanentDeleteUser(t *testing.T) {
 
 	sqlStore := mainHelper.GetSQLStore()
 	_, err1 := sqlStore.GetMaster().Select(&bots1, "SELECT * FROM Bots")
-	assert.Nil(t, err1)
+	assert.NoError(t, err1)
 	assert.Equal(t, 1, len(bots1))
 
 	// test that bot is deleted from bots table
@@ -906,7 +906,7 @@ func TestPermanentDeleteUser(t *testing.T) {
 	assert.Nil(t, err)
 
 	_, err1 = sqlStore.GetMaster().Select(&bots2, "SELECT * FROM Bots")
-	assert.Nil(t, err1)
+	assert.NoError(t, err1)
 	assert.Equal(t, 0, len(bots2))
 
 	err = th.App.PermanentDeleteUser(th.BasicUser)
@@ -938,7 +938,7 @@ func TestPasswordRecovery(t *testing.T) {
 	}{}
 
 	err2 := json.Unmarshal([]byte(token.Extra), &tokenData)
-	assert.Nil(t, err2)
+	assert.NoError(t, err2)
 	assert.Equal(t, th.BasicUser.Id, tokenData.UserId)
 	assert.Equal(t, th.BasicUser.Email, tokenData.Email)
 

app/webhook_test.go

@@ -740,7 +740,7 @@ func TestDoOutgoingWebhookRequest(t *testing.T) {
 		defer server.Close()
 
 		resp, err := th.App.doOutgoingWebhookRequest(server.URL, strings.NewReader(""), "application/json")
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		assert.NotNil(t, resp)
 		assert.NotNil(t, resp.Text)
@@ -754,7 +754,7 @@ func TestDoOutgoingWebhookRequest(t *testing.T) {
 		defer server.Close()
 
 		_, err := th.App.doOutgoingWebhookRequest(server.URL, strings.NewReader(""), "application/json")
-		require.NotNil(t, err)
+		require.Error(t, err)
 		require.IsType(t, &json.SyntaxError{}, err)
 	})
 
@@ -765,7 +765,7 @@ func TestDoOutgoingWebhookRequest(t *testing.T) {
 		defer server.Close()
 
 		_, err := th.App.doOutgoingWebhookRequest(server.URL, strings.NewReader(""), "application/json")
-		require.NotNil(t, err)
+		require.Error(t, err)
 		require.Equal(t, io.ErrUnexpectedEOF, err)
 	})
 
@@ -776,7 +776,7 @@ func TestDoOutgoingWebhookRequest(t *testing.T) {
 		defer server.Close()
 
 		_, err := th.App.doOutgoingWebhookRequest(server.URL, strings.NewReader(""), "application/json")
-		require.NotNil(t, err)
+		require.Error(t, err)
 		require.IsType(t, &json.SyntaxError{}, err)
 	})
 
@@ -796,7 +796,7 @@ func TestDoOutgoingWebhookRequest(t *testing.T) {
 		}()
 
 		_, err := th.App.doOutgoingWebhookRequest(server.URL, strings.NewReader(""), "application/json")
-		require.NotNil(t, err)
+		require.Error(t, err)
 		require.IsType(t, &url.Error{}, err)
 	})
 
@@ -806,7 +806,7 @@ func TestDoOutgoingWebhookRequest(t *testing.T) {
 		defer server.Close()
 
 		resp, err := th.App.doOutgoingWebhookRequest(server.URL, strings.NewReader(""), "application/json")
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Nil(t, resp)
 	})
 }