diff --git a/api4/scheme_test.go b/api4/scheme_test.go
index 0aef98673a..c2fd510701 100644
--- a/api4/scheme_test.go
+++ b/api4/scheme_test.go
@@ -401,9 +401,8 @@ func TestGetChannelsForScheme(t *testing.T) {
 		Type:        model.CHANNEL_OPEN,
 	}
 
-	result1 := <-th.App.Srv.Store.Channel().Save(channel1, 1000000)
-	assert.Nil(t, result1.Err)
-	channel1 = result1.Data.(*model.Channel)
+	channel1, errCh := th.App.Srv.Store.Channel().Save(channel1, 1000000)
+	assert.Nil(t, errCh)
 
 	l2, r2 := th.SystemAdminClient.GetChannelsForScheme(scheme1.Id, 0, 100)
 	CheckNoError(t, r2)
@@ -425,9 +424,8 @@ func TestGetChannelsForScheme(t *testing.T) {
 		Type:        model.CHANNEL_OPEN,
 		SchemeId:    &scheme1.Id,
 	}
-	result3 := <-th.App.Srv.Store.Channel().Save(channel2, 1000000)
-	assert.Nil(t, result3.Err)
-	channel2 = result3.Data.(*model.Channel)
+	channel2, err = th.App.Srv.Store.Channel().Save(channel2, 1000000)
+	assert.Nil(t, err)
 
 	l4, r4 := th.SystemAdminClient.GetChannelsForScheme(scheme1.Id, 0, 100)
 	CheckNoError(t, r4)
