Replacing {require,assert}.{Nil,NotNil} with {require,assert}.{NoError,Error} in the store tests (when comparing errors) (#16886)

* Replacing require.Nil with require.NoError

* More replacements

* More Nil/NotNill to NoError/Error

* Other detected errors

* renaming apperr to err

* Removed not needed line

* Rename old appErr variables that are no longer model.AppError values

* Fixing tiny typo

* Reverting changes outside the store (accidentally added)

* Apply suggestions from code review

Co-authored-by: Doug Lauder <wiggin77@warpmail.net>

Co-authored-by: Doug Lauder <wiggin77@warpmail.net>

store/localcachelayer/channel_layer_test.go

@@ -28,11 +28,11 @@ func TestChannelStoreChannelMemberCountsCache(t *testing.T) {
 		require.NoError(t, err)
 
 		count, err := cachedStore.Channel().GetMemberCount("id", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, count, countResult)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
 		count, err = cachedStore.Channel().GetMemberCount("id", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, count, countResult)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
 	})
@@ -114,11 +114,11 @@ func TestChannelStoreChannelPinnedPostsCountsCache(t *testing.T) {
 		require.NoError(t, err)
 
 		count, err := cachedStore.Channel().GetPinnedPostCount("id", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, count, countResult)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
 		count, err = cachedStore.Channel().GetPinnedPostCount("id", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, count, countResult)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
 	})
@@ -186,11 +186,11 @@ func TestChannelStoreGuestCountCache(t *testing.T) {
 		require.NoError(t, err)
 
 		count, err := cachedStore.Channel().GetGuestCount("id", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, count, countResult)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 1)
 		count, err = cachedStore.Channel().GetGuestCount("id", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, count, countResult)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 1)
 	})
@@ -258,11 +258,11 @@ func TestChannelStoreChannel(t *testing.T) {
 		require.NoError(t, err)
 
 		channel, err := cachedStore.Channel().Get(channelId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, channel, &fakeChannel)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 1)
 		channel, err = cachedStore.Channel().Get(channelId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, channel, &fakeChannel)
 		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 1)
 	})

store/localcachelayer/emoji_layer_test.go

@@ -28,11 +28,11 @@ func TestEmojiStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		emoji, err := cachedStore.Emoji().Get("123", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, emoji, &fakeEmoji)
 		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
 		emoji, err = cachedStore.Emoji().Get("123", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, emoji, &fakeEmoji)
 		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
 	})
@@ -44,11 +44,11 @@ func TestEmojiStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		emoji, err := cachedStore.Emoji().GetByName("name123", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, emoji, &fakeEmoji)
 		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
 		emoji, err = cachedStore.Emoji().GetByName("name123", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, emoji, &fakeEmoji)
 		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
 	})

store/localcachelayer/file_info_layer_test.go

@@ -28,7 +28,7 @@ func TestFileInfoStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		fileInfos, err := cachedStore.FileInfo().GetForPost("123", true, true, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fileInfos, []*model.FileInfo{&fakeFileInfo})
 		mockStore.FileInfo().(*mocks.FileInfoStore).AssertNumberOfCalls(t, "GetForPost", 1)
 		assert.Equal(t, fileInfos, []*model.FileInfo{&fakeFileInfo})

store/localcachelayer/post_layer_test.go

@@ -92,12 +92,12 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {
 		expectedResult := model.NewPostList()
 
 		list, err := cachedStore.Post().GetPostsSince(fakeOptions, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, list, expectedResult)
 		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
 
 		list, err = cachedStore.Post().GetPostsSince(fakeOptions, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, list, expectedResult)
 		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
 	})
@@ -152,7 +152,7 @@ func TestPostStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakePosts, gotPosts)
 		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1)
 
@@ -167,7 +167,7 @@ func TestPostStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakePosts, gotPosts)
 		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1)
 
@@ -182,7 +182,7 @@ func TestPostStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakePosts, gotPosts)
 		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1)
 

store/localcachelayer/reaction_layer_test.go

@@ -28,10 +28,9 @@ func TestReactionStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		reaction, err := cachedStore.Reaction().GetForPost("123", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, reaction, []*model.Reaction{&fakeReaction})
 		mockStore.Reaction().(*mocks.ReactionStore).AssertNumberOfCalls(t, "GetForPost", 1)
-		require.Nil(t, err)
 		assert.Equal(t, reaction, []*model.Reaction{&fakeReaction})
 		cachedStore.Reaction().GetForPost("123", true)
 		mockStore.Reaction().(*mocks.ReactionStore).AssertNumberOfCalls(t, "GetForPost", 1)

store/localcachelayer/role_layer_test.go

@@ -28,10 +28,10 @@ func TestRoleStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		role, err := cachedStore.Role().GetByName("role-name")
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, role, &fakeRole)
 		mockStore.Role().(*mocks.RoleStore).AssertNumberOfCalls(t, "GetByName", 1)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, role, &fakeRole)
 		cachedStore.Role().GetByName("role-name")
 		mockStore.Role().(*mocks.RoleStore).AssertNumberOfCalls(t, "GetByName", 1)

store/localcachelayer/scheme_layer_test.go

@@ -28,10 +28,10 @@ func TestSchemeStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		scheme, err := cachedStore.Scheme().Get("123")
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, scheme, &fakeScheme)
 		mockStore.Scheme().(*mocks.SchemeStore).AssertNumberOfCalls(t, "Get", 1)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, scheme, &fakeScheme)
 		cachedStore.Scheme().Get("123")
 		mockStore.Scheme().(*mocks.SchemeStore).AssertNumberOfCalls(t, "Get", 1)

store/localcachelayer/team_layer_test.go

@@ -28,12 +28,12 @@ func TestTeamStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotUserTeamIds, err := cachedStore.Team().GetUserTeamIds(fakeUserId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeUserTeamIds, gotUserTeamIds)
 		mockStore.Team().(*mocks.TeamStore).AssertNumberOfCalls(t, "GetUserTeamIds", 1)
 
 		gotUserTeamIds, err = cachedStore.Team().GetUserTeamIds(fakeUserId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeUserTeamIds, gotUserTeamIds)
 		mockStore.Team().(*mocks.TeamStore).AssertNumberOfCalls(t, "GetUserTeamIds", 1)
 	})
@@ -45,12 +45,12 @@ func TestTeamStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotUserTeamIds, err := cachedStore.Team().GetUserTeamIds(fakeUserId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeUserTeamIds, gotUserTeamIds)
 		mockStore.Team().(*mocks.TeamStore).AssertNumberOfCalls(t, "GetUserTeamIds", 1)
 
 		gotUserTeamIds, err = cachedStore.Team().GetUserTeamIds(fakeUserId, false)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeUserTeamIds, gotUserTeamIds)
 		mockStore.Team().(*mocks.TeamStore).AssertNumberOfCalls(t, "GetUserTeamIds", 2)
 	})
@@ -62,14 +62,14 @@ func TestTeamStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotUserTeamIds, err := cachedStore.Team().GetUserTeamIds(fakeUserId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeUserTeamIds, gotUserTeamIds)
 		mockStore.Team().(*mocks.TeamStore).AssertNumberOfCalls(t, "GetUserTeamIds", 1)
 
 		cachedStore.Team().InvalidateAllTeamIdsForUser(fakeUserId)
 
 		gotUserTeamIds, err = cachedStore.Team().GetUserTeamIds(fakeUserId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeUserTeamIds, gotUserTeamIds)
 		mockStore.Team().(*mocks.TeamStore).AssertNumberOfCalls(t, "GetUserTeamIds", 2)
 	})

store/localcachelayer/terms_of_service_layer_test.go

@@ -29,11 +29,11 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {
 		require.NoError(t, err)
 
 		termsOfService, err := cachedStore.TermsOfService().GetLatest(true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, termsOfService, &fakeTermsOfService)
 		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 1)
 		termsOfService, err = cachedStore.TermsOfService().GetLatest(true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, termsOfService, &fakeTermsOfService)
 		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 1)
 	})
@@ -45,11 +45,11 @@ func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {
 		require.NoError(t, err)
 
 		termsOfService, err := cachedStore.TermsOfService().Get("123", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, termsOfService, &fakeTermsOfService)
 		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 1)
 		termsOfService, err = cachedStore.TermsOfService().Get("123", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, termsOfService, &fakeTermsOfService)
 		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 1)
 	})

store/localcachelayer/user_layer_test.go

@@ -34,7 +34,7 @@ func TestUserStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotUser, err := cachedStore.User().GetProfileByIds(fakeUserIds, &store.UserGetByIdsOpts{}, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeUser, gotUser)
 		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetProfileByIds", 1)
 
@@ -49,7 +49,7 @@ func TestUserStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotUser, err := cachedStore.User().GetProfileByIds(fakeUserIds, &store.UserGetByIdsOpts{}, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeUser, gotUser)
 		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetProfileByIds", 1)
 
@@ -64,7 +64,7 @@ func TestUserStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotUser, err := cachedStore.User().GetProfileByIds(fakeUserIds, &store.UserGetByIdsOpts{}, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeUser, gotUser)
 
 		cachedStore.User().InvalidateProfileCacheForUser("123")
@@ -80,7 +80,7 @@ func TestUserStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		storedUsers, err := mockStore.User().GetProfileByIds(fakeUserIds, &store.UserGetByIdsOpts{}, false)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		originalProps := make([]model.StringMap, len(storedUsers))
 
@@ -91,14 +91,14 @@ func TestUserStoreCache(t *testing.T) {
 		}
 
 		cachedUsers, err := cachedStore.User().GetProfileByIds(fakeUserIds, &store.UserGetByIdsOpts{}, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		for i := 0; i < len(storedUsers); i++ {
 			assert.Equal(t, storedUsers[i].Id, cachedUsers[i].Id)
 		}
 
 		cachedUsers, err = cachedStore.User().GetProfileByIds(fakeUserIds, &store.UserGetByIdsOpts{}, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		for i := 0; i < len(storedUsers); i++ {
 			storedUsers[i].Props = model.StringMap{}
 			storedUsers[i].Timezone = model.StringMap{}
@@ -130,7 +130,7 @@ func TestUserStoreProfilesInChannelCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotMap, err := cachedStore.User().GetAllProfilesInChannel(fakeChannelId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeMap, gotMap)
 		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetAllProfilesInChannel", 1)
 
@@ -145,7 +145,7 @@ func TestUserStoreProfilesInChannelCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotMap, err := cachedStore.User().GetAllProfilesInChannel(fakeChannelId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeMap, gotMap)
 		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetAllProfilesInChannel", 1)
 
@@ -160,7 +160,7 @@ func TestUserStoreProfilesInChannelCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotMap, err := cachedStore.User().GetAllProfilesInChannel(fakeChannelId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeMap, gotMap)
 		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetAllProfilesInChannel", 1)
 
@@ -177,7 +177,7 @@ func TestUserStoreProfilesInChannelCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotMap, err := cachedStore.User().GetAllProfilesInChannel(fakeChannelId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeMap, gotMap)
 		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetAllProfilesInChannel", 1)
 
@@ -202,7 +202,7 @@ func TestUserStoreGetCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotUser, err := cachedStore.User().Get(fakeUserId)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeUser, gotUser)
 		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "Get", 1)
 
@@ -217,7 +217,7 @@ func TestUserStoreGetCache(t *testing.T) {
 		require.NoError(t, err)
 
 		gotUser, err := cachedStore.User().Get(fakeUserId)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, fakeUser, gotUser)
 		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "Get", 1)
 
@@ -234,20 +234,20 @@ func TestUserStoreGetCache(t *testing.T) {
 		require.NoError(t, err)
 
 		storedUser, err := mockStore.User().Get(fakeUserId)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		originalProps := storedUser.NotifyProps
 
 		storedUser.NotifyProps = map[string]string{}
 		storedUser.NotifyProps["key"] = "somevalue"
 
 		cachedUser, err := cachedStore.User().Get(fakeUserId)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, storedUser, cachedUser)
 
 		storedUser.Props = model.StringMap{}
 		storedUser.Timezone = model.StringMap{}
 		cachedUser, err = cachedStore.User().Get(fakeUserId)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, storedUser, cachedUser)
 		if storedUser == cachedUser {
 			assert.Fail(t, "should be different pointers")

store/localcachelayer/webhook_layer_test.go

@@ -28,7 +28,7 @@ func TestWebhookStoreCache(t *testing.T) {
 		require.NoError(t, err)
 
 		incomingWebhook, err := cachedStore.Webhook().GetIncoming("123", true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, incomingWebhook, &fakeWebhook)
 		mockStore.Webhook().(*mocks.WebhookStore).AssertNumberOfCalls(t, "GetIncoming", 1)
 

store/searchtest/channel_layer.go

@@ -70,100 +70,100 @@ func TestSearchChannelStore(t *testing.T, s store.Store, testEngine *SearchTestE
 		Store: s,
 	}
 	err := th.SetupBasicFixtures()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.CleanFixtures()
 	runTestSearch(t, testEngine, searchChannelStoreTests, th)
 }
 
 func testAutocompleteChannelByName(t *testing.T, th *SearchTestHelper) {
 	alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "Channel Alternate", "", model.CHANNEL_OPEN, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteChannel(alternate)
-	res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-a", false)
+	res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-a", false)
-	require.Nil(t, apperr)
+	require.NoError(t, err)
 	th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id}, res)
 }
 
 func testAutocompleteChannelByDisplayName(t *testing.T, th *SearchTestHelper) {
 	alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "ChannelAlternate", "", model.CHANNEL_OPEN, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteChannel(alternate)
-	res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "ChannelA", false)
+	res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "ChannelA", false)
-	require.Nil(t, apperr)
+	require.NoError(t, err)
 	th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id}, res)
 }
 
 func testAutocompleteChannelByNameSplittedWithDashChar(t *testing.T, th *SearchTestHelper) {
 	alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "ChannelAlternate", "", model.CHANNEL_OPEN, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteChannel(alternate)
-	res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-a", false)
+	res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-a", false)
-	require.Nil(t, apperr)
+	require.NoError(t, err)
 	th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id}, res)
 }
 
 func testAutocompleteChannelByNameSplittedWithUnderscoreChar(t *testing.T, th *SearchTestHelper) {
 	alternate, err := th.createChannel(th.Team.Id, "channel_alternate", "ChannelAlternate", "", model.CHANNEL_OPEN, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteChannel(alternate)
-	res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel_a", false)
+	res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel_a", false)
-	require.Nil(t, apperr)
+	require.NoError(t, err)
 	th.checkChannelIdsMatch(t, []string{alternate.Id}, res)
 }
 
 func testAutocompleteChannelByDisplayNameSplittedByWhitespaces(t *testing.T, th *SearchTestHelper) {
 	alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "Channel Alternate", "", model.CHANNEL_OPEN, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	defer th.deleteChannel(alternate)
-	res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "Channel A", false)
+	res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "Channel A", false)
-	require.Nil(t, apperr)
+	require.NoError(t, err)
 	th.checkChannelIdsMatch(t, []string{alternate.Id}, res)
 }
 func testAutocompleteAllChannelsIfTermIsEmpty(t *testing.T, th *SearchTestHelper) {
 	alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "Channel Alternate", "", model.CHANNEL_OPEN, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	other, err := th.createChannel(th.Team.Id, "other-channel", "Other Channel", "", model.CHANNEL_OPEN, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteChannel(alternate)
 	defer th.deleteChannel(other)
-	res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "", false)
+	res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "", false)
-	require.Nil(t, apperr)
+	require.NoError(t, err)
 	th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id, other.Id}, res)
 }
 
 func testSearchChannelsInCaseInsensitiveManner(t *testing.T, th *SearchTestHelper) {
 	alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "ChannelAlternate", "", model.CHANNEL_OPEN, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteChannel(alternate)
-	res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channela", false)
+	res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channela", false)
-	require.Nil(t, apperr)
+	require.NoError(t, err)
 	th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id}, res)
-	res, apperr = th.Store.Channel().AutocompleteInTeam(th.Team.Id, "ChAnNeL-a", false)
+	res, err = th.Store.Channel().AutocompleteInTeam(th.Team.Id, "ChAnNeL-a", false)
-	require.Nil(t, apperr)
+	require.NoError(t, err)
 	th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id}, res)
 }
 
 func testSearchOnlyPublicChannels(t *testing.T, th *SearchTestHelper) {
 	alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "ChannelAlternate", "", model.CHANNEL_PRIVATE, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteChannel(alternate)
-	res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-a", false)
+	res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-a", false)
-	require.Nil(t, apperr)
+	require.NoError(t, err)
 	th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id}, res)
 }
 
 func testSearchShouldSupportHavingHyphenAsLastCharacter(t *testing.T, th *SearchTestHelper) {
 	alternate, err := th.createChannel(th.Team.Id, "channel-alternate", "ChannelAlternate", "", model.CHANNEL_OPEN, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteChannel(alternate)
-	res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-", false)
+	res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-", false)
-	require.Nil(t, apperr)
+	require.NoError(t, err)
 	th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, alternate.Id}, res)
 }
 
 func testSearchShouldSupportAutocompleteWithArchivedChannels(t *testing.T, th *SearchTestHelper) {
-	res, apperr := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-", true)
+	res, err := th.Store.Channel().AutocompleteInTeam(th.Team.Id, "channel-", true)
-	require.Nil(t, apperr)
+	require.NoError(t, err)
 	th.checkChannelIdsMatch(t, []string{th.ChannelBasic.Id, th.ChannelDeleted.Id}, res)
 }

store/searchtest/helper.go

@@ -147,29 +147,19 @@ func (th *SearchTestHelper) CleanFixtures() error {
 }
 
 func (th *SearchTestHelper) createTeam(name, displayName, teamType string) (*model.Team, error) {
-	team, appError := th.Store.Team().Save(&model.Team{
+	return th.Store.Team().Save(&model.Team{
 		Name:        name,
 		DisplayName: displayName,
 		Type:        teamType,
 	})
-	if appError != nil {
-		return nil, errors.New(appError.Error())
-	}
-
-	return team, nil
 }
 
 func (th *SearchTestHelper) deleteTeam(team *model.Team) error {
-	appError := th.Store.Team().RemoveAllMembersByTeam(team.Id)
+	err := th.Store.Team().RemoveAllMembersByTeam(team.Id)
-	if appError != nil {
-		return errors.New(appError.Error())
-	}
-	err := th.Store.Team().PermanentDelete(team.Id)
 	if err != nil {
 		return err
 	}
-
+	return th.Store.Team().PermanentDelete(team.Id)
-	return nil
 }
 
 func (th *SearchTestHelper) makeEmail() string {
@@ -177,7 +167,7 @@ func (th *SearchTestHelper) makeEmail() string {
 }
 
 func (th *SearchTestHelper) createUser(username, nickname, firstName, lastName string) (*model.User, error) {
-	user, appError := th.Store.User().Save(&model.User{
+	return th.Store.User().Save(&model.User{
 		Username:  username,
 		Password:  username,
 		Nickname:  nickname,
@@ -185,15 +175,10 @@ func (th *SearchTestHelper) createUser(username, nickname, firstName, lastName s
 		LastName:  lastName,
 		Email:     th.makeEmail(),
 	})
-	if appError != nil {
-		return nil, errors.New(appError.Error())
-	}
-
-	return user, nil
 }
 
 func (th *SearchTestHelper) createGuest(username, nickname, firstName, lastName string) (*model.User, error) {
-	user, appError := th.Store.User().Save(&model.User{
+	return th.Store.User().Save(&model.User{
 		Username:  username,
 		Password:  username,
 		Nickname:  nickname,
@@ -202,26 +187,16 @@ func (th *SearchTestHelper) createGuest(username, nickname, firstName, lastName
 		Email:     th.makeEmail(),
 		Roles:     model.SYSTEM_GUEST_ROLE_ID,
 	})
-	if appError != nil {
-		return nil, errors.New(appError.Error())
-	}
-
-	return user, nil
 }
 
 func (th *SearchTestHelper) deleteUser(user *model.User) error {
-	appError := th.Store.User().PermanentDelete(user.Id)
+	return th.Store.User().PermanentDelete(user.Id)
-	if appError != nil {
-		return errors.New(appError.Error())
-	}
-
-	return nil
 }
 
 func (th *SearchTestHelper) cleanAllUsers() error {
-	users, apperr := th.Store.User().GetAll()
+	users, err := th.Store.User().GetAll()
-	if apperr != nil {
+	if err != nil {
-		return apperr
+		return err
 	}
 
 	for _, u := range users {
@@ -241,9 +216,9 @@ func (th *SearchTestHelper) createBot(username, displayName, ownerID string) (*m
 		OwnerId:     ownerID,
 	}
 
-	user, apperr := th.Store.User().Save(model.UserFromBot(botModel))
+	user, err := th.Store.User().Save(model.UserFromBot(botModel))
-	if apperr != nil {
+	if err != nil {
-		return nil, errors.New(apperr.Error())
+		return nil, errors.New(err.Error())
 	}
 
 	botModel.UserId = user.Id
@@ -265,21 +240,21 @@ func (th *SearchTestHelper) deleteBot(botID string) error {
 }
 
 func (th *SearchTestHelper) createChannel(teamID, name, displayName, purpose, channelType string, deleted bool) (*model.Channel, error) {
-	channel, appError := th.Store.Channel().Save(&model.Channel{
+	channel, err := th.Store.Channel().Save(&model.Channel{
 		TeamId:      teamID,
 		DisplayName: displayName,
 		Name:        name,
 		Type:        channelType,
 		Purpose:     purpose,
 	}, 999)
-	if appError != nil {
+	if err != nil {
-		return nil, errors.New(appError.Error())
+		return nil, err
 	}
 
 	if deleted {
-		appError := th.Store.Channel().Delete(channel.Id, model.GetMillis())
+		err := th.Store.Channel().Delete(channel.Id, model.GetMillis())
-		if appError != nil {
+		if err != nil {
-			return nil, errors.New(appError.Error())
+			return nil, err
 		}
 	}
 
@@ -324,9 +299,9 @@ func (th *SearchTestHelper) createGroupChannel(teamID, displayName string, users
 		Type:        model.CHANNEL_GROUP,
 	}
 
-	channel, apperr := th.Store.Channel().Save(group, 10000)
+	channel, err := th.Store.Channel().Save(group, 10000)
-	if apperr != nil {
+	if err != nil {
-		return nil, errors.New(apperr.Error())
+		return nil, errors.New(err.Error())
 	}
 
 	for _, user := range users {
@@ -341,17 +316,12 @@ func (th *SearchTestHelper) createGroupChannel(teamID, displayName string, users
 }
 
 func (th *SearchTestHelper) deleteChannel(channel *model.Channel) error {
-	appError := th.Store.Channel().PermanentDeleteMembersByChannel(channel.Id)
+	err := th.Store.Channel().PermanentDeleteMembersByChannel(channel.Id)
-	if appError != nil {
-		return errors.New(appError.Error())
-	}
-
-	err := th.Store.Channel().PermanentDelete(channel.Id)
 	if err != nil {
 		return err
 	}
 
-	return nil
+	return th.Store.Channel().PermanentDelete(channel.Id)
 }
 
 func (th *SearchTestHelper) deleteChannels(channels []*model.Channel) error {
@@ -384,12 +354,7 @@ func (th *SearchTestHelper) createPost(userID, channelID, message, hashtags, pos
 		creationTime = createAt
 	}
 	postModel := th.createPostModel(userID, channelID, message, hashtags, postType, creationTime, pinned)
-	post, appError := th.Store.Post().Save(postModel)
+	return th.Store.Post().Save(postModel)
-	if appError != nil {
-		return nil, errors.New(appError.Error())
-	}
-
-	return post, nil
 }
 
 func (th *SearchTestHelper) createFileInfoModel(creatorID, postID, name, content, extension, mimeType string, createAt, size int64) *model.FileInfo {
@@ -414,23 +379,14 @@ func (th *SearchTestHelper) createFileInfo(creatorID, postID, name, content, ext
 		creationTime = createAt
 	}
 	fileInfoModel := th.createFileInfoModel(creatorID, postID, name, content, extension, mimeType, creationTime, size)
-	fileInfo, appError := th.Store.FileInfo().Save(fileInfoModel)
+	return th.Store.FileInfo().Save(fileInfoModel)
-	if appError != nil {
-		return nil, errors.New(appError.Error())
-	}
-
-	return fileInfo, nil
 }
 
 func (th *SearchTestHelper) createReply(userID, message, hashtags string, parent *model.Post, createAt int64, pinned bool) (*model.Post, error) {
 	replyModel := th.createPostModel(userID, parent.ChannelId, message, hashtags, parent.Type, createAt, pinned)
 	replyModel.ParentId = parent.Id
 	replyModel.RootId = parent.Id
-	reply, appError := th.Store.Post().Save(replyModel)
+	return th.Store.Post().Save(replyModel)
-	if appError != nil {
-		return nil, errors.New(appError.Error())
-	}
-	return reply, nil
 }
 
 func (th *SearchTestHelper) deleteUserPosts(userID string) error {

store/searchtest/user_layer.go

@@ -159,7 +159,7 @@ func TestSearchUserStore(t *testing.T, s store.Store, testEngine *SearchTestEngi
 		Store: s,
 	}
 	err := th.SetupBasicFixtures()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.CleanFixtures()
 	runTestSearch(t, testEngine, searchUserStoreTests, th)
 }
@@ -170,13 +170,13 @@ func testGetAllUsersInChannelWithEmptyTerm(t *testing.T, th *SearchTestHelper) {
 		Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
 	}
 	users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
 	th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
 
 	t.Run("Should be able to correctly honor limit when autocompleting", func(t *testing.T) {
 		result, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Len(t, result.InChannel, 1)
 		require.Len(t, result.OutOfChannel, 1)
 	})
@@ -184,7 +184,7 @@ func testGetAllUsersInChannelWithEmptyTerm(t *testing.T, th *SearchTestHelper) {
 	t.Run("Return all users in team", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
 	})
@@ -192,15 +192,15 @@ func testGetAllUsersInChannelWithEmptyTerm(t *testing.T, th *SearchTestHelper) {
 	t.Run("Return all users in teams even though some of them don't have a team associated", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		userAlternate, err := th.createUser("user-alternate", "user-alternate", "user", "alternate")
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer th.deleteUser(userAlternate)
 		userGuest, err := th.createGuest("user-guest", "user-guest", "user", "guest")
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer th.deleteUser(userGuest)
 
 		// In case teamId and channelId are empty our current logic goes through Search
 		users, err := th.Store.User().Search("", "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2, th.UserAnotherTeam,
 			userAlternate, userGuest}, users)
 	})
@@ -208,24 +208,24 @@ func testGetAllUsersInChannelWithEmptyTerm(t *testing.T, th *SearchTestHelper) {
 
 func testHonorChannelRestrictionsAutocompletingUsers(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("user-alternate", "user-alternate", "user", "alternate")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	guest, err := th.createGuest("guest", "guest", "guest", "one")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	err = th.addUserToTeams(guest, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(guest, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(guest)
 	t.Run("Autocomplete users with channel restrictions", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		options.ViewRestrictions = &model.ViewUsersRestrictions{Channels: []string{th.ChannelBasic.Id}}
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, userAlternate, guest}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
@@ -233,7 +233,7 @@ func testHonorChannelRestrictionsAutocompletingUsers(t *testing.T, th *SearchTes
 		options := createDefaultOptions(true, false, false)
 		options.ViewRestrictions = &model.ViewUsersRestrictions{Channels: []string{th.ChannelBasic.Id}}
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alt", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
@@ -241,7 +241,7 @@ func testHonorChannelRestrictionsAutocompletingUsers(t *testing.T, th *SearchTes
 		options := createDefaultOptions(true, false, false)
 		options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{}, Channels: []string{}}
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
@@ -249,7 +249,7 @@ func testHonorChannelRestrictionsAutocompletingUsers(t *testing.T, th *SearchTes
 		options := createDefaultOptions(true, false, false)
 		options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{}, Channels: []string{}}
 		users, err := th.Store.User().AutocompleteUsersInChannel("", th.ChannelBasic.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
@@ -258,7 +258,7 @@ func testHonorChannelRestrictionsAutocompletingUsers(t *testing.T, th *SearchTes
 		options.ViewRestrictions = &model.ViewUsersRestrictions{Channels: []string{th.ChannelBasic.Id}}
 		// In case teamId and channelId are empty our current logic goes through Search
 		users, err := th.Store.User().Search("", "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate, guest, th.User}, users)
 	})
 }
@@ -268,7 +268,7 @@ func testHonorTeamRestrictionsAutocompletingUsers(t *testing.T, th *SearchTestHe
 		options := createDefaultOptions(true, false, false)
 		options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{th.Team.Id}}
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
 	})
@@ -276,7 +276,7 @@ func testHonorTeamRestrictionsAutocompletingUsers(t *testing.T, th *SearchTestHe
 		options := createDefaultOptions(true, false, false)
 		options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{}, Channels: []string{}}
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
@@ -284,11 +284,11 @@ func testHonorTeamRestrictionsAutocompletingUsers(t *testing.T, th *SearchTestHe
 		options := createDefaultOptions(true, false, false)
 		options.ViewRestrictions = &model.ViewUsersRestrictions{Teams: []string{th.AnotherTeam.Id}}
 		users, err := th.Store.User().Search(th.Team.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users)
 
 		acusers, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, acusers.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, acusers.OutOfChannel)
 	})
@@ -298,7 +298,7 @@ func testShouldReturnNothingWithoutProperAccess(t *testing.T, th *SearchTestHelp
 		options := createDefaultOptions(true, false, false)
 		options.ListOfAllowedChannels = []string{th.ChannelBasic.Id}
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
@@ -306,351 +306,351 @@ func testShouldReturnNothingWithoutProperAccess(t *testing.T, th *SearchTestHelp
 		options := createDefaultOptions(true, false, false)
 		options.ListOfAllowedChannels = []string{}
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 }
 func testAutocompleteUserByUsername(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("alternateusername", "alternatenick", "user", "alternate")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	options := createDefaultOptions(false, false, false)
 	users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
 	th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
 }
 func testAutocompleteUserByFirstName(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("user-alternate", "user-alternate", "altfirstname", "lastname")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	t.Run("Should autocomplete users when the first name is unique", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "altfirstname", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should autocomplete users for in the channel and out of the channel with the same first name", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicfirstname", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
 	})
 }
 func testAutocompleteUserByLastName(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("user-alternate", "user-alternate", "firstname", "altlastname")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	t.Run("Should return results when the last name is unique", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "altlastname", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should return results for in the channel and out of the channel with the same last name", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basiclastname", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
 	})
 }
 func testAutocompleteUserByNickName(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("alternateusername", "alternatenickname", "firstname", "altlastname")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	t.Run("Should return results when the nickname is unique", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternatenickname", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should return users that share the same part of the nickname", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicnickname", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
 	})
 }
 func testAutocompleteUserByEmail(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("alternateusername", "alternatenickname", "firstname", "altlastname")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	userAlternate.Email = "useralt@test.email.com"
 	_, err = th.Store.User().Update(userAlternate, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	t.Run("Should autocomplete users when the email is unique", func(t *testing.T) {
 		options := createDefaultOptions(false, true, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "useralt@test.email.com", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should autocomplete users that share the same email user prefix", func(t *testing.T) {
 		options := createDefaultOptions(false, true, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "success_", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
 	})
 	t.Run("Should autocomplete users that share the same email domain", func(t *testing.T) {
 		options := createDefaultOptions(false, true, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "simulator.amazon.com", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
 	})
 	t.Run("Should search users when the email is unique", func(t *testing.T) {
 		options := createDefaultOptions(false, true, false)
 		users, err := th.Store.User().Search(th.Team.Id, "useralt@test.email.com", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
 	})
 	t.Run("Should search users that share the same email user prefix", func(t *testing.T) {
 		options := createDefaultOptions(false, true, false)
 		users, err := th.Store.User().Search(th.Team.Id, "success_", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users)
 	})
 	t.Run("Should search users that share the same email domain", func(t *testing.T) {
 		options := createDefaultOptions(false, true, false)
 		users, err := th.Store.User().Search(th.Team.Id, "simulator.amazon.com", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users)
 	})
 }
 func testShouldNotMatchSpecificQueriesEmail(t *testing.T, th *SearchTestHelper) {
 	options := createDefaultOptions(false, false, false)
 	users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "success_", options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.InChannel)
 	th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 }
 func testAutocompleteUserByUsernameWithDot(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("alternate.username", "alternatenickname", "firstname", "altlastname")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	t.Run("Should return results when searching for the whole username with Dot", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate.username", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should return results when searching for part of the username including the Dot", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, ".username", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should return results when searching for part of the username not including the Dot", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 }
 func testAutocompleteUserByUsernameWithUnderscore(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("alternate_username", "alternatenickname", "firstname", "altlastname")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	t.Run("Should return results when searching for the whole username with underscore", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate_username", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should return results when searching for part of the username including the underscore", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "_username", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should return results when searching for part of the username not including the underscore", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 }
 func testAutocompleteUserByUsernameWithHyphen(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("alternate-username", "alternatenickname", "firstname", "altlastname")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	t.Run("Should return results when searching for the whole username with hyphen", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate-username", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should return results when searching for part of the username including the hyphen", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "-username", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should return results when searching for part of the username not including the hyphen", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "username", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 }
 func testShouldEscapePercentageCharacter(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("alternateusername", "alternate%nickname", "firstname", "altlastname")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	t.Run("Should autocomplete users escaping percentage symbol", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate%", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should search users escaping percentage symbol", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().Search(th.Team.Id, "alternate%", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
 	})
 }
 func testShouldEscapeUnderscoreCharacter(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("alternate_username", "alternatenickname", "firstname", "altlastname")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	t.Run("Should autocomplete users escaping underscore symbol", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate_", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should search users escaping underscore symbol", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().Search(th.Team.Id, "alternate_", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
 	})
 }
 
 func testShouldBeAbleToSearchInactiveUsers(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("basicusernamealternate", "alternatenickname", "firstname", "altlastname")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	userAlternate.DeleteAt = model.GetMillis()
 	_, err = th.Store.User().Update(userAlternate, true)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	t.Run("Should autocomplete inactive users if we allow it", func(t *testing.T) {
 		options := createDefaultOptions(false, false, true)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
 	})
 	t.Run("Should search inactive users if we allow it", func(t *testing.T) {
 		options := createDefaultOptions(false, false, true)
 		users, err := th.Store.User().Search(th.Team.Id, "basicusername", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2, userAlternate}, users)
 	})
 	t.Run("Shouldn't autocomplete inactive users if we don't allow it", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "basicusername", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
 	})
 	t.Run("Shouldn't search inactive users if we don't allow it", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().Search(th.Team.Id, "basicusername", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2}, users)
 	})
 }
 
 func testShouldBeAbleToSearchFilteringByRole(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("basicusernamealternate", "alternatenickname", "firstname", "altlastname")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	userAlternate.Roles = "system_admin system_user"
 	_, err = th.Store.User().Update(userAlternate, true)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	userAlternate2, err := th.createUser("basicusernamealternate2", "alternatenickname2", "firstname2", "altlastname2")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	userAlternate2.Roles = "system_user"
 	_, err = th.Store.User().Update(userAlternate2, true)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate2)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	err = th.addUserToTeams(userAlternate2, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	t.Run("Should autocomplete users filtering by roles", func(t *testing.T) {
 		options := createDefaultOptions(false, false, true)
 		options.Role = "system_admin"
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
@@ -658,7 +658,7 @@ func testShouldBeAbleToSearchFilteringByRole(t *testing.T, th *SearchTestHelper)
 		options := createDefaultOptions(false, false, true)
 		options.Role = "system_admin"
 		users, err := th.Store.User().Search(th.Team.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
 	})
 }
@@ -667,14 +667,14 @@ func testShouldIgnoreLeadingAtSymbols(t *testing.T, th *SearchTestHelper) {
 	t.Run("Should autocomplete ignoring the @ symbol at the beginning", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "@basicusername", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
 	})
 	t.Run("Should search ignoring the @ symbol at the beginning", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().Search(th.Team.Id, "@basicusername", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2}, users)
 	})
 }
@@ -682,31 +682,31 @@ func testShouldIgnoreLeadingAtSymbols(t *testing.T, th *SearchTestHelper) {
 func testSearchUsersShouldBeCaseInsensitive(t *testing.T, th *SearchTestHelper) {
 	options := createDefaultOptions(false, false, false)
 	users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "BaSiCUsErNaMe", options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users.InChannel)
 	th.assertUsersMatchInAnyOrder(t, []*model.User{th.User2}, users.OutOfChannel)
 }
 
 func testSearchOneTwoCharUsersnameAndFirstLastNames(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("ho", "alternatenickname", "zi", "k")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	t.Run("Should support two characters in the full name", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "zi", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should support two characters in the username", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "ho", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
@@ -714,24 +714,24 @@ func testSearchOneTwoCharUsersnameAndFirstLastNames(t *testing.T, th *SearchTest
 
 func testShouldSupportKoreanCharacters(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("alternate-username", "alternate-nickname", "서강준", "안신원")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	t.Run("Should support hanja korean characters", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "서강준", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
 	t.Run("Should support hangul korean characters", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "안신원", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 	})
@@ -739,15 +739,15 @@ func testShouldSupportKoreanCharacters(t *testing.T, th *SearchTestHelper) {
 
 func testSearchWithHyphenAtTheEndOfTheTerm(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("alternate-username", "alternate-nickname", "altfirst", "altlast")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	options := createDefaultOptions(true, false, false)
 	users, err := th.Store.User().AutocompleteUsersInChannel(th.Team.Id, th.ChannelBasic.Id, "alternate-", options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users.InChannel)
 	th.assertUsersMatchInAnyOrder(t, []*model.User{}, users.OutOfChannel)
 }
@@ -756,39 +756,39 @@ func testSearchUsersInTeam(t *testing.T, th *SearchTestHelper) {
 	t.Run("Should return all the team users", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().Search(th.Team.Id, "", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2}, users)
 	})
 	t.Run("Should return all the team users with no team id", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().Search("", "basicusername", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2, th.UserAnotherTeam}, users)
 	})
 	t.Run("Should return all the team users filtered by username", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().Search(th.Team.Id, "basicusername1", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users)
 	})
 	t.Run("Should not return spurious results", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().Search(th.Team.Id, "falseuser", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users)
 	})
 	t.Run("Should return all the team users filtered by username and with channel restrictions", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		options.ViewRestrictions = &model.ViewUsersRestrictions{Channels: []string{th.ChannelBasic.Id}}
 		users, err := th.Store.User().Search(th.Team.Id, "basicusername", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users)
 	})
 	t.Run("Should return all the team users filtered by username and with all channel restricted", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		options.ViewRestrictions = &model.ViewUsersRestrictions{Channels: []string{}}
 		users, err := th.Store.User().Search(th.Team.Id, "basicusername1", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users)
 	})
 	t.Run("Should honor the limit when searching users in team", func(t *testing.T) {
@@ -797,50 +797,50 @@ func testSearchUsersInTeam(t *testing.T, th *SearchTestHelper) {
 		}
 
 		users, err := th.Store.User().Search(th.Team.Id, "", optionsWithLimit)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Len(t, users, 1)
 	})
 }
 
 func testSearchUsersInTeamUsernameWithDot(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("alternate.username", "altnickname", "altfirst", "altlast")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	options := createDefaultOptions(true, false, false)
 	users, err := th.Store.User().Search(th.Team.Id, "alternate.", options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
 }
 
 func testSearchUsersInTeamUsernameWithHyphen(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("alternate-username", "altnickname", "altfirst", "altlast")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	options := createDefaultOptions(true, false, false)
 	users, err := th.Store.User().Search(th.Team.Id, "alternate-", options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
 }
 
 func testSearchUsersInTeamUsernameWithUnderscore(t *testing.T, th *SearchTestHelper) {
 	userAlternate, err := th.createUser("alternate_username", "altnickname", "altfirst", "altlast")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer th.deleteUser(userAlternate)
 	err = th.addUserToTeams(userAlternate, []string{th.Team.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = th.addUserToChannels(userAlternate, []string{th.ChannelBasic.Id})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	options := createDefaultOptions(true, false, false)
 	users, err := th.Store.User().Search(th.Team.Id, "alternate_", options)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	th.assertUsersMatchInAnyOrder(t, []*model.User{userAlternate}, users)
 }
 
@@ -848,19 +848,19 @@ func testSearchUsersByFullName(t *testing.T, th *SearchTestHelper) {
 	t.Run("Should search users by full name", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		users, err := th.Store.User().Search(th.Team.Id, "basicfirstname", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User, th.User2}, users)
 	})
 	t.Run("Should search user by full name", func(t *testing.T) {
 		options := createDefaultOptions(true, false, false)
 		users, err := th.Store.User().Search(th.Team.Id, "basicfirstname1", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{th.User}, users)
 	})
 	t.Run("Should return empty when search by full name and is deactivated", func(t *testing.T) {
 		options := createDefaultOptions(false, false, false)
 		users, err := th.Store.User().Search(th.Team.Id, "basicfirstname1", options)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		th.assertUsersMatchInAnyOrder(t, []*model.User{}, users)
 	})
 }

store/sqlstore/channel_store.go

@@ -660,9 +660,9 @@ func (s SqlChannelStore) Update(channel *model.Channel) (*model.Channel, error)
 	}
 	defer finalizeTransaction(transaction)
 
-	updatedChannel, appErr := s.updateChannelT(transaction, channel)
+	updatedChannel, err := s.updateChannelT(transaction, channel)
-	if appErr != nil {
+	if err != nil {
-		return nil, appErr
+		return nil, err
 	}
 
 	// Additionally propagate the write to the PublicChannels table.

store/sqlstore/channel_store_test.go

@@ -34,7 +34,7 @@ func TestChannelSearchQuerySQLInjection(t *testing.T) {
 			opts := store.ChannelSearchOpts{}
 			builder := s.channelSearchQuery("'or'1'=sleep(3))); -- -", opts, false)
 			query, _, err := builder.ToSql()
-			require.Nil(t, err)
+			require.NoError(t, err)
 			assert.NotContains(t, query, "sleep")
 		})
 	}

store/sqlstore/integrity_test.go

@@ -350,7 +350,7 @@ func TestCheckIntegrity(t *testing.T) {
 			require.NotNil(t, results)
 			for result := range results {
 				require.IsType(t, model.IntegrityCheckResult{}, result)
-				require.Nil(t, result.Err)
+				require.NoError(t, result.Err)
 				switch data := result.Data.(type) {
 				case model.RelationalIntegrityCheckData:
 					require.Empty(t, data.Records)
@@ -371,7 +371,7 @@ func TestCheckParentChildIntegrity(t *testing.T) {
 				childIdAttr:  "NotValid",
 			}
 			result := checkParentChildIntegrity(store, config)
-			require.NotNil(t, result.Err)
+			require.Error(t, result.Err)
 			require.Empty(t, result.Data)
 		})
 	})
@@ -384,7 +384,7 @@ func TestCheckChannelsCommandWebhooksIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkChannelsCommandWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -393,7 +393,7 @@ func TestCheckChannelsCommandWebhooksIntegrity(t *testing.T) {
 			channelId := model.NewId()
 			cwh := createCommandWebhook(ss, model.NewId(), model.NewId(), channelId)
 			result := checkChannelsCommandWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -412,7 +412,7 @@ func TestCheckChannelsChannelMemberHistoryIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkChannelsChannelMemberHistoryIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -423,7 +423,7 @@ func TestCheckChannelsChannelMemberHistoryIntegrity(t *testing.T) {
 			cmh := createChannelMemberHistory(ss, channel.Id, user.Id)
 			dbmap.Delete(channel)
 			result := checkChannelsChannelMemberHistoryIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -442,7 +442,7 @@ func TestCheckChannelsChannelMembersIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkChannelsChannelMembersIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -452,7 +452,7 @@ func TestCheckChannelsChannelMembersIntegrity(t *testing.T) {
 			member := createChannelMemberWithChannelId(ss, channel.Id)
 			dbmap.Delete(channel)
 			result := checkChannelsChannelMembersIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -470,7 +470,7 @@ func TestCheckChannelsIncomingWebhooksIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkChannelsIncomingWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -479,7 +479,7 @@ func TestCheckChannelsIncomingWebhooksIntegrity(t *testing.T) {
 			channelId := model.NewId()
 			wh := createIncomingWebhook(ss, model.NewId(), channelId, model.NewId())
 			result := checkChannelsIncomingWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -498,7 +498,7 @@ func TestCheckChannelsOutgoingWebhooksIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkChannelsOutgoingWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -509,7 +509,7 @@ func TestCheckChannelsOutgoingWebhooksIntegrity(t *testing.T) {
 			wh := createOutgoingWebhook(ss, model.NewId(), channelId, model.NewId())
 			dbmap.Delete(channel)
 			result := checkChannelsOutgoingWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -528,7 +528,7 @@ func TestCheckChannelsPostsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkChannelsPostsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -536,7 +536,7 @@ func TestCheckChannelsPostsIntegrity(t *testing.T) {
 		t.Run("should generate a report with one record", func(t *testing.T) {
 			post := createPostWithChannelId(ss, model.NewId())
 			result := checkChannelsPostsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -555,7 +555,7 @@ func TestCheckCommandsCommandWebhooksIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkCommandsCommandWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -564,7 +564,7 @@ func TestCheckCommandsCommandWebhooksIntegrity(t *testing.T) {
 			commandId := model.NewId()
 			cwh := createCommandWebhook(ss, commandId, model.NewId(), model.NewId())
 			result := checkCommandsCommandWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -583,7 +583,7 @@ func TestCheckPostsFileInfoIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkPostsFileInfoIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -592,7 +592,7 @@ func TestCheckPostsFileInfoIntegrity(t *testing.T) {
 			postId := model.NewId()
 			info := createFileInfo(ss, postId, model.NewId())
 			result := checkPostsFileInfoIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -611,7 +611,7 @@ func TestCheckPostsPostsParentIdIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkPostsPostsParentIdIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -621,7 +621,7 @@ func TestCheckPostsPostsParentIdIntegrity(t *testing.T) {
 			parent := createPost(ss, model.NewId(), model.NewId(), root.Id, root.Id)
 			post := createPost(ss, model.NewId(), model.NewId(), root.Id, parent.Id)
 			result := checkPostsPostsParentIdIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 			dbmap.Delete(parent)
@@ -636,7 +636,7 @@ func TestCheckPostsPostsParentIdIntegrity(t *testing.T) {
 			post := createPost(ss, model.NewId(), model.NewId(), root.Id, parent.Id)
 			dbmap.Delete(parent)
 			result := checkPostsPostsParentIdIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -656,7 +656,7 @@ func TestCheckPostsPostsRootIdIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkPostsPostsRootIdIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -667,7 +667,7 @@ func TestCheckPostsPostsRootIdIntegrity(t *testing.T) {
 			post := createPost(ss, model.NewId(), model.NewId(), root.Id, root.Id)
 			dbmap.Delete(root)
 			result := checkPostsPostsRootIdIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -686,7 +686,7 @@ func TestCheckPostsReactionsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkPostsReactionsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -695,7 +695,7 @@ func TestCheckPostsReactionsIntegrity(t *testing.T) {
 			postId := model.NewId()
 			reaction := createReaction(ss, model.NewId(), postId)
 			result := checkPostsReactionsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -713,7 +713,7 @@ func TestCheckSchemesChannelsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkSchemesChannelsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -725,7 +725,7 @@ func TestCheckSchemesChannelsIntegrity(t *testing.T) {
 			channel := createChannelWithSchemeId(ss, &schemeId)
 			dbmap.Delete(scheme)
 			result := checkSchemesChannelsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -744,7 +744,7 @@ func TestCheckSchemesTeamsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkSchemesTeamsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -756,7 +756,7 @@ func TestCheckSchemesTeamsIntegrity(t *testing.T) {
 			team := createTeamWithSchemeId(ss, &schemeId)
 			dbmap.Delete(scheme)
 			result := checkSchemesTeamsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -775,7 +775,7 @@ func TestCheckSessionsAuditsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkSessionsAuditsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -787,7 +787,7 @@ func TestCheckSessionsAuditsIntegrity(t *testing.T) {
 			audit := createAudit(ss, userId, sessionId)
 			dbmap.Delete(session)
 			result := checkSessionsAuditsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -806,7 +806,7 @@ func TestCheckTeamsChannelsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkTeamsChannelsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -814,7 +814,7 @@ func TestCheckTeamsChannelsIntegrity(t *testing.T) {
 		t.Run("should generate a report with one record", func(t *testing.T) {
 			channel := createChannelWithTeamId(ss, model.NewId())
 			result := checkTeamsChannelsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -832,7 +832,7 @@ func TestCheckTeamsChannelsIntegrity(t *testing.T) {
 			require.NoError(t, err)
 			require.NotNil(t, direct)
 			result := checkTeamsChannelsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -855,7 +855,7 @@ func TestCheckTeamsChannelsIntegrity(t *testing.T) {
 			_, err = dbmap.Exec(`UPDATE Channels SET TeamId = 'test' WHERE Id = '` + direct.Id + `'`)
 			require.NoError(t, err)
 			result := checkTeamsChannelsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 2)
 			require.Equal(t, model.OrphanedRecord{
@@ -882,7 +882,7 @@ func TestCheckTeamsCommandsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkTeamsCommandsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -891,7 +891,7 @@ func TestCheckTeamsCommandsIntegrity(t *testing.T) {
 			teamId := model.NewId()
 			cmd := createCommand(ss, model.NewId(), teamId)
 			result := checkTeamsCommandsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -910,7 +910,7 @@ func TestCheckTeamsIncomingWebhooksIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkTeamsIncomingWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -919,7 +919,7 @@ func TestCheckTeamsIncomingWebhooksIntegrity(t *testing.T) {
 			teamId := model.NewId()
 			wh := createIncomingWebhook(ss, model.NewId(), model.NewId(), teamId)
 			result := checkTeamsIncomingWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -938,7 +938,7 @@ func TestCheckTeamsOutgoingWebhooksIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkTeamsOutgoingWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -947,7 +947,7 @@ func TestCheckTeamsOutgoingWebhooksIntegrity(t *testing.T) {
 			teamId := model.NewId()
 			wh := createOutgoingWebhook(ss, model.NewId(), model.NewId(), teamId)
 			result := checkTeamsOutgoingWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -966,7 +966,7 @@ func TestCheckTeamsTeamMembersIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkTeamsTeamMembersIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -976,7 +976,7 @@ func TestCheckTeamsTeamMembersIntegrity(t *testing.T) {
 			member := createTeamMember(ss, team.Id, model.NewId())
 			dbmap.Delete(team)
 			result := checkTeamsTeamMembersIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -994,7 +994,7 @@ func TestCheckUsersAuditsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersAuditsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1005,7 +1005,7 @@ func TestCheckUsersAuditsIntegrity(t *testing.T) {
 			audit := createAudit(ss, userId, model.NewId())
 			dbmap.Delete(user)
 			result := checkUsersAuditsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1024,7 +1024,7 @@ func TestCheckUsersCommandWebhooksIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersCommandWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1033,7 +1033,7 @@ func TestCheckUsersCommandWebhooksIntegrity(t *testing.T) {
 			userId := model.NewId()
 			cwh := createCommandWebhook(ss, model.NewId(), userId, model.NewId())
 			result := checkUsersCommandWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1052,7 +1052,7 @@ func TestCheckUsersChannelsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersChannelsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1060,7 +1060,7 @@ func TestCheckUsersChannelsIntegrity(t *testing.T) {
 		t.Run("should generate a report with one record", func(t *testing.T) {
 			channel := createChannelWithCreatorId(ss, model.NewId())
 			result := checkUsersChannelsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1079,7 +1079,7 @@ func TestCheckUsersChannelMemberHistoryIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersChannelMemberHistoryIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1090,7 +1090,7 @@ func TestCheckUsersChannelMemberHistoryIntegrity(t *testing.T) {
 			cmh := createChannelMemberHistory(ss, channel.Id, user.Id)
 			dbmap.Delete(user)
 			result := checkUsersChannelMemberHistoryIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1109,7 +1109,7 @@ func TestCheckUsersChannelMembersIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersChannelMembersIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1120,7 +1120,7 @@ func TestCheckUsersChannelMembersIntegrity(t *testing.T) {
 			member := createChannelMember(ss, channel.Id, user.Id)
 			dbmap.Delete(user)
 			result := checkUsersChannelMembersIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1139,7 +1139,7 @@ func TestCheckUsersCommandsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersCommandsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1148,7 +1148,7 @@ func TestCheckUsersCommandsIntegrity(t *testing.T) {
 			userId := model.NewId()
 			cmd := createCommand(ss, userId, model.NewId())
 			result := checkUsersCommandsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1167,7 +1167,7 @@ func TestCheckUsersCompliancesIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersCompliancesIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1178,7 +1178,7 @@ func TestCheckUsersCompliancesIntegrity(t *testing.T) {
 			compliance := createCompliance(ss, userId)
 			dbmap.Delete(user)
 			result := checkUsersCompliancesIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1197,7 +1197,7 @@ func TestCheckUsersEmojiIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersEmojiIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1208,7 +1208,7 @@ func TestCheckUsersEmojiIntegrity(t *testing.T) {
 			emoji := createEmoji(ss, userId)
 			dbmap.Delete(user)
 			result := checkUsersEmojiIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1227,7 +1227,7 @@ func TestCheckUsersFileInfoIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersFileInfoIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1238,7 +1238,7 @@ func TestCheckUsersFileInfoIntegrity(t *testing.T) {
 			info := createFileInfo(ss, model.NewId(), userId)
 			dbmap.Delete(user)
 			result := checkUsersFileInfoIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1257,7 +1257,7 @@ func TestCheckUsersIncomingWebhooksIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersIncomingWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1266,7 +1266,7 @@ func TestCheckUsersIncomingWebhooksIntegrity(t *testing.T) {
 			userId := model.NewId()
 			wh := createIncomingWebhook(ss, userId, model.NewId(), model.NewId())
 			result := checkUsersIncomingWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1285,7 +1285,7 @@ func TestCheckUsersOAuthAccessDataIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersOAuthAccessDataIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1296,7 +1296,7 @@ func TestCheckUsersOAuthAccessDataIntegrity(t *testing.T) {
 			ad := createOAuthAccessData(ss, userId)
 			dbmap.Delete(user)
 			result := checkUsersOAuthAccessDataIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1315,7 +1315,7 @@ func TestCheckUsersOAuthAppsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersOAuthAppsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1326,7 +1326,7 @@ func TestCheckUsersOAuthAppsIntegrity(t *testing.T) {
 			app := createOAuthApp(ss, userId)
 			dbmap.Delete(user)
 			result := checkUsersOAuthAppsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1345,7 +1345,7 @@ func TestCheckUsersOAuthAuthDataIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersOAuthAuthDataIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1356,7 +1356,7 @@ func TestCheckUsersOAuthAuthDataIntegrity(t *testing.T) {
 			ad := createOAuthAuthData(ss, userId)
 			dbmap.Delete(user)
 			result := checkUsersOAuthAuthDataIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1375,7 +1375,7 @@ func TestCheckUsersOutgoingWebhooksIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersOutgoingWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1384,7 +1384,7 @@ func TestCheckUsersOutgoingWebhooksIntegrity(t *testing.T) {
 			userId := model.NewId()
 			wh := createOutgoingWebhook(ss, userId, model.NewId(), model.NewId())
 			result := checkUsersOutgoingWebhooksIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1403,7 +1403,7 @@ func TestCheckUsersPostsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersPostsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1411,7 +1411,7 @@ func TestCheckUsersPostsIntegrity(t *testing.T) {
 		t.Run("should generate a report with one record", func(t *testing.T) {
 			post := createPostWithUserId(ss, model.NewId())
 			result := checkUsersPostsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1430,7 +1430,7 @@ func TestCheckUsersPreferencesIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersPreferencesIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1442,7 +1442,7 @@ func TestCheckUsersPreferencesIntegrity(t *testing.T) {
 			preferences := createPreferences(ss, userId)
 			require.NotNil(t, preferences)
 			result := checkUsersPreferencesIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 			dbmap.Exec(`DELETE FROM Preferences`)
@@ -1457,7 +1457,7 @@ func TestCheckUsersPreferencesIntegrity(t *testing.T) {
 			require.NotNil(t, preferences)
 			dbmap.Delete(user)
 			result := checkUsersPreferencesIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1476,7 +1476,7 @@ func TestCheckUsersReactionsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersReactionsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1487,7 +1487,7 @@ func TestCheckUsersReactionsIntegrity(t *testing.T) {
 			reaction := createReaction(ss, user.Id, model.NewId())
 			dbmap.Delete(user)
 			result := checkUsersReactionsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1505,7 +1505,7 @@ func TestCheckUsersSessionsIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersSessionsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1514,7 +1514,7 @@ func TestCheckUsersSessionsIntegrity(t *testing.T) {
 			userId := model.NewId()
 			session := createSession(ss, userId)
 			result := checkUsersSessionsIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1533,7 +1533,7 @@ func TestCheckUsersStatusIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersStatusIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1544,7 +1544,7 @@ func TestCheckUsersStatusIntegrity(t *testing.T) {
 			status := createStatus(ss, user.Id)
 			dbmap.Delete(user)
 			result := checkUsersStatusIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1562,7 +1562,7 @@ func TestCheckUsersTeamMembersIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersTeamMembersIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1573,7 +1573,7 @@ func TestCheckUsersTeamMembersIntegrity(t *testing.T) {
 			member := createTeamMember(ss, team.Id, user.Id)
 			dbmap.Delete(user)
 			result := checkUsersTeamMembersIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{
@@ -1592,7 +1592,7 @@ func TestCheckUsersUserAccessTokensIntegrity(t *testing.T) {
 
 		t.Run("should generate a report with no records", func(t *testing.T) {
 			result := checkUsersUserAccessTokensIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Empty(t, data.Records)
 		})
@@ -1603,7 +1603,7 @@ func TestCheckUsersUserAccessTokensIntegrity(t *testing.T) {
 			uat := createUserAccessToken(ss, user.Id)
 			dbmap.Delete(user)
 			result := checkUsersUserAccessTokensIntegrity(store)
-			require.Nil(t, result.Err)
+			require.NoError(t, result.Err)
 			data := result.Data.(model.RelationalIntegrityCheckData)
 			require.Len(t, data.Records, 1)
 			require.Equal(t, model.OrphanedRecord{

store/sqlstore/preference_store_test.go

@@ -53,7 +53,7 @@ func TestDeleteUnusedFeatures(t *testing.T) {
 		}
 
 		err := ss.Preference().Save(&features)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		ss.Preference().(*SqlPreferenceStore).deleteUnusedFeatures()
 
@@ -63,7 +63,7 @@ func TestDeleteUnusedFeatures(t *testing.T) {
                     WHERE Category = :Category
                     AND Value = :Val
                     AND Name LIKE '`+store.FeatureTogglePrefix+`%'`, map[string]interface{}{"Category": model.PREFERENCE_CATEGORY_ADVANCED_SETTINGS, "Val": "false"}); err != nil {
-			require.Nil(t, err)
+			require.NoError(t, err)
 		} else if val != 0 {
 			require.Fail(t, "Found %d features with value 'false', expected all to be deleted", val)
 		}
@@ -74,7 +74,7 @@ func TestDeleteUnusedFeatures(t *testing.T) {
                     WHERE Category = :Category
                     AND Value = :Val
                     AND Name LIKE '`+store.FeatureTogglePrefix+`%'`, map[string]interface{}{"Category": model.PREFERENCE_CATEGORY_ADVANCED_SETTINGS, "Val": "true"}); err != nil {
-			require.Nil(t, err)
+			require.NoError(t, err)
 		} else if val == 0 {
 			require.Fail(t, "Found %d features with value 'true', expected to find at least %d features", val, 2)
 		}

store/sqlstore/scheme_store.go

@@ -85,9 +85,9 @@ func (s *SqlSchemeStore) createScheme(scheme *model.Scheme, transaction *gorp.Tr
 	// Fetch the default system scheme roles to populate default permissions.
 	defaultRoleNames := []string{model.TEAM_ADMIN_ROLE_ID, model.TEAM_USER_ROLE_ID, model.TEAM_GUEST_ROLE_ID, model.CHANNEL_ADMIN_ROLE_ID, model.CHANNEL_USER_ROLE_ID, model.CHANNEL_GUEST_ROLE_ID}
 	defaultRoles := make(map[string]*model.Role)
-	roles, appErr := s.SqlStore.Role().GetByNames(defaultRoleNames)
+	roles, err := s.SqlStore.Role().GetByNames(defaultRoleNames)
-	if appErr != nil {
+	if err != nil {
-		return nil, appErr
+		return nil, err
 	}
 
 	for _, role := range roles {

store/sqlstore/session_store.go

@@ -249,9 +249,9 @@ func (me SqlSessionStore) UpdateDeviceId(id string, deviceId string, expiresAt i
 }
 
 func (me SqlSessionStore) UpdateProps(session *model.Session) error {
-	oldSession, appErr := me.Get(session.Id)
+	oldSession, err := me.Get(session.Id)
-	if appErr != nil {
+	if err != nil {
-		return appErr
+		return err
 	}
 	oldSession.Props = session.Props
 

store/sqlstore/store_test.go

@@ -371,7 +371,7 @@ func TestGetDbVersion(t *testing.T) {
 			store := New(*settings, nil)
 
 			version, err := store.GetDbVersion(false)
-			require.Nil(t, err)
+			require.NoError(t, err)
 			require.Regexp(t, regexp.MustCompile(`\d+\.\d+(\.\d+)?`), version)
 		})
 	}

store/sqlstore/upgrade_test.go

@@ -87,7 +87,7 @@ func TestSaveSchemaVersion(t *testing.T) {
 		t.Run("set earliest version", func(t *testing.T) {
 			saveSchemaVersion(sqlStore, Version300)
 			props, err := ss.System().Get()
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			require.Equal(t, Version300, props["Version"])
 			require.Equal(t, Version300, sqlStore.GetCurrentSchemaVersion())
@@ -96,7 +96,7 @@ func TestSaveSchemaVersion(t *testing.T) {
 		t.Run("set current version", func(t *testing.T) {
 			saveSchemaVersion(sqlStore, CurrentSchemaVersion)
 			props, err := ss.System().Get()
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			require.Equal(t, CurrentSchemaVersion, props["Version"])
 			require.Equal(t, CurrentSchemaVersion, sqlStore.GetCurrentSchemaVersion())

store/storetest/audit_store.go

@@ -20,32 +20,32 @@ func TestAuditStore(t *testing.T, ss store.Store) {
 
 func testAuditStore(t *testing.T, ss store.Store) {
 	audit := &model.Audit{UserId: model.NewId(), IpAddress: "ipaddress", Action: "Action"}
-	require.Nil(t, ss.Audit().Save(audit))
+	require.NoError(t, ss.Audit().Save(audit))
 	time.Sleep(100 * time.Millisecond)
-	require.Nil(t, ss.Audit().Save(audit))
+	require.NoError(t, ss.Audit().Save(audit))
 	time.Sleep(100 * time.Millisecond)
-	require.Nil(t, ss.Audit().Save(audit))
+	require.NoError(t, ss.Audit().Save(audit))
 	time.Sleep(100 * time.Millisecond)
 	audit.ExtraInfo = "extra"
 	time.Sleep(100 * time.Millisecond)
-	require.Nil(t, ss.Audit().Save(audit))
+	require.NoError(t, ss.Audit().Save(audit))
 
 	time.Sleep(100 * time.Millisecond)
 
 	audits, err := ss.Audit().Get(audit.UserId, 0, 100)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	assert.Len(t, audits, 4)
 
 	assert.Equal(t, "extra", audits[0].ExtraInfo)
 
 	audits, err = ss.Audit().Get("missing", 0, 100)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, audits)
 
 	audits, err = ss.Audit().Get("", 0, 100)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, audits, 4, "Failed to save and retrieve 4 audit logs")
 
-	require.Nil(t, ss.Audit().PermanentDeleteByUser(audit.UserId))
+	require.NoError(t, ss.Audit().PermanentDeleteByUser(audit.UserId))
 }

store/storetest/bot_store.go

@@ -15,11 +15,11 @@ import (
 
 func makeBotWithUser(t *testing.T, ss store.Store, bot *model.Bot) (*model.Bot, *model.User) {
 	user, err := ss.User().Save(model.UserFromBot(bot))
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	bot.UserId = user.Id
 	bot, nErr := ss.Bot().Save(bot)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	return bot, user
 }
@@ -41,9 +41,9 @@ func testBotStoreGet(t *testing.T, ss store.Store, s SqlStore) {
 	})
 	deletedBot.DeleteAt = 1
 	deletedBot, err := ss.Bot().Update(deletedBot)
-	require.Nil(t, err)
+	require.NoError(t, err)
-	defer func() { require.Nil(t, ss.Bot().PermanentDelete(deletedBot.UserId)) }()
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(deletedBot.UserId)) }()
-	defer func() { require.Nil(t, ss.User().PermanentDelete(deletedBot.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(deletedBot.UserId)) }()
 
 	permanentlyDeletedBot, _ := makeBotWithUser(t, ss, &model.Bot{
 		Username:       "permanently_deleted_bot",
@@ -52,8 +52,8 @@ func testBotStoreGet(t *testing.T, ss store.Store, s SqlStore) {
 		LastIconUpdate: model.GetMillis(),
 		DeleteAt:       0,
 	})
-	require.Nil(t, ss.Bot().PermanentDelete(permanentlyDeletedBot.UserId))
+	require.NoError(t, ss.Bot().PermanentDelete(permanentlyDeletedBot.UserId))
-	defer func() { require.Nil(t, ss.User().PermanentDelete(permanentlyDeletedBot.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(permanentlyDeletedBot.UserId)) }()
 
 	b1, _ := makeBotWithUser(t, ss, &model.Bot{
 		Username:       "b1",
@@ -61,8 +61,8 @@ func testBotStoreGet(t *testing.T, ss store.Store, s SqlStore) {
 		OwnerId:        model.NewId(),
 		LastIconUpdate: model.GetMillis(),
 	})
-	defer func() { require.Nil(t, ss.Bot().PermanentDelete(b1.UserId)) }()
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b1.UserId)) }()
-	defer func() { require.Nil(t, ss.User().PermanentDelete(b1.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(b1.UserId)) }()
 
 	b2, _ := makeBotWithUser(t, ss, &model.Bot{
 		Username:       "b2",
@@ -70,8 +70,8 @@ func testBotStoreGet(t *testing.T, ss store.Store, s SqlStore) {
 		OwnerId:        model.NewId(),
 		LastIconUpdate: 0,
 	})
-	defer func() { require.Nil(t, ss.Bot().PermanentDelete(b2.UserId)) }()
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b2.UserId)) }()
-	defer func() { require.Nil(t, ss.User().PermanentDelete(b2.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(b2.UserId)) }()
 
 	// Artificially set b2.LastIconUpdate to NULL to verify handling of same.
 	_, sqlErr := s.GetMaster().Exec("UPDATE Bots SET LastIconUpdate = NULL WHERE UserId = '" + b2.UserId + "'")
@@ -79,40 +79,40 @@ func testBotStoreGet(t *testing.T, ss store.Store, s SqlStore) {
 
 	t.Run("get non-existent bot", func(t *testing.T) {
 		_, err := ss.Bot().Get("unknown", false)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		var nfErr *store.ErrNotFound
 		require.True(t, errors.As(err, &nfErr))
 	})
 
 	t.Run("get deleted bot", func(t *testing.T) {
 		_, err := ss.Bot().Get(deletedBot.UserId, false)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		var nfErr *store.ErrNotFound
 		require.True(t, errors.As(err, &nfErr))
 	})
 
 	t.Run("get deleted bot, include deleted", func(t *testing.T) {
 		bot, err := ss.Bot().Get(deletedBot.UserId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, deletedBot, bot)
 	})
 
 	t.Run("get permanently deleted bot", func(t *testing.T) {
 		_, err := ss.Bot().Get(permanentlyDeletedBot.UserId, false)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		var nfErr *store.ErrNotFound
 		require.True(t, errors.As(err, &nfErr))
 	})
 
 	t.Run("get bot 1", func(t *testing.T) {
 		bot, err := ss.Bot().Get(b1.UserId, false)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, b1, bot)
 	})
 
 	t.Run("get bot 2", func(t *testing.T) {
 		bot, err := ss.Bot().Get(b2.UserId, false)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, b2, bot)
 	})
 }
@@ -129,9 +129,9 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 	})
 	deletedBot.DeleteAt = 1
 	deletedBot, err := ss.Bot().Update(deletedBot)
-	require.Nil(t, err)
+	require.NoError(t, err)
-	defer func() { require.Nil(t, ss.Bot().PermanentDelete(deletedBot.UserId)) }()
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(deletedBot.UserId)) }()
-	defer func() { require.Nil(t, ss.User().PermanentDelete(deletedBot.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(deletedBot.UserId)) }()
 
 	permanentlyDeletedBot, _ := makeBotWithUser(t, ss, &model.Bot{
 		Username:       "permanently_deleted_bot",
@@ -140,8 +140,8 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 		LastIconUpdate: model.GetMillis(),
 		DeleteAt:       0,
 	})
-	require.Nil(t, ss.Bot().PermanentDelete(permanentlyDeletedBot.UserId))
+	require.NoError(t, ss.Bot().PermanentDelete(permanentlyDeletedBot.UserId))
-	defer func() { require.Nil(t, ss.User().PermanentDelete(permanentlyDeletedBot.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(permanentlyDeletedBot.UserId)) }()
 
 	b1, _ := makeBotWithUser(t, ss, &model.Bot{
 		Username:       "b1",
@@ -149,8 +149,8 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 		OwnerId:        OwnerId1,
 		LastIconUpdate: model.GetMillis(),
 	})
-	defer func() { require.Nil(t, ss.Bot().PermanentDelete(b1.UserId)) }()
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b1.UserId)) }()
-	defer func() { require.Nil(t, ss.User().PermanentDelete(b1.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(b1.UserId)) }()
 
 	b2, _ := makeBotWithUser(t, ss, &model.Bot{
 		Username:       "b2",
@@ -158,8 +158,8 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 		OwnerId:        OwnerId1,
 		LastIconUpdate: 0,
 	})
-	defer func() { require.Nil(t, ss.Bot().PermanentDelete(b2.UserId)) }()
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b2.UserId)) }()
-	defer func() { require.Nil(t, ss.User().PermanentDelete(b2.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(b2.UserId)) }()
 
 	// Artificially set b2.LastIconUpdate to NULL to verify handling of same.
 	_, sqlErr := s.GetMaster().Exec("UPDATE Bots SET LastIconUpdate = NULL WHERE UserId = '" + b2.UserId + "'")
@@ -167,7 +167,7 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 
 	t.Run("get original bots", func(t *testing.T) {
 		bot, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, []*model.Bot{
 			b1,
 			b2,
@@ -179,40 +179,40 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 		Description: "The third bot",
 		OwnerId:     OwnerId1,
 	})
-	defer func() { require.Nil(t, ss.Bot().PermanentDelete(b3.UserId)) }()
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b3.UserId)) }()
-	defer func() { require.Nil(t, ss.User().PermanentDelete(b3.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(b3.UserId)) }()
 
 	b4, _ := makeBotWithUser(t, ss, &model.Bot{
 		Username:    "b4",
 		Description: "The fourth bot",
 		OwnerId:     OwnerId2,
 	})
-	defer func() { require.Nil(t, ss.Bot().PermanentDelete(b4.UserId)) }()
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b4.UserId)) }()
-	defer func() { require.Nil(t, ss.User().PermanentDelete(b4.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(b4.UserId)) }()
 
 	deletedUser := model.User{
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
 	_, err1 := ss.User().Save(&deletedUser)
-	require.Nil(t, err1, "couldn't save user")
+	require.NoError(t, err1, "couldn't save user")
 
 	deletedUser.DeleteAt = model.GetMillis()
 	_, err2 := ss.User().Update(&deletedUser, true)
-	require.Nil(t, err2, "couldn't delete user")
+	require.NoError(t, err2, "couldn't delete user")
 
-	defer func() { require.Nil(t, ss.User().PermanentDelete(deletedUser.Id)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(deletedUser.Id)) }()
 	ob5, _ := makeBotWithUser(t, ss, &model.Bot{
 		Username:    "ob5",
 		Description: "Orphaned bot 5",
 		OwnerId:     deletedUser.Id,
 	})
-	defer func() { require.Nil(t, ss.Bot().PermanentDelete(b4.UserId)) }()
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b4.UserId)) }()
-	defer func() { require.Nil(t, ss.User().PermanentDelete(b4.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(b4.UserId)) }()
 
 	t.Run("get newly created bot stoo", func(t *testing.T) {
 		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, []*model.Bot{
 			b1,
 			b2,
@@ -224,7 +224,7 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 
 	t.Run("get orphaned", func(t *testing.T) {
 		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10, OnlyOrphaned: true})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, []*model.Bot{
 			ob5,
 		}, bots)
@@ -232,7 +232,7 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 
 	t.Run("get page=0, per_page=2", func(t *testing.T) {
 		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 2})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, []*model.Bot{
 			b1,
 			b2,
@@ -241,7 +241,7 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 
 	t.Run("get page=1, limit=2", func(t *testing.T) {
 		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 1, PerPage: 2})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, []*model.Bot{
 			b3,
 			b4,
@@ -250,13 +250,13 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 
 	t.Run("get page=5, perpage=1000", func(t *testing.T) {
 		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 5, PerPage: 1000})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, []*model.Bot{}, bots)
 	})
 
 	t.Run("get offset=0, limit=2, include deleted", func(t *testing.T) {
 		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 2, IncludeDeleted: true})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, []*model.Bot{
 			deletedBot,
 			b1,
@@ -265,7 +265,7 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 
 	t.Run("get offset=2, limit=2, include deleted", func(t *testing.T) {
 		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 1, PerPage: 2, IncludeDeleted: true})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, []*model.Bot{
 			b2,
 			b3,
@@ -274,7 +274,7 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 
 	t.Run("get offset=0, limit=10, creator id 1", func(t *testing.T) {
 		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10, OwnerId: OwnerId1})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, []*model.Bot{
 			b1,
 			b2,
@@ -284,7 +284,7 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 
 	t.Run("get offset=0, limit=10, creator id 2", func(t *testing.T) {
 		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10, OwnerId: OwnerId2})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, []*model.Bot{
 			b4,
 		}, bots)
@@ -292,7 +292,7 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 
 	t.Run("get offset=0, limit=10, include deleted, creator id 1", func(t *testing.T) {
 		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10, IncludeDeleted: true, OwnerId: OwnerId1})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, []*model.Bot{
 			deletedBot,
 			b1,
@@ -303,7 +303,7 @@ func testBotStoreGetAll(t *testing.T, ss store.Store, s SqlStore) {
 
 	t.Run("get offset=0, limit=10, include deleted, creator id 2", func(t *testing.T) {
 		bots, err := ss.Bot().GetAll(&model.BotGetOptions{Page: 0, PerPage: 10, IncludeDeleted: true, OwnerId: OwnerId2})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, []*model.Bot{
 			b4,
 		}, bots)
@@ -319,7 +319,7 @@ func testBotStoreSave(t *testing.T, ss store.Store) {
 		}
 
 		_, err := ss.Bot().Save(bot)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		var appErr *model.AppError
 		require.True(t, errors.As(err, &appErr))
 		// require.Equal(t, "model.bot.is_valid.username.app_error", err.Id)
@@ -333,13 +333,13 @@ func testBotStoreSave(t *testing.T, ss store.Store) {
 		}
 
 		user, err := ss.User().Save(model.UserFromBot(bot))
-		require.Nil(t, err)
+		require.NoError(t, err)
-		defer func() { require.Nil(t, ss.User().PermanentDelete(user.Id)) }()
+		defer func() { require.NoError(t, ss.User().PermanentDelete(user.Id)) }()
 		bot.UserId = user.Id
 
 		returnedNewBot, nErr := ss.Bot().Save(bot)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
-		defer func() { require.Nil(t, ss.Bot().PermanentDelete(bot.UserId)) }()
+		defer func() { require.NoError(t, ss.Bot().PermanentDelete(bot.UserId)) }()
 
 		// Verify the returned bot matches the saved bot, modulo expected changes
 		require.NotEqual(t, 0, returnedNewBot.CreateAt)
@@ -353,7 +353,7 @@ func testBotStoreSave(t *testing.T, ss store.Store) {
 
 		// Verify the actual bot in the database matches the saved bot.
 		actualNewBot, nErr := ss.Bot().Get(bot.UserId, false)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 		require.Equal(t, bot, actualNewBot)
 	})
 }
@@ -364,13 +364,13 @@ func testBotStoreUpdate(t *testing.T, ss store.Store) {
 			Username: "existing_bot",
 			OwnerId:  model.NewId(),
 		})
-		defer func() { require.Nil(t, ss.Bot().PermanentDelete(existingBot.UserId)) }()
+		defer func() { require.NoError(t, ss.Bot().PermanentDelete(existingBot.UserId)) }()
-		defer func() { require.Nil(t, ss.User().PermanentDelete(existingBot.UserId)) }()
+		defer func() { require.NoError(t, ss.User().PermanentDelete(existingBot.UserId)) }()
 
 		bot := existingBot.Clone()
 		bot.Username = "invalid username"
 		_, err := ss.Bot().Update(bot)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		var appErr *model.AppError
 		require.True(t, errors.As(err, &appErr))
 		require.Equal(t, "model.bot.is_valid.username.app_error", appErr.Id)
@@ -381,8 +381,8 @@ func testBotStoreUpdate(t *testing.T, ss store.Store) {
 			Username: "existing_bot",
 			OwnerId:  model.NewId(),
 		})
-		defer func() { require.Nil(t, ss.Bot().PermanentDelete(existingBot.UserId)) }()
+		defer func() { require.NoError(t, ss.Bot().PermanentDelete(existingBot.UserId)) }()
-		defer func() { require.Nil(t, ss.User().PermanentDelete(existingBot.UserId)) }()
+		defer func() { require.NoError(t, ss.User().PermanentDelete(existingBot.UserId)) }()
 
 		bot := existingBot.Clone()
 		bot.OwnerId = model.NewId()
@@ -393,7 +393,7 @@ func testBotStoreUpdate(t *testing.T, ss store.Store) {
 		bot.DeleteAt = 100000       // Allowed
 
 		returnedBot, err := ss.Bot().Update(bot)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		// Verify the returned bot matches the updated bot, modulo expected timestamp changes
 		require.Equal(t, existingBot.CreateAt, returnedBot.CreateAt)
@@ -407,7 +407,7 @@ func testBotStoreUpdate(t *testing.T, ss store.Store) {
 
 		// Verify the actual (now deleted) bot in the database
 		actualBot, err := ss.Bot().Get(bot.UserId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, bot, actualBot)
 	})
 
@@ -416,18 +416,18 @@ func testBotStoreUpdate(t *testing.T, ss store.Store) {
 			Username: "existing_bot",
 			OwnerId:  model.NewId(),
 		})
-		defer func() { require.Nil(t, ss.Bot().PermanentDelete(existingBot.UserId)) }()
+		defer func() { require.NoError(t, ss.Bot().PermanentDelete(existingBot.UserId)) }()
-		defer func() { require.Nil(t, ss.User().PermanentDelete(existingBot.UserId)) }()
+		defer func() { require.NoError(t, ss.User().PermanentDelete(existingBot.UserId)) }()
 
 		existingBot.DeleteAt = 100000
 		existingBot, err := ss.Bot().Update(existingBot)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		bot := existingBot.Clone()
 		bot.DeleteAt = 0
 
 		returnedBot, err := ss.Bot().Update(bot)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		// Verify the returned bot matches the updated bot, modulo expected timestamp changes
 		require.EqualValues(t, 0, returnedBot.DeleteAt)
@@ -435,7 +435,7 @@ func testBotStoreUpdate(t *testing.T, ss store.Store) {
 
 		// Verify the actual bot in the database
 		actualBot, err := ss.Bot().Get(bot.UserId, false)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, bot, actualBot)
 	})
 }
@@ -445,24 +445,24 @@ func testBotStorePermanentDelete(t *testing.T, ss store.Store) {
 		Username: "b1",
 		OwnerId:  model.NewId(),
 	})
-	defer func() { require.Nil(t, ss.Bot().PermanentDelete(b1.UserId)) }()
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b1.UserId)) }()
-	defer func() { require.Nil(t, ss.User().PermanentDelete(b1.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(b1.UserId)) }()
 
 	b2, _ := makeBotWithUser(t, ss, &model.Bot{
 		Username: "b2",
 		OwnerId:  model.NewId(),
 	})
-	defer func() { require.Nil(t, ss.Bot().PermanentDelete(b2.UserId)) }()
+	defer func() { require.NoError(t, ss.Bot().PermanentDelete(b2.UserId)) }()
-	defer func() { require.Nil(t, ss.User().PermanentDelete(b2.UserId)) }()
+	defer func() { require.NoError(t, ss.User().PermanentDelete(b2.UserId)) }()
 
 	t.Run("permanently delete a non-existent bot", func(t *testing.T) {
 		err := ss.Bot().PermanentDelete("unknown")
-		require.Nil(t, err)
+		require.NoError(t, err)
 	})
 
 	t.Run("permanently delete bot", func(t *testing.T) {
 		err := ss.Bot().PermanentDelete(b1.UserId)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		_, err = ss.Bot().Get(b1.UserId, false)
 		require.Error(t, err)

store/storetest/channel_member_history_store.go

@@ -32,7 +32,7 @@ func testLogJoinEvent(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_OPEN,
 	}
 	channel, err := ss.Channel().Save(&ch, -1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// and a test user
 	user := model.User{
@@ -41,12 +41,12 @@ func testLogJoinEvent(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	userPtr, err := ss.User().Save(&user)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	user = *userPtr
 
 	// log a join event
 	err = ss.ChannelMemberHistory().LogJoinEvent(user.Id, channel.Id, model.GetMillis())
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 }
 
 func testLogLeaveEvent(t *testing.T, ss store.Store) {
@@ -58,7 +58,7 @@ func testLogLeaveEvent(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_OPEN,
 	}
 	channel, err := ss.Channel().Save(&ch, -1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// and a test user
 	user := model.User{
@@ -67,15 +67,15 @@ func testLogLeaveEvent(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	userPtr, err := ss.User().Save(&user)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	user = *userPtr
 
 	// log a join event, followed by a leave event
 	err = ss.ChannelMemberHistory().LogJoinEvent(user.Id, channel.Id, model.GetMillis())
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	err = ss.ChannelMemberHistory().LogLeaveEvent(user.Id, channel.Id, model.GetMillis())
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 }
 
 func testGetUsersInChannelAtChannelMemberHistory(t *testing.T, ss store.Store) {
@@ -87,7 +87,7 @@ func testGetUsersInChannelAtChannelMemberHistory(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_OPEN,
 	}
 	channel, err := ss.Channel().Save(ch, -1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// and a test user
 	user := model.User{
@@ -96,7 +96,7 @@ func testGetUsersInChannelAtChannelMemberHistory(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	userPtr, err := ss.User().Save(&user)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	user = *userPtr
 
 	// the user was previously in the channel a long time ago, before the export period starts
@@ -105,24 +105,24 @@ func testGetUsersInChannelAtChannelMemberHistory(t *testing.T, ss store.Store) {
 	leaveTime := model.GetMillis() - 20000
 	joinTime := leaveTime - 10000
 	err = ss.ChannelMemberHistory().LogJoinEvent(user.Id, channel.Id, joinTime)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	err = ss.ChannelMemberHistory().LogLeaveEvent(user.Id, channel.Id, leaveTime)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// log a join event
 	leaveTime = model.GetMillis()
 	joinTime = leaveTime - 10000
 	err = ss.ChannelMemberHistory().LogJoinEvent(user.Id, channel.Id, joinTime)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// case 1: user joins and leaves the channel before the export period begins
 	channelMembers, err := ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime-500, joinTime-100, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, channelMembers)
 
 	// case 2: user joins the channel after the export period begins, but has not yet left the channel when the export period ends
 	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime-100, joinTime+500, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, channelMembers, 1)
 	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
 	assert.Equal(t, user.Id, channelMembers[0].UserId)
@@ -133,7 +133,7 @@ func testGetUsersInChannelAtChannelMemberHistory(t *testing.T, ss store.Store) {
 
 	// case 3: user joins the channel before the export period begins, but has not yet left the channel when the export period ends
 	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime+100, joinTime+500, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, channelMembers, 1)
 	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
 	assert.Equal(t, user.Id, channelMembers[0].UserId)
@@ -144,11 +144,11 @@ func testGetUsersInChannelAtChannelMemberHistory(t *testing.T, ss store.Store) {
 
 	// add a leave time for the user
 	err = ss.ChannelMemberHistory().LogLeaveEvent(user.Id, channel.Id, leaveTime)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// case 4: user joins the channel before the export period begins, but has not yet left the channel when the export period ends
 	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime+100, leaveTime-100, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, channelMembers, 1)
 	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
 	assert.Equal(t, user.Id, channelMembers[0].UserId)
@@ -159,7 +159,7 @@ func testGetUsersInChannelAtChannelMemberHistory(t *testing.T, ss store.Store) {
 
 	// case 5: user joins the channel after the export period begins, and leaves the channel before the export period ends
 	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime-100, leaveTime+100, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, channelMembers, 1)
 	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
 	assert.Equal(t, user.Id, channelMembers[0].UserId)
@@ -170,7 +170,7 @@ func testGetUsersInChannelAtChannelMemberHistory(t *testing.T, ss store.Store) {
 
 	// case 6: user has joined and left the channel long before the export period begins
 	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(leaveTime+100, leaveTime+200, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, channelMembers)
 }
 
@@ -183,7 +183,7 @@ func testGetUsersInChannelAtChannelMembers(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_OPEN,
 	}
 	channel, err := ss.Channel().Save(channel, -1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// and a test user
 	user := model.User{
@@ -192,7 +192,7 @@ func testGetUsersInChannelAtChannelMembers(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	userPtr, err := ss.User().Save(&user)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	user = *userPtr
 
 	// clear any existing ChannelMemberHistory data that might interfere with our test
@@ -200,7 +200,7 @@ func testGetUsersInChannelAtChannelMembers(t *testing.T, ss store.Store) {
 	for !tableDataTruncated {
 		var count int64
 		count, err = ss.ChannelMemberHistory().PermanentDeleteBatch(model.GetMillis(), 1000)
-		require.Nil(t, err, "Failed to truncate ChannelMemberHistory contents")
+		require.NoError(t, err, "Failed to truncate ChannelMemberHistory contents")
 		tableDataTruncated = count == int64(0)
 	}
 
@@ -213,14 +213,14 @@ func testGetUsersInChannelAtChannelMembers(t *testing.T, ss store.Store) {
 		UserId:      user.Id,
 		NotifyProps: model.GetDefaultChannelNotifyProps(),
 	})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// in every single case, the user will be included in the export, because ChannelMembers says they were in the channel at some point in
 	// the past, even though the time that they were actually in the channel doesn't necessarily overlap with the export period
 
 	// case 1: user joins and leaves the channel before the export period begins
 	channelMembers, err := ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime-500, joinTime-100, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, channelMembers, 1)
 	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
 	assert.Equal(t, user.Id, channelMembers[0].UserId)
@@ -231,7 +231,7 @@ func testGetUsersInChannelAtChannelMembers(t *testing.T, ss store.Store) {
 
 	// case 2: user joins the channel after the export period begins, but has not yet left the channel when the export period ends
 	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime-100, joinTime+500, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, channelMembers, 1)
 	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
 	assert.Equal(t, user.Id, channelMembers[0].UserId)
@@ -242,7 +242,7 @@ func testGetUsersInChannelAtChannelMembers(t *testing.T, ss store.Store) {
 
 	// case 3: user joins the channel before the export period begins, but has not yet left the channel when the export period ends
 	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime+100, joinTime+500, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, channelMembers, 1)
 	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
 	assert.Equal(t, user.Id, channelMembers[0].UserId)
@@ -253,7 +253,7 @@ func testGetUsersInChannelAtChannelMembers(t *testing.T, ss store.Store) {
 
 	// case 4: user joins the channel before the export period begins, but has not yet left the channel when the export period ends
 	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime+100, leaveTime-100, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, channelMembers, 1)
 	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
 	assert.Equal(t, user.Id, channelMembers[0].UserId)
@@ -264,7 +264,7 @@ func testGetUsersInChannelAtChannelMembers(t *testing.T, ss store.Store) {
 
 	// case 5: user joins the channel after the export period begins, and leaves the channel before the export period ends
 	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime-100, leaveTime+100, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, channelMembers, 1)
 	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
 	assert.Equal(t, user.Id, channelMembers[0].UserId)
@@ -275,7 +275,7 @@ func testGetUsersInChannelAtChannelMembers(t *testing.T, ss store.Store) {
 
 	// case 6: user has joined and left the channel long before the export period begins
 	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(leaveTime+100, leaveTime+200, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, channelMembers, 1)
 	assert.Equal(t, channel.Id, channelMembers[0].ChannelId)
 	assert.Equal(t, user.Id, channelMembers[0].UserId)
@@ -294,7 +294,7 @@ func testPermanentDeleteBatch(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_OPEN,
 	}
 	channel, err := ss.Channel().Save(channel, -1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// and two test users
 	user := model.User{
@@ -303,7 +303,7 @@ func testPermanentDeleteBatch(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	userPtr, err := ss.User().Save(&user)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	user = *userPtr
 
 	user2 := model.User{
@@ -312,34 +312,34 @@ func testPermanentDeleteBatch(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	user2Ptr, err := ss.User().Save(&user2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	user2 = *user2Ptr
 
 	// user1 joins and leaves the channel
 	leaveTime := model.GetMillis()
 	joinTime := leaveTime - 10000
 	err = ss.ChannelMemberHistory().LogJoinEvent(user.Id, channel.Id, joinTime)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	err = ss.ChannelMemberHistory().LogLeaveEvent(user.Id, channel.Id, leaveTime)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// user2 joins the channel but never leaves
 	err = ss.ChannelMemberHistory().LogJoinEvent(user2.Id, channel.Id, joinTime)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// in between the join time and the leave time, both users were members of the channel
 	channelMembers, err := ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime+10, leaveTime-10, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, channelMembers, 2)
 
 	// the permanent delete should delete at least one record
 	rowsDeleted, err := ss.ChannelMemberHistory().PermanentDeleteBatch(leaveTime, math.MaxInt64)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.NotEqual(t, int64(0), rowsDeleted)
 
 	// after the delete, there should be one less member in the channel
 	channelMembers, err = ss.ChannelMemberHistory().GetUsersInChannelDuring(joinTime+10, leaveTime-10, channel.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, channelMembers, 1)
 	assert.Equal(t, user2.Id, channelMembers[0].UserId)
 }

store/storetest/cluster_discovery_store.go

@@ -30,10 +30,10 @@ func testClusterDiscoveryStore(t *testing.T, ss store.Store) {
 	}
 
 	err := ss.ClusterDiscovery().Save(discovery)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	err = ss.ClusterDiscovery().Cleanup()
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testClusterDiscoveryStoreDelete(t *testing.T, ss store.Store) {
@@ -44,10 +44,10 @@ func testClusterDiscoveryStoreDelete(t *testing.T, ss store.Store) {
 	}
 
 	err := ss.ClusterDiscovery().Save(discovery)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.ClusterDiscovery().Delete(discovery)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testClusterDiscoveryStoreLastPing(t *testing.T, ss store.Store) {
@@ -58,20 +58,20 @@ func testClusterDiscoveryStoreLastPing(t *testing.T, ss store.Store) {
 	}
 
 	err := ss.ClusterDiscovery().Save(discovery)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	err = ss.ClusterDiscovery().SetLastPingAt(discovery)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	ttime := model.GetMillis()
 
 	time.Sleep(1 * time.Second)
 
 	err = ss.ClusterDiscovery().SetLastPingAt(discovery)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	list, err := ss.ClusterDiscovery().GetAll(discovery.Type, "cluster_name_lastPing")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, list, 1)
 
 	require.Less(t, int64(500), list[0].LastPingAt-ttime)
@@ -83,7 +83,7 @@ func testClusterDiscoveryStoreLastPing(t *testing.T, ss store.Store) {
 	}
 
 	err = ss.ClusterDiscovery().SetLastPingAt(discovery2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testClusterDiscoveryStoreExists(t *testing.T, ss store.Store) {
@@ -94,16 +94,16 @@ func testClusterDiscoveryStoreExists(t *testing.T, ss store.Store) {
 	}
 
 	err := ss.ClusterDiscovery().Save(discovery)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	val, err := ss.ClusterDiscovery().Exists(discovery)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.True(t, val)
 
 	discovery.ClusterName = "cluster_name_Exists2"
 
 	val, err = ss.ClusterDiscovery().Exists(discovery)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.False(t, val)
 }
 
@@ -115,14 +115,14 @@ func testClusterDiscoveryGetStore(t *testing.T, ss store.Store) {
 		Hostname:    "hostname1",
 		Type:        testType1,
 	}
-	require.Nil(t, ss.ClusterDiscovery().Save(discovery1))
+	require.NoError(t, ss.ClusterDiscovery().Save(discovery1))
 
 	discovery2 := &model.ClusterDiscovery{
 		ClusterName: "cluster_name",
 		Hostname:    "hostname2",
 		Type:        testType1,
 	}
-	require.Nil(t, ss.ClusterDiscovery().Save(discovery2))
+	require.NoError(t, ss.ClusterDiscovery().Save(discovery2))
 
 	discovery3 := &model.ClusterDiscovery{
 		ClusterName: "cluster_name",
@@ -131,7 +131,7 @@ func testClusterDiscoveryGetStore(t *testing.T, ss store.Store) {
 		CreateAt:    1,
 		LastPingAt:  1,
 	}
-	require.Nil(t, ss.ClusterDiscovery().Save(discovery3))
+	require.NoError(t, ss.ClusterDiscovery().Save(discovery3))
 
 	testType2 := model.NewId()
 
@@ -140,17 +140,17 @@ func testClusterDiscoveryGetStore(t *testing.T, ss store.Store) {
 		Hostname:    "hostname1",
 		Type:        testType2,
 	}
-	require.Nil(t, ss.ClusterDiscovery().Save(discovery4))
+	require.NoError(t, ss.ClusterDiscovery().Save(discovery4))
 
 	list, err := ss.ClusterDiscovery().GetAll(testType1, "cluster_name")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, list, 2)
 
 	list, err = ss.ClusterDiscovery().GetAll(testType2, "cluster_name")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, list, 1)
 
 	list, err = ss.ClusterDiscovery().GetAll(model.NewId(), "cluster_name")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, list)
 }

store/storetest/command_store.go

@@ -34,10 +34,10 @@ func testCommandStoreSave(t *testing.T, ss store.Store) {
 	o1.Trigger = "trigger"
 
 	_, nErr := ss.Command().Save(&o1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	_, err := ss.Command().Save(&o1)
-	require.NotNil(t, err, "shouldn't be able to update from save")
+	require.Error(t, err, "shouldn't be able to update from save")
 }
 
 func testCommandStoreGet(t *testing.T, ss store.Store) {
@@ -49,14 +49,14 @@ func testCommandStoreGet(t *testing.T, ss store.Store) {
 	o1.Trigger = "trigger"
 
 	o1, nErr := ss.Command().Save(o1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	r1, nErr := ss.Command().Get(o1.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	require.Equal(t, r1.CreateAt, o1.CreateAt, "invalid returned command")
 
 	_, err := ss.Command().Get("123")
-	require.NotNil(t, err)
+	require.Error(t, err)
 	var nfErr *store.ErrNotFound
 	require.True(t, errors.As(err, &nfErr))
 }
@@ -70,15 +70,15 @@ func testCommandStoreGetByTeam(t *testing.T, ss store.Store) {
 	o1.Trigger = "trigger"
 
 	o1, nErr := ss.Command().Save(o1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	r1, nErr := ss.Command().GetByTeam(o1.TeamId)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	require.NotEmpty(t, r1, "no command returned")
 	require.Equal(t, r1[0].CreateAt, o1.CreateAt, "invalid returned command")
 
 	result, nErr := ss.Command().GetByTeam("123")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	require.Empty(t, result, "no commands should have returned")
 }
 
@@ -98,21 +98,21 @@ func testCommandStoreGetByTrigger(t *testing.T, ss store.Store) {
 	o2.Trigger = "trigger1"
 
 	o1, nErr := ss.Command().Save(o1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	_, nErr = ss.Command().Save(o2)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	var r1 *model.Command
 	r1, nErr = ss.Command().GetByTrigger(o1.TeamId, o1.Trigger)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	require.Equal(t, r1.Id, o1.Id, "invalid returned command")
 
 	nErr = ss.Command().Delete(o1.Id, model.GetMillis())
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	_, err := ss.Command().GetByTrigger(o1.TeamId, o1.Trigger)
-	require.NotNil(t, err)
+	require.Error(t, err)
 	var nfErr *store.ErrNotFound
 	require.True(t, errors.As(err, &nfErr))
 }
@@ -126,17 +126,17 @@ func testCommandStoreDelete(t *testing.T, ss store.Store) {
 	o1.Trigger = "trigger"
 
 	o1, nErr := ss.Command().Save(o1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	r1, nErr := ss.Command().Get(o1.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	require.Equal(t, r1.CreateAt, o1.CreateAt, "invalid returned command")
 
 	nErr = ss.Command().Delete(o1.Id, model.GetMillis())
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	_, err := ss.Command().Get(o1.Id)
-	require.NotNil(t, err)
+	require.Error(t, err)
 	var nfErr *store.ErrNotFound
 	require.True(t, errors.As(err, &nfErr))
 }
@@ -150,17 +150,17 @@ func testCommandStoreDeleteByTeam(t *testing.T, ss store.Store) {
 	o1.Trigger = "trigger"
 
 	o1, nErr := ss.Command().Save(o1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	r1, nErr := ss.Command().Get(o1.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	require.Equal(t, r1.CreateAt, o1.CreateAt, "invalid returned command")
 
 	nErr = ss.Command().PermanentDeleteByTeam(o1.TeamId)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	_, err := ss.Command().Get(o1.Id)
-	require.NotNil(t, err)
+	require.Error(t, err)
 	var nfErr *store.ErrNotFound
 	require.True(t, errors.As(err, &nfErr))
 }
@@ -174,17 +174,17 @@ func testCommandStoreDeleteByUser(t *testing.T, ss store.Store) {
 	o1.Trigger = "trigger"
 
 	o1, nErr := ss.Command().Save(o1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	r1, nErr := ss.Command().Get(o1.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	require.Equal(t, r1.CreateAt, o1.CreateAt, "invalid returned command")
 
 	nErr = ss.Command().PermanentDeleteByUser(o1.CreatorId)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	_, err := ss.Command().Get(o1.Id)
-	require.NotNil(t, err)
+	require.Error(t, err)
 	var nfErr *store.ErrNotFound
 	require.True(t, errors.As(err, &nfErr))
 }
@@ -198,17 +198,17 @@ func testCommandStoreUpdate(t *testing.T, ss store.Store) {
 	o1.Trigger = "trigger"
 
 	o1, nErr := ss.Command().Save(o1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	o1.Token = model.NewId()
 
 	_, nErr = ss.Command().Update(o1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	o1.URL = "junk"
 
 	_, err := ss.Command().Update(o1)
-	require.NotNil(t, err)
+	require.Error(t, err)
 }
 
 func testCommandCount(t *testing.T, ss store.Store) {
@@ -220,13 +220,13 @@ func testCommandCount(t *testing.T, ss store.Store) {
 	o1.Trigger = "trigger"
 
 	o1, nErr := ss.Command().Save(o1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	r1, nErr := ss.Command().AnalyticsCommandCount("")
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	require.NotZero(t, r1, "should be at least 1 command")
 
 	r2, nErr := ss.Command().AnalyticsCommandCount(o1.TeamId)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	require.Equal(t, r2, int64(1), "should be 1 command")
 }

store/storetest/command_webhook_store.go

@@ -26,11 +26,11 @@ func testCommandWebhookStore(t *testing.T, ss store.Store) {
 	h1.UserId = model.NewId()
 	h1.ChannelId = model.NewId()
 	h1, err := cws.Save(h1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	var r1 *model.CommandWebhook
 	r1, nErr := cws.Get(h1.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Equal(t, *r1, *h1, "invalid returned webhook")
 
 	_, nErr = cws.Get("123")
@@ -43,25 +43,25 @@ func testCommandWebhookStore(t *testing.T, ss store.Store) {
 	h2.UserId = model.NewId()
 	h2.ChannelId = model.NewId()
 	h2, err = cws.Save(h2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, nErr = cws.Get(h2.Id)
-	require.NotNil(t, nErr, "Should have set the status as not found for expired webhook")
+	require.Error(t, nErr, "Should have set the status as not found for expired webhook")
 	require.True(t, errors.As(nErr, &nfErr), "Should have set the status as not found for expired webhook")
 
 	cws.Cleanup()
 
 	_, nErr = cws.Get(h1.Id)
-	require.Nil(t, nErr, "Should have no error getting unexpired webhook")
+	require.NoError(t, nErr, "Should have no error getting unexpired webhook")
 
 	_, nErr = cws.Get(h2.Id)
 	require.True(t, errors.As(nErr, &nfErr), "Should have set the status as not found for expired webhook")
 
 	nErr = cws.TryUse(h1.Id, 1)
-	require.Nil(t, nErr, "Should be able to use webhook once")
+	require.NoError(t, nErr, "Should be able to use webhook once")
 
 	nErr = cws.TryUse(h1.Id, 1)
-	require.NotNil(t, nErr, "Should be able to use webhook once")
+	require.Error(t, nErr, "Should be able to use webhook once")
 	var invErr *store.ErrInvalidInput
 	require.True(t, errors.As(nErr, &invErr), "Should be able to use webhook once")
 }

store/storetest/compliance_store.go

@@ -18,30 +18,30 @@ import (
 func cleanupStoreState(t *testing.T, ss store.Store) {
 	//remove existing users
 	allUsers, err := ss.User().GetAll()
-	require.Nilf(t, err, "error cleaning all test users: %v", err)
+	require.NoError(t, err, "error cleaning all test users", err)
 	for _, u := range allUsers {
 		err = ss.User().PermanentDelete(u.Id)
-		require.Nil(t, err, "failed cleaning up test user %s", u.Username)
+		require.NoError(t, err, "failed cleaning up test user %s", u.Username)
 
 		//remove all posts by this user
 		nErr := ss.Post().PermanentDeleteByUser(u.Id)
-		require.Nil(t, nErr, "failed cleaning all posts of test user %s", u.Username)
+		require.NoError(t, nErr, "failed cleaning all posts of test user %s", u.Username)
 	}
 
 	//remove existing channels
 	allChannels, nErr := ss.Channel().GetAllChannels(0, 100000, store.ChannelSearchOpts{IncludeDeleted: true})
-	require.Nilf(t, nErr, "error cleaning all test channels: %v", nErr)
+	require.NoError(t, nErr, "error cleaning all test channels", nErr)
 	for _, channel := range *allChannels {
 		nErr = ss.Channel().PermanentDelete(channel.Id)
-		require.Nil(t, nErr, "failed cleaning up test channel %s", channel.Id)
+		require.NoError(t, nErr, "failed cleaning up test channel %s", channel.Id)
 	}
 
 	//remove existing teams
 	allTeams, nErr := ss.Team().GetAll()
-	require.Nilf(t, nErr, "error cleaning all test teams: %v", nErr)
+	require.NoError(t, nErr, "error cleaning all test teams", nErr)
 	for _, team := range allTeams {
 		err := ss.Team().PermanentDelete(team.Id)
-		require.Nil(t, err, "failed cleaning up test team %s", team.Id)
+		require.NoError(t, err, "failed cleaning up test team %s", team.Id)
 	}
 }
 
@@ -62,12 +62,12 @@ func TestComplianceStore(t *testing.T, ss store.Store) {
 func testComplianceStore(t *testing.T, ss store.Store) {
 	compliance1 := &model.Compliance{Desc: "Audit for federal subpoena case #22443", UserId: model.NewId(), Status: model.COMPLIANCE_STATUS_FAILED, StartAt: model.GetMillis() - 1, EndAt: model.GetMillis() + 1, Type: model.COMPLIANCE_TYPE_ADHOC}
 	_, err := ss.Compliance().Save(compliance1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	time.Sleep(100 * time.Millisecond)
 
 	compliance2 := &model.Compliance{Desc: "Audit for federal subpoena case #11458", UserId: model.NewId(), Status: model.COMPLIANCE_STATUS_RUNNING, StartAt: model.GetMillis() - 1, EndAt: model.GetMillis() + 1, Type: model.COMPLIANCE_TYPE_ADHOC}
 	_, err = ss.Compliance().Save(compliance2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	time.Sleep(100 * time.Millisecond)
 
 	compliances, _ := ss.Compliance().GetAll(0, 1000)
@@ -77,7 +77,7 @@ func testComplianceStore(t *testing.T, ss store.Store) {
 
 	compliance2.Status = model.COMPLIANCE_STATUS_FAILED
 	_, err = ss.Compliance().Update(compliance2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	compliances, _ = ss.Compliance().GetAll(0, 1000)
 
@@ -105,23 +105,23 @@ func testComplianceExport(t *testing.T, ss store.Store) {
 	t1.Email = MakeEmail()
 	t1.Type = model.TEAM_OPEN
 	t1, err := ss.Team().Save(t1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	u1 := &model.User{}
 	u1.Email = MakeEmail()
 	u1.Username = model.NewId()
 	u1, err = ss.User().Save(u1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr := ss.Team().SaveMember(&model.TeamMember{TeamId: t1.Id, UserId: u1.Id}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	u2 := &model.User{}
 	u2.Email = MakeEmail()
 	u2.Username = model.NewId()
 	u2, err = ss.User().Save(u2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr = ss.Team().SaveMember(&model.TeamMember{TeamId: t1.Id, UserId: u2.Id}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	c1 := &model.Channel{}
 	c1.TeamId = t1.Id
@@ -129,7 +129,7 @@ func testComplianceExport(t *testing.T, ss store.Store) {
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
 	c1, nErr = ss.Channel().Save(c1, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	o1 := &model.Post{}
 	o1.ChannelId = c1.Id
@@ -137,7 +137,7 @@ func testComplianceExport(t *testing.T, ss store.Store) {
 	o1.CreateAt = model.GetMillis()
 	o1.Message = "zz" + model.NewId() + "b"
 	o1, nErr = ss.Post().Save(o1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	o1a := &model.Post{}
 	o1a.ChannelId = c1.Id
@@ -145,7 +145,7 @@ func testComplianceExport(t *testing.T, ss store.Store) {
 	o1a.CreateAt = o1.CreateAt + 10
 	o1a.Message = "zz" + model.NewId() + "b"
 	_, nErr = ss.Post().Save(o1a)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	o2 := &model.Post{}
 	o2.ChannelId = c1.Id
@@ -153,7 +153,7 @@ func testComplianceExport(t *testing.T, ss store.Store) {
 	o2.CreateAt = o1.CreateAt + 20
 	o2.Message = "zz" + model.NewId() + "b"
 	_, nErr = ss.Post().Save(o2)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	o2a := &model.Post{}
 	o2a.ChannelId = c1.Id
@@ -161,45 +161,45 @@ func testComplianceExport(t *testing.T, ss store.Store) {
 	o2a.CreateAt = o1.CreateAt + 30
 	o2a.Message = "zz" + model.NewId() + "b"
 	o2a, nErr = ss.Post().Save(o2a)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	time.Sleep(100 * time.Millisecond)
 
 	cr1 := &model.Compliance{Desc: "test" + model.NewId(), StartAt: o1.CreateAt - 1, EndAt: o2a.CreateAt + 1}
 	cposts, nErr := ss.Compliance().ComplianceExport(cr1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, cposts, 4)
 	assert.Equal(t, cposts[0].PostId, o1.Id)
 	assert.Equal(t, cposts[3].PostId, o2a.Id)
 
 	cr2 := &model.Compliance{Desc: "test" + model.NewId(), StartAt: o1.CreateAt - 1, EndAt: o2a.CreateAt + 1, Emails: u2.Email}
 	cposts, nErr = ss.Compliance().ComplianceExport(cr2)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, cposts, 1)
 	assert.Equal(t, cposts[0].PostId, o2a.Id)
 
 	cr3 := &model.Compliance{Desc: "test" + model.NewId(), StartAt: o1.CreateAt - 1, EndAt: o2a.CreateAt + 1, Emails: u2.Email + ", " + u1.Email}
 	cposts, nErr = ss.Compliance().ComplianceExport(cr3)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, cposts, 4)
 	assert.Equal(t, cposts[0].PostId, o1.Id)
 	assert.Equal(t, cposts[3].PostId, o2a.Id)
 
 	cr4 := &model.Compliance{Desc: "test" + model.NewId(), StartAt: o1.CreateAt - 1, EndAt: o2a.CreateAt + 1, Keywords: o2a.Message}
 	cposts, nErr = ss.Compliance().ComplianceExport(cr4)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, cposts, 1)
 	assert.Equal(t, cposts[0].PostId, o2a.Id)
 
 	cr5 := &model.Compliance{Desc: "test" + model.NewId(), StartAt: o1.CreateAt - 1, EndAt: o2a.CreateAt + 1, Keywords: o2a.Message + " " + o1.Message}
 	cposts, nErr = ss.Compliance().ComplianceExport(cr5)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, cposts, 2)
 	assert.Equal(t, cposts[0].PostId, o1.Id)
 
 	cr6 := &model.Compliance{Desc: "test" + model.NewId(), StartAt: o1.CreateAt - 1, EndAt: o2a.CreateAt + 1, Emails: u2.Email + ", " + u1.Email, Keywords: o2a.Message + " " + o1.Message}
 	cposts, nErr = ss.Compliance().ComplianceExport(cr6)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, cposts, 2)
 	assert.Equal(t, cposts[0].PostId, o1.Id)
 	assert.Equal(t, cposts[1].PostId, o2a.Id)
@@ -214,23 +214,23 @@ func testComplianceExportDirectMessages(t *testing.T, ss store.Store) {
 	t1.Email = MakeEmail()
 	t1.Type = model.TEAM_OPEN
 	t1, err := ss.Team().Save(t1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	u1 := &model.User{}
 	u1.Email = MakeEmail()
 	u1.Username = model.NewId()
 	u1, err = ss.User().Save(u1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr := ss.Team().SaveMember(&model.TeamMember{TeamId: t1.Id, UserId: u1.Id}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	u2 := &model.User{}
 	u2.Email = MakeEmail()
 	u2.Username = model.NewId()
 	u2, err = ss.User().Save(u2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr = ss.Team().SaveMember(&model.TeamMember{TeamId: t1.Id, UserId: u2.Id}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	c1 := &model.Channel{}
 	c1.TeamId = t1.Id
@@ -238,17 +238,17 @@ func testComplianceExportDirectMessages(t *testing.T, ss store.Store) {
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
 	c1, nErr = ss.Channel().Save(c1, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	cDM, nErr := ss.Channel().CreateDirectChannel(u1, u2)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	o1 := &model.Post{}
 	o1.ChannelId = c1.Id
 	o1.UserId = u1.Id
 	o1.CreateAt = model.GetMillis()
 	o1.Message = "zz" + model.NewId() + "b"
 	o1, nErr = ss.Post().Save(o1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	o1a := &model.Post{}
 	o1a.ChannelId = c1.Id
@@ -256,7 +256,7 @@ func testComplianceExportDirectMessages(t *testing.T, ss store.Store) {
 	o1a.CreateAt = o1.CreateAt + 10
 	o1a.Message = "zz" + model.NewId() + "b"
 	_, nErr = ss.Post().Save(o1a)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	o2 := &model.Post{}
 	o2.ChannelId = c1.Id
@@ -264,7 +264,7 @@ func testComplianceExportDirectMessages(t *testing.T, ss store.Store) {
 	o2.CreateAt = o1.CreateAt + 20
 	o2.Message = "zz" + model.NewId() + "b"
 	_, nErr = ss.Post().Save(o2)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	o2a := &model.Post{}
 	o2a.ChannelId = c1.Id
@@ -272,7 +272,7 @@ func testComplianceExportDirectMessages(t *testing.T, ss store.Store) {
 	o2a.CreateAt = o1.CreateAt + 30
 	o2a.Message = "zz" + model.NewId() + "b"
 	_, nErr = ss.Post().Save(o2a)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	o3 := &model.Post{}
 	o3.ChannelId = cDM.Id
@@ -280,13 +280,13 @@ func testComplianceExportDirectMessages(t *testing.T, ss store.Store) {
 	o3.CreateAt = o1.CreateAt + 40
 	o3.Message = "zz" + model.NewId() + "b"
 	o3, nErr = ss.Post().Save(o3)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	time.Sleep(100 * time.Millisecond)
 
 	cr1 := &model.Compliance{Desc: "test" + model.NewId(), StartAt: o1.CreateAt - 1, EndAt: o3.CreateAt + 1, Emails: u1.Email}
 	cposts, nErr := ss.Compliance().ComplianceExport(cr1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	assert.Len(t, cposts, 4)
 	assert.Equal(t, cposts[0].PostId, o1.Id)
 	assert.Equal(t, cposts[len(cposts)-1].PostId, o3.Id)
@@ -298,7 +298,7 @@ func testMessageExportPublicChannel(t *testing.T, ss store.Store) {
 	// get the starting number of message export entries
 	startTime := model.GetMillis()
 	messages, err := ss.Compliance().MessageExport(startTime-10, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, len(messages))
 
 	// need a team
@@ -309,7 +309,7 @@ func testMessageExportPublicChannel(t *testing.T, ss store.Store) {
 		Type:        model.TEAM_OPEN,
 	}
 	team, err = ss.Team().Save(team)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// and two users that are a part of that team
 	user1 := &model.User{
@@ -317,24 +317,24 @@ func testMessageExportPublicChannel(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	user1, err = ss.User().Save(user1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr := ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user1.Id,
 	}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	user2 := &model.User{
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
 	user2, err = ss.User().Save(user2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr = ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user2.Id,
 	}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// need a public channel
 	channel := &model.Channel{
@@ -344,7 +344,7 @@ func testMessageExportPublicChannel(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_OPEN,
 	}
 	channel, nErr = ss.Channel().Save(channel, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// user1 posts twice in the public channel
 	post1 := &model.Post{
@@ -354,7 +354,7 @@ func testMessageExportPublicChannel(t *testing.T, ss store.Store) {
 		Message:   "zz" + model.NewId() + "a",
 	}
 	post1, err = ss.Post().Save(post1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	post2 := &model.Post{
 		ChannelId: channel.Id,
@@ -363,12 +363,12 @@ func testMessageExportPublicChannel(t *testing.T, ss store.Store) {
 		Message:   "zz" + model.NewId() + "b",
 	}
 	post2, err = ss.Post().Save(post2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// fetch the message exports for both posts that user1 sent
 	messageExportMap := map[string]model.MessageExport{}
 	messages, err = ss.Compliance().MessageExport(startTime-10, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 2, len(messages))
 
 	for _, v := range messages {
@@ -402,7 +402,7 @@ func testMessageExportPrivateChannel(t *testing.T, ss store.Store) {
 	// get the starting number of message export entries
 	startTime := model.GetMillis()
 	messages, err := ss.Compliance().MessageExport(startTime-10, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, len(messages))
 
 	// need a team
@@ -413,7 +413,7 @@ func testMessageExportPrivateChannel(t *testing.T, ss store.Store) {
 		Type:        model.TEAM_OPEN,
 	}
 	team, err = ss.Team().Save(team)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// and two users that are a part of that team
 	user1 := &model.User{
@@ -421,24 +421,24 @@ func testMessageExportPrivateChannel(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	user1, err = ss.User().Save(user1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr := ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user1.Id,
 	}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	user2 := &model.User{
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
 	user2, err = ss.User().Save(user2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr = ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user2.Id,
 	}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// need a private channel
 	channel := &model.Channel{
@@ -448,7 +448,7 @@ func testMessageExportPrivateChannel(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_PRIVATE,
 	}
 	channel, nErr = ss.Channel().Save(channel, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// user1 posts twice in the private channel
 	post1 := &model.Post{
@@ -458,7 +458,7 @@ func testMessageExportPrivateChannel(t *testing.T, ss store.Store) {
 		Message:   "zz" + model.NewId() + "a",
 	}
 	post1, err = ss.Post().Save(post1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	post2 := &model.Post{
 		ChannelId: channel.Id,
@@ -467,12 +467,12 @@ func testMessageExportPrivateChannel(t *testing.T, ss store.Store) {
 		Message:   "zz" + model.NewId() + "b",
 	}
 	post2, err = ss.Post().Save(post2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// fetch the message exports for both posts that user1 sent
 	messageExportMap := map[string]model.MessageExport{}
 	messages, err = ss.Compliance().MessageExport(startTime-10, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 2, len(messages))
 
 	for _, v := range messages {
@@ -508,7 +508,7 @@ func testMessageExportDirectMessageChannel(t *testing.T, ss store.Store) {
 	// get the starting number of message export entries
 	startTime := model.GetMillis()
 	messages, err := ss.Compliance().MessageExport(startTime-10, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, len(messages))
 
 	// need a team
@@ -519,7 +519,7 @@ func testMessageExportDirectMessageChannel(t *testing.T, ss store.Store) {
 		Type:        model.TEAM_OPEN,
 	}
 	team, err = ss.Team().Save(team)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// and two users that are a part of that team
 	user1 := &model.User{
@@ -527,28 +527,28 @@ func testMessageExportDirectMessageChannel(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	user1, err = ss.User().Save(user1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr := ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user1.Id,
 	}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	user2 := &model.User{
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
 	user2, err = ss.User().Save(user2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr = ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user2.Id,
 	}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// as well as a DM channel between those users
 	directMessageChannel, nErr := ss.Channel().CreateDirectChannel(user1, user2)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// user1 also sends a DM to user2
 	post := &model.Post{
@@ -558,12 +558,12 @@ func testMessageExportDirectMessageChannel(t *testing.T, ss store.Store) {
 		Message:   "zz" + model.NewId() + "c",
 	}
 	post, err = ss.Post().Save(post)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// fetch the message export for the post that user1 sent
 	messageExportMap := map[string]model.MessageExport{}
 	messages, err = ss.Compliance().MessageExport(startTime-10, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, 1, len(messages))
 
@@ -589,7 +589,7 @@ func testMessageExportGroupMessageChannel(t *testing.T, ss store.Store) {
 	// get the starting number of message export entries
 	startTime := model.GetMillis()
 	messages, err := ss.Compliance().MessageExport(startTime-10, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, len(messages))
 
 	// need a team
@@ -600,7 +600,7 @@ func testMessageExportGroupMessageChannel(t *testing.T, ss store.Store) {
 		Type:        model.TEAM_OPEN,
 	}
 	team, err = ss.Team().Save(team)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// and three users that are a part of that team
 	user1 := &model.User{
@@ -608,36 +608,36 @@ func testMessageExportGroupMessageChannel(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	user1, err = ss.User().Save(user1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr := ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user1.Id,
 	}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	user2 := &model.User{
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
 	user2, err = ss.User().Save(user2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr = ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user2.Id,
 	}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	user3 := &model.User{
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
 	user3, err = ss.User().Save(user3)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr = ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user3.Id,
 	}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// can't create a group channel directly, because importing app creates an import cycle, so we have to fake it
 	groupMessageChannel := &model.Channel{
@@ -646,7 +646,7 @@ func testMessageExportGroupMessageChannel(t *testing.T, ss store.Store) {
 		Type:   model.CHANNEL_GROUP,
 	}
 	groupMessageChannel, nErr = ss.Channel().Save(groupMessageChannel, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// user1 posts in the GM
 	post := &model.Post{
@@ -656,12 +656,12 @@ func testMessageExportGroupMessageChannel(t *testing.T, ss store.Store) {
 		Message:   "zz" + model.NewId() + "c",
 	}
 	post, err = ss.Post().Save(post)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// fetch the message export for the post that user1 sent
 	messageExportMap := map[string]model.MessageExport{}
 	messages, err = ss.Compliance().MessageExport(startTime-10, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 1, len(messages))
 
 	for _, v := range messages {
@@ -686,7 +686,7 @@ func testEditExportMessage(t *testing.T, ss store.Store) {
 	// get the starting number of message export entries
 	startTime := model.GetMillis()
 	messages, err := ss.Compliance().MessageExport(startTime-1, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, len(messages))
 
 	// need a team
@@ -697,7 +697,7 @@ func testEditExportMessage(t *testing.T, ss store.Store) {
 		Type:        model.TEAM_OPEN,
 	}
 	team, err = ss.Team().Save(team)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// need a user part of that team
 	user1 := &model.User{
@@ -705,12 +705,12 @@ func testEditExportMessage(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	user1, err = ss.User().Save(user1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr := ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user1.Id,
 	}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// need a public channel
 	channel := &model.Channel{
@@ -720,7 +720,7 @@ func testEditExportMessage(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_OPEN,
 	}
 	channel, nErr = ss.Channel().Save(channel, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// user1 posts in the public channel
 	post1 := &model.Post{
@@ -730,7 +730,7 @@ func testEditExportMessage(t *testing.T, ss store.Store) {
 		Message:   "zz" + model.NewId() + "a",
 	}
 	post1, err = ss.Post().Save(post1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	//user 1 edits the previous post
 	post1e := &model.Post{}
@@ -738,11 +738,11 @@ func testEditExportMessage(t *testing.T, ss store.Store) {
 	post1e.Message = "edit " + post1.Message
 
 	post1e, err = ss.Post().Update(post1e, post1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// fetch the message exports from the start
 	messages, err = ss.Compliance().MessageExport(startTime-1, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 2, len(messages))
 
 	for _, v := range messages {
@@ -779,7 +779,7 @@ func testEditAfterExportMessage(t *testing.T, ss store.Store) {
 	// get the starting number of message export entries
 	startTime := model.GetMillis()
 	messages, err := ss.Compliance().MessageExport(startTime-1, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, len(messages))
 
 	// need a team
@@ -790,7 +790,7 @@ func testEditAfterExportMessage(t *testing.T, ss store.Store) {
 		Type:        model.TEAM_OPEN,
 	}
 	team, err = ss.Team().Save(team)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// need a user part of that team
 	user1 := &model.User{
@@ -798,12 +798,12 @@ func testEditAfterExportMessage(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	user1, err = ss.User().Save(user1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr := ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user1.Id,
 	}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// need a public channel
 	channel := &model.Channel{
@@ -813,7 +813,7 @@ func testEditAfterExportMessage(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_OPEN,
 	}
 	channel, nErr = ss.Channel().Save(channel, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// user1 posts in the public channel
 	post1 := &model.Post{
@@ -823,11 +823,11 @@ func testEditAfterExportMessage(t *testing.T, ss store.Store) {
 		Message:   "zz" + model.NewId() + "a",
 	}
 	post1, err = ss.Post().Save(post1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// fetch the message exports from the start
 	messages, err = ss.Compliance().MessageExport(startTime-1, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 1, len(messages))
 
 	v := messages[0]
@@ -850,11 +850,11 @@ func testEditAfterExportMessage(t *testing.T, ss store.Store) {
 	post1e.EditAt = postEditTime
 	post1e.Message = "edit " + post1.Message
 	post1e, err = ss.Post().Update(post1e, post1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// fetch the message exports after edit
 	messages, err = ss.Compliance().MessageExport(postEditTime-1, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 2, len(messages))
 
 	for _, v := range messages {
@@ -891,7 +891,7 @@ func testDeleteExportMessage(t *testing.T, ss store.Store) {
 	// get the starting number of message export entries
 	startTime := model.GetMillis()
 	messages, err := ss.Compliance().MessageExport(startTime-1, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, len(messages))
 
 	// need a team
@@ -902,7 +902,7 @@ func testDeleteExportMessage(t *testing.T, ss store.Store) {
 		Type:        model.TEAM_OPEN,
 	}
 	team, err = ss.Team().Save(team)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// need a user part of that team
 	user1 := &model.User{
@@ -910,12 +910,12 @@ func testDeleteExportMessage(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	user1, err = ss.User().Save(user1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr := ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user1.Id,
 	}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// need a public channel
 	channel := &model.Channel{
@@ -925,7 +925,7 @@ func testDeleteExportMessage(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_OPEN,
 	}
 	channel, nErr = ss.Channel().Save(channel, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// user1 posts in the public channel
 	post1 := &model.Post{
@@ -935,16 +935,16 @@ func testDeleteExportMessage(t *testing.T, ss store.Store) {
 		Message:   "zz" + model.NewId() + "a",
 	}
 	post1, err = ss.Post().Save(post1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	//user 1 deletes the previous post
 	postDeleteTime := post1.UpdateAt + 1
 	err = ss.Post().Delete(post1.Id, postDeleteTime, user1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// fetch the message exports from the start
 	messages, err = ss.Compliance().MessageExport(startTime-1, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 1, len(messages))
 
 	v := messages[0]
@@ -957,7 +957,7 @@ func testDeleteExportMessage(t *testing.T, ss store.Store) {
 
 	props := map[string]interface{}{}
 	e := json.Unmarshal([]byte(*v.PostProps), &props)
-	require.Nil(t, e)
+	require.NoError(t, e)
 
 	_, ok := props[model.POST_PROPS_DELETE_BY]
 	assert.True(t, ok)
@@ -976,7 +976,7 @@ func testDeleteAfterExportMessage(t *testing.T, ss store.Store) {
 	// get the starting number of message export entries
 	startTime := model.GetMillis()
 	messages, err := ss.Compliance().MessageExport(startTime-1, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, len(messages))
 
 	// need a team
@@ -987,7 +987,7 @@ func testDeleteAfterExportMessage(t *testing.T, ss store.Store) {
 		Type:        model.TEAM_OPEN,
 	}
 	team, err = ss.Team().Save(team)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// need a user part of that team
 	user1 := &model.User{
@@ -995,12 +995,12 @@ func testDeleteAfterExportMessage(t *testing.T, ss store.Store) {
 		Username: model.NewId(),
 	}
 	user1, err = ss.User().Save(user1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, nErr := ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user1.Id,
 	}, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// need a public channel
 	channel := &model.Channel{
@@ -1010,7 +1010,7 @@ func testDeleteAfterExportMessage(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_OPEN,
 	}
 	channel, nErr = ss.Channel().Save(channel, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// user1 posts in the public channel
 	post1 := &model.Post{
@@ -1020,11 +1020,11 @@ func testDeleteAfterExportMessage(t *testing.T, ss store.Store) {
 		Message:   "zz" + model.NewId() + "a",
 	}
 	post1, err = ss.Post().Save(post1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// fetch the message exports from the start
 	messages, err = ss.Compliance().MessageExport(startTime-1, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 1, len(messages))
 
 	v := messages[0]
@@ -1043,11 +1043,11 @@ func testDeleteAfterExportMessage(t *testing.T, ss store.Store) {
 	//user 1 deletes the previous post
 	postDeleteTime := post1.UpdateAt + 1
 	err = ss.Post().Delete(post1.Id, postDeleteTime, user1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// fetch the message exports after delete
 	messages, err = ss.Compliance().MessageExport(postDeleteTime-1, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 1, len(messages))
 
 	v = messages[0]
@@ -1060,7 +1060,7 @@ func testDeleteAfterExportMessage(t *testing.T, ss store.Store) {
 
 	props := map[string]interface{}{}
 	e := json.Unmarshal([]byte(*v.PostProps), &props)
-	require.Nil(t, e)
+	require.NoError(t, e)
 
 	_, ok := props[model.POST_PROPS_DELETE_BY]
 	assert.True(t, ok)

store/storetest/emoji_store.go

@@ -30,7 +30,7 @@ func testEmojiSaveDelete(t *testing.T, ss store.Store) {
 	}
 
 	_, err := ss.Emoji().Save(emoji1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	assert.Len(t, emoji1.Id, 26, "should've set id for emoji")
 
@@ -39,16 +39,16 @@ func testEmojiSaveDelete(t *testing.T, ss store.Store) {
 		Name:      emoji1.Name,
 	}
 	_, err = ss.Emoji().Save(&emoji2)
-	require.NotNil(t, err, "shouldn't be able to save emoji with duplicate name")
+	require.Error(t, err, "shouldn't be able to save emoji with duplicate name")
 
 	err = ss.Emoji().Delete(emoji1, time.Now().Unix())
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.Emoji().Save(&emoji2)
-	require.Nil(t, err, "should be able to save emoji with duplicate name now that original has been deleted")
+	require.NoError(t, err, "should be able to save emoji with duplicate name now that original has been deleted")
 
 	err = ss.Emoji().Delete(&emoji2, time.Now().Unix()+1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testEmojiGet(t *testing.T, ss store.Store) {
@@ -69,24 +69,24 @@ func testEmojiGet(t *testing.T, ss store.Store) {
 
 	for i, emoji := range emojis {
 		data, err := ss.Emoji().Save(&emoji)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		emojis[i] = *data
 	}
 	defer func() {
 		for _, emoji := range emojis {
 			err := ss.Emoji().Delete(&emoji, time.Now().Unix())
-			require.Nil(t, err)
+			require.NoError(t, err)
 		}
 	}()
 
 	for _, emoji := range emojis {
 		_, err := ss.Emoji().Get(emoji.Id, false)
-		require.Nilf(t, err, "failed to get emoji with id %v", emoji.Id)
+		require.NoErrorf(t, err, "failed to get emoji with id %v", emoji.Id)
 	}
 
 	for _, emoji := range emojis {
 		_, err := ss.Emoji().Get(emoji.Id, true)
-		require.Nilf(t, err, "failed to get emoji with id %v", emoji.Id)
+		require.NoErrorf(t, err, "failed to get emoji with id %v", emoji.Id)
 	}
 }
 
@@ -108,19 +108,19 @@ func testEmojiGetByName(t *testing.T, ss store.Store) {
 
 	for i, emoji := range emojis {
 		data, err := ss.Emoji().Save(&emoji)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		emojis[i] = *data
 	}
 	defer func() {
 		for _, emoji := range emojis {
 			err := ss.Emoji().Delete(&emoji, time.Now().Unix())
-			require.Nil(t, err)
+			require.NoError(t, err)
 		}
 	}()
 
 	for _, emoji := range emojis {
 		_, err := ss.Emoji().GetByName(emoji.Name, true)
-		require.Nilf(t, err, "failed to get emoji with name %v", emoji.Name)
+		require.NoErrorf(t, err, "failed to get emoji with name %v", emoji.Name)
 	}
 }
 
@@ -142,38 +142,38 @@ func testEmojiGetMultipleByName(t *testing.T, ss store.Store) {
 
 	for i, emoji := range emojis {
 		data, err := ss.Emoji().Save(&emoji)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		emojis[i] = *data
 	}
 	defer func() {
 		for _, emoji := range emojis {
 			err := ss.Emoji().Delete(&emoji, time.Now().Unix())
-			require.Nil(t, err)
+			require.NoError(t, err)
 		}
 	}()
 
 	t.Run("one emoji", func(t *testing.T) {
 		received, err := ss.Emoji().GetMultipleByName([]string{emojis[0].Name})
-		require.Nilf(t, err, "could not get emoji")
+		require.NoError(t, err, "could not get emoji")
 		require.Len(t, received, 1, "got incorrect emoji")
 		require.Equal(t, *received[0], emojis[0], "got incorrect emoji")
 	})
 
 	t.Run("multiple emojis", func(t *testing.T) {
 		received, err := ss.Emoji().GetMultipleByName([]string{emojis[0].Name, emojis[1].Name, emojis[2].Name})
-		require.Nil(t, err, "could not get emojis")
+		require.NoError(t, err, "could not get emojis")
 		require.Len(t, received, 3, "got incorrect emojis")
 	})
 
 	t.Run("one nonexistent emoji", func(t *testing.T) {
 		received, err := ss.Emoji().GetMultipleByName([]string{"ab"})
-		require.Nilf(t, err, "%v, could not get emoji", err)
+		require.NoError(t, err, "could not get emoji", err)
 		require.Empty(t, received, "got incorrect emoji")
 	})
 
 	t.Run("multiple emojis with nonexistent names", func(t *testing.T) {
 		received, err := ss.Emoji().GetMultipleByName([]string{emojis[0].Name, emojis[1].Name, emojis[2].Name, "abcd", "1234"})
-		require.Nil(t, err, "could not get emojis")
+		require.NoError(t, err, "could not get emojis")
 		require.Len(t, received, 3, "got incorrect emojis")
 	})
 }
@@ -196,18 +196,18 @@ func testEmojiGetList(t *testing.T, ss store.Store) {
 
 	for i, emoji := range emojis {
 		data, err := ss.Emoji().Save(&emoji)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		emojis[i] = *data
 	}
 	defer func() {
 		for _, emoji := range emojis {
 			err := ss.Emoji().Delete(&emoji, time.Now().Unix())
-			require.Nil(t, err)
+			require.NoError(t, err)
 		}
 	}()
 
 	result, err := ss.Emoji().GetList(0, 100, "")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	for _, emoji := range emojis {
 		found := false
@@ -223,14 +223,14 @@ func testEmojiGetList(t *testing.T, ss store.Store) {
 	}
 
 	remojis, err := ss.Emoji().GetList(0, 3, model.EMOJI_SORT_BY_NAME)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, 3, len(remojis))
 	assert.Equal(t, emojis[0].Name, remojis[0].Name)
 	assert.Equal(t, emojis[1].Name, remojis[1].Name)
 	assert.Equal(t, emojis[2].Name, remojis[2].Name)
 
 	remojis, err = ss.Emoji().GetList(1, 2, model.EMOJI_SORT_BY_NAME)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, 2, len(remojis))
 	assert.Equal(t, emojis[1].Name, remojis[0].Name)
 	assert.Equal(t, emojis[2].Name, remojis[1].Name)
@@ -259,20 +259,20 @@ func testEmojiSearch(t *testing.T, ss store.Store) {
 
 	for i, emoji := range emojis {
 		data, err := ss.Emoji().Save(&emoji)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		emojis[i] = *data
 	}
 	defer func() {
 		for _, emoji := range emojis {
 			err := ss.Emoji().Delete(&emoji, time.Now().Unix())
-			require.Nil(t, err)
+			require.NoError(t, err)
 		}
 	}()
 
 	shouldFind := []bool{true, false, false, false}
 
 	result, err := ss.Emoji().Search("blargh", true, 100)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	for i, emoji := range emojis {
 		found := false
 
@@ -288,7 +288,7 @@ func testEmojiSearch(t *testing.T, ss store.Store) {
 
 	shouldFind = []bool{true, true, true, false}
 	result, err = ss.Emoji().Search("blargh", false, 100)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	for i, emoji := range emojis {
 		found := false
 

store/storetest/file_info_store.go

@@ -36,7 +36,7 @@ func testFileInfoSaveGet(t *testing.T, ss store.Store) {
 	}
 
 	info, err := ss.FileInfo().Save(info)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.NotEqual(t, len(info.Id), 0)
 
 	defer func() {
@@ -44,7 +44,7 @@ func testFileInfoSaveGet(t *testing.T, ss store.Store) {
 	}()
 
 	rinfo, err := ss.FileInfo().Get(info.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, info.Id, rinfo.Id)
 
 	info2, err := ss.FileInfo().Save(&model.FileInfo{
@@ -52,10 +52,10 @@ func testFileInfoSaveGet(t *testing.T, ss store.Store) {
 		Path:      "file.txt",
 		DeleteAt:  123,
 	})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.FileInfo().Get(info2.Id)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	defer func() {
 		ss.FileInfo().PermanentDelete(info2.Id)
@@ -69,14 +69,14 @@ func testFileInfoSaveGetByPath(t *testing.T, ss store.Store) {
 	}
 
 	info, err := ss.FileInfo().Save(info)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.NotEqual(t, len(info.Id), 0)
 	defer func() {
 		ss.FileInfo().PermanentDelete(info.Id)
 	}()
 
 	rinfo, err := ss.FileInfo().GetByPath(info.Path)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, info.Id, rinfo.Id)
 
 	info2, err := ss.FileInfo().Save(&model.FileInfo{
@@ -84,10 +84,10 @@ func testFileInfoSaveGetByPath(t *testing.T, ss store.Store) {
 		Path:      "file.txt",
 		DeleteAt:  123,
 	})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.FileInfo().GetByPath(info2.Id)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	defer func() {
 		ss.FileInfo().PermanentDelete(info2.Id)
@@ -124,7 +124,7 @@ func testFileInfoGetForPost(t *testing.T, ss store.Store) {
 
 	for i, info := range infos {
 		newInfo, err := ss.FileInfo().Save(info)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		infos[i] = newInfo
 		defer func(id string) {
 			ss.FileInfo().PermanentDelete(id)
@@ -205,7 +205,7 @@ func testFileInfoGetForPost(t *testing.T, ss store.Store) {
 				tc.IncludeDeleted,
 				tc.AllowFromCache,
 			)
-			require.Nil(t, err)
+			require.NoError(t, err)
 			assert.Len(t, postInfos, tc.ExpectedPosts)
 
 		})
@@ -242,7 +242,7 @@ func testFileInfoGetForUser(t *testing.T, ss store.Store) {
 
 	for i, info := range infos {
 		newInfo, err := ss.FileInfo().Save(info)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		infos[i] = newInfo
 		defer func(id string) {
 			ss.FileInfo().PermanentDelete(id)
@@ -250,11 +250,11 @@ func testFileInfoGetForUser(t *testing.T, ss store.Store) {
 	}
 
 	userPosts, err := ss.FileInfo().GetForUser(userId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, userPosts, 3)
 
 	userPosts, err = ss.FileInfo().GetForUser(userId2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, userPosts, 1)
 }
 
@@ -264,7 +264,7 @@ func testFileInfoGetWithOptions(t *testing.T, ss store.Store) {
 		post.ChannelId = chId
 		post.UserId = user
 		_, err := ss.Post().Save(&post)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		return &post
 	}
 
@@ -281,7 +281,7 @@ func testFileInfoGetWithOptions(t *testing.T, ss store.Store) {
 			fileInfo.PostId = post.Id
 		}
 		_, err := ss.FileInfo().Save(&fileInfo)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		return fileInfo
 	}
 
@@ -306,7 +306,7 @@ func testFileInfoGetWithOptions(t *testing.T, ss store.Store) {
 
 	// delete a file
 	_, err := ss.FileInfo().DeleteForPost(file2_2.PostId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	testCases := []struct {
 		Name            string
@@ -386,7 +386,7 @@ func testFileInfoGetWithOptions(t *testing.T, ss store.Store) {
 	for _, tc := range testCases {
 		t.Run(tc.Name, func(t *testing.T) {
 			fileInfos, err := ss.FileInfo().GetWithOptions(tc.Page, tc.PerPage, tc.Opt)
-			require.Nil(t, err)
+			require.NoError(t, err)
 			require.Len(t, fileInfos, len(tc.ExpectedFileIds))
 			for i := range tc.ExpectedFileIds {
 				assert.Equal(t, tc.ExpectedFileIds[i], fileInfos[i].Id)
@@ -410,26 +410,26 @@ func testFileInfoAttachToPost(t *testing.T, ss store.Store) {
 			CreatorId: userId,
 			Path:      "file.txt",
 		})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		info2, err := ss.FileInfo().Save(&model.FileInfo{
 			CreatorId: userId,
 			Path:      "file2.txt",
 		})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		require.Equal(t, "", info1.PostId)
 		require.Equal(t, "", info2.PostId)
 
 		err = ss.FileInfo().AttachToPost(info1.Id, postId, userId)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		info1.PostId = postId
 
 		err = ss.FileInfo().AttachToPost(info2.Id, postId, userId)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		info2.PostId = postId
 
 		data, err := ss.FileInfo().GetForPost(postId, true, false, false)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		expected := []*model.FileInfo{info1, info2}
 		sort.Sort(byFileInfoId(expected))
@@ -445,15 +445,15 @@ func testFileInfoAttachToPost(t *testing.T, ss store.Store) {
 			CreatorId: userId,
 			Path:      "file.txt",
 		})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		require.Equal(t, "", info.PostId)
 
 		err = ss.FileInfo().AttachToPost(info.Id, model.NewId(), userId)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		err = ss.FileInfo().AttachToPost(info.Id, postId, userId)
-		require.NotNil(t, err)
+		require.Error(t, err)
 	})
 
 	t.Run("should not attach files owned from a different user", func(t *testing.T) {
@@ -464,12 +464,12 @@ func testFileInfoAttachToPost(t *testing.T, ss store.Store) {
 			CreatorId: model.NewId(),
 			Path:      "file.txt",
 		})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		require.Equal(t, "", info.PostId)
 
 		err = ss.FileInfo().AttachToPost(info.Id, postId, userId)
-		assert.NotNil(t, err)
+		assert.Error(t, err)
 	})
 
 	t.Run("should attach files uploaded by nouser", func(t *testing.T) {
@@ -479,14 +479,14 @@ func testFileInfoAttachToPost(t *testing.T, ss store.Store) {
 			CreatorId: "nouser",
 			Path:      "file.txt",
 		})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "", info.PostId)
 
 		err = ss.FileInfo().AttachToPost(info.Id, postId, model.NewId())
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		data, err := ss.FileInfo().GetForPost(postId, true, false, false)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		info.PostId = postId
 		assert.EqualValues(t, []*model.FileInfo{info}, data)
 	})
@@ -522,7 +522,7 @@ func testFileInfoDeleteForPost(t *testing.T, ss store.Store) {
 
 	for i, info := range infos {
 		newInfo, err := ss.FileInfo().Save(info)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		infos[i] = newInfo
 		defer func(id string) {
 			ss.FileInfo().PermanentDelete(id)
@@ -530,10 +530,10 @@ func testFileInfoDeleteForPost(t *testing.T, ss store.Store) {
 	}
 
 	_, err := ss.FileInfo().DeleteForPost(postId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	infos, err = ss.FileInfo().GetForPost(postId, true, false, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, infos)
 }
 
@@ -543,10 +543,10 @@ func testFileInfoPermanentDelete(t *testing.T, ss store.Store) {
 		CreatorId: model.NewId(),
 		Path:      "file.txt",
 	})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	err = ss.FileInfo().PermanentDelete(info.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testFileInfoPermanentDeleteBatch(t *testing.T, ss store.Store) {
@@ -558,7 +558,7 @@ func testFileInfoPermanentDeleteBatch(t *testing.T, ss store.Store) {
 		Path:      "file.txt",
 		CreateAt:  1000,
 	})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.FileInfo().Save(&model.FileInfo{
 		PostId:    postId,
@@ -566,7 +566,7 @@ func testFileInfoPermanentDeleteBatch(t *testing.T, ss store.Store) {
 		Path:      "file.txt",
 		CreateAt:  1200,
 	})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.FileInfo().Save(&model.FileInfo{
 		PostId:    postId,
@@ -574,17 +574,17 @@ func testFileInfoPermanentDeleteBatch(t *testing.T, ss store.Store) {
 		Path:      "file.txt",
 		CreateAt:  2000,
 	})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	postFiles, err := ss.FileInfo().GetForPost(postId, true, false, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, postFiles, 3)
 
 	_, err = ss.FileInfo().PermanentDeleteBatch(1500, 1000)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	postFiles, err = ss.FileInfo().GetForPost(postId, true, false, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, postFiles, 1)
 }
 
@@ -597,8 +597,8 @@ func testFileInfoPermanentDeleteByUser(t *testing.T, ss store.Store) {
 		CreatorId: userId,
 		Path:      "file.txt",
 	})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.FileInfo().PermanentDeleteByUser(userId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }

store/storetest/job_store.go

@@ -43,12 +43,12 @@ func testJobSaveGet(t *testing.T, ss store.Store) {
 	}
 
 	_, err := ss.Job().Save(job)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	defer ss.Job().Delete(job.Id)
 
 	received, err := ss.Job().Get(job.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, job.Id, received.Id, "received incorrect job after save")
 	require.Equal(t, "12345", received.Data["Total"])
 }
@@ -73,12 +73,12 @@ func testJobGetAllByType(t *testing.T, ss store.Store) {
 
 	for _, job := range jobs {
 		_, err := ss.Job().Save(job)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer ss.Job().Delete(job.Id)
 	}
 
 	received, err := ss.Job().GetAllByType(jobType)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, received, 2)
 	require.ElementsMatch(t, []string{jobs[0].Id, jobs[1].Id}, []string{received[0].Id, received[1].Id})
 }
@@ -111,18 +111,18 @@ func testJobGetAllByTypePage(t *testing.T, ss store.Store) {
 
 	for _, job := range jobs {
 		_, err := ss.Job().Save(job)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer ss.Job().Delete(job.Id)
 	}
 
 	received, err := ss.Job().GetAllByTypePage(jobType, 0, 2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, received, 2)
 	require.Equal(t, received[0].Id, jobs[2].Id, "should've received newest job first")
 	require.Equal(t, received[1].Id, jobs[0].Id, "should've received second newest job second")
 
 	received, err = ss.Job().GetAllByTypePage(jobType, 2, 2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, received, 1)
 	require.Equal(t, received[0].Id, jobs[1].Id, "should've received oldest job last")
 }
@@ -151,18 +151,18 @@ func testJobGetAllPage(t *testing.T, ss store.Store) {
 
 	for _, job := range jobs {
 		_, err := ss.Job().Save(job)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer ss.Job().Delete(job.Id)
 	}
 
 	received, err := ss.Job().GetAllPage(0, 2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, received, 2)
 	require.Equal(t, received[0].Id, jobs[2].Id, "should've received newest job first")
 	require.Equal(t, received[1].Id, jobs[0].Id, "should've received second newest job second")
 
 	received, err = ss.Job().GetAllPage(2, 2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.NotEmpty(t, received)
 	require.Equal(t, received[0].Id, jobs[1].Id, "should've received oldest job last")
 }
@@ -203,12 +203,12 @@ func testJobGetAllByStatus(t *testing.T, ss store.Store) {
 
 	for _, job := range jobs {
 		_, err := ss.Job().Save(job)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer ss.Job().Delete(job.Id)
 	}
 
 	received, err := ss.Job().GetAllByStatus(status)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, received, 3)
 	require.Equal(t, received[0].Id, jobs[1].Id)
 	require.Equal(t, received[1].Id, jobs[0].Id)
@@ -251,16 +251,16 @@ func testJobStoreGetNewestJobByStatusAndType(t *testing.T, ss store.Store) {
 
 	for _, job := range jobs {
 		_, err := ss.Job().Save(job)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer ss.Job().Delete(job.Id)
 	}
 
 	received, err := ss.Job().GetNewestJobByStatusAndType(status1, jobType1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.EqualValues(t, jobs[0].Id, received.Id)
 
 	received, err = ss.Job().GetNewestJobByStatusAndType(model.NewId(), model.NewId())
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 	var nfErr *store.ErrNotFound
 	assert.True(t, errors.As(err, &nfErr))
 	assert.Nil(t, received)
@@ -301,31 +301,31 @@ func testJobStoreGetNewestJobByStatusesAndType(t *testing.T, ss store.Store) {
 
 	for _, job := range jobs {
 		_, err := ss.Job().Save(job)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer ss.Job().Delete(job.Id)
 	}
 
 	received, err := ss.Job().GetNewestJobByStatusesAndType([]string{status1, status2}, jobType1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.EqualValues(t, jobs[3].Id, received.Id)
 
 	received, err = ss.Job().GetNewestJobByStatusesAndType([]string{model.NewId(), model.NewId()}, model.NewId())
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 	var nfErr *store.ErrNotFound
 	assert.True(t, errors.As(err, &nfErr))
 	assert.Nil(t, received)
 
 	received, err = ss.Job().GetNewestJobByStatusesAndType([]string{status2}, jobType2)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 	assert.True(t, errors.As(err, &nfErr))
 	assert.Nil(t, received)
 
 	received, err = ss.Job().GetNewestJobByStatusesAndType([]string{status1}, jobType2)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.EqualValues(t, jobs[2].Id, received.Id)
 
 	received, err = ss.Job().GetNewestJobByStatusesAndType([]string{}, jobType1)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 	assert.True(t, errors.As(err, &nfErr))
 	assert.Nil(t, received)
 }
@@ -365,24 +365,24 @@ func testJobStoreGetCountByStatusAndType(t *testing.T, ss store.Store) {
 
 	for _, job := range jobs {
 		_, err := ss.Job().Save(job)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		defer ss.Job().Delete(job.Id)
 	}
 
 	count, err := ss.Job().GetCountByStatusAndType(status1, jobType1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.EqualValues(t, 2, count)
 
 	count, err = ss.Job().GetCountByStatusAndType(status2, jobType2)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.EqualValues(t, 0, count)
 
 	count, err = ss.Job().GetCountByStatusAndType(status1, jobType2)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.EqualValues(t, 1, count)
 
 	count, err = ss.Job().GetCountByStatusAndType(status2, jobType1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.EqualValues(t, 1, count)
 }
 
@@ -395,7 +395,7 @@ func testJobUpdateOptimistically(t *testing.T, ss store.Store) {
 	}
 
 	_, err := ss.Job().Save(job)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer ss.Job().Delete(job.Id)
 
 	job.LastActivityAt = model.GetMillis()
@@ -411,11 +411,11 @@ func testJobUpdateOptimistically(t *testing.T, ss store.Store) {
 	time.Sleep(2 * time.Millisecond)
 
 	updated, err = ss.Job().UpdateOptimistically(job, model.JOB_STATUS_PENDING)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.True(t, updated)
 
 	updatedJob, err := ss.Job().Get(job.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	require.Equal(t, updatedJob.Type, job.Type)
 	require.Equal(t, updatedJob.CreateAt, job.CreateAt)
@@ -435,7 +435,7 @@ func testJobUpdateStatusUpdateStatusOptimistically(t *testing.T, ss store.Store)
 
 	var lastUpdateAt int64
 	received, err := ss.Job().Save(job)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	lastUpdateAt = received.LastActivityAt
 
 	defer ss.Job().Delete(job.Id)
@@ -443,7 +443,7 @@ func testJobUpdateStatusUpdateStatusOptimistically(t *testing.T, ss store.Store)
 	time.Sleep(2 * time.Millisecond)
 
 	received, err = ss.Job().UpdateStatus(job.Id, model.JOB_STATUS_PENDING)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	require.Equal(t, model.JOB_STATUS_PENDING, received.Status)
 	require.Greater(t, received.LastActivityAt, lastUpdateAt)
@@ -452,11 +452,11 @@ func testJobUpdateStatusUpdateStatusOptimistically(t *testing.T, ss store.Store)
 	time.Sleep(2 * time.Millisecond)
 
 	updated, err := ss.Job().UpdateStatusOptimistically(job.Id, model.JOB_STATUS_IN_PROGRESS, model.JOB_STATUS_SUCCESS)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.False(t, updated)
 
 	received, err = ss.Job().Get(job.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	require.Equal(t, model.JOB_STATUS_PENDING, received.Status)
 	require.Equal(t, received.LastActivityAt, lastUpdateAt)
@@ -464,12 +464,12 @@ func testJobUpdateStatusUpdateStatusOptimistically(t *testing.T, ss store.Store)
 	time.Sleep(2 * time.Millisecond)
 
 	updated, err = ss.Job().UpdateStatusOptimistically(job.Id, model.JOB_STATUS_PENDING, model.JOB_STATUS_IN_PROGRESS)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.True(t, updated, "should have succeeded")
 
 	var startAtSet int64
 	received, err = ss.Job().Get(job.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, model.JOB_STATUS_IN_PROGRESS, received.Status)
 	require.NotEqual(t, 0, received.StartAt)
 	require.Greater(t, received.LastActivityAt, lastUpdateAt)
@@ -479,11 +479,11 @@ func testJobUpdateStatusUpdateStatusOptimistically(t *testing.T, ss store.Store)
 	time.Sleep(2 * time.Millisecond)
 
 	updated, err = ss.Job().UpdateStatusOptimistically(job.Id, model.JOB_STATUS_IN_PROGRESS, model.JOB_STATUS_SUCCESS)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.True(t, updated, "should have succeeded")
 
 	received, err = ss.Job().Get(job.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, model.JOB_STATUS_SUCCESS, received.Status)
 	require.Equal(t, startAtSet, received.StartAt)
 	require.Greater(t, received.LastActivityAt, lastUpdateAt)
@@ -491,8 +491,8 @@ func testJobUpdateStatusUpdateStatusOptimistically(t *testing.T, ss store.Store)
 
 func testJobDelete(t *testing.T, ss store.Store) {
 	job, err := ss.Job().Save(&model.Job{Id: model.NewId()})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.Job().Delete(job.Id)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 }

store/storetest/license_store.go

@@ -23,15 +23,15 @@ func testLicenseStoreSave(t *testing.T, ss store.Store) {
 	l1.Bytes = "junk"
 
 	_, err := ss.License().Save(&l1)
-	require.Nil(t, err, "couldn't save license record")
+	require.NoError(t, err, "couldn't save license record")
 
 	_, err = ss.License().Save(&l1)
-	require.Nil(t, err, "shouldn't fail on trying to save existing license record")
+	require.NoError(t, err, "shouldn't fail on trying to save existing license record")
 
 	l1.Id = ""
 
 	_, err = ss.License().Save(&l1)
-	require.NotNil(t, err, "should fail on invalid license")
+	require.Error(t, err, "should fail on invalid license")
 }
 
 func testLicenseStoreGet(t *testing.T, ss store.Store) {
@@ -40,13 +40,13 @@ func testLicenseStoreGet(t *testing.T, ss store.Store) {
 	l1.Bytes = "junk"
 
 	_, err := ss.License().Save(&l1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	record, err := ss.License().Get(l1.Id)
-	require.Nil(t, err, "couldn't get license")
+	require.NoError(t, err, "couldn't get license")
 
 	require.Equal(t, record.Bytes, l1.Bytes, "license bytes didn't match")
 
 	_, err = ss.License().Get("missing")
-	require.NotNil(t, err, "should fail on get license")
+	require.Error(t, err, "should fail on get license")
 }

store/storetest/link_metadata_store.go

@@ -41,7 +41,7 @@ func testLinkMetadataStoreSave(t *testing.T, ss store.Store) {
 
 		linkMetadata, err := ss.LinkMetadata().Save(metadata)
 
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, *metadata, *linkMetadata)
 	})
 
@@ -55,7 +55,7 @@ func testLinkMetadataStoreSave(t *testing.T, ss store.Store) {
 
 		_, err := ss.LinkMetadata().Save(metadata)
 
-		assert.NotNil(t, err)
+		assert.Error(t, err)
 	})
 
 	t.Run("should save with duplicate URL and different timestamp", func(t *testing.T) {
@@ -67,13 +67,13 @@ func testLinkMetadataStoreSave(t *testing.T, ss store.Store) {
 		}
 
 		_, err := ss.LinkMetadata().Save(metadata)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		metadata.Timestamp = getNextLinkMetadataTimestamp()
 
 		linkMetadata, err := ss.LinkMetadata().Save(metadata)
 
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, *metadata, *linkMetadata)
 	})
 
@@ -86,13 +86,13 @@ func testLinkMetadataStoreSave(t *testing.T, ss store.Store) {
 		}
 
 		_, err := ss.LinkMetadata().Save(metadata)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		metadata.URL = "http://example.com/another/page"
 
 		linkMetadata, err := ss.LinkMetadata().Save(metadata)
 
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, *metadata, *linkMetadata)
 	})
 
@@ -105,18 +105,18 @@ func testLinkMetadataStoreSave(t *testing.T, ss store.Store) {
 		}
 
 		linkMetadata, err := ss.LinkMetadata().Save(metadata)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, &model.PostImage{}, linkMetadata.Data)
 
 		metadata.Data = &model.PostImage{Height: 10, Width: 20}
 
 		linkMetadata, err = ss.LinkMetadata().Save(metadata)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, linkMetadata.Data, &model.PostImage{Height: 10, Width: 20})
 
 		// Should return the original result, not the duplicate one
 		linkMetadata, err = ss.LinkMetadata().Get(metadata.URL, metadata.Timestamp)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, &model.PostImage{}, linkMetadata.Data)
 	})
 }
@@ -131,11 +131,11 @@ func testLinkMetadataStoreGet(t *testing.T, ss store.Store) {
 		}
 
 		_, err := ss.LinkMetadata().Save(metadata)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		linkMetadata, err := ss.LinkMetadata().Get(metadata.URL, metadata.Timestamp)
 
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.IsType(t, metadata, linkMetadata)
 		assert.Equal(t, *metadata, *linkMetadata)
 	})
@@ -149,11 +149,11 @@ func testLinkMetadataStoreGet(t *testing.T, ss store.Store) {
 		}
 
 		_, err := ss.LinkMetadata().Save(metadata)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		_, err = ss.LinkMetadata().Get("http://example.com/another_page", metadata.Timestamp)
 
-		require.NotNil(t, err)
+		require.Error(t, err)
 		var nfErr *store.ErrNotFound
 		assert.True(t, errors.As(err, &nfErr))
 	})
@@ -167,11 +167,11 @@ func testLinkMetadataStoreGet(t *testing.T, ss store.Store) {
 		}
 
 		_, err := ss.LinkMetadata().Save(metadata)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		_, err = ss.LinkMetadata().Get(metadata.URL, getNextLinkMetadataTimestamp())
 
-		require.NotNil(t, err)
+		require.Error(t, err)
 		var nfErr *store.ErrNotFound
 		assert.True(t, errors.As(err, &nfErr))
 	})
@@ -190,13 +190,13 @@ func testLinkMetadataStoreTypes(t *testing.T, ss store.Store) {
 		}
 
 		received, err := ss.LinkMetadata().Save(metadata)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		require.IsType(t, &model.PostImage{}, received.Data)
 		assert.Equal(t, *(metadata.Data.(*model.PostImage)), *(received.Data.(*model.PostImage)))
 
 		received, err = ss.LinkMetadata().Get(metadata.URL, metadata.Timestamp)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		require.IsType(t, &model.PostImage{}, received.Data)
 		assert.Equal(t, *(metadata.Data.(*model.PostImage)), *(received.Data.(*model.PostImage)))
@@ -220,13 +220,13 @@ func testLinkMetadataStoreTypes(t *testing.T, ss store.Store) {
 		}
 
 		received, err := ss.LinkMetadata().Save(metadata)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		require.IsType(t, &opengraph.OpenGraph{}, received.Data)
 		assert.Equal(t, *(metadata.Data.(*opengraph.OpenGraph)), *(received.Data.(*opengraph.OpenGraph)))
 
 		received, err = ss.LinkMetadata().Get(metadata.URL, metadata.Timestamp)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		require.IsType(t, &opengraph.OpenGraph{}, received.Data)
 		assert.Equal(t, *(metadata.Data.(*opengraph.OpenGraph)), *(received.Data.(*opengraph.OpenGraph)))
@@ -241,11 +241,11 @@ func testLinkMetadataStoreTypes(t *testing.T, ss store.Store) {
 		}
 
 		received, err := ss.LinkMetadata().Save(metadata)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, received.Data)
 
 		received, err = ss.LinkMetadata().Get(metadata.URL, metadata.Timestamp)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		require.Nil(t, received.Data)
 	})

store/storetest/oauth_store.go

@@ -40,18 +40,18 @@ func testOAuthStoreSaveApp(t *testing.T, ss store.Store) {
 	// Try to save an app that already has an Id
 	a1.Id = model.NewId()
 	_, err := ss.OAuth().SaveApp(&a1)
-	require.NotNil(t, err, "Should have failed, cannot add an OAuth app cannot be save with an Id, it has to be updated")
+	require.Error(t, err, "Should have failed, cannot add an OAuth app cannot be save with an Id, it has to be updated")
 
 	// Try to save an Invalid App
 	a1.Id = ""
 	_, err = ss.OAuth().SaveApp(&a1)
-	require.NotNil(t, err, "Should have failed, app should be invalid cause it doesn' have a name set")
+	require.Error(t, err, "Should have failed, app should be invalid cause it doesn' have a name set")
 
 	// Save the app
 	a1.Id = ""
 	a1.Name = "TestApp" + model.NewId()
 	_, err = ss.OAuth().SaveApp(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testOAuthStoreGetApp(t *testing.T, ss store.Store) {
@@ -61,25 +61,25 @@ func testOAuthStoreGetApp(t *testing.T, ss store.Store) {
 	a1.CallbackUrls = []string{"https://nowhere.com"}
 	a1.Homepage = "https://nowhere.com"
 	_, err := ss.OAuth().SaveApp(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// Lets try to get and app that does not exists
 	_, err = ss.OAuth().GetApp("fake0123456789abcderfgret1")
-	require.NotNil(t, err, "Should have failed. App does not exists")
+	require.Error(t, err, "Should have failed. App does not exists")
 
 	_, err = ss.OAuth().GetApp(a1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// Lets try and get the app from a user that hasn't created any apps
 	apps, err := ss.OAuth().GetAppByUser("fake0123456789abcderfgret1", 0, 1000)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, apps, "Should have failed. Fake user hasn't created any apps")
 
 	_, err = ss.OAuth().GetAppByUser(a1.CreatorId, 0, 1000)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.OAuth().GetApps(0, 1000)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testOAuthStoreUpdateApp(t *testing.T, ss store.Store) {
@@ -89,7 +89,7 @@ func testOAuthStoreUpdateApp(t *testing.T, ss store.Store) {
 	a1.CallbackUrls = []string{"https://nowhere.com"}
 	a1.Homepage = "https://nowhere.com"
 	_, err := ss.OAuth().SaveApp(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// temporarily save the created app id
 	id := a1.Id
@@ -101,17 +101,17 @@ func testOAuthStoreUpdateApp(t *testing.T, ss store.Store) {
 	// Lets update the app by removing the name
 	a1.Name = ""
 	_, err = ss.OAuth().UpdateApp(&a1)
-	require.NotNil(t, err, "Should have failed. App name is not set")
+	require.Error(t, err, "Should have failed. App name is not set")
 
 	// Lets not find the app that we are trying to update
 	a1.Id = "fake0123456789abcderfgret1"
 	a1.Name = "NewName"
 	_, err = ss.OAuth().UpdateApp(&a1)
-	require.NotNil(t, err, "Should have failed. Not able to find the app")
+	require.Error(t, err, "Should have failed. Not able to find the app")
 
 	a1.Id = id
 	ua, err := ss.OAuth().UpdateApp(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, ua.Name, "NewName", "name did not update")
 	require.NotEqual(t, ua.CreateAt, 1, "create at should not have updated")
 	require.NotEqual(t, ua.CreatorId, "12345678901234567890123456", "creator id should not have updated")
@@ -124,14 +124,14 @@ func testOAuthStoreSaveAccessData(t *testing.T, ss store.Store) {
 
 	// Lets try and save an incomplete access data
 	_, err := ss.OAuth().SaveAccessData(&a1)
-	require.NotNil(t, err, "Should have failed. Access data needs the token")
+	require.Error(t, err, "Should have failed. Access data needs the token")
 
 	a1.Token = model.NewId()
 	a1.RefreshToken = model.NewId()
 	a1.RedirectUri = "http://example.com"
 
 	_, err = ss.OAuth().SaveAccessData(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testOAuthUpdateAccessData(t *testing.T, ss store.Store) {
@@ -143,24 +143,24 @@ func testOAuthUpdateAccessData(t *testing.T, ss store.Store) {
 	a1.ExpiresAt = model.GetMillis()
 	a1.RedirectUri = "http://example.com"
 	_, err := ss.OAuth().SaveAccessData(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	//Try to update to invalid Refresh Token
 	refreshToken := a1.RefreshToken
 	a1.RefreshToken = model.NewId() + "123"
 	_, err = ss.OAuth().UpdateAccessData(&a1)
-	require.NotNil(t, err, "Should have failed with invalid token")
+	require.Error(t, err, "Should have failed with invalid token")
 
 	//Try to update to invalid RedirectUri
 	a1.RefreshToken = model.NewId()
 	a1.RedirectUri = ""
 	_, err = ss.OAuth().UpdateAccessData(&a1)
-	require.NotNil(t, err, "Should have failed with invalid Redirect URI")
+	require.Error(t, err, "Should have failed with invalid Redirect URI")
 
 	// Should update fine
 	a1.RedirectUri = "http://example.com"
 	ra1, err := ss.OAuth().UpdateAccessData(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.NotEqual(t, ra1.RefreshToken, refreshToken, "refresh tokens didn't match")
 }
 
@@ -173,28 +173,28 @@ func testOAuthStoreGetAccessData(t *testing.T, ss store.Store) {
 	a1.ExpiresAt = model.GetMillis()
 	a1.RedirectUri = "http://example.com"
 	_, err := ss.OAuth().SaveAccessData(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.OAuth().GetAccessData("invalidToken")
-	require.NotNil(t, err, "Should have failed. There is no data with an invalid token")
+	require.Error(t, err, "Should have failed. There is no data with an invalid token")
 
 	ra1, err := ss.OAuth().GetAccessData(a1.Token)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, a1.Token, ra1.Token, "tokens didn't match")
 
 	_, err = ss.OAuth().GetPreviousAccessData(a1.UserId, a1.ClientId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.OAuth().GetPreviousAccessData("user", "junk")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// Try to get the Access data using an invalid refresh token
 	_, err = ss.OAuth().GetAccessDataByRefreshToken(a1.Token)
-	require.NotNil(t, err, "Should have failed. There is no data with an invalid token")
+	require.Error(t, err, "Should have failed. There is no data with an invalid token")
 
 	// Get the Access Data using the refresh token
 	ra1, err = ss.OAuth().GetAccessDataByRefreshToken(a1.RefreshToken)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, a1.RefreshToken, ra1.RefreshToken, "tokens didn't match")
 }
 
@@ -206,10 +206,10 @@ func testOAuthStoreRemoveAccessData(t *testing.T, ss store.Store) {
 	a1.RefreshToken = model.NewId()
 	a1.RedirectUri = "http://example.com"
 	_, err := ss.OAuth().SaveAccessData(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	err = ss.OAuth().RemoveAccessData(a1.Token)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	result, _ := ss.OAuth().GetPreviousAccessData(a1.UserId, a1.ClientId)
 	require.Nil(t, result, "did not delete access token")
@@ -223,10 +223,10 @@ func testOAuthStoreRemoveAllAccessData(t *testing.T, ss store.Store) {
 	a1.RefreshToken = model.NewId()
 	a1.RedirectUri = "http://example.com"
 	_, err := ss.OAuth().SaveAccessData(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	err = ss.OAuth().RemoveAllAccessData()
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	result, _ := ss.OAuth().GetPreviousAccessData(a1.UserId, a1.ClientId)
 	require.Nil(t, result, "did not delete access token")
@@ -239,7 +239,7 @@ func testOAuthStoreSaveAuthData(t *testing.T, ss store.Store) {
 	a1.Code = model.NewId()
 	a1.RedirectUri = "http://example.com"
 	_, err := ss.OAuth().SaveAuthData(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testOAuthStoreGetAuthData(t *testing.T, ss store.Store) {
@@ -249,10 +249,10 @@ func testOAuthStoreGetAuthData(t *testing.T, ss store.Store) {
 	a1.Code = model.NewId()
 	a1.RedirectUri = "http://example.com"
 	_, err := ss.OAuth().SaveAuthData(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.OAuth().GetAuthData(a1.Code)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testOAuthStoreRemoveAuthData(t *testing.T, ss store.Store) {
@@ -262,13 +262,13 @@ func testOAuthStoreRemoveAuthData(t *testing.T, ss store.Store) {
 	a1.Code = model.NewId()
 	a1.RedirectUri = "http://example.com"
 	_, err := ss.OAuth().SaveAuthData(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	err = ss.OAuth().RemoveAuthData(a1.Code)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.OAuth().GetAuthData(a1.Code)
-	require.NotNil(t, err, "should have errored - auth code removed")
+	require.Error(t, err, "should have errored - auth code removed")
 }
 
 func testOAuthStoreRemoveAuthDataByUser(t *testing.T, ss store.Store) {
@@ -278,10 +278,10 @@ func testOAuthStoreRemoveAuthDataByUser(t *testing.T, ss store.Store) {
 	a1.Code = model.NewId()
 	a1.RedirectUri = "http://example.com"
 	_, err := ss.OAuth().SaveAuthData(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	err = ss.OAuth().PermanentDeleteAuthDataByUser(a1.UserId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testOAuthGetAuthorizedApps(t *testing.T, ss store.Store) {
@@ -291,11 +291,11 @@ func testOAuthGetAuthorizedApps(t *testing.T, ss store.Store) {
 	a1.CallbackUrls = []string{"https://nowhere.com"}
 	a1.Homepage = "https://nowhere.com"
 	_, err := ss.OAuth().SaveApp(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// Lets try and get an Authorized app for a user who hasn't authorized it
 	apps, err := ss.OAuth().GetAuthorizedApps("fake0123456789abcderfgret1", 0, 1000)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, apps, "Should have failed. Fake user hasn't authorized the app")
 
 	// allow the app
@@ -305,10 +305,10 @@ func testOAuthGetAuthorizedApps(t *testing.T, ss store.Store) {
 	p.Name = a1.Id
 	p.Value = "true"
 	nErr := ss.Preference().Save(&model.Preferences{p})
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	apps, err = ss.OAuth().GetAuthorizedApps(a1.CreatorId, 0, 1000)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.NotEqual(t, len(apps), 0, "It should have return apps")
 }
 
@@ -319,7 +319,7 @@ func testOAuthGetAccessDataByUserForApp(t *testing.T, ss store.Store) {
 	a1.CallbackUrls = []string{"https://nowhere.com"}
 	a1.Homepage = "https://nowhere.com"
 	_, err := ss.OAuth().SaveApp(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// allow the app
 	p := model.Preference{}
@@ -328,10 +328,10 @@ func testOAuthGetAccessDataByUserForApp(t *testing.T, ss store.Store) {
 	p.Name = a1.Id
 	p.Value = "true"
 	nErr := ss.Preference().Save(&model.Preferences{p})
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	apps, err := ss.OAuth().GetAuthorizedApps(a1.CreatorId, 0, 1000)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.NotEqual(t, len(apps), 0, "It should have return apps")
 
 	// save the token
@@ -343,10 +343,10 @@ func testOAuthGetAccessDataByUserForApp(t *testing.T, ss store.Store) {
 	ad1.RedirectUri = "http://example.com"
 
 	_, err = ss.OAuth().SaveAccessData(&ad1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	accessData, err := ss.OAuth().GetAccessDataByUserForApp(a1.CreatorId, a1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.NotEqual(t, len(accessData), 0, "It should have return access data")
 }
 
@@ -357,11 +357,11 @@ func testOAuthStoreDeleteApp(t *testing.T, ss store.Store) {
 	a1.CallbackUrls = []string{"https://nowhere.com"}
 	a1.Homepage = "https://nowhere.com"
 	_, err := ss.OAuth().SaveApp(&a1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// delete a non-existent app
 	err = ss.OAuth().DeleteApp("fakeclientId")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s1 := &model.Session{}
 	s1.UserId = model.NewId()
@@ -369,7 +369,7 @@ func testOAuthStoreDeleteApp(t *testing.T, ss store.Store) {
 	s1.IsOAuth = true
 
 	s1, nErr := ss.Session().Save(s1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	ad1 := model.AccessData{}
 	ad1.ClientId = a1.Id
@@ -379,14 +379,14 @@ func testOAuthStoreDeleteApp(t *testing.T, ss store.Store) {
 	ad1.RedirectUri = "http://example.com"
 
 	_, err = ss.OAuth().SaveAccessData(&ad1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	err = ss.OAuth().DeleteApp(a1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, nErr = ss.Session().Get(s1.Token)
-	require.NotNil(t, nErr, "should error - session should be deleted")
+	require.Error(t, nErr, "should error - session should be deleted")
 
 	_, err = ss.OAuth().GetAccessData(s1.Token)
-	require.NotNil(t, err, "should error - access data should be deleted")
+	require.Error(t, err, "should error - access data should be deleted")
 }

store/storetest/plugin_store.go

@@ -39,7 +39,7 @@ func setupKVs(t *testing.T, ss store.Store) (string, func()) {
 		ExpireAt: 0,
 	}
 	_, err := ss.Plugin().SaveOrUpdate(otherKV)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// otherPluginKV is a key value for another plugin, and used to verify other plugins' keys
 	// aren't modified unintentionally.
@@ -50,15 +50,15 @@ func setupKVs(t *testing.T, ss store.Store) (string, func()) {
 		ExpireAt: 0,
 	}
 	_, err = ss.Plugin().SaveOrUpdate(otherPluginKV)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	return pluginId, func() {
 		actualOtherKV, err := ss.Plugin().Get(otherKV.PluginId, otherKV.Key)
-		require.Nil(t, err, "failed to find other key value for same plugin")
+		require.NoError(t, err, "failed to find other key value for same plugin")
 		assert.Equal(t, otherKV, actualOtherKV)
 
 		actualOtherPluginKV, err := ss.Plugin().Get(otherPluginKV.PluginId, otherPluginKV.Key)
-		require.Nil(t, err, "failed to find other key value from different plugin")
+		require.NoError(t, err, "failed to find other key value from different plugin")
 		assert.Equal(t, otherPluginKV, actualOtherPluginKV)
 	}
 }
@@ -76,7 +76,7 @@ func doTestPluginSaveOrUpdate(t *testing.T, ss store.Store, doer func(kv *model.
 		}
 
 		kv, err := doer(kv)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		appErr, ok := err.(*model.AppError)
 		require.True(t, ok)
 		require.Equal(t, "model.plugin_key_value.is_valid.plugin_id.app_error", appErr.Id)
@@ -99,7 +99,7 @@ func doTestPluginSaveOrUpdate(t *testing.T, ss store.Store, doer func(kv *model.
 		}
 
 		retKV, err := doer(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kv, retKV)
 		// SaveOrUpdate returns the kv passed in, so test each field individually for
 		// completeness. It should probably be changed to not bother doing that.
@@ -109,7 +109,7 @@ func doTestPluginSaveOrUpdate(t *testing.T, ss store.Store, doer func(kv *model.
 		assert.Equal(t, expireAt, kv.ExpireAt)
 
 		actualKV, nErr := ss.Plugin().Get(pluginId, key)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 		assert.Equal(t, kv, actualKV)
 	})
 
@@ -129,7 +129,7 @@ func doTestPluginSaveOrUpdate(t *testing.T, ss store.Store, doer func(kv *model.
 		}
 
 		retKV, err := doer(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kv, retKV)
 		// SaveOrUpdate returns the kv passed in, so test each field individually for
 		// completeness. It should probably be changed to not bother doing that.
@@ -140,7 +140,7 @@ func doTestPluginSaveOrUpdate(t *testing.T, ss store.Store, doer func(kv *model.
 
 		actualKV, nErr := ss.Plugin().Get(pluginId, key)
 		_, ok := nErr.(*store.ErrNotFound)
-		require.NotNil(t, nErr)
+		require.Error(t, nErr)
 		assert.True(t, ok)
 		assert.Nil(t, actualKV)
 	})
@@ -161,13 +161,13 @@ func doTestPluginSaveOrUpdate(t *testing.T, ss store.Store, doer func(kv *model.
 		}
 
 		_, err := doer(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		newValue := model.NewId()
 		kv.Value = []byte(newValue)
 
 		retKV, err := doer(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kv, retKV)
 		// SaveOrUpdate returns the kv passed in, so test each field individually for
 		// completeness. It should probably be changed to not bother doing that.
@@ -177,7 +177,7 @@ func doTestPluginSaveOrUpdate(t *testing.T, ss store.Store, doer func(kv *model.
 		assert.Equal(t, expireAt, kv.ExpireAt)
 
 		actualKV, nErr := ss.Plugin().Get(pluginId, key)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 		assert.Equal(t, kv, actualKV)
 	})
 
@@ -197,12 +197,12 @@ func doTestPluginSaveOrUpdate(t *testing.T, ss store.Store, doer func(kv *model.
 		}
 
 		_, err := doer(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kv.Value = nil
 		retKV, err := doer(kv)
 
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kv, retKV)
 		// SaveOrUpdate returns the kv passed in, so test each field individually for
 		// completeness. It should probably be changed to not bother doing that.
@@ -213,7 +213,7 @@ func doTestPluginSaveOrUpdate(t *testing.T, ss store.Store, doer func(kv *model.
 
 		actualKV, nErr := ss.Plugin().Get(pluginId, key)
 		_, ok := nErr.(*store.ErrNotFound)
-		require.NotNil(t, nErr)
+		require.Error(t, nErr)
 		assert.True(t, ok)
 		assert.Nil(t, actualKV)
 	})
@@ -240,7 +240,7 @@ func doTestPluginCompareAndSet(t *testing.T, ss store.Store, compareAndSet func(
 		}
 
 		ok, err := compareAndSet(kv, nil)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		assert.False(t, ok)
 		appErr, ok := err.(*model.AppError)
 		require.True(t, ok)
@@ -252,11 +252,11 @@ func doTestPluginCompareAndSet(t *testing.T, ss store.Store, compareAndSet func(
 		t.Helper()
 
 		ok, err := compareAndSet(kv, oldValue)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.True(t, ok, "should have succeeded to CompareAndSet")
 
 		actualKV, nErr := ss.Plugin().Get(kv.PluginId, kv.Key)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 
 		// When tested with KVSetWithOptions, a strict comparison can fail because that
 		// function accepts a relative time and makes its own call to model.GetMillis(),
@@ -277,17 +277,17 @@ func doTestPluginCompareAndSet(t *testing.T, ss store.Store, compareAndSet func(
 		t.Helper()
 
 		ok, err := compareAndSet(kv, oldValue)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.False(t, ok, "should have failed to CompareAndSet")
 
 		actualKV, nErr := ss.Plugin().Get(kv.PluginId, kv.Key)
 		if existingKV == nil {
-			require.NotNil(t, nErr)
+			require.Error(t, nErr)
 			_, ok := nErr.(*store.ErrNotFound)
 			assert.True(t, ok)
 			assert.Nil(t, actualKV)
 		} else {
-			require.Nil(t, nErr)
+			require.NoError(t, nErr)
 			assert.Equal(t, existingKV, actualKV)
 		}
 	}
@@ -297,12 +297,12 @@ func doTestPluginCompareAndSet(t *testing.T, ss store.Store, compareAndSet func(
 		t.Helper()
 
 		ok, err := compareAndSet(kv, oldValue)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.True(t, ok, "should have succeeded to CompareAndSet")
 
 		actualKV, nErr := ss.Plugin().Get(kv.PluginId, kv.Key)
 		_, ok = nErr.(*store.ErrNotFound)
-		require.NotNil(t, nErr)
+		require.Error(t, nErr)
 		assert.True(t, ok)
 		assert.Nil(t, actualKV)
 	}
@@ -331,7 +331,7 @@ func doTestPluginCompareAndSet(t *testing.T, ss store.Store, compareAndSet func(
 				ExpireAt: 1,
 			}
 			_, err := ss.Plugin().SaveOrUpdate(expiredKV)
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			return expiredKV, tearDown
 		},
@@ -407,7 +407,7 @@ func doTestPluginCompareAndSet(t *testing.T, ss store.Store, compareAndSet func(
 				ExpireAt: 0,
 			}
 			_, err := ss.Plugin().SaveOrUpdate(existingKV)
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			return existingKV, tearDown
 		}
@@ -543,7 +543,7 @@ func testPluginCompareAndDelete(t *testing.T, ss store.Store) {
 		}
 
 		ok, err := ss.Plugin().CompareAndDelete(kv, nil)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		assert.False(t, ok)
 		appErr, ok := err.(*model.AppError)
 		require.True(t, ok)
@@ -573,7 +573,7 @@ func testPluginCompareAndDelete(t *testing.T, ss store.Store) {
 		for description, oldValue := range testCases {
 			t.Run(description, func(t *testing.T) {
 				ok, err := ss.Plugin().CompareAndDelete(kv, oldValue)
-				require.Nil(t, err)
+				require.NoError(t, err)
 				assert.False(t, ok)
 			})
 		}
@@ -594,7 +594,7 @@ func testPluginCompareAndDelete(t *testing.T, ss store.Store) {
 			ExpireAt: expireAt,
 		}
 		_, err := ss.Plugin().SaveOrUpdate(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		testCases := map[string][]byte{
 			"given nil old value":       nil,
@@ -605,7 +605,7 @@ func testPluginCompareAndDelete(t *testing.T, ss store.Store) {
 		for description, oldValue := range testCases {
 			t.Run(description, func(t *testing.T) {
 				ok, err := ss.Plugin().CompareAndDelete(kv, oldValue)
-				require.Nil(t, err)
+				require.NoError(t, err)
 				assert.False(t, ok)
 			})
 		}
@@ -626,12 +626,12 @@ func testPluginCompareAndDelete(t *testing.T, ss store.Store) {
 			ExpireAt: expireAt,
 		}
 		_, err := ss.Plugin().SaveOrUpdate(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		oldValue := []byte(model.NewId())
 
 		ok, err := ss.Plugin().CompareAndDelete(kv, oldValue)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.False(t, ok)
 	})
 
@@ -650,12 +650,12 @@ func testPluginCompareAndDelete(t *testing.T, ss store.Store) {
 			ExpireAt: expireAt,
 		}
 		_, err := ss.Plugin().SaveOrUpdate(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		oldValue := []byte(value)
 
 		ok, err := ss.Plugin().CompareAndDelete(kv, oldValue)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.True(t, ok)
 	})
 }
@@ -674,7 +674,7 @@ func testPluginSetWithOptions(t *testing.T, ss store.Store) {
 		}
 
 		ok, err := ss.Plugin().SetWithOptions(pluginId, key, []byte(value), options)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		assert.False(t, ok)
 		appErr, ok := err.(*model.AppError)
 		require.True(t, ok)
@@ -691,7 +691,7 @@ func testPluginSetWithOptions(t *testing.T, ss store.Store) {
 		options := model.PluginKVSetOptions{}
 
 		ok, err := ss.Plugin().SetWithOptions(pluginId, key, []byte(value), options)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		assert.False(t, ok)
 		appErr, ok := err.(*model.AppError)
 		require.True(t, ok)
@@ -741,7 +741,7 @@ func testPluginGet(t *testing.T, ss store.Store) {
 
 		kv, nErr := ss.Plugin().Get(pluginId, key)
 		_, ok := nErr.(*store.ErrNotFound)
-		require.NotNil(t, nErr)
+		require.Error(t, nErr)
 		assert.True(t, ok)
 		assert.Nil(t, kv)
 	})
@@ -760,11 +760,11 @@ func testPluginGet(t *testing.T, ss store.Store) {
 		}
 
 		_, err := ss.Plugin().SaveOrUpdate(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kv, err = ss.Plugin().Get(model.NewId(), key)
 		_, ok := err.(*store.ErrNotFound)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		assert.True(t, ok)
 		assert.Nil(t, kv)
 	})
@@ -783,11 +783,11 @@ func testPluginGet(t *testing.T, ss store.Store) {
 		}
 
 		_, err := ss.Plugin().SaveOrUpdate(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kv, err = ss.Plugin().Get(pluginId, model.NewId())
 		_, ok := err.(*store.ErrNotFound)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		assert.True(t, ok)
 		assert.Nil(t, kv)
 	})
@@ -806,11 +806,11 @@ func testPluginGet(t *testing.T, ss store.Store) {
 		}
 
 		_, err := ss.Plugin().SaveOrUpdate(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kv, err = ss.Plugin().Get(pluginId, model.NewId())
 		_, ok := err.(*store.ErrNotFound)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		assert.True(t, ok)
 		assert.Nil(t, kv)
 	})
@@ -829,11 +829,11 @@ func testPluginGet(t *testing.T, ss store.Store) {
 		}
 
 		_, err := ss.Plugin().SaveOrUpdate(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kv, err = ss.Plugin().Get(pluginId, model.NewId())
 		_, ok := err.(*store.ErrNotFound)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		assert.True(t, ok)
 		assert.Nil(t, kv)
 	})
@@ -852,10 +852,10 @@ func testPluginGet(t *testing.T, ss store.Store) {
 		}
 
 		_, err := ss.Plugin().SaveOrUpdate(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		actualKV, err := ss.Plugin().Get(pluginId, key)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, kv, actualKV)
 	})
 
@@ -873,10 +873,10 @@ func testPluginGet(t *testing.T, ss store.Store) {
 		}
 
 		_, err := ss.Plugin().SaveOrUpdate(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		actualKV, err := ss.Plugin().Get(pluginId, key)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, kv, actualKV)
 	})
 }
@@ -889,11 +889,11 @@ func testPluginDelete(t *testing.T, ss store.Store) {
 		key := model.NewId()
 
 		err := ss.Plugin().Delete(pluginId, key)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kv, err := ss.Plugin().Get(pluginId, key)
 		_, ok := err.(*store.ErrNotFound)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		assert.True(t, ok)
 		assert.Nil(t, kv)
 	})
@@ -933,14 +933,14 @@ func testPluginDelete(t *testing.T, ss store.Store) {
 			}
 
 			_, err := ss.Plugin().SaveOrUpdate(kv)
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			err = ss.Plugin().Delete(pluginId, key)
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			kv, err = ss.Plugin().Get(pluginId, key)
 			_, ok := err.(*store.ErrNotFound)
-			require.NotNil(t, err)
+			require.Error(t, err)
 			assert.True(t, ok)
 			assert.Nil(t, kv)
 		})
@@ -961,11 +961,11 @@ func testPluginDeleteAllForPlugin(t *testing.T, ss store.Store) {
 			ExpireAt: 0,
 		}
 		_, err := ss.Plugin().SaveOrUpdate(otherPluginKV)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		return pluginId, func() {
 			actualOtherPluginKV, err := ss.Plugin().Get(otherPluginKV.PluginId, otherPluginKV.Key)
-			require.Nil(t, err, "failed to find other key value from different plugin")
+			require.NoError(t, err, "failed to find other key value from different plugin")
 			assert.Equal(t, otherPluginKV, actualOtherPluginKV)
 		}
 	}
@@ -975,7 +975,7 @@ func testPluginDeleteAllForPlugin(t *testing.T, ss store.Store) {
 		defer tearDown()
 
 		err := ss.Plugin().DeleteAllForPlugin(pluginId)
-		require.Nil(t, err)
+		require.NoError(t, err)
 	})
 
 	t.Run("multiple keys to delete", func(t *testing.T) {
@@ -989,7 +989,7 @@ func testPluginDeleteAllForPlugin(t *testing.T, ss store.Store) {
 			ExpireAt: 0,
 		}
 		_, err := ss.Plugin().SaveOrUpdate(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kv2 := &model.PluginKeyValue{
 			PluginId: pluginId,
@@ -998,19 +998,19 @@ func testPluginDeleteAllForPlugin(t *testing.T, ss store.Store) {
 			ExpireAt: 0,
 		}
 		_, err = ss.Plugin().SaveOrUpdate(kv2)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		err = ss.Plugin().DeleteAllForPlugin(pluginId)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		_, err = ss.Plugin().Get(kv.PluginId, kv.Key)
 		_, ok := err.(*store.ErrNotFound)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		assert.True(t, ok)
 
 		_, err = ss.Plugin().Get(kv.PluginId, kv2.Key)
 		_, ok = err.(*store.ErrNotFound)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		assert.True(t, ok)
 	})
 }
@@ -1018,7 +1018,7 @@ func testPluginDeleteAllForPlugin(t *testing.T, ss store.Store) {
 func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
 	t.Run("no keys", func(t *testing.T) {
 		err := ss.Plugin().DeleteAllExpired()
-		require.Nil(t, err)
+		require.NoError(t, err)
 	})
 
 	t.Run("no expiring keys to delete", func(t *testing.T) {
@@ -1032,7 +1032,7 @@ func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
 			ExpireAt: 0,
 		}
 		_, err := ss.Plugin().SaveOrUpdate(kvA1)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kvA2 := &model.PluginKeyValue{
 			PluginId: pluginIdA,
@@ -1041,7 +1041,7 @@ func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
 			ExpireAt: 0,
 		}
 		_, err = ss.Plugin().SaveOrUpdate(kvA2)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kvB1 := &model.PluginKeyValue{
 			PluginId: pluginIdB,
@@ -1050,7 +1050,7 @@ func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
 			ExpireAt: 0,
 		}
 		_, err = ss.Plugin().SaveOrUpdate(kvB1)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kvB2 := &model.PluginKeyValue{
 			PluginId: pluginIdB,
@@ -1059,25 +1059,25 @@ func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
 			ExpireAt: 0,
 		}
 		_, err = ss.Plugin().SaveOrUpdate(kvB2)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		err = ss.Plugin().DeleteAllExpired()
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		actualKVA1, err := ss.Plugin().Get(pluginIdA, kvA1.Key)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kvA1, actualKVA1)
 
 		actualKVA2, err := ss.Plugin().Get(pluginIdA, kvA2.Key)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kvA2, actualKVA2)
 
 		actualKVB1, err := ss.Plugin().Get(pluginIdB, kvB1.Key)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kvB1, actualKVB1)
 
 		actualKVB2, err := ss.Plugin().Get(pluginIdB, kvB2.Key)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kvB2, actualKVB2)
 	})
 
@@ -1092,7 +1092,7 @@ func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
 			ExpireAt: model.GetMillis() + 15*1000,
 		}
 		_, err := ss.Plugin().SaveOrUpdate(kvA1)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kvA2 := &model.PluginKeyValue{
 			PluginId: pluginIdA,
@@ -1101,7 +1101,7 @@ func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
 			ExpireAt: model.GetMillis() + 15*1000,
 		}
 		_, err = ss.Plugin().SaveOrUpdate(kvA2)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kvB1 := &model.PluginKeyValue{
 			PluginId: pluginIdB,
@@ -1110,7 +1110,7 @@ func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
 			ExpireAt: model.GetMillis() + 15*1000,
 		}
 		_, err = ss.Plugin().SaveOrUpdate(kvB1)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kvB2 := &model.PluginKeyValue{
 			PluginId: pluginIdB,
@@ -1119,25 +1119,25 @@ func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
 			ExpireAt: model.GetMillis() + 15*1000,
 		}
 		_, err = ss.Plugin().SaveOrUpdate(kvB2)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		err = ss.Plugin().DeleteAllExpired()
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		actualKVA1, err := ss.Plugin().Get(pluginIdA, kvA1.Key)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kvA1, actualKVA1)
 
 		actualKVA2, err := ss.Plugin().Get(pluginIdA, kvA2.Key)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kvA2, actualKVA2)
 
 		actualKVB1, err := ss.Plugin().Get(pluginIdB, kvB1.Key)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kvB1, actualKVB1)
 
 		actualKVB2, err := ss.Plugin().Get(pluginIdB, kvB2.Key)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kvB2, actualKVB2)
 	})
 
@@ -1152,7 +1152,7 @@ func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
 			ExpireAt: model.GetMillis() + 15*1000,
 		}
 		_, err := ss.Plugin().SaveOrUpdate(kvA1)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		expiredKVA2 := &model.PluginKeyValue{
 			PluginId: pluginIdA,
@@ -1161,7 +1161,7 @@ func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
 			ExpireAt: model.GetMillis() - 15*1000,
 		}
 		_, err = ss.Plugin().SaveOrUpdate(expiredKVA2)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		kvB1 := &model.PluginKeyValue{
 			PluginId: pluginIdB,
@@ -1170,7 +1170,7 @@ func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
 			ExpireAt: model.GetMillis() + 15*1000,
 		}
 		_, err = ss.Plugin().SaveOrUpdate(kvB1)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		expiredKVB2 := &model.PluginKeyValue{
 			PluginId: pluginIdB,
@@ -1179,28 +1179,28 @@ func testPluginDeleteAllExpired(t *testing.T, ss store.Store) {
 			ExpireAt: model.GetMillis() - 15*1000,
 		}
 		_, err = ss.Plugin().SaveOrUpdate(expiredKVB2)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		err = ss.Plugin().DeleteAllExpired()
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		actualKVA1, err := ss.Plugin().Get(pluginIdA, kvA1.Key)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kvA1, actualKVA1)
 
 		actualKVA2, err := ss.Plugin().Get(pluginIdA, expiredKVA2.Key)
 		_, ok := err.(*store.ErrNotFound)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		assert.True(t, ok)
 		assert.Nil(t, actualKVA2)
 
 		actualKVB1, err := ss.Plugin().Get(pluginIdB, kvB1.Key)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, kvB1, actualKVB1)
 
 		actualKVB2, err := ss.Plugin().Get(pluginIdB, expiredKVB2.Key)
 		_, ok = err.(*store.ErrNotFound)
-		require.NotNil(t, err)
+		require.Error(t, err)
 		assert.True(t, ok)
 		assert.Nil(t, actualKVB2)
 	})
@@ -1214,7 +1214,7 @@ func testPluginList(t *testing.T, ss store.Store) {
 		// Ignore the pluginId setup by setupKVs
 		pluginId := model.NewId()
 		keys, err := ss.Plugin().List(pluginId, 0, 100)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Empty(t, keys)
 	})
 
@@ -1232,10 +1232,10 @@ func testPluginList(t *testing.T, ss store.Store) {
 			ExpireAt: 0,
 		}
 		_, err := ss.Plugin().SaveOrUpdate(kv)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		keys, err := ss.Plugin().List(pluginId, 0, 100)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Len(t, keys, 1)
 		assert.Equal(t, kv.Key, keys[0])
 	})
@@ -1257,18 +1257,18 @@ func testPluginList(t *testing.T, ss store.Store) {
 				ExpireAt: 0,
 			}
 			_, err := ss.Plugin().SaveOrUpdate(kv)
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			keys = append(keys, key)
 		}
 		sort.Strings(keys)
 
 		keys1, err := ss.Plugin().List(pluginId, 0, 100)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Len(t, keys1, 100)
 
 		keys2, err := ss.Plugin().List(pluginId, 100, 100)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Len(t, keys2, 50)
 
 		actualKeys := append(keys1, keys2...)
@@ -1307,7 +1307,7 @@ func testPluginList(t *testing.T, ss store.Store) {
 				ExpireAt: expireAt,
 			}
 			_, err := ss.Plugin().SaveOrUpdate(kv)
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			if expireAt == 0 || expireAt > now {
 				keys = append(keys, key)
@@ -1318,11 +1318,11 @@ func testPluginList(t *testing.T, ss store.Store) {
 		sort.Strings(keys)
 
 		keys1, err := ss.Plugin().List(pluginId, 0, 100)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Len(t, keys1, 100)
 
 		keys2, err := ss.Plugin().List(pluginId, 100, 100)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Len(t, keys2, 35)
 
 		actualKeys := append(keys1, keys2...)
@@ -1348,7 +1348,7 @@ func testPluginList(t *testing.T, ss store.Store) {
 				ExpireAt: 0,
 			}
 			_, err := ss.Plugin().SaveOrUpdate(kv)
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			keys = append(keys, key)
 		}
@@ -1356,19 +1356,19 @@ func testPluginList(t *testing.T, ss store.Store) {
 
 		t.Run("default limit", func(t *testing.T) {
 			keys1, err := ss.Plugin().List(pluginId, 0, 0)
-			require.Nil(t, err)
+			require.NoError(t, err)
 			require.Len(t, keys1, 10)
 		})
 
 		t.Run("offset 0, limit 1", func(t *testing.T) {
 			keys2, err := ss.Plugin().List(pluginId, 0, 1)
-			require.Nil(t, err)
+			require.NoError(t, err)
 			require.Len(t, keys2, 1)
 		})
 
 		t.Run("offset 1, limit 1", func(t *testing.T) {
 			keys2, err := ss.Plugin().List(pluginId, 1, 1)
-			require.Nil(t, err)
+			require.NoError(t, err)
 			require.Len(t, keys2, 1)
 		})
 	})

store/storetest/preference_store.go

@@ -43,7 +43,7 @@ func testPreferenceSave(t *testing.T, ss store.Store) {
 		},
 	}
 	err := ss.Preference().Save(&preferences)
-	require.Nil(t, err, "saving preference returned error")
+	require.NoError(t, err, "saving preference returned error")
 
 	for _, preference := range preferences {
 		data, _ := ss.Preference().Get(preference.UserId, preference.Category, preference.Name)
@@ -53,7 +53,7 @@ func testPreferenceSave(t *testing.T, ss store.Store) {
 	preferences[0].Value = "value2a"
 	preferences[1].Value = "value2b"
 	err = ss.Preference().Save(&preferences)
-	require.Nil(t, err, "saving preference returned error")
+	require.NoError(t, err, "saving preference returned error")
 
 	for _, preference := range preferences {
 		data, _ := ss.Preference().Get(preference.UserId, preference.Category, preference.Name)
@@ -90,15 +90,15 @@ func testPreferenceGet(t *testing.T, ss store.Store) {
 	}
 
 	err := ss.Preference().Save(&preferences)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	data, err := ss.Preference().Get(userId, category, name)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, preferences[0].ToJson(), data.ToJson(), "got incorrect preference")
 
 	// make sure getting a missing preference fails
 	_, err = ss.Preference().Get(model.NewId(), model.NewId(), model.NewId())
-	require.NotNil(t, err, "no error on getting a missing preference")
+	require.Error(t, err, "no error on getting a missing preference")
 }
 
 func testPreferenceGetCategory(t *testing.T, ss store.Store) {
@@ -133,10 +133,10 @@ func testPreferenceGetCategory(t *testing.T, ss store.Store) {
 	}
 
 	err := ss.Preference().Save(&preferences)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	preferencesByCategory, err := ss.Preference().GetCategory(userId, category)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, 2, len(preferencesByCategory), "got the wrong number of preferences")
 	require.True(
 		t,
@@ -146,7 +146,7 @@ func testPreferenceGetCategory(t *testing.T, ss store.Store) {
 
 	// make sure getting a missing preference category doesn't fail
 	preferencesByCategory, err = ss.Preference().GetCategory(model.NewId(), model.NewId())
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, 0, len(preferencesByCategory), "shouldn't have got any preferences")
 }
 
@@ -182,10 +182,10 @@ func testPreferenceGetAll(t *testing.T, ss store.Store) {
 	}
 
 	err := ss.Preference().Save(&preferences)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	result, err := ss.Preference().GetAll(userId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, 3, len(result), "got the wrong number of preferences")
 
 	for i := 0; i < 3; i++ {
@@ -226,10 +226,10 @@ func testPreferenceDeleteByUser(t *testing.T, ss store.Store) {
 	}
 
 	err := ss.Preference().Save(&preferences)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	err = ss.Preference().PermanentDeleteByUser(userId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testPreferenceDelete(t *testing.T, ss store.Store) {
@@ -241,16 +241,16 @@ func testPreferenceDelete(t *testing.T, ss store.Store) {
 	}
 
 	err := ss.Preference().Save(&model.Preferences{preference})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	preferences, err := ss.Preference().GetAll(preference.UserId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, preferences, 1, "should've returned 1 preference")
 
 	err = ss.Preference().Delete(preference.UserId, preference.Category, preference.Name)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	preferences, err = ss.Preference().GetAll(preference.UserId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, preferences, "should've returned no preferences")
 }
 
@@ -273,17 +273,17 @@ func testPreferenceDeleteCategory(t *testing.T, ss store.Store) {
 	}
 
 	err := ss.Preference().Save(&model.Preferences{preference1, preference2})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	preferences, err := ss.Preference().GetAll(userId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, preferences, 2, "should've returned 2 preferences")
 
 	err = ss.Preference().DeleteCategory(userId, category)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	preferences, err = ss.Preference().GetAll(userId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, preferences, "should've returned no preferences")
 }
 
@@ -308,25 +308,25 @@ func testPreferenceDeleteCategoryAndName(t *testing.T, ss store.Store) {
 	}
 
 	err := ss.Preference().Save(&model.Preferences{preference1, preference2})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	preferences, err := ss.Preference().GetAll(userId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, preferences, 1, "should've returned 1 preference")
 
 	preferences, err = ss.Preference().GetAll(userId2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, preferences, 1, "should've returned 1 preference")
 
 	err = ss.Preference().DeleteCategoryAndName(category, name)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	preferences, err = ss.Preference().GetAll(userId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, preferences, "should've returned no preference")
 
 	preferences, err = ss.Preference().GetAll(userId2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, preferences, "should've returned no preference")
 }
 
@@ -340,7 +340,7 @@ func testPreferenceCleanupFlagsBatch(t *testing.T, ss store.Store) {
 	o1.Message = "zz" + model.NewId() + "AAAAAAAAAAA"
 	o1.CreateAt = 1000
 	o1, err := ss.Post().Save(o1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	preference1 := model.Preference{
 		UserId:   userId,
@@ -357,14 +357,14 @@ func testPreferenceCleanupFlagsBatch(t *testing.T, ss store.Store) {
 	}
 
 	nErr := ss.Preference().Save(&model.Preferences{preference1, preference2})
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	_, nErr = ss.Preference().CleanupFlagsBatch(10000)
-	assert.Nil(t, nErr)
+	assert.NoError(t, nErr)
 
 	_, nErr = ss.Preference().Get(userId, category, preference1.Name)
-	assert.Nil(t, nErr)
+	assert.NoError(t, nErr)
 
 	_, nErr = ss.Preference().Get(userId, category, preference2.Name)
-	assert.NotNil(t, nErr)
+	assert.Error(t, nErr)
 }

store/storetest/reaction_store.go

@@ -31,7 +31,7 @@ func testReactionSave(t *testing.T, ss store.Store) {
 		ChannelId: model.NewId(),
 		UserId:    model.NewId(),
 	})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	firstUpdateAt := post.UpdateAt
 
 	reaction1 := &model.Reaction{
@@ -42,7 +42,7 @@ func testReactionSave(t *testing.T, ss store.Store) {
 
 	time.Sleep(time.Millisecond)
 	reaction, nErr := ss.Reaction().Save(reaction1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	saved := reaction
 	assert.Equal(t, saved.UserId, reaction1.UserId, "should've saved reaction user_id and returned it")
@@ -53,7 +53,7 @@ func testReactionSave(t *testing.T, ss store.Store) {
 
 	var secondUpdateAt int64
 	postList, err := ss.Post().Get(reaction1.PostId, false, false, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	assert.True(t, postList.Posts[post.Id].HasReactions, "should've set HasReactions = true on post")
 	assert.NotEqual(t, postList.Posts[post.Id].UpdateAt, firstUpdateAt, "should've marked post as updated when HasReactions changed")
@@ -63,7 +63,7 @@ func testReactionSave(t *testing.T, ss store.Store) {
 	}
 
 	_, nErr = ss.Reaction().Save(reaction1)
-	assert.Nil(t, nErr, "should've allowed saving a duplicate reaction")
+	assert.NoError(t, nErr, "should've allowed saving a duplicate reaction")
 
 	// different user
 	reaction2 := &model.Reaction{
@@ -74,10 +74,10 @@ func testReactionSave(t *testing.T, ss store.Store) {
 
 	time.Sleep(time.Millisecond)
 	_, nErr = ss.Reaction().Save(reaction2)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	postList, err = ss.Post().Get(reaction2.PostId, false, false, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	assert.NotEqual(t, postList.Posts[post.Id].UpdateAt, secondUpdateAt, "should've marked post as updated even if HasReactions doesn't change")
 
@@ -88,7 +88,7 @@ func testReactionSave(t *testing.T, ss store.Store) {
 		EmojiName: reaction1.EmojiName,
 	}
 	_, nErr = ss.Reaction().Save(reaction3)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// different emoji
 	reaction4 := &model.Reaction{
@@ -97,7 +97,7 @@ func testReactionSave(t *testing.T, ss store.Store) {
 		EmojiName: model.NewId(),
 	}
 	_, nErr = ss.Reaction().Save(reaction4)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// invalid reaction
 	reaction5 := &model.Reaction{
@@ -105,7 +105,7 @@ func testReactionSave(t *testing.T, ss store.Store) {
 		PostId: reaction1.PostId,
 	}
 	_, nErr = ss.Reaction().Save(reaction5)
-	require.NotNil(t, nErr, "should've failed for invalid reaction")
+	require.Error(t, nErr, "should've failed for invalid reaction")
 
 }
 
@@ -115,7 +115,7 @@ func testReactionDelete(t *testing.T, ss store.Store) {
 			ChannelId: model.NewId(),
 			UserId:    model.NewId(),
 		})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		reaction := &model.Reaction{
 			UserId:    model.NewId(),
@@ -124,23 +124,23 @@ func testReactionDelete(t *testing.T, ss store.Store) {
 		}
 
 		_, nErr := ss.Reaction().Save(reaction)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 
 		result, err := ss.Post().Get(reaction.PostId, false, false, false)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		firstUpdateAt := result.Posts[post.Id].UpdateAt
 
 		_, nErr = ss.Reaction().Delete(reaction)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 
 		reactions, rErr := ss.Reaction().GetForPost(post.Id, false)
-		require.Nil(t, rErr)
+		require.NoError(t, rErr)
 
 		assert.Empty(t, reactions, "should've deleted reaction")
 
 		postList, err := ss.Post().Get(post.Id, false, false, false)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		assert.False(t, postList.Posts[post.Id].HasReactions, "should've set HasReactions = false on post")
 		assert.NotEqual(t, postList.Posts[post.Id].UpdateAt, firstUpdateAt, "should mark post as updated after deleting reactions")
@@ -151,7 +151,7 @@ func testReactionDelete(t *testing.T, ss store.Store) {
 			ChannelId: model.NewId(),
 			UserId:    model.NewId(),
 		})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		reaction := &model.Reaction{
 			UserId:    model.NewId(),
@@ -160,19 +160,19 @@ func testReactionDelete(t *testing.T, ss store.Store) {
 		}
 
 		savedReaction, nErr := ss.Reaction().Save(reaction)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 
 		updateAt := savedReaction.UpdateAt
 
 		_, nErr = ss.Reaction().Delete(savedReaction)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 
 		// add same reaction back and ensure update_at is set
 		_, nErr = ss.Reaction().Save(savedReaction)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 
 		reactions, err := ss.Reaction().GetForPost(post.Id, false)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		assert.Len(t, reactions, 1)
 		assert.GreaterOrEqual(t, reactions[0].UpdateAt, updateAt)
@@ -209,7 +209,7 @@ func testReactionGetForPost(t *testing.T, ss store.Store) {
 
 	for _, reaction := range reactions {
 		_, err := ss.Reaction().Save(reaction)
-		require.Nil(t, err)
+		require.NoError(t, err)
 	}
 
 	// save and delete an additional reaction to test soft deletion
@@ -219,12 +219,12 @@ func testReactionGetForPost(t *testing.T, ss store.Store) {
 		EmojiName: "grin",
 	}
 	savedTmp, err := ss.Reaction().Save(temp)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = ss.Reaction().Delete(savedTmp)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	returned, err := ss.Reaction().GetForPost(postId, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, returned, 3, "should've returned 3 reactions")
 
 	for _, reaction := range reactions {
@@ -247,7 +247,7 @@ func testReactionGetForPost(t *testing.T, ss store.Store) {
 
 	// Should return cached item
 	returned, err = ss.Reaction().GetForPost(postId, true)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, returned, 3, "should've returned 3 reactions")
 
 	for _, reaction := range reactions {
@@ -276,17 +276,17 @@ func testReactionDeleteAllWithEmojiName(t *testing.T, ss store.Store, s SqlStore
 		ChannelId: model.NewId(),
 		UserId:    model.NewId(),
 	})
-	require.Nil(t, err1)
+	require.NoError(t, err1)
 	post2, err2 := ss.Post().Save(&model.Post{
 		ChannelId: model.NewId(),
 		UserId:    model.NewId(),
 	})
-	require.Nil(t, err2)
+	require.NoError(t, err2)
 	post3, err3 := ss.Post().Save(&model.Post{
 		ChannelId: model.NewId(),
 		UserId:    model.NewId(),
 	})
-	require.Nil(t, err3)
+	require.NoError(t, err3)
 
 	userId := model.NewId()
 
@@ -320,7 +320,7 @@ func testReactionDeleteAllWithEmojiName(t *testing.T, ss store.Store, s SqlStore
 
 	for _, reaction := range reactions {
 		_, err := ss.Reaction().Save(reaction)
-		require.Nil(t, err)
+		require.NoError(t, err)
 	}
 
 	// make at least one Reaction record contain NULL for Update and DeleteAt to simulate post schema upgrade case.
@@ -336,17 +336,17 @@ func testReactionDeleteAllWithEmojiName(t *testing.T, ss store.Store, s SqlStore
 			"PostId":    post.Id,
 			"EmojiName": emojiToDelete,
 		})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	rowsAffected, err := sqlResult.RowsAffected()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.NotZero(t, rowsAffected)
 
 	err = ss.Reaction().DeleteAllWithEmojiName(emojiToDelete)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// check that the reactions were deleted
 	returned, err := ss.Reaction().GetForPost(post.Id, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, returned, 1, "should've only removed reactions with emoji name")
 
 	for _, reaction := range returned {
@@ -354,24 +354,24 @@ func testReactionDeleteAllWithEmojiName(t *testing.T, ss store.Store, s SqlStore
 	}
 
 	returned, err = ss.Reaction().GetForPost(post2.Id, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, returned, 1, "should've only removed reactions with emoji name")
 
 	returned, err = ss.Reaction().GetForPost(post3.Id, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, returned, "should've only removed reactions with emoji name")
 
 	// check that the posts are updated
 	postList, err := ss.Post().Get(post.Id, false, false, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.True(t, postList.Posts[post.Id].HasReactions, "post should still have reactions")
 
 	postList, err = ss.Post().Get(post2.Id, false, false, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.True(t, postList.Posts[post2.Id].HasReactions, "post should still have reactions")
 
 	postList, err = ss.Post().Get(post3.Id, false, false, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.False(t, postList.Posts[post3.Id].HasReactions, "post shouldn't have reactions any more")
 
 }
@@ -381,7 +381,7 @@ func testReactionStorePermanentDeleteBatch(t *testing.T, ss store.Store) {
 		ChannelId: model.NewId(),
 		UserId:    model.NewId(),
 	})
-	require.Nil(t, err1)
+	require.NoError(t, err1)
 
 	reactions := []*model.Reaction{
 		{
@@ -415,22 +415,22 @@ func testReactionStorePermanentDeleteBatch(t *testing.T, ss store.Store) {
 	for _, reaction := range reactions {
 		var nErr error
 		lastReaction, nErr = ss.Reaction().Save(reaction)
-		require.Nil(t, nErr)
+		require.NoError(t, nErr)
 	}
 
 	returned, err := ss.Reaction().GetForPost(post.Id, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, returned, 4, "expected 4 reactions")
 
 	_, err = ss.Reaction().PermanentDeleteBatch(1800, 1000)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// This is to force a clear of the cache.
 	_, err = ss.Reaction().Delete(lastReaction)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	returned, err = ss.Reaction().GetForPost(post.Id, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, returned, 1, "expected 1 reaction. Got: %v", len(returned))
 }
 
@@ -477,12 +477,12 @@ func testReactionBulkGetForPosts(t *testing.T, ss store.Store) {
 
 	for _, reaction := range reactions {
 		_, err := ss.Reaction().Save(reaction)
-		require.Nil(t, err)
+		require.NoError(t, err)
 	}
 
 	postIds := []string{postId, post2Id, post3Id}
 	returned, err := ss.Reaction().BulkGetForPosts(postIds)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, returned, 5, "should've returned 5 reactions")
 
 	post4IdFound := false
@@ -506,7 +506,7 @@ func testReactionDeadlock(t *testing.T, ss store.Store) {
 		ChannelId: model.NewId(),
 		UserId:    model.NewId(),
 	})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	reaction1 := &model.Reaction{
 		UserId:    model.NewId(),
@@ -514,7 +514,7 @@ func testReactionDeadlock(t *testing.T, ss store.Store) {
 		EmojiName: model.NewId(),
 	}
 	_, nErr := ss.Reaction().Save(reaction1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// different user
 	reaction2 := &model.Reaction{
@@ -523,7 +523,7 @@ func testReactionDeadlock(t *testing.T, ss store.Store) {
 		EmojiName: reaction1.EmojiName,
 	}
 	_, nErr = ss.Reaction().Save(reaction2)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// different post
 	reaction3 := &model.Reaction{
@@ -532,7 +532,7 @@ func testReactionDeadlock(t *testing.T, ss store.Store) {
 		EmojiName: reaction1.EmojiName,
 	}
 	_, nErr = ss.Reaction().Save(reaction3)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	// different emoji
 	reaction4 := &model.Reaction{
@@ -541,7 +541,7 @@ func testReactionDeadlock(t *testing.T, ss store.Store) {
 		EmojiName: model.NewId(),
 	}
 	_, nErr = ss.Reaction().Save(reaction4)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	var wg sync.WaitGroup
 	wg.Add(2)
@@ -549,14 +549,14 @@ func testReactionDeadlock(t *testing.T, ss store.Store) {
 	go func() {
 		defer wg.Done()
 		err := ss.Reaction().DeleteAllWithEmojiName(reaction1.EmojiName)
-		require.Nil(t, err)
+		require.NoError(t, err)
 	}()
 
 	// 2nd tx
 	go func() {
 		defer wg.Done()
 		_, err := ss.Reaction().Delete(reaction2)
-		require.Nil(t, err)
+		require.NoError(t, err)
 	}()
 	wg.Wait()
 }

store/storetest/role_store.go

@@ -41,7 +41,7 @@ func testRoleStoreSave(t *testing.T, ss store.Store) {
 	}
 
 	d1, err := ss.Role().Save(r1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, d1.Id, 26)
 	assert.Equal(t, r1.Name, d1.Name)
 	assert.Equal(t, r1.DisplayName, d1.DisplayName)
@@ -57,7 +57,7 @@ func testRoleStoreSave(t *testing.T, ss store.Store) {
 	}
 
 	d2, err := ss.Role().Save(d1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, d2.Id, 26)
 	assert.Equal(t, r1.Name, d2.Name)
 	assert.Equal(t, r1.DisplayName, d2.DisplayName)
@@ -80,7 +80,7 @@ func testRoleStoreSave(t *testing.T, ss store.Store) {
 	}
 
 	_, err = ss.Role().Save(r3)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	// Try saving one with a duplicate "name" field.
 	r4 := &model.Role{
@@ -96,12 +96,12 @@ func testRoleStoreSave(t *testing.T, ss store.Store) {
 	}
 
 	_, err = ss.Role().Save(r4)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func testRoleStoreGetAll(t *testing.T, ss store.Store) {
 	prev, err := ss.Role().GetAll()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	prevCount := len(prev)
 
 	// Save a role to test with.
@@ -118,7 +118,7 @@ func testRoleStoreGetAll(t *testing.T, ss store.Store) {
 	}
 
 	_, err = ss.Role().Save(r1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	r2 := &model.Role{
 		Name:        model.NewId(),
@@ -132,10 +132,10 @@ func testRoleStoreGetAll(t *testing.T, ss store.Store) {
 		SchemeManaged: false,
 	}
 	_, err = ss.Role().Save(r2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	data, err := ss.Role().GetAll()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Len(t, data, prevCount+2)
 }
 
@@ -154,12 +154,12 @@ func testRoleStoreGet(t *testing.T, ss store.Store) {
 	}
 
 	d1, err := ss.Role().Save(r1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, d1.Id, 26)
 
 	// Get a valid role
 	d2, err := ss.Role().Get(d1.Id)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, d1.Id, d2.Id)
 	assert.Equal(t, r1.Name, d2.Name)
 	assert.Equal(t, r1.DisplayName, d2.DisplayName)
@@ -169,7 +169,7 @@ func testRoleStoreGet(t *testing.T, ss store.Store) {
 
 	// Get an invalid role
 	_, err = ss.Role().Get(model.NewId())
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func testRoleStoreGetByName(t *testing.T, ss store.Store) {
@@ -187,12 +187,12 @@ func testRoleStoreGetByName(t *testing.T, ss store.Store) {
 	}
 
 	d1, err := ss.Role().Save(r1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, d1.Id, 26)
 
 	// Get a valid role
 	d2, err := ss.Role().GetByName(d1.Name)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, d1.Id, d2.Id)
 	assert.Equal(t, r1.Name, d2.Name)
 	assert.Equal(t, r1.DisplayName, d2.DisplayName)
@@ -202,7 +202,7 @@ func testRoleStoreGetByName(t *testing.T, ss store.Store) {
 
 	// Get an invalid role
 	_, err = ss.Role().GetByName(model.NewId())
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func testRoleStoreGetByNames(t *testing.T, ss store.Store) {
@@ -242,21 +242,21 @@ func testRoleStoreGetByNames(t *testing.T, ss store.Store) {
 	}
 
 	d1, err := ss.Role().Save(r1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, d1.Id, 26)
 
 	d2, err := ss.Role().Save(r2)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, d2.Id, 26)
 
 	d3, err := ss.Role().Save(r3)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, d3.Id, 26)
 
 	// Get two valid roles.
 	n4 := []string{r1.Name, r2.Name}
 	roles4, err := ss.Role().GetByNames(n4)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, roles4, 2)
 	assert.Contains(t, roles4, d1)
 	assert.Contains(t, roles4, d2)
@@ -265,13 +265,13 @@ func testRoleStoreGetByNames(t *testing.T, ss store.Store) {
 	// Get two invalid roles.
 	n5 := []string{model.NewId(), model.NewId()}
 	roles5, err := ss.Role().GetByNames(n5)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Empty(t, roles5)
 
 	// Get one valid one and one invalid one.
 	n6 := []string{r1.Name, model.NewId()}
 	roles6, err := ss.Role().GetByNames(n6)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, roles6, 1)
 	assert.Contains(t, roles6, d1)
 	assert.NotContains(t, roles6, d2)
@@ -293,29 +293,29 @@ func testRoleStoreDelete(t *testing.T, ss store.Store) {
 	}
 
 	d1, err := ss.Role().Save(r1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, d1.Id, 26)
 
 	// Check the role is there.
 	_, err = ss.Role().Get(d1.Id)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	// Delete the role.
 	_, err = ss.Role().Delete(d1.Id)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	// Check the role is deleted there.
 	d2, err := ss.Role().Get(d1.Id)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.NotZero(t, d2.DeleteAt)
 
 	d3, err := ss.Role().GetByName(d1.Name)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.NotZero(t, d3.DeleteAt)
 
 	// Try and delete a role that does not exist.
 	_, err = ss.Role().Delete(model.NewId())
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func testRoleStorePermanentDeleteAll(t *testing.T, ss store.Store) {
@@ -344,19 +344,19 @@ func testRoleStorePermanentDeleteAll(t *testing.T, ss store.Store) {
 	}
 
 	_, err := ss.Role().Save(r1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	_, err = ss.Role().Save(r2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	roles, err := ss.Role().GetByNames([]string{r1.Name, r2.Name})
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, roles, 2)
 
 	err = ss.Role().PermanentDeleteAll()
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	roles, err = ss.Role().GetByNames([]string{r1.Name, r2.Name})
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Empty(t, roles)
 }
 
@@ -370,7 +370,7 @@ func testRoleStoreLowerScopedChannelSchemeRoles(t *testing.T, ss store.Store) {
 		Scope:       model.SCHEME_SCOPE_TEAM,
 	}
 	teamScheme1, err := ss.Scheme().Save(teamScheme1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer ss.Scheme().Delete(teamScheme1.Id)
 
 	teamScheme2 := &model.Scheme{
@@ -380,7 +380,7 @@ func testRoleStoreLowerScopedChannelSchemeRoles(t *testing.T, ss store.Store) {
 		Scope:       model.SCHEME_SCOPE_TEAM,
 	}
 	teamScheme2, err = ss.Scheme().Save(teamScheme2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer ss.Scheme().Delete(teamScheme2.Id)
 
 	channelScheme1 := &model.Scheme{
@@ -390,7 +390,7 @@ func testRoleStoreLowerScopedChannelSchemeRoles(t *testing.T, ss store.Store) {
 		Scope:       model.SCHEME_SCOPE_CHANNEL,
 	}
 	channelScheme1, err = ss.Scheme().Save(channelScheme1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer ss.Scheme().Delete(channelScheme1.Id)
 
 	channelScheme2 := &model.Scheme{
@@ -400,7 +400,7 @@ func testRoleStoreLowerScopedChannelSchemeRoles(t *testing.T, ss store.Store) {
 		Scope:       model.SCHEME_SCOPE_CHANNEL,
 	}
 	channelScheme2, err = ss.Scheme().Save(channelScheme2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer ss.Scheme().Delete(channelScheme1.Id)
 
 	team1 := &model.Team{
@@ -411,7 +411,7 @@ func testRoleStoreLowerScopedChannelSchemeRoles(t *testing.T, ss store.Store) {
 		SchemeId:    &teamScheme1.Id,
 	}
 	team1, err = ss.Team().Save(team1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer ss.Team().PermanentDelete(team1.Id)
 
 	team2 := &model.Team{
@@ -422,7 +422,7 @@ func testRoleStoreLowerScopedChannelSchemeRoles(t *testing.T, ss store.Store) {
 		SchemeId:    &teamScheme2.Id,
 	}
 	team2, err = ss.Team().Save(team2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer ss.Team().PermanentDelete(team2.Id)
 
 	channel1 := &model.Channel{
@@ -433,7 +433,7 @@ func testRoleStoreLowerScopedChannelSchemeRoles(t *testing.T, ss store.Store) {
 		SchemeId:    &channelScheme1.Id,
 	}
 	channel1, nErr := ss.Channel().Save(channel1, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	defer ss.Channel().Delete(channel1.Id, 0)
 
 	channel2 := &model.Channel{
@@ -444,13 +444,13 @@ func testRoleStoreLowerScopedChannelSchemeRoles(t *testing.T, ss store.Store) {
 		SchemeId:    &channelScheme2.Id,
 	}
 	channel2, nErr = ss.Channel().Save(channel2, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	defer ss.Channel().Delete(channel2.Id, 0)
 
 	t.Run("ChannelRolesUnderTeamRole", func(t *testing.T) {
 		t.Run("guest role for the right team's channels are returned", func(t *testing.T) {
 			actualRoles, err := ss.Role().ChannelRolesUnderTeamRole(teamScheme1.DefaultChannelGuestRole)
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			var actualRoleNames []string
 			for _, role := range actualRoles {
@@ -463,7 +463,7 @@ func testRoleStoreLowerScopedChannelSchemeRoles(t *testing.T, ss store.Store) {
 
 		t.Run("user role for the right team's channels are returned", func(t *testing.T) {
 			actualRoles, err := ss.Role().ChannelRolesUnderTeamRole(teamScheme1.DefaultChannelUserRole)
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			var actualRoleNames []string
 			for _, role := range actualRoles {
@@ -476,7 +476,7 @@ func testRoleStoreLowerScopedChannelSchemeRoles(t *testing.T, ss store.Store) {
 
 		t.Run("admin role for the right team's channels are returned", func(t *testing.T) {
 			actualRoles, err := ss.Role().ChannelRolesUnderTeamRole(teamScheme1.DefaultChannelAdminRole)
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			var actualRoleNames []string
 			for _, role := range actualRoles {
@@ -491,7 +491,7 @@ func testRoleStoreLowerScopedChannelSchemeRoles(t *testing.T, ss store.Store) {
 	t.Run("AllChannelSchemeRoles", func(t *testing.T) {
 		t.Run("guest role for the right team's channels are returned", func(t *testing.T) {
 			actualRoles, err := ss.Role().AllChannelSchemeRoles()
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			var actualRoleNames []string
 			for _, role := range actualRoles {
@@ -524,7 +524,7 @@ func testRoleStoreChannelHigherScopedPermissionsBlankTeamSchemeChannelGuest(t *t
 		Scope:       model.SCHEME_SCOPE_TEAM,
 	}
 	teamScheme, err := ss.Scheme().Save(teamScheme)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer ss.Scheme().Delete(teamScheme.Id)
 
 	channelScheme := &model.Scheme{
@@ -534,7 +534,7 @@ func testRoleStoreChannelHigherScopedPermissionsBlankTeamSchemeChannelGuest(t *t
 		Scope:       model.SCHEME_SCOPE_CHANNEL,
 	}
 	channelScheme, err = ss.Scheme().Save(channelScheme)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer ss.Scheme().Delete(channelScheme.Id)
 
 	team := &model.Team{
@@ -545,7 +545,7 @@ func testRoleStoreChannelHigherScopedPermissionsBlankTeamSchemeChannelGuest(t *t
 		SchemeId:    &teamScheme.Id,
 	}
 	team, err = ss.Team().Save(team)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	defer ss.Team().PermanentDelete(team.Id)
 
 	channel := &model.Channel{
@@ -556,42 +556,42 @@ func testRoleStoreChannelHigherScopedPermissionsBlankTeamSchemeChannelGuest(t *t
 		SchemeId:    &channelScheme.Id,
 	}
 	channel, nErr := ss.Channel().Save(channel, -1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	defer ss.Channel().Delete(channel.Id, 0)
 
 	channelSchemeUserRole, err := ss.Role().GetByName(channelScheme.DefaultChannelUserRole)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	channelSchemeUserRole.Permissions = []string{}
 	_, err = ss.Role().Save(channelSchemeUserRole)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	teamSchemeUserRole, err := ss.Role().GetByName(teamScheme.DefaultChannelUserRole)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	teamSchemeUserRole.Permissions = []string{model.PERMISSION_UPLOAD_FILE.Id}
 	_, err = ss.Role().Save(teamSchemeUserRole)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// get the channel scheme user role again and ensure that it has the permission inherited from the team
 	// scheme user role
 	roleMapBefore, err := ss.Role().ChannelHigherScopedPermissions([]string{channelSchemeUserRole.Name})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	// blank-out the guest role to simulate an old team scheme, ensure it's blank
 	result, sqlErr := s.GetMaster().Exec(fmt.Sprintf("UPDATE Schemes SET DefaultChannelGuestRole = '' WHERE Id = '%s'", teamScheme.Id))
-	require.Nil(t, sqlErr)
+	require.NoError(t, sqlErr)
 	rows, serr := result.RowsAffected()
-	require.Nil(t, serr)
+	require.NoError(t, serr)
 	require.Equal(t, int64(1), rows)
 	teamScheme, err = ss.Scheme().Get(teamScheme.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, "", teamScheme.DefaultChannelGuestRole)
 
 	// trigger a cache clear
 	_, err = ss.Role().Save(channelSchemeUserRole)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	roleMapAfter, err := ss.Role().ChannelHigherScopedPermissions([]string{channelSchemeUserRole.Name})
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	require.Equal(t, len(roleMapBefore), len(roleMapAfter))
 }

store/storetest/scheme_store.go

@@ -91,7 +91,7 @@ func testSchemeStoreSave(t *testing.T, ss store.Store) {
 
 	// Check all fields saved correctly.
 	d1, err := ss.Scheme().Save(s1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, d1.Id, 26)
 	assert.Equal(t, s1.DisplayName, d1.DisplayName)
 	assert.Equal(t, s1.Name, d1.Name)
@@ -109,32 +109,32 @@ func testSchemeStoreSave(t *testing.T, ss store.Store) {
 
 	// Check the default roles were created correctly.
 	role1, err := ss.Role().GetByName(d1.DefaultTeamAdminRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, role1.Permissions, []string{"delete_others_posts"})
 	assert.True(t, role1.SchemeManaged)
 
 	role2, err := ss.Role().GetByName(d1.DefaultTeamUserRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, role2.Permissions, []string{"view_team", "add_user_to_team"})
 	assert.True(t, role2.SchemeManaged)
 
 	role3, err := ss.Role().GetByName(d1.DefaultChannelAdminRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, role3.Permissions, []string{"manage_public_channel_members", "manage_private_channel_members"})
 	assert.True(t, role3.SchemeManaged)
 
 	role4, err := ss.Role().GetByName(d1.DefaultChannelUserRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, role4.Permissions, []string{"read_channel", "create_post"})
 	assert.True(t, role4.SchemeManaged)
 
 	role5, err := ss.Role().GetByName(d1.DefaultTeamGuestRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, role5.Permissions, []string{"view_team"})
 	assert.True(t, role5.SchemeManaged)
 
 	role6, err := ss.Role().GetByName(d1.DefaultChannelGuestRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, role6.Permissions, []string{"read_channel", "create_post"})
 	assert.True(t, role6.SchemeManaged)
 
@@ -142,7 +142,7 @@ func testSchemeStoreSave(t *testing.T, ss store.Store) {
 	d1.Description = model.NewId()
 
 	d2, err := ss.Scheme().Save(d1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, d1.Id, d2.Id)
 	assert.Equal(t, s1.DisplayName, d2.DisplayName)
 	assert.Equal(t, s1.Name, d2.Name)
@@ -168,7 +168,7 @@ func testSchemeStoreSave(t *testing.T, ss store.Store) {
 	}
 
 	_, err = ss.Scheme().Save(s3)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func testSchemeStoreGet(t *testing.T, ss store.Store) {
@@ -181,12 +181,12 @@ func testSchemeStoreGet(t *testing.T, ss store.Store) {
 	}
 
 	d1, err := ss.Scheme().Save(s1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, d1.Id, 26)
 
 	// Get a valid scheme
 	d2, err := ss.Scheme().Get(d1.Id)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, d1.Id, d2.Id)
 	assert.Equal(t, s1.DisplayName, d2.DisplayName)
 	assert.Equal(t, s1.Name, d2.Name)
@@ -204,7 +204,7 @@ func testSchemeStoreGet(t *testing.T, ss store.Store) {
 
 	// Get an invalid scheme
 	_, err = ss.Scheme().Get(model.NewId())
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func testSchemeStoreGetByName(t *testing.T, ss store.Store) {
@@ -217,12 +217,12 @@ func testSchemeStoreGetByName(t *testing.T, ss store.Store) {
 	}
 
 	d1, err := ss.Scheme().Save(s1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, d1.Id, 26)
 
 	// Get a valid scheme
 	d2, err := ss.Scheme().GetByName(d1.Name)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, d1.Id, d2.Id)
 	assert.Equal(t, s1.DisplayName, d2.DisplayName)
 	assert.Equal(t, s1.Name, d2.Name)
@@ -240,7 +240,7 @@ func testSchemeStoreGetByName(t *testing.T, ss store.Store) {
 
 	// Get an invalid scheme
 	_, err = ss.Scheme().GetByName(model.NewId())
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func testSchemeStoreGetAllPage(t *testing.T, ss store.Store) {
@@ -274,15 +274,15 @@ func testSchemeStoreGetAllPage(t *testing.T, ss store.Store) {
 
 	for _, scheme := range schemes {
 		_, err := ss.Scheme().Save(scheme)
-		require.Nil(t, err)
+		require.NoError(t, err)
 	}
 
 	s1, err := ss.Scheme().GetAllPage("", 0, 2)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, s1, 2)
 
 	s2, err := ss.Scheme().GetAllPage("", 2, 2)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, s2, 2)
 	assert.NotEqual(t, s1[0].DisplayName, s2[0].DisplayName)
 	assert.NotEqual(t, s1[0].DisplayName, s2[1].DisplayName)
@@ -294,14 +294,14 @@ func testSchemeStoreGetAllPage(t *testing.T, ss store.Store) {
 	assert.NotEqual(t, s1[1].Name, s2[1].Name)
 
 	s3, err := ss.Scheme().GetAllPage("team", 0, 1000)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.NotZero(t, len(s3))
 	for _, s := range s3 {
 		assert.Equal(t, "team", s.Scope)
 	}
 
 	s4, err := ss.Scheme().GetAllPage("channel", 0, 1000)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.NotZero(t, len(s4))
 	for _, s := range s4 {
 		assert.Equal(t, "channel", s.Scope)
@@ -319,7 +319,7 @@ func testSchemeStoreDelete(t *testing.T, ss store.Store) {
 
 	// Check all fields saved correctly.
 	d1, err := ss.Scheme().Save(s1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, d1.Id, 26)
 	assert.Equal(t, s1.DisplayName, d1.DisplayName)
 	assert.Equal(t, s1.Name, d1.Name)
@@ -337,68 +337,68 @@ func testSchemeStoreDelete(t *testing.T, ss store.Store) {
 
 	// Check the default roles were created correctly.
 	role1, err := ss.Role().GetByName(d1.DefaultTeamAdminRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, role1.Permissions, []string{"delete_others_posts"})
 	assert.True(t, role1.SchemeManaged)
 
 	role2, err := ss.Role().GetByName(d1.DefaultTeamUserRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, role2.Permissions, []string{"view_team", "add_user_to_team"})
 	assert.True(t, role2.SchemeManaged)
 
 	role3, err := ss.Role().GetByName(d1.DefaultChannelAdminRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, role3.Permissions, []string{"manage_public_channel_members", "manage_private_channel_members"})
 	assert.True(t, role3.SchemeManaged)
 
 	role4, err := ss.Role().GetByName(d1.DefaultChannelUserRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, role4.Permissions, []string{"read_channel", "create_post"})
 	assert.True(t, role4.SchemeManaged)
 
 	role5, err := ss.Role().GetByName(d1.DefaultTeamGuestRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, role5.Permissions, []string{"view_team"})
 	assert.True(t, role5.SchemeManaged)
 
 	role6, err := ss.Role().GetByName(d1.DefaultChannelGuestRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, role6.Permissions, []string{"read_channel", "create_post"})
 	assert.True(t, role6.SchemeManaged)
 
 	// Delete the scheme.
 	d2, err := ss.Scheme().Delete(d1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.NotZero(t, d2.DeleteAt)
 
 	// Check that the roles are deleted too.
 	role7, err := ss.Role().GetByName(d1.DefaultTeamAdminRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.NotZero(t, role7.DeleteAt)
 
 	role8, err := ss.Role().GetByName(d1.DefaultTeamUserRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.NotZero(t, role8.DeleteAt)
 
 	role9, err := ss.Role().GetByName(d1.DefaultChannelAdminRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.NotZero(t, role9.DeleteAt)
 
 	role10, err := ss.Role().GetByName(d1.DefaultChannelUserRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.NotZero(t, role10.DeleteAt)
 
 	role11, err := ss.Role().GetByName(d1.DefaultTeamGuestRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.NotZero(t, role11.DeleteAt)
 
 	role12, err := ss.Role().GetByName(d1.DefaultChannelGuestRole)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.NotZero(t, role12.DeleteAt)
 
 	// Try deleting a scheme that does not exist.
 	_, err = ss.Scheme().Delete(model.NewId())
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	// Try deleting a team scheme that's in use.
 	s4 := &model.Scheme{
@@ -408,7 +408,7 @@ func testSchemeStoreDelete(t *testing.T, ss store.Store) {
 		Scope:       model.SCHEME_SCOPE_TEAM,
 	}
 	d4, err := ss.Scheme().Save(s4)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	t4 := &model.Team{
 		Name:        "xx" + model.NewId(),
@@ -418,13 +418,13 @@ func testSchemeStoreDelete(t *testing.T, ss store.Store) {
 		SchemeId:    &d4.Id,
 	}
 	t4, err = ss.Team().Save(t4)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.Scheme().Delete(d4.Id)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	t5, err := ss.Team().Get(t4.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "", *t5.SchemeId)
 
 	// Try deleting a channel scheme that's in use.
@@ -435,7 +435,7 @@ func testSchemeStoreDelete(t *testing.T, ss store.Store) {
 		Scope:       model.SCHEME_SCOPE_CHANNEL,
 	}
 	d5, err := ss.Scheme().Save(s5)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	c5 := &model.Channel{
 		TeamId:      model.NewId(),
@@ -445,13 +445,13 @@ func testSchemeStoreDelete(t *testing.T, ss store.Store) {
 		SchemeId:    &d5.Id,
 	}
 	c5, nErr := ss.Channel().Save(c5, -1)
-	assert.Nil(t, nErr)
+	assert.NoError(t, nErr)
 
 	_, err = ss.Scheme().Delete(d5.Id)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	c6, nErr := ss.Channel().Get(c5.Id, true)
-	assert.Nil(t, nErr)
+	assert.NoError(t, nErr)
 	assert.Equal(t, "", *c6.SchemeId)
 }
 
@@ -471,32 +471,32 @@ func testSchemeStorePermanentDeleteAll(t *testing.T, ss store.Store) {
 	}
 
 	s1, err := ss.Scheme().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	s2, err = ss.Scheme().Save(s2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	err = ss.Scheme().PermanentDeleteAll()
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	_, err = ss.Scheme().Get(s1.Id)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	_, err = ss.Scheme().Get(s2.Id)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	schemes, err := ss.Scheme().GetAllPage("", 0, 100000)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Empty(t, schemes)
 }
 
 func testSchemeStoreCountByScope(t *testing.T, ss store.Store) {
 	testCounts := func(expectedTeamCount, expectedChannelCount int) {
 		actualCount, err := ss.Scheme().CountByScope(model.SCHEME_SCOPE_TEAM)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, int64(expectedTeamCount), actualCount)
 
 		actualCount, err = ss.Scheme().CountByScope(model.SCHEME_SCOPE_CHANNEL)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, int64(expectedChannelCount), actualCount)
 	}
 
@@ -507,11 +507,11 @@ func testSchemeStoreCountByScope(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       scope,
 		})
-		require.Nil(t, err)
+		require.NoError(t, err)
 	}
 
 	err := ss.Scheme().PermanentDeleteAll()
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	createScheme(model.SCHEME_SCOPE_CHANNEL)
 	createScheme(model.SCHEME_SCOPE_TEAM)
@@ -532,17 +532,17 @@ func testCountWithoutPermission(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       scope,
 		})
-		require.Nil(t, err)
+		require.NoError(t, err)
 		return scheme
 	}
 
 	getRoles := func(scheme *model.Scheme) (channelUser, channelGuest *model.Role) {
 		var err error
 		channelUser, err = ss.Role().GetByName(scheme.DefaultChannelUserRole)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.NotNil(t, channelUser)
 		channelGuest, err = ss.Role().GetByName(scheme.DefaultChannelGuestRole)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.NotNil(t, channelGuest)
 		return
 	}
@@ -573,11 +573,11 @@ func testCountWithoutPermission(t *testing.T, ss store.Store) {
 	}
 
 	teamUserCount, err := ss.Scheme().CountWithoutPermission(model.SCHEME_SCOPE_TEAM, perm, model.RoleScopeChannel, model.RoleTypeUser)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, int64(0), teamUserCount)
 
 	teamGuestCount, err := ss.Scheme().CountWithoutPermission(model.SCHEME_SCOPE_TEAM, perm, model.RoleScopeChannel, model.RoleTypeGuest)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, int64(0), teamGuestCount)
 
 	var tests = []struct {
@@ -604,7 +604,7 @@ func testCountWithoutPermission(t *testing.T, ss store.Store) {
 				roleMatched = true
 				role.Permissions = []string{}
 				_, err = ss.Role().Save(role)
-				require.Nil(t, err)
+				require.NoError(t, err)
 			}
 		}
 		require.True(t, roleMatched)
@@ -614,19 +614,19 @@ func testCountWithoutPermission(t *testing.T, ss store.Store) {
 		removePermission(test.removePermissionFromRole)
 
 		count, err := ss.Scheme().CountWithoutPermission(model.SCHEME_SCOPE_TEAM, perm, model.RoleScopeChannel, model.RoleTypeUser)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, int64(test.expectTeamSchemeChannelUserCount), count)
 
 		count, err = ss.Scheme().CountWithoutPermission(model.SCHEME_SCOPE_TEAM, perm, model.RoleScopeChannel, model.RoleTypeGuest)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, int64(test.expectTeamSchemeChannelGuestCount), count)
 
 		count, err = ss.Scheme().CountWithoutPermission(model.SCHEME_SCOPE_CHANNEL, perm, model.RoleScopeChannel, model.RoleTypeUser)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, int64(test.expectChannelSchemeChannelUserCount), count)
 
 		count, err = ss.Scheme().CountWithoutPermission(model.SCHEME_SCOPE_CHANNEL, perm, model.RoleScopeChannel, model.RoleTypeGuest)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, int64(test.expectChannelSchemeChannelGuestCount), count)
 	}
 }

store/storetest/session_store.go

@@ -42,7 +42,7 @@ func testSessionStoreSave(t *testing.T, ss store.Store) {
 	s1.UserId = model.NewId()
 
 	_, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testSessionGet(t *testing.T, ss store.Store) {
@@ -50,27 +50,27 @@ func testSessionGet(t *testing.T, ss store.Store) {
 	s1.UserId = model.NewId()
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s2 := &model.Session{}
 	s2.UserId = s1.UserId
 
 	s2, err = ss.Session().Save(s2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s3 := &model.Session{}
 	s3.UserId = s1.UserId
 	s3.ExpiresAt = 1
 
 	s3, err = ss.Session().Save(s3)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	session, err := ss.Session().Get(s1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, session.Id, s1.Id, "should match")
 
 	data, err := ss.Session().GetSessions(s1.UserId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, data, 3, "should match len")
 }
 
@@ -80,7 +80,7 @@ func testSessionGetWithDeviceId(t *testing.T, ss store.Store) {
 	s1.ExpiresAt = model.GetMillis() + 10000
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s2 := &model.Session{}
 	s2.UserId = s1.UserId
@@ -88,7 +88,7 @@ func testSessionGetWithDeviceId(t *testing.T, ss store.Store) {
 	s2.ExpiresAt = model.GetMillis() + 10000
 
 	s2, err = ss.Session().Save(s2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s3 := &model.Session{}
 	s3.UserId = s1.UserId
@@ -96,10 +96,10 @@ func testSessionGetWithDeviceId(t *testing.T, ss store.Store) {
 	s3.DeviceId = model.NewId()
 
 	s3, err = ss.Session().Save(s3)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	data, err := ss.Session().GetSessionsWithActiveDeviceIds(s1.UserId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, data, 1, "should match len")
 }
 
@@ -108,17 +108,17 @@ func testSessionRemove(t *testing.T, ss store.Store) {
 	s1.UserId = model.NewId()
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	session, err := ss.Session().Get(s1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, session.Id, s1.Id, "should match")
 
 	removeErr := ss.Session().Remove(s1.Id)
-	require.Nil(t, removeErr)
+	require.NoError(t, removeErr)
 
 	_, err = ss.Session().Get(s1.Id)
-	require.NotNil(t, err, "should have been removed")
+	require.Error(t, err, "should have been removed")
 }
 
 func testSessionRemoveAll(t *testing.T, ss store.Store) {
@@ -126,17 +126,17 @@ func testSessionRemoveAll(t *testing.T, ss store.Store) {
 	s1.UserId = model.NewId()
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	session, err := ss.Session().Get(s1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, session.Id, s1.Id, "should match")
 
 	removeErr := ss.Session().RemoveAllSessions()
-	require.Nil(t, removeErr)
+	require.NoError(t, removeErr)
 
 	_, err = ss.Session().Get(s1.Id)
-	require.NotNil(t, err, "should have been removed")
+	require.Error(t, err, "should have been removed")
 }
 
 func testSessionRemoveByUser(t *testing.T, ss store.Store) {
@@ -144,17 +144,17 @@ func testSessionRemoveByUser(t *testing.T, ss store.Store) {
 	s1.UserId = model.NewId()
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	session, err := ss.Session().Get(s1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, session.Id, s1.Id, "should match")
 
 	deleteErr := ss.Session().PermanentDeleteSessionsByUser(s1.UserId)
-	require.Nil(t, deleteErr)
+	require.NoError(t, deleteErr)
 
 	_, err = ss.Session().Get(s1.Id)
-	require.NotNil(t, err, "should have been removed")
+	require.Error(t, err, "should have been removed")
 }
 
 func testSessionRemoveToken(t *testing.T, ss store.Store) {
@@ -162,20 +162,20 @@ func testSessionRemoveToken(t *testing.T, ss store.Store) {
 	s1.UserId = model.NewId()
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	session, err := ss.Session().Get(s1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, session.Id, s1.Id, "should match")
 
 	removeErr := ss.Session().Remove(s1.Token)
-	require.Nil(t, removeErr)
+	require.NoError(t, removeErr)
 
 	_, err = ss.Session().Get(s1.Id)
-	require.NotNil(t, err, "should have been removed")
+	require.Error(t, err, "should have been removed")
 
 	data, err := ss.Session().GetSessions(s1.UserId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Empty(t, data, "should match len")
 }
 
@@ -184,19 +184,19 @@ func testSessionUpdateDeviceId(t *testing.T, ss store.Store) {
 	s1.UserId = model.NewId()
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.Session().UpdateDeviceId(s1.Id, model.PUSH_NOTIFY_APPLE+":1234567890", s1.ExpiresAt)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s2 := &model.Session{}
 	s2.UserId = model.NewId()
 
 	s2, err = ss.Session().Save(s2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.Session().UpdateDeviceId(s2.Id, model.PUSH_NOTIFY_APPLE+":1234567890", s1.ExpiresAt)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testSessionUpdateDeviceId2(t *testing.T, ss store.Store) {
@@ -204,19 +204,19 @@ func testSessionUpdateDeviceId2(t *testing.T, ss store.Store) {
 	s1.UserId = model.NewId()
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.Session().UpdateDeviceId(s1.Id, model.PUSH_NOTIFY_APPLE_REACT_NATIVE+":1234567890", s1.ExpiresAt)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s2 := &model.Session{}
 	s2.UserId = model.NewId()
 
 	s2, err = ss.Session().Save(s2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.Session().UpdateDeviceId(s2.Id, model.PUSH_NOTIFY_APPLE_REACT_NATIVE+":1234567890", s1.ExpiresAt)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testSessionStoreUpdateExpiresAt(t *testing.T, ss store.Store) {
@@ -224,13 +224,13 @@ func testSessionStoreUpdateExpiresAt(t *testing.T, ss store.Store) {
 	s1.UserId = model.NewId()
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	err = ss.Session().UpdateExpiresAt(s1.Id, 1234567890)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	session, err := ss.Session().Get(s1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.EqualValues(t, session.ExpiresAt, 1234567890, "ExpiresAt not updated correctly")
 }
 
@@ -239,13 +239,13 @@ func testSessionStoreUpdateLastActivityAt(t *testing.T, ss store.Store) {
 	s1.UserId = model.NewId()
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	err = ss.Session().UpdateLastActivityAt(s1.Id, 1234567890)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	session, err := ss.Session().Get(s1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.EqualValues(t, session.LastActivityAt, 1234567890, "LastActivityAt not updated correctly")
 }
 
@@ -255,10 +255,10 @@ func testSessionCount(t *testing.T, ss store.Store) {
 	s1.ExpiresAt = model.GetMillis() + 100000
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	count, err := ss.Session().AnalyticsSessionCount()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.NotZero(t, count, "should have at least 1 session")
 }
 
@@ -270,48 +270,48 @@ func testSessionCleanup(t *testing.T, ss store.Store) {
 	s1.ExpiresAt = 0 // never expires
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s2 := &model.Session{}
 	s2.UserId = s1.UserId
 	s2.ExpiresAt = now + 1000000 // expires in the future
 
 	s2, err = ss.Session().Save(s2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s3 := &model.Session{}
 	s3.UserId = model.NewId()
 	s3.ExpiresAt = 1 // expired
 
 	s3, err = ss.Session().Save(s3)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s4 := &model.Session{}
 	s4.UserId = model.NewId()
 	s4.ExpiresAt = 2 // expired
 
 	s4, err = ss.Session().Save(s4)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	ss.Session().Cleanup(now, 1)
 
 	_, err = ss.Session().Get(s1.Id)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	_, err = ss.Session().Get(s2.Id)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	_, err = ss.Session().Get(s3.Id)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	_, err = ss.Session().Get(s4.Id)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	removeErr := ss.Session().Remove(s1.Id)
-	require.Nil(t, removeErr)
+	require.NoError(t, removeErr)
 
 	removeErr = ss.Session().Remove(s2.Id)
-	require.Nil(t, removeErr)
+	require.NoError(t, removeErr)
 }
 
 func testGetSessionsExpired(t *testing.T, ss store.Store) {
@@ -319,49 +319,49 @@ func testGetSessionsExpired(t *testing.T, ss store.Store) {
 
 	// Clear existing sessions.
 	err := ss.Session().RemoveAllSessions()
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s1 := &model.Session{}
 	s1.UserId = model.NewId()
 	s1.DeviceId = model.NewId()
 	s1.ExpiresAt = 0 // never expires
 	s1, err = ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s2 := &model.Session{}
 	s2.UserId = model.NewId()
 	s2.DeviceId = model.NewId()
 	s2.ExpiresAt = now - TenMinutes // expired within threshold
 	s2, err = ss.Session().Save(s2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s3 := &model.Session{}
 	s3.UserId = model.NewId()
 	s3.DeviceId = model.NewId()
 	s3.ExpiresAt = now - (TenMinutes * 100) // expired outside threshold
 	s3, err = ss.Session().Save(s3)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s4 := &model.Session{}
 	s4.UserId = model.NewId()
 	s4.ExpiresAt = now - TenMinutes // expired within threshold, but not mobile
 	s4, err = ss.Session().Save(s4)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	s5 := &model.Session{}
 	s5.UserId = model.NewId()
 	s5.DeviceId = model.NewId()
 	s5.ExpiresAt = now + (TenMinutes * 100000) // not expired
 	s5, err = ss.Session().Save(s5)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	sessions, err := ss.Session().GetSessionsExpired(TenMinutes*2, true, true) // mobile only
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, sessions, 1)
 	require.Equal(t, s2.Id, sessions[0].Id)
 
 	sessions, err = ss.Session().GetSessionsExpired(TenMinutes*2, false, true) // all client types
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, sessions, 2)
 	expected := []string{s2.Id, s4.Id}
 	for _, sess := range sessions {
@@ -375,21 +375,21 @@ func testUpdateExpiredNotify(t *testing.T, ss store.Store) {
 	s1.DeviceId = model.NewId()
 	s1.ExpiresAt = model.GetMillis() + TenMinutes
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	session, err := ss.Session().Get(s1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.False(t, session.ExpiredNotify)
 
 	err = ss.Session().UpdateExpiredNotify(session.Id, true)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	session, err = ss.Session().Get(s1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.True(t, session.ExpiredNotify)
 
 	err = ss.Session().UpdateExpiredNotify(session.Id, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	session, err = ss.Session().Get(s1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.False(t, session.ExpiredNotify)
 }

store/storetest/status_store.go

@@ -19,40 +19,40 @@ func TestStatusStore(t *testing.T, ss store.Store) {
 
 func testStatusStore(t *testing.T, ss store.Store) {
 	status := &model.Status{UserId: model.NewId(), Status: model.STATUS_ONLINE, Manual: false, LastActivityAt: 0, ActiveChannel: ""}
-	require.Nil(t, ss.Status().SaveOrUpdate(status))
+	require.NoError(t, ss.Status().SaveOrUpdate(status))
 
 	status.LastActivityAt = 10
 
 	_, err := ss.Status().Get(status.UserId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	status2 := &model.Status{UserId: model.NewId(), Status: model.STATUS_AWAY, Manual: false, LastActivityAt: 0, ActiveChannel: ""}
-	require.Nil(t, ss.Status().SaveOrUpdate(status2))
+	require.NoError(t, ss.Status().SaveOrUpdate(status2))
 
 	status3 := &model.Status{UserId: model.NewId(), Status: model.STATUS_OFFLINE, Manual: false, LastActivityAt: 0, ActiveChannel: ""}
-	require.Nil(t, ss.Status().SaveOrUpdate(status3))
+	require.NoError(t, ss.Status().SaveOrUpdate(status3))
 
 	statuses, err := ss.Status().GetByIds([]string{status.UserId, "junk"})
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, statuses, 1, "should only have 1 status")
 
 	err = ss.Status().ResetAll()
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	statusParameter, err := ss.Status().Get(status.UserId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, statusParameter.Status, model.STATUS_OFFLINE, "should be offline")
 
 	err = ss.Status().UpdateLastActivityAt(status.UserId, 10)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testActiveUserCount(t *testing.T, ss store.Store) {
 	status := &model.Status{UserId: model.NewId(), Status: model.STATUS_ONLINE, Manual: false, LastActivityAt: model.GetMillis(), ActiveChannel: ""}
-	require.Nil(t, ss.Status().SaveOrUpdate(status))
+	require.NoError(t, ss.Status().SaveOrUpdate(status))
 
 	count, err := ss.Status().GetTotalActiveUsersCount()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.True(t, count > 0, "expected count > 0, got %d", count)
 }
 

store/storetest/system_store.go

@@ -27,7 +27,7 @@ func TestSystemStore(t *testing.T, ss store.Store) {
 func testSystemStore(t *testing.T, ss store.Store) {
 	system := &model.System{Name: model.NewId(), Value: "value"}
 	err := ss.System().Save(system)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	systems, _ := ss.System().Get()
 
@@ -35,7 +35,7 @@ func testSystemStore(t *testing.T, ss store.Store) {
 
 	system.Value = "value2"
 	err = ss.System().Update(system)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	systems2, _ := ss.System().Get()
 	require.Equal(t, system.Value, systems2[system.Name])
@@ -48,38 +48,38 @@ func testSystemStoreSaveOrUpdate(t *testing.T, ss store.Store) {
 	system := &model.System{Name: model.NewId(), Value: "value"}
 
 	err := ss.System().SaveOrUpdate(system)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	system.Value = "value2"
 
 	err = ss.System().SaveOrUpdate(system)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testSystemStoreSaveOrUpdateWithWarnMetricHandling(t *testing.T, ss store.Store) {
 	system := &model.System{Name: model.NewId(), Value: "value"}
 
 	err := ss.System().SaveOrUpdateWithWarnMetricHandling(system)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.System().GetByName(model.SYSTEM_WARN_METRIC_LAST_RUN_TIMESTAMP_KEY)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	system.Name = "warn_metric_number_of_active_users_100"
 	system.Value = model.WARN_METRIC_STATUS_RUNONCE
 	err = ss.System().SaveOrUpdateWithWarnMetricHandling(system)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	val1, nerr := ss.System().GetByName(model.SYSTEM_WARN_METRIC_LAST_RUN_TIMESTAMP_KEY)
-	assert.Nil(t, nerr)
+	assert.NoError(t, nerr)
 
 	system.Name = "warn_metric_number_of_active_users_100"
 	system.Value = model.WARN_METRIC_STATUS_ACK
 	err = ss.System().SaveOrUpdateWithWarnMetricHandling(system)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	val2, nerr := ss.System().GetByName(model.SYSTEM_WARN_METRIC_LAST_RUN_TIMESTAMP_KEY)
-	assert.Nil(t, nerr)
+	assert.NoError(t, nerr)
 	assert.Equal(t, val1, val2)
 }
 
@@ -88,33 +88,33 @@ func testSystemStorePermanentDeleteByName(t *testing.T, ss store.Store) {
 	s2 := &model.System{Name: model.NewId(), Value: "value"}
 
 	err := ss.System().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	err = ss.System().Save(s2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.System().GetByName(s1.Name)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	_, err = ss.System().GetByName(s2.Name)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	_, err = ss.System().PermanentDeleteByName(s1.Name)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	_, err = ss.System().GetByName(s1.Name)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	_, err = ss.System().GetByName(s2.Name)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	_, err = ss.System().PermanentDeleteByName(s2.Name)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	_, err = ss.System().GetByName(s1.Name)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	_, err = ss.System().GetByName(s2.Name)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func testInsertIfExists(t *testing.T, ss store.Store) {
@@ -122,13 +122,13 @@ func testInsertIfExists(t *testing.T, ss store.Store) {
 		s1 := &model.System{Name: model.SYSTEM_CLUSTER_ENCRYPTION_KEY, Value: "somekey"}
 
 		s2, err := ss.System().InsertIfExists(s1)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, s1.Value, s2.Value)
 
 		s1New := &model.System{Name: model.SYSTEM_CLUSTER_ENCRYPTION_KEY, Value: "anotherKey"}
 
 		s3, err := ss.System().InsertIfExists(s1New)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, s1.Value, s3.Value)
 	})
 
@@ -141,7 +141,7 @@ func testInsertIfExists(t *testing.T, ss store.Store) {
 			s1 := &model.System{Name: model.SYSTEM_CLUSTER_ENCRYPTION_KEY, Value: "firstKey"}
 			var err error
 			s2, err = ss.System().InsertIfExists(s1)
-			require.Nil(t, err)
+			require.NoError(t, err)
 		}()
 
 		go func() {
@@ -149,7 +149,7 @@ func testInsertIfExists(t *testing.T, ss store.Store) {
 			s1 := &model.System{Name: model.SYSTEM_CLUSTER_ENCRYPTION_KEY, Value: "secondKey"}
 			var err error
 			s3, err = ss.System().InsertIfExists(s1)
-			require.Nil(t, err)
+			require.NoError(t, err)
 		}()
 		wg.Wait()
 		assert.Equal(t, s2.Value, s3.Value)

store/storetest/terms_of_service_store.go

@@ -36,12 +36,12 @@ func testSaveTermsOfService(t *testing.T, ss store.Store) {
 	u1.Username = model.NewId()
 	u1.Email = MakeEmail()
 	u1.Nickname = model.NewId()
-	_, appErr := ss.User().Save(&u1)
+	_, err := ss.User().Save(&u1)
-	require.Nil(t, appErr)
+	require.NoError(t, err)
 
 	termsOfService := &model.TermsOfService{Text: "terms of service", UserId: u1.Id}
 	savedTermsOfService, err := ss.TermsOfService().Save(termsOfService)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	require.Len(t, savedTermsOfService.Id, 26, "Id should have been populated")
 
@@ -55,15 +55,15 @@ func testGetLatestTermsOfService(t *testing.T, ss store.Store) {
 	u1.Username = model.NewId()
 	u1.Email = MakeEmail()
 	u1.Nickname = model.NewId()
-	_, appErr := ss.User().Save(&u1)
+	_, err := ss.User().Save(&u1)
-	require.Nil(t, appErr)
+	require.NoError(t, err)
 
 	termsOfService := &model.TermsOfService{Text: "terms of service 2", UserId: u1.Id}
-	_, err := ss.TermsOfService().Save(termsOfService)
+	_, err = ss.TermsOfService().Save(termsOfService)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	fetchedTermsOfService, err := ss.TermsOfService().GetLatest(true)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, termsOfService.Text, fetchedTermsOfService.Text)
 	assert.Equal(t, termsOfService.UserId, fetchedTermsOfService.UserId)
 }
@@ -75,18 +75,18 @@ func testGetTermsOfService(t *testing.T, ss store.Store) {
 	u1.Username = model.NewId()
 	u1.Email = MakeEmail()
 	u1.Nickname = model.NewId()
-	_, appErr := ss.User().Save(&u1)
+	_, err := ss.User().Save(&u1)
-	require.Nil(t, appErr)
+	require.NoError(t, err)
 
 	termsOfService := &model.TermsOfService{Text: "terms of service", UserId: u1.Id}
-	_, err := ss.TermsOfService().Save(termsOfService)
+	_, err = ss.TermsOfService().Save(termsOfService)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	r1, err := ss.TermsOfService().Get("an_invalid_id", true)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 	assert.Nil(t, r1)
 
 	receivedTermsOfService, err := ss.TermsOfService().Get(termsOfService.Id, true)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, "terms of service", receivedTermsOfService.Text)
 }

store/storetest/thread_store.go

@@ -27,7 +27,7 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 		}
 
 		u, err := ss.User().Save(&u1)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		c, err2 := ss.Channel().Save(&model.Channel{
 			DisplayName: model.NewId(),
@@ -73,7 +73,7 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 		o1 := olist.Posts[olist.Order[0]]
 
 		newPosts = append([]*model.Post{o1}, newPosts...)
-		require.Nil(t, err3, "couldn't save item")
+		require.NoError(t, err3, "couldn't save item")
 		require.Equal(t, -1, errIdx)
 		require.Len(t, newPosts, 4)
 		require.Equal(t, int64(2), newPosts[0].ReplyCount)
@@ -86,7 +86,7 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 	t.Run("Save replies creates a thread", func(t *testing.T) {
 		newPosts := makeSomePosts()
 		thread, err := ss.Thread().Get(newPosts[0].Id)
-		require.Nil(t, err, "couldn't get thread")
+		require.NoError(t, err, "couldn't get thread")
 		require.NotNil(t, thread)
 		require.Equal(t, int64(2), thread.ReplyCount)
 		require.ElementsMatch(t, model.StringArray{newPosts[0].UserId, newPosts[1].UserId}, thread.Participants)
@@ -98,10 +98,10 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 		o5.Message = "zz" + model.NewId() + "b"
 
 		_, _, err = ss.Post().SaveMultiple([]*model.Post{&o5})
-		require.Nil(t, err, "couldn't save item")
+		require.NoError(t, err, "couldn't save item")
 
 		thread, err = ss.Thread().Get(newPosts[0].Id)
-		require.Nil(t, err, "couldn't get thread")
+		require.NoError(t, err, "couldn't get thread")
 		require.NotNil(t, thread)
 		require.Equal(t, int64(3), thread.ReplyCount)
 		require.ElementsMatch(t, model.StringArray{newPosts[0].UserId, newPosts[1].UserId, o5.UserId}, thread.Participants)
@@ -110,16 +110,16 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 	t.Run("Delete a reply updates count on a thread", func(t *testing.T) {
 		newPosts := makeSomePosts()
 		thread, err := ss.Thread().Get(newPosts[0].Id)
-		require.Nil(t, err, "couldn't get thread")
+		require.NoError(t, err, "couldn't get thread")
 		require.NotNil(t, thread)
 		require.Equal(t, int64(2), thread.ReplyCount)
 		require.ElementsMatch(t, model.StringArray{newPosts[0].UserId, newPosts[1].UserId}, thread.Participants)
 
 		err = ss.Post().Delete(newPosts[1].Id, 1234, model.NewId())
-		require.Nil(t, err, "couldn't delete post")
+		require.NoError(t, err, "couldn't delete post")
 
 		thread, err = ss.Thread().Get(newPosts[0].Id)
-		require.Nil(t, err, "couldn't get thread")
+		require.NoError(t, err, "couldn't get thread")
 		require.NotNil(t, thread)
 		require.Equal(t, int64(1), thread.ReplyCount)
 		require.ElementsMatch(t, model.StringArray{newPosts[0].UserId, newPosts[1].UserId}, thread.Participants)
@@ -139,13 +139,13 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 		replyPost.RootId = rootPost.RootId
 
 		newPosts, _, err := ss.Post().SaveMultiple([]*model.Post{&rootPost, &replyPost})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		thread1, err := ss.Thread().Get(newPosts[0].RootId)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		rrootPost, err := ss.Post().GetSingle(rootPost.Id)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Equal(t, rrootPost.UpdateAt, rootPost.UpdateAt)
 
 		replyPost2 := model.Post{}
@@ -161,14 +161,14 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 		replyPost3.RootId = rootPost.Id
 
 		_, _, err = ss.Post().SaveMultiple([]*model.Post{&replyPost2, &replyPost3})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		rrootPost2, err := ss.Post().GetSingle(rootPost.Id)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Greater(t, rrootPost2.UpdateAt, rrootPost.UpdateAt)
 
 		thread2, err := ss.Thread().Get(rootPost.Id)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.Greater(t, thread2.LastReplyAt, thread1.LastReplyAt)
 	})
 
@@ -186,18 +186,18 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 		replyPost.RootId = rootPost.RootId
 
 		newPosts, _, err := ss.Post().SaveMultiple([]*model.Post{&rootPost, &replyPost})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		thread1, err := ss.Thread().Get(newPosts[0].RootId)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.EqualValues(t, thread1.ReplyCount, 2)
 		require.Len(t, thread1.Participants, 2)
 
 		err = ss.Post().Delete(replyPost.Id, 123, model.NewId())
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		thread2, err := ss.Thread().Get(rootPost.RootId)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.EqualValues(t, thread2.ReplyCount, 1)
 		require.Len(t, thread2.Participants, 2)
 	})
@@ -209,7 +209,7 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 		rootPost.Message = "zz" + model.NewId() + "b"
 
 		newPosts1, _, err := ss.Post().SaveMultiple([]*model.Post{&rootPost})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		replyPost := model.Post{}
 		replyPost.ChannelId = rootPost.ChannelId
@@ -218,15 +218,15 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 		replyPost.RootId = newPosts1[0].Id
 
 		_, _, err = ss.Post().SaveMultiple([]*model.Post{&replyPost})
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		thread1, err := ss.Thread().Get(newPosts1[0].Id)
-		require.Nil(t, err)
+		require.NoError(t, err)
 		require.EqualValues(t, thread1.ReplyCount, 1)
 		require.Len(t, thread1.Participants, 2)
 
 		err = ss.Post().PermanentDeleteByUser(rootPost.UserId)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		thread2, _ := ss.Thread().Get(rootPost.Id)
 		require.Nil(t, thread2)
@@ -235,19 +235,19 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 	t.Run("Thread last updated is changed when channel is updated after UpdateLastViewedAtPost", func(t *testing.T) {
 		newPosts := makeSomePosts()
 
-		require.Nil(t, ss.Thread().CreateMembershipIfNeeded(newPosts[0].UserId, newPosts[0].Id, true, false, true))
+		require.NoError(t, ss.Thread().CreateMembershipIfNeeded(newPosts[0].UserId, newPosts[0].Id, true, false, true))
 		m, err1 := ss.Thread().GetMembershipForUser(newPosts[0].UserId, newPosts[0].Id)
-		require.Nil(t, err1)
+		require.NoError(t, err1)
 		m.LastUpdated -= 1000
 		_, err := ss.Thread().UpdateMembership(m)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		_, err = ss.Channel().UpdateLastViewedAtPost(newPosts[0], newPosts[0].UserId, 0, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		assert.Eventually(t, func() bool {
 			m2, err2 := ss.Thread().GetMembershipForUser(newPosts[0].UserId, newPosts[0].Id)
-			require.Nil(t, err2)
+			require.NoError(t, err2)
 			return m2.LastUpdated > m.LastUpdated
 		}, time.Second, 10*time.Millisecond)
 	})
@@ -255,19 +255,19 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 	t.Run("Thread last updated is changed when channel is updated after IncrementMentionCount", func(t *testing.T) {
 		newPosts := makeSomePosts()
 
-		require.Nil(t, ss.Thread().CreateMembershipIfNeeded(newPosts[0].UserId, newPosts[0].Id, true, false, true))
+		require.NoError(t, ss.Thread().CreateMembershipIfNeeded(newPosts[0].UserId, newPosts[0].Id, true, false, true))
 		m, err1 := ss.Thread().GetMembershipForUser(newPosts[0].UserId, newPosts[0].Id)
-		require.Nil(t, err1)
+		require.NoError(t, err1)
 		m.LastUpdated -= 1000
 		_, err := ss.Thread().UpdateMembership(m)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		err = ss.Channel().IncrementMentionCount(newPosts[0].ChannelId, newPosts[0].UserId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		assert.Eventually(t, func() bool {
 			m2, err2 := ss.Thread().GetMembershipForUser(newPosts[0].UserId, newPosts[0].Id)
-			require.Nil(t, err2)
+			require.NoError(t, err2)
 			return m2.LastUpdated > m.LastUpdated
 		}, time.Second, 10*time.Millisecond)
 	})
@@ -275,19 +275,19 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 	t.Run("Thread last updated is changed when channel is updated after UpdateLastViewedAt", func(t *testing.T) {
 		newPosts := makeSomePosts()
 
-		require.Nil(t, ss.Thread().CreateMembershipIfNeeded(newPosts[0].UserId, newPosts[0].Id, true, false, true))
+		require.NoError(t, ss.Thread().CreateMembershipIfNeeded(newPosts[0].UserId, newPosts[0].Id, true, false, true))
 		m, err1 := ss.Thread().GetMembershipForUser(newPosts[0].UserId, newPosts[0].Id)
-		require.Nil(t, err1)
+		require.NoError(t, err1)
 		m.LastUpdated -= 1000
 		_, err := ss.Thread().UpdateMembership(m)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		_, err = ss.Channel().UpdateLastViewedAt([]string{newPosts[0].ChannelId}, newPosts[0].UserId, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		assert.Eventually(t, func() bool {
 			m2, err2 := ss.Thread().GetMembershipForUser(newPosts[0].UserId, newPosts[0].Id)
-			require.Nil(t, err2)
+			require.NoError(t, err2)
 			return m2.LastUpdated > m.LastUpdated
 		}, time.Second, 10*time.Millisecond)
 	})
@@ -295,19 +295,19 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
 	t.Run("Thread last updated is changed when channel is updated after UpdateLastViewedAtPost for mark unread", func(t *testing.T) {
 		newPosts := makeSomePosts()
 
-		require.Nil(t, ss.Thread().CreateMembershipIfNeeded(newPosts[0].UserId, newPosts[0].Id, true, false, true))
+		require.NoError(t, ss.Thread().CreateMembershipIfNeeded(newPosts[0].UserId, newPosts[0].Id, true, false, true))
 		m, err1 := ss.Thread().GetMembershipForUser(newPosts[0].UserId, newPosts[0].Id)
-		require.Nil(t, err1)
+		require.NoError(t, err1)
 		m.LastUpdated += 1000
 		_, err := ss.Thread().UpdateMembership(m)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		_, err = ss.Channel().UpdateLastViewedAtPost(newPosts[0], newPosts[0].UserId, 0, true)
-		require.Nil(t, err)
+		require.NoError(t, err)
 
 		assert.Eventually(t, func() bool {
 			m2, err2 := ss.Thread().GetMembershipForUser(newPosts[0].UserId, newPosts[0].Id)
-			require.Nil(t, err2)
+			require.NoError(t, err2)
 			return m2.LastUpdated < m.LastUpdated
 		}, time.Second, 10*time.Millisecond)
 	})

store/storetest/user_access_token_store.go

@@ -30,57 +30,57 @@ func testUserAccessTokenSaveGetDelete(t *testing.T, ss store.Store) {
 	s1.Token = uat.Token
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, nErr := ss.UserAccessToken().Save(uat)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	result, terr := ss.UserAccessToken().Get(uat.Id)
-	require.Nil(t, terr)
+	require.NoError(t, terr)
 	require.Equal(t, result.Token, uat.Token, "received incorrect token after save")
 
 	received, err2 := ss.UserAccessToken().GetByToken(uat.Token)
-	require.Nil(t, err2)
+	require.NoError(t, err2)
 	require.Equal(t, received.Token, uat.Token, "received incorrect token after save")
 
 	_, nErr = ss.UserAccessToken().GetByToken("notarealtoken")
-	require.NotNil(t, nErr, "should have failed on bad token")
+	require.Error(t, nErr, "should have failed on bad token")
 
 	received2, err2 := ss.UserAccessToken().GetByUser(uat.UserId, 0, 100)
-	require.Nil(t, err2)
+	require.NoError(t, err2)
 	require.Equal(t, 1, len(received2), "received incorrect number of tokens after save")
 
-	result2, appError := ss.UserAccessToken().GetAll(0, 100)
+	result2, err := ss.UserAccessToken().GetAll(0, 100)
-	require.Nil(t, appError)
+	require.NoError(t, err)
 	require.Equal(t, 1, len(result2), "received incorrect number of tokens after save")
 
 	nErr = ss.UserAccessToken().Delete(uat.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	_, err = ss.Session().Get(s1.Token)
-	require.NotNil(t, err, "should error - session should be deleted")
+	require.Error(t, err, "should error - session should be deleted")
 
 	_, nErr = ss.UserAccessToken().GetByToken(s1.Token)
-	require.NotNil(t, nErr, "should error - access token should be deleted")
+	require.Error(t, nErr, "should error - access token should be deleted")
 
 	s2 := &model.Session{}
 	s2.UserId = uat.UserId
 	s2.Token = uat.Token
 
 	s2, err = ss.Session().Save(s2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, nErr = ss.UserAccessToken().Save(uat)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	nErr = ss.UserAccessToken().DeleteAllForUser(uat.UserId)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	_, err = ss.Session().Get(s2.Token)
-	require.NotNil(t, err, "should error - session should be deleted")
+	require.Error(t, err, "should error - session should be deleted")
 
 	_, nErr = ss.UserAccessToken().GetByToken(s2.Token)
-	require.NotNil(t, nErr, "should error - access token should be deleted")
+	require.Error(t, nErr, "should error - access token should be deleted")
 }
 
 func testUserAccessTokenDisableEnable(t *testing.T, ss store.Store) {
@@ -95,26 +95,26 @@ func testUserAccessTokenDisableEnable(t *testing.T, ss store.Store) {
 	s1.Token = uat.Token
 
 	s1, err := ss.Session().Save(s1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, nErr := ss.UserAccessToken().Save(uat)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	nErr = ss.UserAccessToken().UpdateTokenDisable(uat.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	_, err = ss.Session().Get(s1.Token)
-	require.NotNil(t, err, "should error - session should be deleted")
+	require.Error(t, err, "should error - session should be deleted")
 
 	s2 := &model.Session{}
 	s2.UserId = uat.UserId
 	s2.Token = uat.Token
 
 	s2, err = ss.Session().Save(s2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	nErr = ss.UserAccessToken().UpdateTokenEnable(uat.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 }
 
 func testUserAccessTokenSearch(t *testing.T, ss store.Store) {
@@ -123,7 +123,7 @@ func testUserAccessTokenSearch(t *testing.T, ss store.Store) {
 	u1.Username = model.NewId()
 
 	_, err := ss.User().Save(&u1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	uat := &model.UserAccessToken{
 		Token:       model.NewId(),
@@ -136,21 +136,21 @@ func testUserAccessTokenSearch(t *testing.T, ss store.Store) {
 	s1.Token = uat.Token
 
 	s1, nErr := ss.Session().Save(s1)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	_, nErr = ss.UserAccessToken().Save(uat)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	received, nErr := ss.UserAccessToken().Search(uat.Id)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 
 	require.Equal(t, 1, len(received), "received incorrect number of tokens after search")
 
 	received, nErr = ss.UserAccessToken().Search(uat.UserId)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	require.Equal(t, 1, len(received), "received incorrect number of tokens after search")
 
 	received, nErr = ss.UserAccessToken().Search(u1.Username)
-	require.Nil(t, nErr)
+	require.NoError(t, nErr)
 	require.Equal(t, 1, len(received), "received incorrect number of tokens after search")
 }

store/storetest/user_terms_of_service.go

@@ -27,7 +27,7 @@ func testSaveUserTermsOfService(t *testing.T, ss store.Store) {
 	}
 
 	savedUserTermsOfService, err := ss.UserTermsOfService().Save(userTermsOfService)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, userTermsOfService.UserId, savedUserTermsOfService.UserId)
 	assert.Equal(t, userTermsOfService.TermsOfServiceId, savedUserTermsOfService.TermsOfServiceId)
 	assert.NotEmpty(t, savedUserTermsOfService.CreateAt)
@@ -40,10 +40,10 @@ func testGetByUserTermsOfService(t *testing.T, ss store.Store) {
 	}
 
 	_, err := ss.UserTermsOfService().Save(userTermsOfService)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	fetchedUserTermsOfService, err := ss.UserTermsOfService().GetByUser(userTermsOfService.UserId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, userTermsOfService.UserId, fetchedUserTermsOfService.UserId)
 	assert.Equal(t, userTermsOfService.TermsOfServiceId, fetchedUserTermsOfService.TermsOfServiceId)
 	assert.NotEmpty(t, fetchedUserTermsOfService.CreateAt)
@@ -56,16 +56,16 @@ func testDeleteUserTermsOfService(t *testing.T, ss store.Store) {
 	}
 
 	_, err := ss.UserTermsOfService().Save(userTermsOfService)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.UserTermsOfService().GetByUser(userTermsOfService.UserId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	err = ss.UserTermsOfService().Delete(userTermsOfService.UserId, userTermsOfService.TermsOfServiceId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.UserTermsOfService().GetByUser(userTermsOfService.UserId)
 	var nfErr *store.ErrNotFound
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 	assert.True(t, errors.As(err, &nfErr))
 }

store/storetest/webhook_store.go

@@ -46,10 +46,10 @@ func testWebhookStoreSaveIncoming(t *testing.T, ss store.Store) {
 	o1 := buildIncomingWebhook()
 
 	_, err := ss.Webhook().SaveIncoming(o1)
-	require.Nil(t, err, "couldn't save item")
+	require.NoError(t, err, "couldn't save item")
 
 	_, err = ss.Webhook().SaveIncoming(o1)
-	require.NotNil(t, err, "shouldn't be able to update from save")
+	require.Error(t, err, "shouldn't be able to update from save")
 }
 
 func testWebhookStoreUpdateIncoming(t *testing.T, ss store.Store) {
@@ -58,7 +58,7 @@ func testWebhookStoreUpdateIncoming(t *testing.T, ss store.Store) {
 
 	o1 := buildIncomingWebhook()
 	o1, err = ss.Webhook().SaveIncoming(o1)
-	require.Nil(t, err, "unable to save webhook")
+	require.NoError(t, err, "unable to save webhook")
 
 	previousUpdatedAt := o1.UpdateAt
 
@@ -66,7 +66,7 @@ func testWebhookStoreUpdateIncoming(t *testing.T, ss store.Store) {
 	time.Sleep(10 * time.Millisecond)
 
 	webhook, err := ss.Webhook().UpdateIncoming(o1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	require.NotEqual(t, webhook.UpdateAt, previousUpdatedAt, "should have updated the UpdatedAt of the hook")
 
@@ -78,24 +78,24 @@ func testWebhookStoreGetIncoming(t *testing.T, ss store.Store) {
 
 	o1 := buildIncomingWebhook()
 	o1, err = ss.Webhook().SaveIncoming(o1)
-	require.Nil(t, err, "unable to save webhook")
+	require.NoError(t, err, "unable to save webhook")
 
 	webhook, err := ss.Webhook().GetIncoming(o1.Id, false)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
 
 	webhook, err = ss.Webhook().GetIncoming(o1.Id, true)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
 
 	_, err = ss.Webhook().GetIncoming("123", false)
-	require.NotNil(t, err, "Missing id should have failed")
+	require.Error(t, err, "Missing id should have failed")
 
 	_, err = ss.Webhook().GetIncoming("123", true)
-	require.NotNil(t, err, "Missing id should have failed")
+	require.Error(t, err, "Missing id should have failed")
 
 	_, err = ss.Webhook().GetIncoming("123", true)
-	require.NotNil(t, err)
+	require.Error(t, err)
 	var nfErr *store.ErrNotFound
 	require.True(t, errors.As(err, &nfErr), "Should have set the status as not found for missing id")
 }
@@ -108,10 +108,10 @@ func testWebhookStoreGetIncomingList(t *testing.T, ss store.Store) {
 
 	var err error
 	o1, err = ss.Webhook().SaveIncoming(o1)
-	require.Nil(t, err, "unable to save webhook")
+	require.NoError(t, err, "unable to save webhook")
 
 	hooks, err := ss.Webhook().GetIncomingList(0, 1000)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	found := false
 	for _, hook := range hooks {
@@ -122,7 +122,7 @@ func testWebhookStoreGetIncomingList(t *testing.T, ss store.Store) {
 	require.True(t, found, "missing webhook")
 
 	hooks, err = ss.Webhook().GetIncomingList(0, 1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, hooks, 1, "only 1 should be returned")
 }
 
@@ -132,19 +132,19 @@ func testWebhookStoreGetIncomingListByUser(t *testing.T, ss store.Store) {
 	o1.UserId = model.NewId()
 	o1.TeamId = model.NewId()
 
-	o1, appErr := ss.Webhook().SaveIncoming(o1)
+	o1, err := ss.Webhook().SaveIncoming(o1)
-	require.Nil(t, appErr)
+	require.NoError(t, err)
 
 	t.Run("GetIncomingListByUser, known user filtered", func(t *testing.T) {
-		hooks, appErr := ss.Webhook().GetIncomingListByUser(o1.UserId, 0, 100)
+		hooks, err := ss.Webhook().GetIncomingListByUser(o1.UserId, 0, 100)
-		require.Nil(t, appErr)
+		require.NoError(t, err)
 		require.Equal(t, 1, len(hooks))
 		require.Equal(t, o1.CreateAt, hooks[0].CreateAt)
 	})
 
 	t.Run("GetIncomingListByUser, unknown user filtered", func(t *testing.T) {
-		hooks, appErr := ss.Webhook().GetIncomingListByUser("123465", 0, 100)
+		hooks, err := ss.Webhook().GetIncomingListByUser("123465", 0, 100)
-		require.Nil(t, appErr)
+		require.NoError(t, err)
 		require.Equal(t, 0, len(hooks))
 	})
 }
@@ -154,45 +154,45 @@ func testWebhookStoreGetIncomingByTeam(t *testing.T, ss store.Store) {
 
 	o1 := buildIncomingWebhook()
 	o1, err = ss.Webhook().SaveIncoming(o1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	hooks, err := ss.Webhook().GetIncomingByTeam(o1.TeamId, 0, 100)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, hooks[0].CreateAt, o1.CreateAt, "invalid returned webhook")
 
 	hooks, err = ss.Webhook().GetIncomingByTeam("123", 0, 100)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Empty(t, hooks, "no webhooks should have returned")
 }
 
 func TestWebhookStoreGetIncomingByTeamByUser(t *testing.T, ss store.Store) {
-	var appErr error
+	var err error
 
 	o1 := buildIncomingWebhook()
-	o1, appErr = ss.Webhook().SaveIncoming(o1)
+	o1, err = ss.Webhook().SaveIncoming(o1)
-	require.Nil(t, appErr)
+	require.NoError(t, err)
 
 	o2 := buildIncomingWebhook()
 	o2.TeamId = o1.TeamId //Set both to the same team
-	o2, appErr = ss.Webhook().SaveIncoming(o2)
+	o2, err = ss.Webhook().SaveIncoming(o2)
-	require.Nil(t, appErr)
+	require.NoError(t, err)
 
 	t.Run("GetIncomingByTeamByUser, no user filter", func(t *testing.T) {
-		hooks, appErr := ss.Webhook().GetIncomingByTeam(o1.TeamId, 0, 100)
+		hooks, err := ss.Webhook().GetIncomingByTeam(o1.TeamId, 0, 100)
-		require.Nil(t, appErr)
+		require.NoError(t, err)
 		require.Equal(t, len(hooks), 2)
 	})
 
 	t.Run("GetIncomingByTeamByUser, known user filtered", func(t *testing.T) {
-		hooks, appErr := ss.Webhook().GetIncomingByTeamByUser(o1.TeamId, o1.UserId, 0, 100)
+		hooks, err := ss.Webhook().GetIncomingByTeamByUser(o1.TeamId, o1.UserId, 0, 100)
-		require.Nil(t, appErr)
+		require.NoError(t, err)
 		require.Equal(t, len(hooks), 1)
 		require.Equal(t, hooks[0].CreateAt, o1.CreateAt)
 	})
 
 	t.Run("GetIncomingByTeamByUser, unknown user filtered", func(t *testing.T) {
-		hooks, appErr := ss.Webhook().GetIncomingByTeamByUser(o2.TeamId, "123465", 0, 100)
+		hooks, err := ss.Webhook().GetIncomingByTeamByUser(o2.TeamId, "123465", 0, 100)
-		require.Nil(t, appErr)
+		require.NoError(t, err)
 		require.Equal(t, len(hooks), 0)
 	})
 }
@@ -201,14 +201,14 @@ func testWebhookStoreGetIncomingByChannel(t *testing.T, ss store.Store) {
 	o1 := buildIncomingWebhook()
 
 	o1, err := ss.Webhook().SaveIncoming(o1)
-	require.Nil(t, err, "unable to save webhook")
+	require.NoError(t, err, "unable to save webhook")
 
 	webhooks, err := ss.Webhook().GetIncomingByChannel(o1.ChannelId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, webhooks[0].CreateAt, o1.CreateAt, "invalid returned webhook")
 
 	webhooks, err = ss.Webhook().GetIncomingByChannel("123")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Empty(t, webhooks, "no webhooks should have returned")
 }
 
@@ -217,17 +217,17 @@ func testWebhookStoreDeleteIncoming(t *testing.T, ss store.Store) {
 
 	o1 := buildIncomingWebhook()
 	o1, err = ss.Webhook().SaveIncoming(o1)
-	require.Nil(t, err, "unable to save webhook")
+	require.NoError(t, err, "unable to save webhook")
 
 	webhook, err := ss.Webhook().GetIncoming(o1.Id, true)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
 
 	err = ss.Webhook().DeleteIncoming(o1.Id, model.GetMillis())
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	webhook, err = ss.Webhook().GetIncoming(o1.Id, true)
-	require.NotNil(t, err)
+	require.Error(t, err)
 }
 
 func testWebhookStoreDeleteIncomingByChannel(t *testing.T, ss store.Store) {
@@ -235,17 +235,17 @@ func testWebhookStoreDeleteIncomingByChannel(t *testing.T, ss store.Store) {
 
 	o1 := buildIncomingWebhook()
 	o1, err = ss.Webhook().SaveIncoming(o1)
-	require.Nil(t, err, "unable to save webhook")
+	require.NoError(t, err, "unable to save webhook")
 
 	webhook, err := ss.Webhook().GetIncoming(o1.Id, true)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
 
 	err = ss.Webhook().PermanentDeleteIncomingByChannel(o1.ChannelId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.Webhook().GetIncoming(o1.Id, true)
-	require.NotNil(t, err, "Missing id should have failed")
+	require.Error(t, err, "Missing id should have failed")
 }
 
 func testWebhookStoreDeleteIncomingByUser(t *testing.T, ss store.Store) {
@@ -253,17 +253,17 @@ func testWebhookStoreDeleteIncomingByUser(t *testing.T, ss store.Store) {
 
 	o1 := buildIncomingWebhook()
 	o1, err = ss.Webhook().SaveIncoming(o1)
-	require.Nil(t, err, "unable to save webhook")
+	require.NoError(t, err, "unable to save webhook")
 
 	webhook, err := ss.Webhook().GetIncoming(o1.Id, true)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
 
 	err = ss.Webhook().PermanentDeleteIncomingByUser(o1.UserId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.Webhook().GetIncoming(o1.Id, true)
-	require.NotNil(t, err, "Missing id should have failed")
+	require.Error(t, err, "Missing id should have failed")
 }
 
 func buildIncomingWebhook() *model.IncomingWebhook {
@@ -285,10 +285,10 @@ func testWebhookStoreSaveOutgoing(t *testing.T, ss store.Store) {
 	o1.IconURL = "http://nowhere.com/icon"
 
 	_, err := ss.Webhook().SaveOutgoing(&o1)
-	require.Nil(t, err, "couldn't save item")
+	require.NoError(t, err, "couldn't save item")
 
 	_, err = ss.Webhook().SaveOutgoing(&o1)
-	require.NotNil(t, err, "shouldn't be able to update from save")
+	require.Error(t, err, "shouldn't be able to update from save")
 }
 
 func testWebhookStoreGetOutgoing(t *testing.T, ss store.Store) {
@@ -303,11 +303,11 @@ func testWebhookStoreGetOutgoing(t *testing.T, ss store.Store) {
 	o1, _ = ss.Webhook().SaveOutgoing(o1)
 
 	webhook, err := ss.Webhook().GetOutgoing(o1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
 
 	_, err = ss.Webhook().GetOutgoing("123")
-	require.NotNil(t, err, "Missing id should have failed")
+	require.Error(t, err, "Missing id should have failed")
 }
 
 func testWebhookStoreGetOutgoingListByUser(t *testing.T, ss store.Store) {
@@ -317,19 +317,19 @@ func testWebhookStoreGetOutgoingListByUser(t *testing.T, ss store.Store) {
 	o1.TeamId = model.NewId()
 	o1.CallbackURLs = []string{"http://nowhere.com/"}
 
-	o1, appErr := ss.Webhook().SaveOutgoing(o1)
+	o1, err := ss.Webhook().SaveOutgoing(o1)
-	require.Nil(t, appErr)
+	require.NoError(t, err)
 
 	t.Run("GetOutgoingListByUser, known user filtered", func(t *testing.T) {
-		hooks, appErr := ss.Webhook().GetOutgoingListByUser(o1.CreatorId, 0, 100)
+		hooks, err := ss.Webhook().GetOutgoingListByUser(o1.CreatorId, 0, 100)
-		require.Nil(t, appErr)
+		require.NoError(t, err)
 		require.Equal(t, 1, len(hooks))
 		require.Equal(t, o1.CreateAt, hooks[0].CreateAt)
 	})
 
 	t.Run("GetOutgoingListByUser, unknown user filtered", func(t *testing.T) {
-		hooks, appErr := ss.Webhook().GetOutgoingListByUser("123465", 0, 100)
+		hooks, err := ss.Webhook().GetOutgoingListByUser("123465", 0, 100)
-		require.Nil(t, appErr)
+		require.NoError(t, err)
 		require.Equal(t, 0, len(hooks))
 	})
 }
@@ -352,7 +352,7 @@ func testWebhookStoreGetOutgoingList(t *testing.T, ss store.Store) {
 	o2, _ = ss.Webhook().SaveOutgoing(o2)
 
 	r1, err := ss.Webhook().GetOutgoingList(0, 1000)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	hooks := r1
 	found1 := false
 	found2 := false
@@ -371,7 +371,7 @@ func testWebhookStoreGetOutgoingList(t *testing.T, ss store.Store) {
 	require.True(t, found2, "missing hook2")
 
 	result, err := ss.Webhook().GetOutgoingList(0, 2)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Len(t, result, 2, "wrong number of hooks returned")
 }
 
@@ -385,11 +385,11 @@ func testWebhookStoreGetOutgoingByChannel(t *testing.T, ss store.Store) {
 	o1, _ = ss.Webhook().SaveOutgoing(o1)
 
 	r1, err := ss.Webhook().GetOutgoingByChannel(o1.ChannelId, 0, 100)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, r1[0].CreateAt, o1.CreateAt, "invalid returned webhook")
 
 	result, err := ss.Webhook().GetOutgoingByChannel("123", -1, -1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Empty(t, result, "no webhooks should have returned")
 }
 
@@ -400,8 +400,8 @@ func testWebhookStoreGetOutgoingByChannelByUser(t *testing.T, ss store.Store) {
 	o1.TeamId = model.NewId()
 	o1.CallbackURLs = []string{"http://nowhere.com/"}
 
-	o1, appErr := ss.Webhook().SaveOutgoing(o1)
+	o1, err := ss.Webhook().SaveOutgoing(o1)
-	require.Nil(t, appErr)
+	require.NoError(t, err)
 
 	o2 := &model.OutgoingWebhook{}
 	o2.ChannelId = o1.ChannelId
@@ -409,25 +409,25 @@ func testWebhookStoreGetOutgoingByChannelByUser(t *testing.T, ss store.Store) {
 	o2.TeamId = model.NewId()
 	o2.CallbackURLs = []string{"http://nowhere.com/"}
 
-	o2, appErr = ss.Webhook().SaveOutgoing(o2)
+	o2, err = ss.Webhook().SaveOutgoing(o2)
-	require.Nil(t, appErr)
+	require.NoError(t, err)
 
 	t.Run("GetOutgoingByChannelByUser, no user filter", func(t *testing.T) {
-		hooks, appErr := ss.Webhook().GetOutgoingByChannel(o1.ChannelId, 0, 100)
+		hooks, err := ss.Webhook().GetOutgoingByChannel(o1.ChannelId, 0, 100)
-		require.Nil(t, appErr)
+		require.NoError(t, err)
 		require.Equal(t, len(hooks), 2)
 	})
 
 	t.Run("GetOutgoingByChannelByUser, known user filtered", func(t *testing.T) {
-		hooks, appErr := ss.Webhook().GetOutgoingByChannelByUser(o1.ChannelId, o1.CreatorId, 0, 100)
+		hooks, err := ss.Webhook().GetOutgoingByChannelByUser(o1.ChannelId, o1.CreatorId, 0, 100)
-		require.Nil(t, appErr)
+		require.NoError(t, err)
 		require.Equal(t, 1, len(hooks))
 		require.Equal(t, o1.CreateAt, hooks[0].CreateAt)
 	})
 
 	t.Run("GetOutgoingByChannelByUser, unknown user filtered", func(t *testing.T) {
-		hooks, appErr := ss.Webhook().GetOutgoingByChannelByUser(o1.ChannelId, "123465", 0, 100)
+		hooks, err := ss.Webhook().GetOutgoingByChannelByUser(o1.ChannelId, "123465", 0, 100)
-		require.Nil(t, appErr)
+		require.NoError(t, err)
 		require.Equal(t, 0, len(hooks))
 	})
 }
@@ -442,16 +442,16 @@ func testWebhookStoreGetOutgoingByTeam(t *testing.T, ss store.Store) {
 	o1, _ = ss.Webhook().SaveOutgoing(o1)
 
 	r1, err := ss.Webhook().GetOutgoingByTeam(o1.TeamId, 0, 100)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, r1[0].CreateAt, o1.CreateAt, "invalid returned webhook")
 
 	result, err := ss.Webhook().GetOutgoingByTeam("123", -1, -1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Empty(t, result, "no webhooks should have returned")
 }
 
 func testWebhookStoreGetOutgoingByTeamByUser(t *testing.T, ss store.Store) {
-	var appErr error
+	var err error
 
 	o1 := &model.OutgoingWebhook{}
 	o1.ChannelId = model.NewId()
@@ -459,8 +459,8 @@ func testWebhookStoreGetOutgoingByTeamByUser(t *testing.T, ss store.Store) {
 	o1.TeamId = model.NewId()
 	o1.CallbackURLs = []string{"http://nowhere.com/"}
 
-	o1, appErr = ss.Webhook().SaveOutgoing(o1)
+	o1, err = ss.Webhook().SaveOutgoing(o1)
-	require.Nil(t, appErr)
+	require.NoError(t, err)
 
 	o2 := &model.OutgoingWebhook{}
 	o2.ChannelId = model.NewId()
@@ -468,25 +468,25 @@ func testWebhookStoreGetOutgoingByTeamByUser(t *testing.T, ss store.Store) {
 	o2.TeamId = o1.TeamId
 	o2.CallbackURLs = []string{"http://nowhere.com/"}
 
-	o2, appErr = ss.Webhook().SaveOutgoing(o2)
+	o2, err = ss.Webhook().SaveOutgoing(o2)
-	require.Nil(t, appErr)
+	require.NoError(t, err)
 
 	t.Run("GetOutgoingByTeamByUser, no user filter", func(t *testing.T) {
-		hooks, appErr := ss.Webhook().GetOutgoingByTeam(o1.TeamId, 0, 100)
+		hooks, err := ss.Webhook().GetOutgoingByTeam(o1.TeamId, 0, 100)
-		require.Nil(t, appErr)
+		require.NoError(t, err)
 		require.Equal(t, len(hooks), 2)
 	})
 
 	t.Run("GetOutgoingByTeamByUser, known user filtered", func(t *testing.T) {
-		hooks, appErr := ss.Webhook().GetOutgoingByTeamByUser(o1.TeamId, o1.CreatorId, 0, 100)
+		hooks, err := ss.Webhook().GetOutgoingByTeamByUser(o1.TeamId, o1.CreatorId, 0, 100)
-		require.Nil(t, appErr)
+		require.NoError(t, err)
 		require.Equal(t, len(hooks), 1)
 		require.Equal(t, hooks[0].CreateAt, o1.CreateAt)
 	})
 
 	t.Run("GetOutgoingByTeamByUser, unknown user filtered", func(t *testing.T) {
-		hooks, appErr := ss.Webhook().GetOutgoingByTeamByUser(o2.TeamId, "123465", 0, 100)
+		hooks, err := ss.Webhook().GetOutgoingByTeamByUser(o2.TeamId, "123465", 0, 100)
-		require.Nil(t, appErr)
+		require.NoError(t, err)
 		require.Equal(t, len(hooks), 0)
 	})
 }
@@ -501,14 +501,14 @@ func testWebhookStoreDeleteOutgoing(t *testing.T, ss store.Store) {
 	o1, _ = ss.Webhook().SaveOutgoing(o1)
 
 	webhook, err := ss.Webhook().GetOutgoing(o1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
 
 	err = ss.Webhook().DeleteOutgoing(o1.Id, model.GetMillis())
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.Webhook().GetOutgoing(o1.Id)
-	require.NotNil(t, err, "Missing id should have failed")
+	require.Error(t, err, "Missing id should have failed")
 }
 
 func testWebhookStoreDeleteOutgoingByChannel(t *testing.T, ss store.Store) {
@@ -521,14 +521,14 @@ func testWebhookStoreDeleteOutgoingByChannel(t *testing.T, ss store.Store) {
 	o1, _ = ss.Webhook().SaveOutgoing(o1)
 
 	webhook, err := ss.Webhook().GetOutgoing(o1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
 
 	err = ss.Webhook().PermanentDeleteOutgoingByChannel(o1.ChannelId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.Webhook().GetOutgoing(o1.Id)
-	require.NotNil(t, err, "Missing id should have failed")
+	require.Error(t, err, "Missing id should have failed")
 }
 
 func testWebhookStoreDeleteOutgoingByUser(t *testing.T, ss store.Store) {
@@ -541,14 +541,14 @@ func testWebhookStoreDeleteOutgoingByUser(t *testing.T, ss store.Store) {
 	o1, _ = ss.Webhook().SaveOutgoing(o1)
 
 	webhook, err := ss.Webhook().GetOutgoing(o1.Id)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, webhook.CreateAt, o1.CreateAt, "invalid returned webhook")
 
 	err = ss.Webhook().PermanentDeleteOutgoingByUser(o1.CreatorId)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	_, err = ss.Webhook().GetOutgoing(o1.Id)
-	require.NotNil(t, err, "Missing id should have failed")
+	require.Error(t, err, "Missing id should have failed")
 }
 
 func testWebhookStoreUpdateOutgoing(t *testing.T, ss store.Store) {
@@ -566,7 +566,7 @@ func testWebhookStoreUpdateOutgoing(t *testing.T, ss store.Store) {
 	o1.Username = "another-test-user-name"
 
 	_, err := ss.Webhook().UpdateOutgoing(o1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func testWebhookStoreCountIncoming(t *testing.T, ss store.Store) {
@@ -578,7 +578,7 @@ func testWebhookStoreCountIncoming(t *testing.T, ss store.Store) {
 	_, _ = ss.Webhook().SaveIncoming(o1)
 
 	c, err := ss.Webhook().AnalyticsIncomingCount("")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	require.NotEqual(t, 0, c, "should have at least 1 incoming hook")
 }
@@ -591,9 +591,9 @@ func testWebhookStoreCountOutgoing(t *testing.T, ss store.Store) {
 	o1.CallbackURLs = []string{"http://nowhere.com/"}
 
 	_, err := ss.Webhook().SaveOutgoing(o1)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	r, err := ss.Webhook().AnalyticsOutgoingCount("")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.NotEqual(t, 0, r, "should have at least 1 outgoing hook")
 }