@@ -691,15 +689,14 @@ func TestDeleteScheme(t *testing.T) {
 		assert.Zero(t, role6.DeleteAt)
 
 		// Make sure this scheme is in use by a team.
-		res := <-th.App.Srv.Store.Channel().Save(&model.Channel{
+		channel, err := th.App.Srv.Store.Channel().Save(&model.Channel{
 			TeamId:      model.NewId(),
 			DisplayName: model.NewId(),
 			Name:        model.NewId(),
 			Type:        model.CHANNEL_OPEN,
 			SchemeId:    &s1.Id,
 		}, -1)
-		assert.Nil(t, res.Err)
-		channel := res.Data.(*model.Channel)
+		assert.Nil(t, err)
 
 		// Delete the Scheme.
 		_, r3 := th.SystemAdminClient.DeleteScheme(s1.Id)
diff --git a/app/channel.go b/app/channel.go
index 2ae6f9d130..87ac50766e 100644
--- a/app/channel.go
+++ b/app/channel.go
@@ -221,13 +221,11 @@ func (a *App) RenameChannel(channel *model.Channel, newChannelName string, newDi
 }
 
 func (a *App) CreateChannel(channel *model.Channel, addMember bool) (*model.Channel, *model.AppError) {
-	result := <-a.Srv.Store.Channel().Save(channel, *a.Config().TeamSettings.MaxChannelsPerTeam)
-	if result.Err != nil {
-		return nil, result.Err
+	sc, err := a.Srv.Store.Channel().Save(channel, *a.Config().TeamSettings.MaxChannelsPerTeam)
+	if err != nil {
+		return nil, err
 	}
 
-	sc := result.Data.(*model.Channel)
-
 	if addMember {
 		user, err := a.Srv.Store.User().Get(channel.CreatorId)
 		if err != nil {
@@ -456,14 +454,13 @@ func (a *App) createGroupChannel(userIds []string, creatorId string) (*model.Cha
 		Type:        model.CHANNEL_GROUP,
 	}
 
-	result = <-a.Srv.Store.Channel().Save(group, *a.Config().TeamSettings.MaxChannelsPerTeam)
-	if result.Err != nil {
-		if result.Err.Id == store.CHANNEL_EXISTS_ERROR {
-			return result.Data.(*model.Channel), result.Err
+	channel, err := a.Srv.Store.Channel().Save(group, *a.Config().TeamSettings.MaxChannelsPerTeam)
+	if err != nil {
+		if err.Id == store.CHANNEL_EXISTS_ERROR {
+			return channel, err
 		}
-		return nil, result.Err
+		return nil, err
 	}
-	channel := result.Data.(*model.Channel)
 
 	for _, user := range users {
 		cm := &model.ChannelMember{
diff --git a/app/slackimport.go b/app/slackimport.go
index b95c8a3f39..63baed4515 100644
--- a/app/slackimport.go
+++ b/app/slackimport.go
@@ -786,11 +786,10 @@ func (a *App) OldImportUser(team *model.Team, user *model.User) *model.User {
 }
 
 func (a *App) OldImportChannel(channel *model.Channel) *model.Channel {
-	result := <-a.Srv.Store.Channel().Save(channel, *a.Config().TeamSettings.MaxChannelsPerTeam)
-	if result.Err != nil {
+	sc, err := a.Srv.Store.Channel().Save(channel, *a.Config().TeamSettings.MaxChannelsPerTeam)
+	if err != nil {
 		return nil
 	}
-	sc := result.Data.(*model.Channel)
 
 	return sc
 }
diff --git a/store/sqlstore/channel_store.go b/store/sqlstore/channel_store.go
index cf63c706db..f4cdd16a85 100644
--- a/store/sqlstore/channel_store.go
+++ b/store/sqlstore/channel_store.go
@@ -450,41 +450,44 @@ func (s SqlChannelStore) upsertPublicChannelT(transaction *gorp.Transaction, cha
 }
 
 // Save writes the (non-direct) channel channel to the database.
-func (s SqlChannelStore) Save(channel *model.Channel, maxChannelsPerTeam int64) store.StoreChannel {
-	return store.Do(func(result *store.StoreResult) {
-		if channel.DeleteAt != 0 {
-			result.Err = model.NewAppError("SqlChannelStore.Save", "store.sql_channel.save.archived_channel.app_error", nil, "", http.StatusBadRequest)
-			return
-		}
+func (s SqlChannelStore) Save(channel *model.Channel, maxChannelsPerTeam int64) (*model.Channel, *model.AppError) {
 
-		if channel.Type == model.CHANNEL_DIRECT {
-			result.Err = model.NewAppError("SqlChannelStore.Save", "store.sql_channel.save.direct_channel.app_error", nil, "", http.StatusBadRequest)
-			return
-		}
+	if channel.DeleteAt != 0 {
+		return nil, model.NewAppError("SqlChannelStore.Save", "store.sql_channel.save.archived_channel.app_error", nil, "", http.StatusBadRequest)
+	}
 
-		transaction, err := s.GetMaster().Begin()
-		if err != nil {
-			result.Err = model.NewAppError("SqlChannelStore.Save", "store.sql_channel.save.open_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		defer finalizeTransaction(transaction)
+	if channel.Type == model.CHANNEL_DIRECT {
+		return nil, model.NewAppError("SqlChannelStore.Save", "store.sql_channel.save.direct_channel.app_error", nil, "", http.StatusBadRequest)
+	}
 
-		*result = s.saveChannelT(transaction, channel, maxChannelsPerTeam)
-		if result.Err != nil {
-			return
-		}
+	transaction, err := s.GetMaster().Begin()
+	if err != nil {
+		return nil, model.NewAppError("SqlChannelStore.Save", "store.sql_channel.save.open_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+	defer finalizeTransaction(transaction)
 
-		// Additionally propagate the write to the PublicChannels table.
-		if err := s.upsertPublicChannelT(transaction, result.Data.(*model.Channel)); err != nil {
-			result.Err = model.NewAppError("SqlChannelStore.Save", "store.sql_channel.save.upsert_public_channel.app_error", nil, err.Error(), http.StatusInternalServerError)
-			return
-		}
+	channelResult := s.saveChannelT(transaction, channel, maxChannelsPerTeam)
+	var newChannel *model.Channel
+	if channelResult.Data != nil {
+		newChannel = channelResult.Data.(*model.Channel)
+	}
+	appErr := channelResult.Err
 
-		if err := transaction.Commit(); err != nil {
-			result.Err = model.NewAppError("SqlChannelStore.Save", "store.sql_channel.save.commit_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
-			return
-		}
-	})
+	if appErr != nil {
+		return newChannel, appErr
+	}
+
+	// Additionally propagate the write to the PublicChannels table.
+	if err := s.upsertPublicChannelT(transaction, newChannel); err != nil {
+		return nil, model.NewAppError("SqlChannelStore.Save", "store.sql_channel.save.upsert_public_channel.app_error", nil, err.Error(), http.StatusInternalServerError)
+
+	}
+
+	if err := transaction.Commit(); err != nil {
+		return nil, model.NewAppError("SqlChannelStore.Save", "store.sql_channel.save.commit_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+
+	return newChannel, nil
 }
 
 func (s SqlChannelStore) CreateDirectChannel(userId string, otherUserId string) (*model.Channel, *model.AppError) {
diff --git a/store/store.go b/store/store.go
index 8c5e187b9d..8ac715c552 100644
--- a/store/store.go
+++ b/store/store.go
@@ -129,7 +129,7 @@ type TeamStore interface {
 }
 
 type ChannelStore interface {
-	Save(channel *model.Channel, maxChannelsPerTeam int64) StoreChannel
+	Save(channel *model.Channel, maxChannelsPerTeam int64) (*model.Channel, *model.AppError)
 	CreateDirectChannel(userId string, otherUserId string) (*model.Channel, *model.AppError)
 	SaveDirectChannel(channel *model.Channel, member1 *model.ChannelMember, member2 *model.ChannelMember) (*model.Channel, *model.AppError)
 	Update(channel *model.Channel) (*model.Channel, *model.AppError)
diff --git a/store/storetest/channel_member_history_store.go b/store/storetest/channel_member_history_store.go
index 883047cc2f..6ae50cbf56 100644
--- a/store/storetest/channel_member_history_store.go
+++ b/store/storetest/channel_member_history_store.go
@@ -11,6 +11,7 @@ import (
 	"github.com/mattermost/mattermost-server/model"
 	"github.com/mattermost/mattermost-server/store"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestChannelMemberHistoryStore(t *testing.T, ss store.Store) {
@@ -23,13 +24,14 @@ func TestChannelMemberHistoryStore(t *testing.T, ss store.Store) {
 
 func testLogJoinEvent(t *testing.T, ss store.Store) {
 	// create a test channel
-	channel := model.Channel{
+	ch := model.Channel{
 		TeamId:      model.NewId(),
 		DisplayName: "Display " + model.NewId(),
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	channel = *store.Must(ss.Channel().Save(&channel, -1)).(*model.Channel)
+	channel, err := ss.Channel().Save(&ch, -1)
+	require.Nil(t, err)
 
 	// and a test user
 	user := model.User{
@@ -46,13 +48,14 @@ func testLogJoinEvent(t *testing.T, ss store.Store) {
 
 func testLogLeaveEvent(t *testing.T, ss store.Store) {
 	// create a test channel
-	channel := model.Channel{
+	ch := model.Channel{
 		TeamId:      model.NewId(),
 		DisplayName: "Display " + model.NewId(),
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	channel = *store.Must(ss.Channel().Save(&channel, -1)).(*model.Channel)
+	channel, err := ss.Channel().Save(&ch, -1)
+	require.Nil(t, err)
 
 	// and a test user
 	user := model.User{
@@ -72,13 +75,14 @@ func testLogLeaveEvent(t *testing.T, ss store.Store) {
 
 func testGetUsersInChannelAtChannelMemberHistory(t *testing.T, ss store.Store) {
 	// create a test channel
-	channel := model.Channel{
+	ch := &model.Channel{
 		TeamId:      model.NewId(),
 		DisplayName: "Display " + model.NewId(),
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	channel = *store.Must(ss.Channel().Save(&channel, -1)).(*model.Channel)
+	channel, err := ss.Channel().Save(ch, -1)
+	require.Nil(t, err)
 
 	// and a test user
 	user := model.User{
@@ -155,13 +159,14 @@ func testGetUsersInChannelAtChannelMemberHistory(t *testing.T, ss store.Store) {
 
 func testGetUsersInChannelAtChannelMembers(t *testing.T, ss store.Store) {
 	// create a test channel
-	channel := model.Channel{
+	channel := &model.Channel{
 		TeamId:      model.NewId(),
 		DisplayName: "Display " + model.NewId(),
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	channel = *store.Must(ss.Channel().Save(&channel, -1)).(*model.Channel)
+	channel, err := ss.Channel().Save(channel, -1)
+	require.Nil(t, err)
 
 	// and a test user
 	user := model.User{
@@ -257,13 +262,14 @@ func testGetUsersInChannelAtChannelMembers(t *testing.T, ss store.Store) {
 
 func testPermanentDeleteBatch(t *testing.T, ss store.Store) {
 	// create a test channel
-	channel := model.Channel{
+	channel := &model.Channel{
 		TeamId:      model.NewId(),
 		DisplayName: "Display " + model.NewId(),
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	channel = *store.Must(ss.Channel().Save(&channel, -1)).(*model.Channel)
+	channel, err := ss.Channel().Save(channel, -1)
+	require.Nil(t, err)
 
 	// and two test users
 	user := model.User{
diff --git a/store/storetest/channel_store.go b/store/storetest/channel_store.go
index 43ec111e83..888c78023a 100644
--- a/store/storetest/channel_store.go
+++ b/store/storetest/channel_store.go
@@ -97,23 +97,23 @@ func testChannelStoreSave(t *testing.T, ss store.Store) {
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
 
-	if err := (<-ss.Channel().Save(&o1, -1)).Err; err != nil {
+	if _, err := ss.Channel().Save(&o1, -1); err != nil {
 		t.Fatal("couldn't save item", err)
 	}
 
-	if err := (<-ss.Channel().Save(&o1, -1)).Err; err == nil {
+	if _, err := ss.Channel().Save(&o1, -1); err == nil {
 		t.Fatal("shouldn't be able to update from save")
 	}
 
 	o1.Id = ""
-	if err := (<-ss.Channel().Save(&o1, -1)).Err; err == nil {
+	if _, err := ss.Channel().Save(&o1, -1); err == nil {
 		t.Fatal("should be unique name")
 	}
 
 	o1.Id = ""
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_DIRECT
-	if err := (<-ss.Channel().Save(&o1, -1)).Err; err == nil {
+	if _, err := ss.Channel().Save(&o1, -1); err == nil {
 		t.Fatal("Should not be able to save direct channel")
 	}
 }
@@ -239,14 +239,18 @@ func testChannelStoreUpdate(t *testing.T, ss store.Store) {
 	o1.DisplayName = "Name"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	o2 := model.Channel{}
 	o2.TeamId = o1.TeamId
 	o2.DisplayName = "Name"
 	o2.Name = "zz" + model.NewId() + "b"
 	o2.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o2, -1))
+
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	time.Sleep(100 * time.Millisecond)
 
@@ -289,13 +293,17 @@ func testGetChannelUnread(t *testing.T, ss store.Store) {
 
 	// Setup Channel 1
 	c1 := &model.Channel{TeamId: m1.TeamId, Name: model.NewId(), DisplayName: "Downtown", Type: model.CHANNEL_OPEN, TotalMsgCount: 100}
-	store.Must(ss.Channel().Save(c1, -1))
+	_, err := ss.Channel().Save(c1, -1)
+	require.Nil(t, err)
+
 	cm1 := &model.ChannelMember{ChannelId: c1.Id, UserId: m1.UserId, NotifyProps: notifyPropsModel, MsgCount: 90}
 	store.Must(ss.Channel().SaveMember(cm1))
 
 	// Setup Channel 2
 	c2 := &model.Channel{TeamId: m2.TeamId, Name: model.NewId(), DisplayName: "Cultural", Type: model.CHANNEL_OPEN, TotalMsgCount: 100}
-	store.Must(ss.Channel().Save(c2, -1))
+	_, err = ss.Channel().Save(c2, -1)
+	require.Nil(t, err)
+
 	cm2 := &model.ChannelMember{ChannelId: c2.Id, UserId: m2.UserId, NotifyProps: notifyPropsModel, MsgCount: 90, MentionCount: 5}
 	store.Must(ss.Channel().SaveMember(cm2))
 
@@ -352,9 +360,11 @@ func testChannelStoreGet(t *testing.T, ss store.Store, s SqlSupplier) {
 	o1.DisplayName = "Name"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
-	if c1, err := ss.Channel().Get(o1.Id, false); err != nil {
+	c1 := &model.Channel{}
+	if c1, err = ss.Channel().Get(o1.Id, false); err != nil {
 		t.Fatal(err)
 	} else {
 		if c1.ToJson() != o1.ToJson() {
@@ -362,7 +372,7 @@ func testChannelStoreGet(t *testing.T, ss store.Store, s SqlSupplier) {
 		}
 	}
 
-	if _, err := ss.Channel().Get("", false); err == nil {
+	if _, err = ss.Channel().Get("", false); err == nil {
 		t.Fatal("Missing id should have failed")
 	}
 
@@ -394,7 +404,7 @@ func testChannelStoreGet(t *testing.T, ss store.Store, s SqlSupplier) {
 	m2.UserId = u2.Id
 	m2.NotifyProps = model.GetDefaultChannelNotifyProps()
 
-	_, err := ss.Channel().SaveDirectChannel(&o2, &m1, &m2)
+	_, err = ss.Channel().SaveDirectChannel(&o2, &m1, &m2)
 	require.Nil(t, err)
 
 	if c2, err := ss.Channel().Get(o2.Id, false); err != nil {
@@ -440,7 +450,8 @@ func testChannelStoreGetChannelsByIds(t *testing.T, ss store.Store) {
 	o1.DisplayName = "Name"
 	o1.Name = "aa" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	u1 := &model.User{}
 	u1.Email = MakeEmail()
@@ -470,7 +481,7 @@ func testChannelStoreGetChannelsByIds(t *testing.T, ss store.Store) {
 	m2.UserId = u2.Id
 	m2.NotifyProps = model.GetDefaultChannelNotifyProps()
 
-	_, err := ss.Channel().SaveDirectChannel(&o2, &m1, &m2)
+	_, err = ss.Channel().SaveDirectChannel(&o2, &m1, &m2)
 	require.Nil(t, err)
 
 	if r1 := <-ss.Channel().GetChannelsByIds([]string{o1.Id, o2.Id}); r1.Err != nil {
@@ -503,12 +514,15 @@ func testChannelStoreGetChannelsByIds(t *testing.T, ss store.Store) {
 }
 
 func testChannelStoreGetForPost(t *testing.T, ss store.Store) {
-	o1 := store.Must(ss.Channel().Save(&model.Channel{
+
+	ch := &model.Channel{
 		TeamId:      model.NewId(),
 		DisplayName: "Name",
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
-	}, -1)).(*model.Channel)
+	}
+	o1, err := ss.Channel().Save(ch, -1)
+	require.Nil(t, err)
 
 	p1 := store.Must(ss.Post().Save(&model.Post{
 		UserId:    model.NewId(),
@@ -529,7 +543,8 @@ func testChannelStoreRestore(t *testing.T, ss store.Store) {
 	o1.DisplayName = "Channel1"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	if err := ss.Channel().Delete(o1.Id, model.GetMillis()); err != nil {
 		t.Fatal(err)
@@ -555,28 +570,32 @@ func testChannelStoreDelete(t *testing.T, ss store.Store) {
 	o1.DisplayName = "Channel1"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	o2 := model.Channel{}
 	o2.TeamId = o1.TeamId
 	o2.DisplayName = "Channel2"
 	o2.Name = "zz" + model.NewId() + "b"
 	o2.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	o3 := model.Channel{}
 	o3.TeamId = o1.TeamId
 	o3.DisplayName = "Channel3"
 	o3.Name = "zz" + model.NewId() + "b"
 	o3.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o3, -1))
+	_, err = ss.Channel().Save(&o3, -1)
+	require.Nil(t, err)
 
 	o4 := model.Channel{}
 	o4.TeamId = o1.TeamId
 	o4.DisplayName = "Channel4"
 	o4.Name = "zz" + model.NewId() + "b"
 	o4.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o4, -1))
+	_, err = ss.Channel().Save(&o4, -1)
+	require.Nil(t, err)
 
 	m1 := model.ChannelMember{}
 	m1.ChannelId = o1.Id
@@ -639,7 +658,8 @@ func testChannelStoreGetByName(t *testing.T, ss store.Store) {
 	o1.DisplayName = "Name"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	result := <-ss.Channel().GetByName(o1.TeamId, o1.Name, true)
 	require.Nil(t, result.Err)
@@ -657,7 +677,7 @@ func testChannelStoreGetByName(t *testing.T, ss store.Store) {
 	result = <-ss.Channel().GetByName(o1.TeamId, "", false)
 	require.NotNil(t, result.Err, "Missing id should have failed")
 
-	err := ss.Channel().Delete(channelID, model.GetMillis())
+	err = ss.Channel().Delete(channelID, model.GetMillis())
 	require.Nil(t, err, "channel should have been deleted")
 
 	result = <-ss.Channel().GetByName(o1.TeamId, o1.Name, false)
@@ -671,7 +691,8 @@ func testChannelStoreGetByNames(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	o2 := model.Channel{
 		TeamId:      o1.TeamId,
@@ -679,7 +700,8 @@ func testChannelStoreGetByNames(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	for index, tc := range []struct {
 		TeamId      string
@@ -706,7 +728,7 @@ func testChannelStoreGetByNames(t *testing.T, ss store.Store) {
 		assert.Equal(t, tc.ExpectedIds, ids, "tc %v", index)
 	}
 
-	err := ss.Channel().Delete(o1.Id, model.GetMillis())
+	err = ss.Channel().Delete(o1.Id, model.GetMillis())
 	require.Nil(t, err, "channel should have been deleted")
 
 	err = ss.Channel().Delete(o2.Id, model.GetMillis())
@@ -724,9 +746,11 @@ func testChannelStoreGetDeletedByName(t *testing.T, ss store.Store) {
 	o1.DisplayName = "Name"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
+
 	now := model.GetMillis()
-	err := ss.Channel().Delete(o1.Id, model.GetMillis())
+	err = ss.Channel().Delete(o1.Id, model.GetMillis())
 	require.Nil(t, err, "channel should have been deleted")
 	o1.DeleteAt = now
 	o1.UpdateAt = now
@@ -750,8 +774,11 @@ func testChannelStoreGetDeleted(t *testing.T, ss store.Store) {
 	o1.DisplayName = "Channel1"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
-	err := ss.Channel().Delete(o1.Id, model.GetMillis())
+
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
+
+	err = ss.Channel().Delete(o1.Id, model.GetMillis())
 	require.Nil(t, err, "channel should have been deleted")
 
 	cresult := <-ss.Channel().GetDeleted(o1.TeamId, 0, 100)
@@ -773,7 +800,8 @@ func testChannelStoreGetDeleted(t *testing.T, ss store.Store) {
 	o2.DisplayName = "Channel2"
 	o2.Name = "zz" + model.NewId() + "b"
 	o2.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	cresult = <-ss.Channel().GetDeleted(o1.TeamId, 0, 100)
 	if cresult.Err != nil {
@@ -790,7 +818,10 @@ func testChannelStoreGetDeleted(t *testing.T, ss store.Store) {
 	o3.DisplayName = "Channel3"
 	o3.Name = "zz" + model.NewId() + "b"
 	o3.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o3, -1))
+
+	_, err = ss.Channel().Save(&o3, -1)
+	require.Nil(t, err)
+
 	err = ss.Channel().Delete(o3.Id, model.GetMillis())
 	require.Nil(t, err, "channel should have been deleted")
 
@@ -827,12 +858,13 @@ func testChannelStoreGetDeleted(t *testing.T, ss store.Store) {
 }
 
 func testChannelMemberStore(t *testing.T, ss store.Store) {
-	c1 := model.Channel{}
+	c1 := &model.Channel{}
 	c1.TeamId = model.NewId()
 	c1.DisplayName = "NameName"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	c1 = *store.Must(ss.Channel().Save(&c1, -1)).(*model.Channel)
+	c1, err := ss.Channel().Save(c1, -1)
+	require.Nil(t, err)
 
 	c1t1, _ := ss.Channel().Get(c1.Id, false)
 	assert.EqualValues(t, 0, c1t1.ExtraUpdateAt, "ExtraUpdateAt should be 0")
@@ -911,12 +943,13 @@ func testChannelMemberStore(t *testing.T, ss store.Store) {
 }
 
 func testChannelDeleteMemberStore(t *testing.T, ss store.Store) {
-	c1 := model.Channel{}
+	c1 := &model.Channel{}
 	c1.TeamId = model.NewId()
 	c1.DisplayName = "NameName"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	c1 = *store.Must(ss.Channel().Save(&c1, -1)).(*model.Channel)
+	c1, err := ss.Channel().Save(c1, -1)
+	require.Nil(t, err)
 
 	c1t1, _ := ss.Channel().Get(c1.Id, false)
 	assert.EqualValues(t, 0, c1t1.ExtraUpdateAt, "ExtraUpdateAt should be 0")
@@ -976,14 +1009,16 @@ func testChannelStoreGetChannels(t *testing.T, ss store.Store) {
 	o2.DisplayName = "Channel2"
 	o2.Name = "zz" + model.NewId() + "b"
 	o2.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err := ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	o1 := model.Channel{}
 	o1.TeamId = model.NewId()
 	o1.DisplayName = "Channel1"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err = ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	m1 := model.ChannelMember{}
 	m1.ChannelId = o1.Id
@@ -1071,7 +1106,8 @@ func testChannelStoreGetAllChannels(t *testing.T, ss store.Store, s SqlSupplier)
 	c1.DisplayName = "Channel1" + model.NewId()
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&c1, -1))
+	_, err = ss.Channel().Save(&c1, -1)
+	require.Nil(t, err)
 
 	group := &model.Group{
 		Name:        model.NewId(),
@@ -1087,7 +1123,8 @@ func testChannelStoreGetAllChannels(t *testing.T, ss store.Store, s SqlSupplier)
 	c2.DisplayName = "Channel2" + model.NewId()
 	c2.Name = "zz" + model.NewId() + "b"
 	c2.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&c2, -1))
+	_, err = ss.Channel().Save(&c2, -1)
+	require.Nil(t, err)
 	c2.DeleteAt = model.GetMillis()
 	c2.UpdateAt = c2.DeleteAt
 	err = ss.Channel().Delete(c2.Id, c2.DeleteAt)
@@ -1098,7 +1135,8 @@ func testChannelStoreGetAllChannels(t *testing.T, ss store.Store, s SqlSupplier)
 	c3.DisplayName = "Channel3" + model.NewId()
 	c3.Name = "zz" + model.NewId() + "b"
 	c3.Type = model.CHANNEL_PRIVATE
-	store.Must(ss.Channel().Save(&c3, -1))
+	_, err = ss.Channel().Save(&c3, -1)
+	require.Nil(t, err)
 
 	_, err = ss.Channel().CreateDirectChannel(model.NewId(), model.NewId())
 	require.Nil(t, err)
@@ -1110,7 +1148,8 @@ func testChannelStoreGetAllChannels(t *testing.T, ss store.Store, s SqlSupplier)
 	c5.DisplayName = "GroupChannel" + model.NewId()
 	c5.Name = "zz" + model.NewId() + "b"
 	c5.Type = model.CHANNEL_GROUP
-	store.Must(ss.Channel().Save(&c5, -1))
+	_, err = ss.Channel().Save(&c5, -1)
+	require.Nil(t, err)
 
 	cresult := <-ss.Channel().GetAllChannels(0, 10, store.ChannelSearchOpts{})
 	list := cresult.Data.(*model.ChannelListWithTeamData)
@@ -1162,7 +1201,8 @@ func testChannelStoreGetMoreChannels(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
 		ChannelId:   o1.Id,
@@ -1183,7 +1223,8 @@ func testChannelStoreGetMoreChannels(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
 		ChannelId:   o2.Id,
@@ -1199,7 +1240,8 @@ func testChannelStoreGetMoreChannels(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o3, -1))
+	_, err = ss.Channel().Save(&o3, -1)
+	require.Nil(t, err)
 
 	// o4 is a private channel on the team to which the user does not belong
 	o4 := model.Channel{
@@ -1208,7 +1250,8 @@ func testChannelStoreGetMoreChannels(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	store.Must(ss.Channel().Save(&o4, -1))
+	_, err = ss.Channel().Save(&o4, -1)
+	require.Nil(t, err)
 
 	// o5 is another private channel on the team to which the user does belong
 	o5 := model.Channel{
@@ -1217,7 +1260,8 @@ func testChannelStoreGetMoreChannels(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	store.Must(ss.Channel().Save(&o5, -1))
+	_, err = ss.Channel().Save(&o5, -1)
+	require.Nil(t, err)
 
 	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
 		ChannelId:   o5.Id,
@@ -1239,7 +1283,8 @@ func testChannelStoreGetMoreChannels(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o6, -1))
+	_, err = ss.Channel().Save(&o6, -1)
+	require.Nil(t, err)
 
 	// o7 is another channel on the team to which the user does not belong, but is deleted,
 	// and thus would not start showing up in "more channels"
@@ -1249,8 +1294,10 @@ func testChannelStoreGetMoreChannels(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o7, -1))
-	err := ss.Channel().Delete(o7.Id, model.GetMillis())
+	_, err = ss.Channel().Save(&o7, -1)
+	require.Nil(t, err)
+
+	err = ss.Channel().Delete(o7.Id, model.GetMillis())
 	require.Nil(t, err, "channel should have been deleted")
 
 	t.Run("both o3 and o6 listed in more channels", func(t *testing.T) {
@@ -1294,7 +1341,8 @@ func testChannelStoreGetPublicChannelsForTeam(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	// o2 is a public channel on another team
 	o2 := model.Channel{
@@ -1303,7 +1351,8 @@ func testChannelStoreGetPublicChannelsForTeam(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	// o3 is a private channel on the team
 	o3 := model.Channel{
@@ -1312,7 +1361,8 @@ func testChannelStoreGetPublicChannelsForTeam(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	store.Must(ss.Channel().Save(&o3, -1))
+	_, err = ss.Channel().Save(&o3, -1)
+	require.Nil(t, err)
 
 	t.Run("only o1 initially listed in public channels", func(t *testing.T) {
 		result := <-ss.Channel().GetPublicChannelsForTeam(teamId, 0, 100)
@@ -1327,7 +1377,8 @@ func testChannelStoreGetPublicChannelsForTeam(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o4, -1))
+	_, err = ss.Channel().Save(&o4, -1)
+	require.Nil(t, err)
 
 	// o5 is another public, but deleted channel on the team
 	o5 := model.Channel{
@@ -1336,8 +1387,9 @@ func testChannelStoreGetPublicChannelsForTeam(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o5, -1))
-	err := ss.Channel().Delete(o5.Id, model.GetMillis())
+	_, err = ss.Channel().Save(&o5, -1)
+	require.Nil(t, err)
+	err = ss.Channel().Delete(o5.Id, model.GetMillis())
 	require.Nil(t, err, "channel should have been deleted")
 
 	t.Run("both o1 and o4 listed in public channels", func(t *testing.T) {
@@ -1381,7 +1433,8 @@ func testChannelStoreGetPublicChannelsByIdsForTeam(t *testing.T, ss store.Store)
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&oc1, -1))
+	_, err := ss.Channel().Save(&oc1, -1)
+	require.Nil(t, err)
 
 	// oc2 is a public channel on another team
 	oc2 := model.Channel{
@@ -1390,7 +1443,8 @@ func testChannelStoreGetPublicChannelsByIdsForTeam(t *testing.T, ss store.Store)
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&oc2, -1))
+	_, err = ss.Channel().Save(&oc2, -1)
+	require.Nil(t, err)
 
 	// pc3 is a private channel on the team
 	pc3 := model.Channel{
@@ -1399,7 +1453,8 @@ func testChannelStoreGetPublicChannelsByIdsForTeam(t *testing.T, ss store.Store)
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	store.Must(ss.Channel().Save(&pc3, -1))
+	_, err = ss.Channel().Save(&pc3, -1)
+	require.Nil(t, err)
 
 	t.Run("oc1 by itself should be found as a public channel in the team", func(t *testing.T) {
 		result := <-ss.Channel().GetPublicChannelsByIdsForTeam(teamId, []string{oc1.Id})
@@ -1420,7 +1475,8 @@ func testChannelStoreGetPublicChannelsByIdsForTeam(t *testing.T, ss store.Store)
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&oc4, -1))
+	_, err = ss.Channel().Save(&oc4, -1)
+	require.Nil(t, err)
 
 	// oc4 is another public, but deleted channel on the team
 	oc5 := model.Channel{
@@ -1429,8 +1485,10 @@ func testChannelStoreGetPublicChannelsByIdsForTeam(t *testing.T, ss store.Store)
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&oc5, -1))
-	err := ss.Channel().Delete(oc5.Id, model.GetMillis())
+	_, err = ss.Channel().Save(&oc5, -1)
+	require.Nil(t, err)
+
+	err = ss.Channel().Delete(oc5.Id, model.GetMillis())
 	require.Nil(t, err, "channel should have been deleted")
 
 	t.Run("only oc1 and oc4, among others, should be found as a public channel in the team", func(t *testing.T) {
@@ -1452,14 +1510,16 @@ func testChannelStoreGetChannelCounts(t *testing.T, ss store.Store) {
 	o2.DisplayName = "Channel2"
 	o2.Name = "zz" + model.NewId() + "b"
 	o2.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err := ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	o1 := model.Channel{}
 	o1.TeamId = model.NewId()
 	o1.DisplayName = "Channel1"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err = ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	m1 := model.ChannelMember{}
 	m1.ChannelId = o1.Id
@@ -1505,14 +1565,16 @@ func testChannelStoreGetMembersForUser(t *testing.T, ss store.Store) {
 	o1.DisplayName = "Channel1"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err = ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	o2 := model.Channel{}
 	o2.TeamId = o1.TeamId
 	o2.DisplayName = "Channel2"
 	o2.Name = "zz" + model.NewId() + "b"
 	o2.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	m1 := model.ChannelMember{}
 	m1.ChannelId = o1.Id
@@ -1549,14 +1611,16 @@ func testChannelStoreGetMembersForUserWithPagination(t *testing.T, ss store.Stor
 	o1.DisplayName = "Channel1"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err = ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	o2 := model.Channel{}
 	o2.TeamId = o1.TeamId
 	o2.DisplayName = "Channel2"
 	o2.Name = "zz" + model.NewId() + "b"
 	o2.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	m1 := model.ChannelMember{}
 	m1.ChannelId = o1.Id
@@ -1588,7 +1652,8 @@ func testChannelStoreUpdateLastViewedAt(t *testing.T, ss store.Store) {
 	o1.Type = model.CHANNEL_OPEN
 	o1.TotalMsgCount = 25
 	o1.LastPostAt = 12345
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	m1 := model.ChannelMember{}
 	m1.ChannelId = o1.Id
@@ -1603,7 +1668,8 @@ func testChannelStoreUpdateLastViewedAt(t *testing.T, ss store.Store) {
 	o2.Type = model.CHANNEL_OPEN
 	o2.TotalMsgCount = 26
 	o2.LastPostAt = 123456
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	m2 := model.ChannelMember{}
 	m2.ChannelId = o2.Id
@@ -1647,7 +1713,8 @@ func testChannelStoreIncrementMentionCount(t *testing.T, ss store.Store) {
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
 	o1.TotalMsgCount = 25
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	m1 := model.ChannelMember{}
 	m1.ChannelId = o1.Id
@@ -1655,7 +1722,7 @@ func testChannelStoreIncrementMentionCount(t *testing.T, ss store.Store) {
 	m1.NotifyProps = model.GetDefaultChannelNotifyProps()
 	store.Must(ss.Channel().SaveMember(&m1))
 
-	err := (<-ss.Channel().IncrementMentionCount(m1.ChannelId, m1.UserId)).Err
+	err = (<-ss.Channel().IncrementMentionCount(m1.ChannelId, m1.UserId)).Err
 	if err != nil {
 		t.Fatal("failed to update")
 	}
@@ -1685,7 +1752,8 @@ func testUpdateChannelMember(t *testing.T, ss store.Store) {
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(c1, -1))
+	_, err := ss.Channel().Save(c1, -1)
+	require.Nil(t, err)
 
 	m1 := &model.ChannelMember{
 		ChannelId:   c1.Id,
@@ -1714,7 +1782,8 @@ func testGetMember(t *testing.T, ss store.Store) {
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(c1, -1))
+	_, err := ss.Channel().Save(c1, -1)
+	require.Nil(t, err)
 
 	c2 := &model.Channel{
 		TeamId:      c1.TeamId,
@@ -1722,7 +1791,8 @@ func testGetMember(t *testing.T, ss store.Store) {
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(c2, -1))
+	_, err = ss.Channel().Save(c2, -1)
+	require.Nil(t, err)
 
 	m1 := &model.ChannelMember{
 		ChannelId:   c1.Id,
@@ -1784,12 +1854,15 @@ func testGetMember(t *testing.T, ss store.Store) {
 }
 
 func testChannelStoreGetMemberForPost(t *testing.T, ss store.Store) {
-	o1 := store.Must(ss.Channel().Save(&model.Channel{
+	ch := &model.Channel{
 		TeamId:      model.NewId(),
 		DisplayName: "Name",
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
-	}, -1)).(*model.Channel)
+	}
+
+	o1, err := ss.Channel().Save(ch, -1)
+	require.Nil(t, err)
 
 	m1 := store.Must(ss.Channel().SaveMember(&model.ChannelMember{
 		ChannelId:   o1.Id,
@@ -1823,7 +1896,8 @@ func testGetMemberCount(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&c1, -1))
+	_, err := ss.Channel().Save(&c1, -1)
+	require.Nil(t, err)
 
 	c2 := model.Channel{
 		TeamId:      teamId,
@@ -1831,7 +1905,8 @@ func testGetMemberCount(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&c2, -1))
+	_, err = ss.Channel().Save(&c2, -1)
+	require.Nil(t, err)
 
 	u1 := &model.User{
 		Email:    MakeEmail(),
@@ -1926,7 +2001,8 @@ func testChannelStoreSearchMore(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	m1 := model.ChannelMember{
 		ChannelId:   o1.Id,
@@ -1948,7 +2024,8 @@ func testChannelStoreSearchMore(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	m3 := model.ChannelMember{
 		ChannelId:   o2.Id,
@@ -1963,7 +2040,8 @@ func testChannelStoreSearchMore(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o3, -1))
+	_, err = ss.Channel().Save(&o3, -1)
+	require.Nil(t, err)
 
 	o4 := model.Channel{
 		TeamId:      teamId,
@@ -1971,7 +2049,8 @@ func testChannelStoreSearchMore(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	store.Must(ss.Channel().Save(&o4, -1))
+	_, err = ss.Channel().Save(&o4, -1)
+	require.Nil(t, err)
 
 	o5 := model.Channel{
 		TeamId:      teamId,
@@ -1979,7 +2058,8 @@ func testChannelStoreSearchMore(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	store.Must(ss.Channel().Save(&o5, -1))
+	_, err = ss.Channel().Save(&o5, -1)
+	require.Nil(t, err)
 
 	o6 := model.Channel{
 		TeamId:      teamId,
@@ -1987,7 +2067,8 @@ func testChannelStoreSearchMore(t *testing.T, ss store.Store) {
 		Name:        "off-topic",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o6, -1))
+	_, err = ss.Channel().Save(&o6, -1)
+	require.Nil(t, err)
 
 	o7 := model.Channel{
 		TeamId:      teamId,
@@ -1995,7 +2076,8 @@ func testChannelStoreSearchMore(t *testing.T, ss store.Store) {
 		Name:        "off-set",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o7, -1))
+	_, err = ss.Channel().Save(&o7, -1)
+	require.Nil(t, err)
 
 	o8 := model.Channel{
 		TeamId:      teamId,
@@ -2003,7 +2085,8 @@ func testChannelStoreSearchMore(t *testing.T, ss store.Store) {
 		Name:        "off-limit",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	store.Must(ss.Channel().Save(&o8, -1))
+	_, err = ss.Channel().Save(&o8, -1)
+	require.Nil(t, err)
 
 	o9 := model.Channel{
 		TeamId:      teamId,
@@ -2012,7 +2095,8 @@ func testChannelStoreSearchMore(t *testing.T, ss store.Store) {
 		Name:        "with-purpose",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o9, -1))
+	_, err = ss.Channel().Save(&o9, -1)
+	require.Nil(t, err)
 
 	o10 := model.Channel{
 		TeamId:      teamId,
@@ -2020,10 +2104,12 @@ func testChannelStoreSearchMore(t *testing.T, ss store.Store) {
 		Name:        "channel-a-deleted",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o10, -1))
+	_, err = ss.Channel().Save(&o10, -1)
+	require.Nil(t, err)
+
 	o10.DeleteAt = model.GetMillis()
 	o10.UpdateAt = o10.DeleteAt
-	err := ss.Channel().Delete(o10.Id, model.GetMillis())
+	err = ss.Channel().Delete(o10.Id, model.GetMillis())
 	require.Nil(t, err, "channel should have been deleted")
 
 	t.Run("three public channels matching 'ChannelA', but already a member of one and one deleted", func(t *testing.T) {
@@ -2081,7 +2167,8 @@ func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	o2 := model.Channel{
 		TeamId:      otherTeamId,
@@ -2089,7 +2176,8 @@ func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	m1 := model.ChannelMember{
 		ChannelId:   o1.Id,
@@ -2118,7 +2206,8 @@ func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o3, -1))
+	_, err = ss.Channel().Save(&o3, -1)
+	require.Nil(t, err)
 
 	o4 := model.Channel{
 		TeamId:      teamId,
@@ -2126,7 +2215,8 @@ func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	store.Must(ss.Channel().Save(&o4, -1))
+	_, err = ss.Channel().Save(&o4, -1)
+	require.Nil(t, err)
 
 	o5 := model.Channel{
 		TeamId:      teamId,
@@ -2134,7 +2224,8 @@ func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	store.Must(ss.Channel().Save(&o5, -1))
+	_, err = ss.Channel().Save(&o5, -1)
+	require.Nil(t, err)
 
 	o6 := model.Channel{
 		TeamId:      teamId,
@@ -2142,7 +2233,8 @@ func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) {
 		Name:        "off-topic",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o6, -1))
+	_, err = ss.Channel().Save(&o6, -1)
+	require.Nil(t, err)
 
 	o7 := model.Channel{
 		TeamId:      teamId,
@@ -2150,7 +2242,8 @@ func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) {
 		Name:        "off-set",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o7, -1))
+	_, err = ss.Channel().Save(&o7, -1)
+	require.Nil(t, err)
 
 	o8 := model.Channel{
 		TeamId:      teamId,
@@ -2158,7 +2251,8 @@ func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) {
 		Name:        "off-limit",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	store.Must(ss.Channel().Save(&o8, -1))
+	_, err = ss.Channel().Save(&o8, -1)
+	require.Nil(t, err)
 
 	o9 := model.Channel{
 		TeamId:      teamId,
@@ -2166,7 +2260,8 @@ func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) {
 		Name:        "town-square",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o9, -1))
+	_, err = ss.Channel().Save(&o9, -1)
+	require.Nil(t, err)
 
 	o10 := model.Channel{
 		TeamId:      teamId,
@@ -2174,7 +2269,8 @@ func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) {
 		Name:        "the",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o10, -1))
+	_, err = ss.Channel().Save(&o10, -1)
+	require.Nil(t, err)
 
 	o11 := model.Channel{
 		TeamId:      teamId,
@@ -2182,7 +2278,8 @@ func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) {
 		Name:        "native-mobile-apps",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o11, -1))
+	_, err = ss.Channel().Save(&o11, -1)
+	require.Nil(t, err)
 
 	o12 := model.Channel{
 		TeamId:      teamId,
@@ -2191,7 +2288,8 @@ func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) {
 		Name:        "with-purpose",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o12, -1))
+	_, err = ss.Channel().Save(&o12, -1)
+	require.Nil(t, err)
 
 	o13 := model.Channel{
 		TeamId:      teamId,
@@ -2199,10 +2297,11 @@ func testChannelStoreSearchInTeam(t *testing.T, ss store.Store) {
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o13, -1))
+	_, err = ss.Channel().Save(&o13, -1)
+	require.Nil(t, err)
 	o13.DeleteAt = model.GetMillis()
 	o13.UpdateAt = o13.DeleteAt
-	err := ss.Channel().Delete(o13.Id, model.GetMillis())
+	err = ss.Channel().Delete(o13.Id, model.GetMillis())
 	require.Nil(t, err, "channel should have been deleted")
 
 	testCases := []struct {
@@ -2273,7 +2372,8 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err = ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	o2 := model.Channel{
 		TeamId:      t2.Id,
@@ -2281,7 +2381,8 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	m1 := model.ChannelMember{
 		ChannelId:   o1.Id,
@@ -2310,7 +2411,8 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o3, -1))
+	_, err = ss.Channel().Save(&o3, -1)
+	require.Nil(t, err)
 
 	o4 := model.Channel{
 		TeamId:      t1.Id,
@@ -2318,7 +2420,8 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	store.Must(ss.Channel().Save(&o4, -1))
+	_, err = ss.Channel().Save(&o4, -1)
+	require.Nil(t, err)
 
 	o5 := model.Channel{
 		TeamId:      t1.Id,
@@ -2326,7 +2429,8 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	store.Must(ss.Channel().Save(&o5, -1))
+	_, err = ss.Channel().Save(&o5, -1)
+	require.Nil(t, err)
 
 	o6 := model.Channel{
 		TeamId:      t1.Id,
@@ -2334,7 +2438,8 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Name:        "off-topic",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o6, -1))
+	_, err = ss.Channel().Save(&o6, -1)
+	require.Nil(t, err)
 
 	o7 := model.Channel{
 		TeamId:      t1.Id,
@@ -2342,7 +2447,8 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Name:        "off-set",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o7, -1))
+	_, err = ss.Channel().Save(&o7, -1)
+	require.Nil(t, err)
 
 	group := &model.Group{
 		Name:        model.NewId(),
@@ -2359,7 +2465,8 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Name:        "off-limit",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	store.Must(ss.Channel().Save(&o8, -1))
+	_, err = ss.Channel().Save(&o8, -1)
+	require.Nil(t, err)
 
 	o9 := model.Channel{
 		TeamId:      t1.Id,
@@ -2367,7 +2474,8 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Name:        "town-square",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o9, -1))
+	_, err = ss.Channel().Save(&o9, -1)
+	require.Nil(t, err)
 
 	o10 := model.Channel{
 		TeamId:      t1.Id,
@@ -2375,7 +2483,8 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Name:        "the",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o10, -1))
+	_, err = ss.Channel().Save(&o10, -1)
+	require.Nil(t, err)
 
 	o11 := model.Channel{
 		TeamId:      t1.Id,
@@ -2383,7 +2492,8 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Name:        "native-mobile-apps",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o11, -1))
+	_, err = ss.Channel().Save(&o11, -1)
+	require.Nil(t, err)
 
 	o12 := model.Channel{
 		TeamId:      t1.Id,
@@ -2392,7 +2502,8 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Name:        "with-purpose",
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o12, -1))
+	_, err = ss.Channel().Save(&o12, -1)
+	require.Nil(t, err)
 
 	o13 := model.Channel{
 		TeamId:      t1.Id,
@@ -2400,7 +2511,9 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o13, -1))
+	_, err = ss.Channel().Save(&o13, -1)
+	require.Nil(t, err)
+
 	o13.DeleteAt = model.GetMillis()
 	o13.UpdateAt = o13.DeleteAt
 	err = ss.Channel().Delete(o13.Id, o13.DeleteAt)
@@ -2471,7 +2584,8 @@ func testChannelStoreAutocompleteInTeamForSearch(t *testing.T, ss store.Store, s
 	o1.DisplayName = "ChannelA"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	m1 := model.ChannelMember{}
 	m1.ChannelId = o1.Id
@@ -2484,7 +2598,8 @@ func testChannelStoreAutocompleteInTeamForSearch(t *testing.T, ss store.Store, s
 	o2.DisplayName = "Channel2"
 	o2.Name = "zz" + model.NewId() + "b"
 	o2.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	m2 := model.ChannelMember{}
 	m2.ChannelId = o2.Id
@@ -2497,7 +2612,8 @@ func testChannelStoreAutocompleteInTeamForSearch(t *testing.T, ss store.Store, s
 	o3.DisplayName = "ChannelA"
 	o3.Name = "zz" + model.NewId() + "b"
 	o3.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o3, -1))
+	_, err = ss.Channel().Save(&o3, -1)
+	require.Nil(t, err)
 
 	m3 := model.ChannelMember{}
 	m3.ChannelId = o3.Id
@@ -2505,7 +2621,7 @@ func testChannelStoreAutocompleteInTeamForSearch(t *testing.T, ss store.Store, s
 	m3.NotifyProps = model.GetDefaultChannelNotifyProps()
 	store.Must(ss.Channel().SaveMember(&m3))
 
-	err := ss.Channel().SetDeleteAt(o3.Id, 100, 100)
+	err = ss.Channel().SetDeleteAt(o3.Id, 100, 100)
 	require.Nil(t, err, "channel should have been deleted")
 
 	o4 := model.Channel{}
@@ -2513,7 +2629,8 @@ func testChannelStoreAutocompleteInTeamForSearch(t *testing.T, ss store.Store, s
 	o4.DisplayName = "ChannelA"
 	o4.Name = "zz" + model.NewId() + "b"
 	o4.Type = model.CHANNEL_PRIVATE
-	store.Must(ss.Channel().Save(&o4, -1))
+	_, err = ss.Channel().Save(&o4, -1)
+	require.Nil(t, err)
 
 	m4 := model.ChannelMember{}
 	m4.ChannelId = o4.Id
@@ -2526,7 +2643,8 @@ func testChannelStoreAutocompleteInTeamForSearch(t *testing.T, ss store.Store, s
 	o5.DisplayName = "ChannelC"
 	o5.Name = "zz" + model.NewId() + "b"
 	o5.Type = model.CHANNEL_PRIVATE
-	store.Must(ss.Channel().Save(&o5, -1))
+	_, err = ss.Channel().Save(&o5, -1)
+	require.Nil(t, err)
 
 	_, err = ss.Channel().CreateDirectChannel(u1.Id, u2.Id)
 	require.Nil(t, err)
@@ -2568,7 +2686,8 @@ func testChannelStoreGetMembersByIds(t *testing.T, ss store.Store) {
 	o1.DisplayName = "ChannelA"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	m1 := &model.ChannelMember{ChannelId: o1.Id, UserId: model.NewId(), NotifyProps: model.GetDefaultChannelNotifyProps()}
 	store.Must(ss.Channel().SaveMember(m1))
@@ -2611,21 +2730,24 @@ func testChannelStoreAnalyticsDeletedTypeCount(t *testing.T, ss store.Store) {
 	o1.DisplayName = "ChannelA"
 	o1.Name = "zz" + model.NewId() + "b"
 	o1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	o2 := model.Channel{}
 	o2.TeamId = model.NewId()
 	o2.DisplayName = "Channel2"
 	o2.Name = "zz" + model.NewId() + "b"
 	o2.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	p3 := model.Channel{}
 	p3.TeamId = model.NewId()
 	p3.DisplayName = "Channel3"
 	p3.Name = "zz" + model.NewId() + "b"
 	p3.Type = model.CHANNEL_PRIVATE
-	store.Must(ss.Channel().Save(&p3, -1))
+	_, err = ss.Channel().Save(&p3, -1)
+	require.Nil(t, err)
 
 	u1 := &model.User{}
 	u1.Email = MakeEmail()
@@ -2702,12 +2824,15 @@ func testChannelStoreAnalyticsDeletedTypeCount(t *testing.T, ss store.Store) {
 }
 
 func testChannelStoreGetPinnedPosts(t *testing.T, ss store.Store) {
-	o1 := store.Must(ss.Channel().Save(&model.Channel{
+	ch1 := &model.Channel{
 		TeamId:      model.NewId(),
 		DisplayName: "Name",
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
-	}, -1)).(*model.Channel)
+	}
+
+	o1, err := ss.Channel().Save(ch1, -1)
+	require.Nil(t, err)
 
 	p1 := store.Must(ss.Post().Save(&model.Post{
 		UserId:    model.NewId(),
@@ -2722,12 +2847,15 @@ func testChannelStoreGetPinnedPosts(t *testing.T, ss store.Store) {
 		t.Fatal("didn't return relevant pinned posts")
 	}
 
-	o2 := store.Must(ss.Channel().Save(&model.Channel{
+	ch2 := &model.Channel{
 		TeamId:      model.NewId(),
 		DisplayName: "Name",
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
-	}, -1)).(*model.Channel)
+	}
+
+	o2, err := ss.Channel().Save(ch2, -1)
+	require.Nil(t, err)
 
 	store.Must(ss.Post().Save(&model.Post{
 		UserId:    model.NewId(),
@@ -2749,13 +2877,13 @@ func testChannelStoreMaxChannelsPerTeam(t *testing.T, ss store.Store) {
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_OPEN,
 	}
-	result := <-ss.Channel().Save(channel, 0)
-	assert.NotEqual(t, nil, result.Err)
-	assert.Equal(t, result.Err.Id, "store.sql_channel.save_channel.limit.app_error")
+	_, err := ss.Channel().Save(channel, 0)
+	assert.NotEqual(t, nil, err)
+	assert.Equal(t, err.Id, "store.sql_channel.save_channel.limit.app_error")
 
 	channel.Id = ""
-	result = <-ss.Channel().Save(channel, 1)
-	assert.Nil(t, result.Err)
+	_, err = ss.Channel().Save(channel, 1)
+	assert.Nil(t, err)
 }
 
 func testChannelStoreGetChannelsByScheme(t *testing.T, ss store.Store) {
@@ -2803,9 +2931,9 @@ func testChannelStoreGetChannelsByScheme(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_OPEN,
 	}
 
-	_ = (<-ss.Channel().Save(c1, 100)).Data.(*model.Channel)
-	_ = (<-ss.Channel().Save(c2, 100)).Data.(*model.Channel)
-	_ = (<-ss.Channel().Save(c3, 100)).Data.(*model.Channel)
+	_, _ = ss.Channel().Save(c1, 100)
+	_, _ = ss.Channel().Save(c2, 100)
+	_, _ = ss.Channel().Save(c3, 100)
 
 	// Get the channels by a valid Scheme ID.
 	res1 := <-ss.Channel().GetChannelsByScheme(s1.Id, 0, 100)
@@ -2835,7 +2963,7 @@ func testChannelStoreMigrateChannelMembers(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_OPEN,
 		SchemeId:    &s1,
 	}
-	c1 = (<-ss.Channel().Save(c1, 100)).Data.(*model.Channel)
+	c1, _ = ss.Channel().Save(c1, 100)
 
 	cm1 := &model.ChannelMember{
 		ChannelId:     c1.Id,
@@ -2924,8 +3052,8 @@ func testResetAllChannelSchemes(t *testing.T, ss store.Store) {
 		SchemeId:    &s1.Id,
 	}
 
-	c1 = (<-ss.Channel().Save(c1, 100)).Data.(*model.Channel)
-	c2 = (<-ss.Channel().Save(c2, 100)).Data.(*model.Channel)
+	c1, _ = ss.Channel().Save(c1, 100)
+	c2, _ = ss.Channel().Save(c2, 100)
 
 	assert.Equal(t, s1.Id, *c1.SchemeId)
 	assert.Equal(t, s1.Id, *c2.SchemeId)
@@ -2948,7 +3076,7 @@ func testChannelStoreClearAllCustomRoleAssignments(t *testing.T, ss store.Store)
 		Type:        model.CHANNEL_OPEN,
 	}
 
-	c = (<-ss.Channel().Save(c, 100)).Data.(*model.Channel)
+	c, _ = ss.Channel().Save(c, 100)
 
 	m1 := &model.ChannelMember{
 		ChannelId:     c.Id,
@@ -3011,7 +3139,8 @@ func testMaterializedPublicChannels(t *testing.T, ss store.Store, s SqlSupplier)
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o1, -1))
+	_, err := ss.Channel().Save(&o1, -1)
+	require.Nil(t, err)
 
 	// o2 is another public channel on the team
 	o2 := model.Channel{
@@ -3020,7 +3149,8 @@ func testMaterializedPublicChannels(t *testing.T, ss store.Store, s SqlSupplier)
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_OPEN,
 	}
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err = ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	t.Run("o1 and o2 initially listed in public channels", func(t *testing.T) {
 		result := <-ss.Channel().SearchInTeam(teamId, "", true)
@@ -3077,7 +3207,7 @@ func testMaterializedPublicChannels(t *testing.T, ss store.Store, s SqlSupplier)
 		Type:        model.CHANNEL_OPEN,
 	}
 
-	_, err := s.GetMaster().ExecNoTimeout(`
+	_, execerr := s.GetMaster().ExecNoTimeout(`
 		INSERT INTO
 		    PublicChannels(Id, DeleteAt, TeamId, DisplayName, Name, Header, Purpose)
 		VALUES
@@ -3091,11 +3221,11 @@ func testMaterializedPublicChannels(t *testing.T, ss store.Store, s SqlSupplier)
 		"Header":      o3.Header,
 		"Purpose":     o3.Purpose,
 	})
-	require.Nil(t, err)
+	require.Nil(t, execerr)
 
 	o3.DisplayName = "Open Channel 3 - Modified"
 
-	_, err = s.GetMaster().ExecNoTimeout(`
+	_, execerr = s.GetMaster().ExecNoTimeout(`
 		INSERT INTO
 		    Channels(Id, CreateAt, UpdateAt, DeleteAt, TeamId, Type, DisplayName, Name, Header, Purpose, LastPostAt, TotalMsgCount, ExtraUpdateAt, CreatorId)
 		VALUES
@@ -3116,7 +3246,7 @@ func testMaterializedPublicChannels(t *testing.T, ss store.Store, s SqlSupplier)
 		"ExtraUpdateAt": o3.ExtraUpdateAt,
 		"CreatorId":     o3.CreatorId,
 	})
-	require.Nil(t, err)
+	require.Nil(t, execerr)
 
 	t.Run("verify o3 INSERT converted to UPDATE", func(t *testing.T) {
 		result := <-ss.Channel().SearchInTeam(teamId, "", true)
@@ -3132,9 +3262,10 @@ func testMaterializedPublicChannels(t *testing.T, ss store.Store, s SqlSupplier)
 		Type:        model.CHANNEL_OPEN,
 	}
 
-	store.Must(ss.Channel().Save(&o4, -1))
+	_, err = ss.Channel().Save(&o4, -1)
+	require.Nil(t, err)
 
-	_, err = s.GetMaster().ExecNoTimeout(`
+	_, execerr = s.GetMaster().ExecNoTimeout(`
 		DELETE FROM
 		    PublicChannels
 		WHERE
@@ -3142,7 +3273,7 @@ func testMaterializedPublicChannels(t *testing.T, ss store.Store, s SqlSupplier)
 	`, map[string]interface{}{
 		"Id": o4.Id,
 	})
-	require.Nil(t, err)
+	require.Nil(t, execerr)
 
 	o4.DisplayName += " - Modified"
 	_, appErr = ss.Channel().Update(&o4)
@@ -3169,7 +3300,8 @@ func testChannelStoreGetAllChannelsForExportAfter(t *testing.T, ss store.Store)
 	c1.DisplayName = "Channel1"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&c1, -1))
+	_, err = ss.Channel().Save(&c1, -1)
+	require.Nil(t, err)
 
 	r1 := <-ss.Channel().GetAllChannelsForExportAfter(10000, strings.Repeat("0", 26))
 	assert.Nil(t, r1.Err)
@@ -3201,14 +3333,16 @@ func testChannelStoreGetChannelMembersForExport(t *testing.T, ss store.Store) {
 	c1.DisplayName = "Channel1"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&c1, -1))
+	_, err = ss.Channel().Save(&c1, -1)
+	require.Nil(t, err)
 
 	c2 := model.Channel{}
 	c2.TeamId = model.NewId()
 	c2.DisplayName = "Channel2"
 	c2.Name = "zz" + model.NewId() + "b"
 	c2.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&c2, -1))
+	_, err = ss.Channel().Save(&c2, -1)
+	require.Nil(t, err)
 
 	u1 := model.User{}
 	u1.Email = MakeEmail()
@@ -3254,7 +3388,8 @@ func testChannelStoreRemoveAllDeactivatedMembers(t *testing.T, ss store.Store) {
 	c1.DisplayName = "Channel1"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&c1, -1))
+	_, err = ss.Channel().Save(&c1, -1)
+	require.Nil(t, err)
 
 	u1 := model.User{}
 	u1.Email = MakeEmail()
@@ -3328,7 +3463,8 @@ func testChannelStoreExportAllDirectChannels(t *testing.T, ss store.Store, s Sql
 	o2.DisplayName = "GroupChannel" + model.NewId()
 	o2.Name = "zz" + model.NewId() + "b"
 	o2.Type = model.CHANNEL_GROUP
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err := ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	u1 := &model.User{}
 	u1.Email = MakeEmail()
@@ -3379,14 +3515,16 @@ func testChannelStoreExportAllDirectChannelsExcludePrivateAndPublic(t *testing.T
 	o2.DisplayName = "Channel2" + model.NewId()
 	o2.Name = "zz" + model.NewId() + "b"
 	o2.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&o2, -1))
+	_, err := ss.Channel().Save(&o2, -1)
+	require.Nil(t, err)
 
 	o3 := model.Channel{}
 	o3.TeamId = teamId
 	o3.DisplayName = "Channel3" + model.NewId()
 	o3.Name = "zz" + model.NewId() + "b"
 	o3.Type = model.CHANNEL_PRIVATE
-	store.Must(ss.Channel().Save(&o3, -1))
+	_, err = ss.Channel().Save(&o3, -1)
+	require.Nil(t, err)
 
 	u1 := &model.User{}
 	u1.Email = MakeEmail()
@@ -3475,7 +3613,8 @@ func testChannelStoreGetChannelsBatchForIndexing(t *testing.T, ss store.Store) {
 	c1.DisplayName = "Channel1"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(c1, -1))
+	_, err := ss.Channel().Save(c1, -1)
+	require.Nil(t, err)
 
 	time.Sleep(10 * time.Millisecond)
 
@@ -3483,7 +3622,8 @@ func testChannelStoreGetChannelsBatchForIndexing(t *testing.T, ss store.Store) {
 	c2.DisplayName = "Channel2"
 	c2.Name = "zz" + model.NewId() + "b"
 	c2.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(c2, -1))
+	_, err = ss.Channel().Save(c2, -1)
+	require.Nil(t, err)
 
 	time.Sleep(10 * time.Millisecond)
 	startTime := c2.CreateAt
@@ -3492,19 +3632,22 @@ func testChannelStoreGetChannelsBatchForIndexing(t *testing.T, ss store.Store) {
 	c3.DisplayName = "Channel3"
 	c3.Name = "zz" + model.NewId() + "b"
 	c3.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(c3, -1))
+	_, err = ss.Channel().Save(c3, -1)
+	require.Nil(t, err)
 
 	c4 := &model.Channel{}
 	c4.DisplayName = "Channel4"
 	c4.Name = "zz" + model.NewId() + "b"
 	c4.Type = model.CHANNEL_PRIVATE
-	store.Must(ss.Channel().Save(c4, -1))
+	_, err = ss.Channel().Save(c4, -1)
+	require.Nil(t, err)
 
 	c5 := &model.Channel{}
 	c5.DisplayName = "Channel5"
 	c5.Name = "zz" + model.NewId() + "b"
 	c5.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(c5, -1))
+	_, err = ss.Channel().Save(c5, -1)
+	require.Nil(t, err)
 
 	time.Sleep(10 * time.Millisecond)
 
@@ -3512,7 +3655,8 @@ func testChannelStoreGetChannelsBatchForIndexing(t *testing.T, ss store.Store) {
 	c6.DisplayName = "Channel6"
 	c6.Name = "zz" + model.NewId() + "b"
 	c6.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(c6, -1))
+	_, err = ss.Channel().Save(c6, -1)
+	require.Nil(t, err)
 
 	endTime := c6.CreateAt
 
diff --git a/store/storetest/compliance_store.go b/store/storetest/compliance_store.go
index 72f9db69fb..f1c40998f2 100644
--- a/store/storetest/compliance_store.go
+++ b/store/storetest/compliance_store.go
@@ -90,7 +90,8 @@ func testComplianceExport(t *testing.T, ss store.Store) {
 	c1.DisplayName = "Channel2"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	c1 = store.Must(ss.Channel().Save(c1, -1)).(*model.Channel)
+	c1, err = ss.Channel().Save(c1, -1)
+	require.Nil(t, err)
 
 	o1 := &model.Post{}
 	o1.ChannelId = c1.Id
@@ -190,7 +191,8 @@ func testComplianceExportDirectMessages(t *testing.T, ss store.Store) {
 	c1.DisplayName = "Channel2"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	c1 = store.Must(ss.Channel().Save(c1, -1)).(*model.Channel)
+	c1, err = ss.Channel().Save(c1, -1)
+	require.Nil(t, err)
 
 	cDM, err := ss.Channel().CreateDirectChannel(u1.Id, u2.Id)
 	require.Nil(t, err)
@@ -284,7 +286,8 @@ func testMessageExportPublicChannel(t *testing.T, ss store.Store) {
 		DisplayName: "Public Channel",
 		Type:        model.CHANNEL_OPEN,
 	}
-	channel = store.Must(ss.Channel().Save(channel, -1)).(*model.Channel)
+	channel, err = ss.Channel().Save(channel, -1)
+	require.Nil(t, err)
 
 	// user1 posts twice in the public channel
 	post1 := &model.Post{
@@ -379,7 +382,8 @@ func testMessageExportPrivateChannel(t *testing.T, ss store.Store) {
 		DisplayName: "Private Channel",
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	channel = store.Must(ss.Channel().Save(channel, -1)).(*model.Channel)
+	channel, err = ss.Channel().Save(channel, -1)
+	require.Nil(t, err)
 
 	// user1 posts twice in the private channel
 	post1 := &model.Post{
@@ -559,7 +563,8 @@ func testMessageExportGroupMessageChannel(t *testing.T, ss store.Store) {
 		Name:   model.NewId(),
 		Type:   model.CHANNEL_GROUP,
 	}
-	groupMessageChannel = store.Must(ss.Channel().Save(groupMessageChannel, -1)).(*model.Channel)
+	groupMessageChannel, err = ss.Channel().Save(groupMessageChannel, -1)
+	require.Nil(t, err)
 
 	// user1 posts in the GM
 	post := &model.Post{
diff --git a/store/storetest/group_supplier.go b/store/storetest/group_supplier.go
index 83dd2859e8..da8f76771c 100644
--- a/store/storetest/group_supplier.go
+++ b/store/storetest/group_supplier.go
@@ -1090,9 +1090,8 @@ func testPendingAutoAddChannelMembers(t *testing.T, ss store.Store) {
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_OPEN, // Query does not look at type so this shouldn't matter.
 	}
-	res = <-ss.Channel().Save(channel, 9999)
-	require.Nil(t, res.Err)
-	channel = res.Data.(*model.Channel)
+	channel, err := ss.Channel().Save(channel, 9999)
+	require.Nil(t, err)
 
 	// Create GroupChannel
 	res = <-ss.Group().CreateGroupSyncable(model.NewGroupChannel(group.Id, channel.Id, true))
@@ -1169,7 +1168,7 @@ func testPendingAutoAddChannelMembers(t *testing.T, ss store.Store) {
 	require.Len(t, res.Data, 1)
 
 	// No result if Channel deleted
-	err := ss.Channel().Delete(channel.Id, model.GetMillis())
+	err = ss.Channel().Delete(channel.Id, model.GetMillis())
 	require.Nil(t, err)
 	res = <-ss.Group().ChannelMembersToAdd(0)
 	require.Nil(t, res.Err)
@@ -1456,9 +1455,8 @@ func pendingMemberRemovalsDataSetup(t *testing.T, ss store.Store) *removalsData
 		Type:             model.CHANNEL_PRIVATE,
 		GroupConstrained: model.NewBool(true),
 	}
-	res = <-ss.Channel().Save(channelConstrained, 9999)
-	require.Nil(t, res.Err)
-	channelConstrained = res.Data.(*model.Channel)
+	channelConstrained, err := ss.Channel().Save(channelConstrained, 9999)
+	require.Nil(t, err)
 
 	channelUnconstrained := &model.Channel{
 		TeamId:      model.NewId(),
@@ -1466,9 +1464,8 @@ func pendingMemberRemovalsDataSetup(t *testing.T, ss store.Store) *removalsData
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	res = <-ss.Channel().Save(channelUnconstrained, 9999)
-	require.Nil(t, res.Err)
-	channelUnconstrained = res.Data.(*model.Channel)
+	channelUnconstrained, err = ss.Channel().Save(channelUnconstrained, 9999)
+	require.Nil(t, err)
 
 	// create teams
 	teamConstrained := &model.Team{
@@ -1482,7 +1479,7 @@ func pendingMemberRemovalsDataSetup(t *testing.T, ss store.Store) *removalsData
 		Type:             model.TEAM_INVITE,
 		GroupConstrained: model.NewBool(true),
 	}
-	teamConstrained, err := ss.Team().Save(teamConstrained)
+	teamConstrained, err = ss.Team().Save(teamConstrained)
 	require.Nil(t, err)
 
 	teamUnconstrained := &model.Team{
@@ -1569,12 +1566,11 @@ func testGetGroupsByChannel(t *testing.T, ss store.Store) {
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_OPEN,
 	}
-	res := <-ss.Channel().Save(channel1, 9999)
-	require.Nil(t, res.Err)
-	channel1 = res.Data.(*model.Channel)
+	channel1, err := ss.Channel().Save(channel1, 9999)
+	require.Nil(t, err)
 
 	// Create Groups 1 and 2
-	res = <-ss.Group().Create(&model.Group{
+	res := <-ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "group-1",
 		RemoteId:    model.NewId(),
@@ -1610,9 +1606,8 @@ func testGetGroupsByChannel(t *testing.T, ss store.Store) {
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_OPEN,
 	}
-	res = <-ss.Channel().Save(channel2, 9999)
-	require.Nil(t, res.Err)
-	channel2 = res.Data.(*model.Channel)
+	channel2, err = ss.Channel().Save(channel2, 9999)
+	require.Nil(t, err)
 
 	// Create Group3
 	res = <-ss.Group().Create(&model.Group{
@@ -1981,12 +1976,11 @@ func testGetGroups(t *testing.T, ss store.Store) {
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	res := <-ss.Channel().Save(channel1, 9999)
-	require.Nil(t, res.Err)
-	channel1 = res.Data.(*model.Channel)
+	channel1, err = ss.Channel().Save(channel1, 9999)
+	require.Nil(t, err)
 
 	// Create Groups 1 and 2
-	res = <-ss.Group().Create(&model.Group{
+	res := <-ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "group-1",
 		RemoteId:    model.NewId(),
@@ -2036,9 +2030,8 @@ func testGetGroups(t *testing.T, ss store.Store) {
 		Name:        model.NewId(),
 		Type:        model.CHANNEL_PRIVATE,
 	}
-	res = <-ss.Channel().Save(channel2, 9999)
-	require.Nil(t, res.Err)
-	channel2 = res.Data.(*model.Channel)
+	channel2, err = ss.Channel().Save(channel2, 9999)
+	require.Nil(t, err)
 
 	// Create Group3
 	res = <-ss.Group().Create(&model.Group{
diff --git a/store/storetest/mocks/ChannelStore.go b/store/storetest/mocks/ChannelStore.go
index bc38cd120f..b011206a1d 100644
--- a/store/storetest/mocks/ChannelStore.go
+++ b/store/storetest/mocks/ChannelStore.go
@@ -947,19 +947,28 @@ func (_m *ChannelStore) Restore(channelId string, time int64) *model.AppError {
 }
 
 // Save provides a mock function with given fields: channel, maxChannelsPerTeam
-func (_m *ChannelStore) Save(channel *model.Channel, maxChannelsPerTeam int64) store.StoreChannel {
+func (_m *ChannelStore) Save(channel *model.Channel, maxChannelsPerTeam int64) (*model.Channel, *model.AppError) {
 	ret := _m.Called(channel, maxChannelsPerTeam)
 
-	var r0 store.StoreChannel
-	if rf, ok := ret.Get(0).(func(*model.Channel, int64) store.StoreChannel); ok {
+	var r0 *model.Channel
+	if rf, ok := ret.Get(0).(func(*model.Channel, int64) *model.Channel); ok {
 		r0 = rf(channel, maxChannelsPerTeam)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.Channel)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(*model.Channel, int64) *model.AppError); ok {
+		r1 = rf(channel, maxChannelsPerTeam)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // SaveDirectChannel provides a mock function with given fields: channel, member1, member2
diff --git a/store/storetest/post_store.go b/store/storetest/post_store.go
index 1b24e9ea3f..68ee41555d 100644
--- a/store/storetest/post_store.go
+++ b/store/storetest/post_store.go
@@ -70,8 +70,8 @@ func testPostStoreSave(t *testing.T, ss store.Store) {
 
 func testPostStoreSaveChannelMsgCounts(t *testing.T, ss store.Store) {
 	c1 := &model.Channel{Name: model.NewId(), DisplayName: "posttestchannel", Type: model.CHANNEL_OPEN}
-	res := <-ss.Channel().Save(c1, 1000000)
-	require.Nil(t, res.Err)
+	_, err := ss.Channel().Save(c1, 1000000)
+	require.Nil(t, err)
 
 	o1 := model.Post{}
 	o1.ChannelId = c1.Id
@@ -80,7 +80,7 @@ func testPostStoreSaveChannelMsgCounts(t *testing.T, ss store.Store) {
 
 	require.Nil(t, (<-ss.Post().Save(&o1)).Err)
 
-	c1, err := ss.Channel().Get(c1.Id, false)
+	c1, err = ss.Channel().Get(c1.Id, false)
 	require.Nil(t, err)
 	assert.Equal(t, int64(1), c1.TotalMsgCount, "Message count should update by 1")
 
@@ -991,7 +991,7 @@ func testPostStoreSearch(t *testing.T, ss store.Store) {
 	c1.DisplayName = "Channel1"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	c1 = (<-ss.Channel().Save(c1, -1)).Data.(*model.Channel)
+	c1, _ = ss.Channel().Save(c1, -1)
 
 	m1 := model.ChannelMember{}
 	m1.ChannelId = c1.Id
@@ -1004,14 +1004,15 @@ func testPostStoreSearch(t *testing.T, ss store.Store) {
 	c2.DisplayName = "Channel1"
 	c2.Name = "zz" + model.NewId() + "b"
 	c2.Type = model.CHANNEL_OPEN
-	c2 = (<-ss.Channel().Save(c2, -1)).Data.(*model.Channel)
+	c2, _ = ss.Channel().Save(c2, -1)
 
 	c3 := &model.Channel{}
 	c3.TeamId = teamId
 	c3.DisplayName = "Channel1"
 	c3.Name = "zz" + model.NewId() + "b"
 	c3.Type = model.CHANNEL_OPEN
-	c3 = (<-ss.Channel().Save(c3, -1)).Data.(*model.Channel)
+	c3, _ = ss.Channel().Save(c3, -1)
+
 	ss.Channel().Delete(c3.Id, model.GetMillis())
 
 	m3 := model.ChannelMember{}
@@ -1198,7 +1199,8 @@ func testUserCountsWithPostsByDay(t *testing.T, ss store.Store) {
 	c1.DisplayName = "Channel2"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	c1 = store.Must(ss.Channel().Save(c1, -1)).(*model.Channel)
+	c1, err = ss.Channel().Save(c1, -1)
+	require.Nil(t, err)
 
 	o1 := &model.Post{}
 	o1.ChannelId = c1.Id
@@ -1257,7 +1259,8 @@ func testPostCountsByDay(t *testing.T, ss store.Store) {
 	c1.DisplayName = "Channel2"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	c1 = store.Must(ss.Channel().Save(c1, -1)).(*model.Channel)
+	c1, err = ss.Channel().Save(c1, -1)
+	require.Nil(t, err)
 
 	o1 := &model.Post{}
 	o1.ChannelId = c1.Id
@@ -1318,7 +1321,8 @@ func testPostStoreGetFlaggedPostsForTeam(t *testing.T, ss store.Store, s SqlSupp
 	c1.DisplayName = "Channel1"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	c1 = store.Must(ss.Channel().Save(c1, -1)).(*model.Channel)
+	c1, err := ss.Channel().Save(c1, -1)
+	require.Nil(t, err)
 
 	o1 := &model.Post{}
 	o1.ChannelId = c1.Id
@@ -1364,7 +1368,7 @@ func testPostStoreGetFlaggedPostsForTeam(t *testing.T, ss store.Store, s SqlSupp
 	m2.UserId = model.NewId()
 	m2.NotifyProps = model.GetDefaultChannelNotifyProps()
 
-	c2, err := ss.Channel().SaveDirectChannel(c2, m1, m2)
+	c2, err = ss.Channel().SaveDirectChannel(c2, m1, m2)
 	require.Nil(t, err)
 
 	o5 := &model.Post{}
@@ -1934,14 +1938,14 @@ func testPostStoreGetPostsBatchForIndexing(t *testing.T, ss store.Store) {
 	c1.DisplayName = "Channel1"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	c1 = (<-ss.Channel().Save(c1, -1)).Data.(*model.Channel)
+	c1, _ = ss.Channel().Save(c1, -1)
 
 	c2 := &model.Channel{}
 	c2.TeamId = model.NewId()
 	c2.DisplayName = "Channel2"
 	c2.Name = "zz" + model.NewId() + "b"
 	c2.Type = model.CHANNEL_OPEN
-	c2 = (<-ss.Channel().Save(c2, -1)).Data.(*model.Channel)
+	c2, _ = ss.Channel().Save(c2, -1)
 
 	o1 := &model.Post{}
 	o1.ChannelId = c1.Id
@@ -2078,7 +2082,8 @@ func testPostStoreGetParentsForExportAfter(t *testing.T, ss store.Store) {
 	c1.DisplayName = "Channel1"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&c1, -1))
+	_, err = ss.Channel().Save(&c1, -1)
+	require.Nil(t, err)
 
 	u1 := model.User{}
 	u1.Username = model.NewId()
@@ -2125,7 +2130,8 @@ func testPostStoreGetRepliesForExport(t *testing.T, ss store.Store) {
 	c1.DisplayName = "Channel1"
 	c1.Name = "zz" + model.NewId() + "b"
 	c1.Type = model.CHANNEL_OPEN
-	store.Must(ss.Channel().Save(&c1, -1))
+	_, err = ss.Channel().Save(&c1, -1)
+	require.Nil(t, err)
 
 	u1 := model.User{}
 	u1.Email = MakeEmail()
diff --git a/store/storetest/scheme_store.go b/store/storetest/scheme_store.go
index 4753cc68e6..d604b837a4 100644
--- a/store/storetest/scheme_store.go
+++ b/store/storetest/scheme_store.go
@@ -457,9 +457,8 @@ func testSchemeStoreDelete(t *testing.T, ss store.Store) {
 		Type:        model.CHANNEL_OPEN,
 		SchemeId:    &d5.Id,
 	}
-	cres5 := <-ss.Channel().Save(c5, -1)
-	assert.Nil(t, cres5.Err)
-	c5 = cres5.Data.(*model.Channel)
+	c5, err = ss.Channel().Save(c5, -1)
+	assert.Nil(t, err)
 
 	sres5 := <-ss.Scheme().Delete(d5.Id)
 	assert.Nil(t, sres5.Err)
diff --git a/store/storetest/team_store.go b/store/storetest/team_store.go
index a43327d1ef..3d4a92929c 100644
--- a/store/storetest/team_store.go
+++ b/store/storetest/team_store.go
@@ -1213,9 +1213,12 @@ func testGetChannelUnreadsForAllTeams(t *testing.T, ss store.Store) {
 	store.Must(ss.Team().SaveMember(m2, -1))
 
 	c1 := &model.Channel{TeamId: m1.TeamId, Name: model.NewId(), DisplayName: "Town Square", Type: model.CHANNEL_OPEN, TotalMsgCount: 100}
-	store.Must(ss.Channel().Save(c1, -1))
+	_, err := ss.Channel().Save(c1, -1)
+	require.Nil(t, err)
+
 	c2 := &model.Channel{TeamId: m2.TeamId, Name: model.NewId(), DisplayName: "Town Square", Type: model.CHANNEL_OPEN, TotalMsgCount: 100}
-	store.Must(ss.Channel().Save(c2, -1))
+	_, err = ss.Channel().Save(c2, -1)
+	require.Nil(t, err)
 
 	cm1 := &model.ChannelMember{ChannelId: c1.Id, UserId: m1.UserId, NotifyProps: model.GetDefaultChannelNotifyProps(), MsgCount: 90}
 	store.Must(ss.Channel().SaveMember(cm1))
@@ -1276,9 +1279,12 @@ func testGetChannelUnreadsForTeam(t *testing.T, ss store.Store) {
 	store.Must(ss.Team().SaveMember(m1, -1))
 
 	c1 := &model.Channel{TeamId: m1.TeamId, Name: model.NewId(), DisplayName: "Town Square", Type: model.CHANNEL_OPEN, TotalMsgCount: 100}
-	store.Must(ss.Channel().Save(c1, -1))
+	_, err := ss.Channel().Save(c1, -1)
+	require.Nil(t, err)
+
 	c2 := &model.Channel{TeamId: m1.TeamId, Name: model.NewId(), DisplayName: "Town Square", Type: model.CHANNEL_OPEN, TotalMsgCount: 100}
-	store.Must(ss.Channel().Save(c2, -1))
+	_, err = ss.Channel().Save(c2, -1)
+	require.Nil(t, err)
 
 	cm1 := &model.ChannelMember{ChannelId: c1.Id, UserId: m1.UserId, NotifyProps: model.GetDefaultChannelNotifyProps(), MsgCount: 90}
 	store.Must(ss.Channel().SaveMember(cm1))
diff --git a/store/storetest/user_store.go b/store/storetest/user_store.go
index 89a02e3f12..1e465b528c 100644
--- a/store/storetest/user_store.go
+++ b/store/storetest/user_store.go
@@ -678,19 +678,23 @@ func testUserStoreGetProfilesInChannel(t *testing.T, ss store.Store) {
 	u3.IsBot = true
 	defer func() { store.Must(ss.Bot().PermanentDelete(u3.Id)) }()
 
-	c1 := store.Must(ss.Channel().Save(&model.Channel{
+	ch1 := &model.Channel{
 		TeamId:      teamId,
 		DisplayName: "Profiles in channel",
 		Name:        "profiles-" + model.NewId(),
 		Type:        model.CHANNEL_OPEN,
-	}, -1)).(*model.Channel)
+	}
+	c1, err := ss.Channel().Save(ch1, -1)
+	require.Nil(t, err)
 
-	c2 := store.Must(ss.Channel().Save(&model.Channel{
+	ch2 := &model.Channel{
 		TeamId:      teamId,
 		DisplayName: "Profiles in private",
 		Name:        "profiles-" + model.NewId(),
 		Type:        model.CHANNEL_PRIVATE,
-	}, -1)).(*model.Channel)
+	}
+	c2, err := ss.Channel().Save(ch2, -1)
+	require.Nil(t, err)
 
 	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
 		ChannelId:   c1.Id,
@@ -766,19 +770,23 @@ func testUserStoreGetProfilesInChannelByStatus(t *testing.T, ss store.Store) {
 	u3.IsBot = true
 	defer func() { store.Must(ss.Bot().PermanentDelete(u3.Id)) }()
 
-	c1 := store.Must(ss.Channel().Save(&model.Channel{
+	ch1 := &model.Channel{
 		TeamId:      teamId,
 		DisplayName: "Profiles in channel",
 		Name:        "profiles-" + model.NewId(),
 		Type:        model.CHANNEL_OPEN,
-	}, -1)).(*model.Channel)
+	}
+	c1, err := ss.Channel().Save(ch1, -1)
+	require.Nil(t, err)
 
-	c2 := store.Must(ss.Channel().Save(&model.Channel{
+	ch2 := &model.Channel{
 		TeamId:      teamId,
 		DisplayName: "Profiles in private",
 		Name:        "profiles-" + model.NewId(),
 		Type:        model.CHANNEL_PRIVATE,
-	}, -1)).(*model.Channel)
+	}
+	c2, err := ss.Channel().Save(ch2, -1)
+	require.Nil(t, err)
 
 	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
 		ChannelId:   c1.Id,
@@ -909,19 +917,23 @@ func testUserStoreGetAllProfilesInChannel(t *testing.T, ss store.Store) {
 	u3.IsBot = true
 	defer func() { store.Must(ss.Bot().PermanentDelete(u3.Id)) }()
 
-	c1 := store.Must(ss.Channel().Save(&model.Channel{
+	ch1 := &model.Channel{
 		TeamId:      teamId,
 		DisplayName: "Profiles in channel",
 		Name:        "profiles-" + model.NewId(),
 		Type:        model.CHANNEL_OPEN,
-	}, -1)).(*model.Channel)
+	}
+	c1, err := ss.Channel().Save(ch1, -1)
+	require.Nil(t, err)
 
-	c2 := store.Must(ss.Channel().Save(&model.Channel{
+	ch2 := &model.Channel{
 		TeamId:      teamId,
 		DisplayName: "Profiles in private",
 		Name:        "profiles-" + model.NewId(),
 		Type:        model.CHANNEL_PRIVATE,
-	}, -1)).(*model.Channel)
+	}
+	c2, err := ss.Channel().Save(ch2, -1)
+	require.Nil(t, err)
 
 	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
 		ChannelId:   c1.Id,
@@ -1016,19 +1028,23 @@ func testUserStoreGetProfilesNotInChannel(t *testing.T, ss store.Store) {
 	u3.IsBot = true
 	defer func() { store.Must(ss.Bot().PermanentDelete(u3.Id)) }()
 
-	c1 := store.Must(ss.Channel().Save(&model.Channel{
+	ch1 := &model.Channel{
 		TeamId:      teamId,
 		DisplayName: "Profiles in channel",
 		Name:        "profiles-" + model.NewId(),
 		Type:        model.CHANNEL_OPEN,
-	}, -1)).(*model.Channel)
+	}
+	c1, err := ss.Channel().Save(ch1, -1)
+	require.Nil(t, err)
 
-	c2 := store.Must(ss.Channel().Save(&model.Channel{
+	ch2 := &model.Channel{
 		TeamId:      teamId,
 		DisplayName: "Profiles in private",
 		Name:        "profiles-" + model.NewId(),
 		Type:        model.CHANNEL_PRIVATE,
-	}, -1)).(*model.Channel)
+	}
+	c2, err := ss.Channel().Save(ch2, -1)
+	require.Nil(t, err)
 
 	t.Run("get team 1, channel 1, offset 0, limit 100", func(t *testing.T) {
 		result := <-ss.User().GetProfilesNotInChannel(teamId, c1.Id, false, 0, 100, nil)
@@ -1669,7 +1685,7 @@ func testUserUnreadCount(t *testing.T, ss store.Store) {
 	defer func() { require.Nil(t, ss.User().PermanentDelete(u2.Id)) }()
 	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id}, -1))
 
-	if err := (<-ss.Channel().Save(&c1, -1)).Err; err != nil {
+	if _, err := ss.Channel().Save(&c1, -1); err != nil {
 		t.Fatal("couldn't save item", err)
 	}
 
@@ -2332,21 +2348,23 @@ func testUserStoreSearchNotInChannel(t *testing.T, ss store.Store) {
 	u2.AuthData = nilAuthData
 	u3.AuthData = nilAuthData
 
-	c1 := model.Channel{
+	ch1 := model.Channel{
 		TeamId:      tid,
 		DisplayName: "NameName",
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	c1 = *store.Must(ss.Channel().Save(&c1, -1)).(*model.Channel)
+	c1, err := ss.Channel().Save(&ch1, -1)
+	require.Nil(t, err)
 
-	c2 := model.Channel{
+	ch2 := model.Channel{
 		TeamId:      tid,
 		DisplayName: "NameName",
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	c2 = *store.Must(ss.Channel().Save(&c2, -1)).(*model.Channel)
+	c2, err := ss.Channel().Save(&ch2, -1)
+	require.Nil(t, err)
 
 	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
 		ChannelId:   c2.Id,
@@ -2546,21 +2564,23 @@ func testUserStoreSearchInChannel(t *testing.T, ss store.Store) {
 	u2.AuthData = nilAuthData
 	u3.AuthData = nilAuthData
 
-	c1 := model.Channel{
+	ch1 := model.Channel{
 		TeamId:      tid,
 		DisplayName: "NameName",
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	c1 = *store.Must(ss.Channel().Save(&c1, -1)).(*model.Channel)
+	c1, err := ss.Channel().Save(&ch1, -1)
+	require.Nil(t, err)
 
-	c2 := model.Channel{
+	ch2 := model.Channel{
 		TeamId:      tid,
 		DisplayName: "NameName",
 		Name:        "zz" + model.NewId() + "b",
 		Type:        model.CHANNEL_OPEN,
 	}
-	c2 = *store.Must(ss.Channel().Save(&c2, -1)).(*model.Channel)
+	c2, err := ss.Channel().Save(&ch2, -1)
+	require.Nil(t, err)
 
 	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
 		ChannelId:   c1.Id,
@@ -3411,18 +3431,28 @@ func testUserStoreGetUsersBatchForIndexing(t *testing.T, ss store.Store) {
 		Type:        model.TEAM_OPEN,
 	})
 	require.Nil(t, err)
-	cPub1 := store.Must(ss.Channel().Save(&model.Channel{
+
+	ch1 := &model.Channel{
 		Name: model.NewId(),
 		Type: model.CHANNEL_OPEN,
-	}, -1)).(*model.Channel)
-	cPub2 := store.Must(ss.Channel().Save(&model.Channel{
+	}
+	cPub1, err := ss.Channel().Save(ch1, -1)
+	require.Nil(t, err)
+
+	ch2 := &model.Channel{
 		Name: model.NewId(),
 		Type: model.CHANNEL_OPEN,
-	}, -1)).(*model.Channel)
-	cPriv := store.Must(ss.Channel().Save(&model.Channel{
+	}
+	cPub2, err := ss.Channel().Save(ch2, -1)
+	require.Nil(t, err)
+
+	ch3 := &model.Channel{
 		Name: model.NewId(),
 		Type: model.CHANNEL_PRIVATE,
-	}, -1)).(*model.Channel)
+	}
+
+	cPriv, err := ss.Channel().Save(ch3, -1)
+	require.Nil(t, err)
 
 	u1 := store.Must(ss.User().Save(&model.User{
 		Email:    MakeEmail(),
@@ -3649,20 +3679,19 @@ func testUserStoreGetTeamGroupUsers(t *testing.T, ss store.Store) {
 func testUserStoreGetChannelGroupUsers(t *testing.T, ss store.Store) {
 	// create channel
 	id := model.NewId()
-	res := <-ss.Channel().Save(&model.Channel{
+	channel, err := ss.Channel().Save(&model.Channel{
 		DisplayName: "dn_" + id,
 		Name:        "n-" + id,
 		Type:        model.CHANNEL_PRIVATE,
 	}, 999)
-	require.Nil(t, res.Err)
-	channel := res.Data.(*model.Channel)
+	require.Nil(t, err)
 	require.NotNil(t, channel)
 
 	// create users
 	var testUsers []*model.User
 	for i := 0; i < 3; i++ {
 		id = model.NewId()
-		res = <-ss.User().Save(&model.User{
+		res := <-ss.User().Save(&model.User{
 			Email:     id + "@test.com",
 			Username:  "un_" + id,
 			Nickname:  "nn_" + id,
@@ -3680,7 +3709,7 @@ func testUserStoreGetChannelGroupUsers(t *testing.T, ss store.Store) {
 	userNoGroup := testUsers[2]
 
 	// add non-group-member to the channel (to prove that the query isn't just returning all members)
-	res = <-ss.Channel().SaveMember(&model.ChannelMember{
+	res := <-ss.Channel().SaveMember(&model.ChannelMember{
 		ChannelId:   channel.Id,
 		UserId:      userNoGroup.Id,
 		NotifyProps: model.GetDefaultChannelNotifyProps(),
@@ -3734,7 +3763,7 @@ func testUserStoreGetChannelGroupUsers(t *testing.T, ss store.Store) {
 
 	// update team to be group-constrained
 	channel.GroupConstrained = model.NewBool(true)
-	_, err := ss.Channel().Update(channel)
+	_, err = ss.Channel().Update(channel)
 	require.Nil(t, err)
 
 	// still returns user (being group-constrained has no effect)