Migrating some GroupStore methods to sync by default (#11445)

* Migrating some GroupStore methods to sync by default

* Fixing shadow variables

app/group.go

@@ -10,51 +10,27 @@ import (
 )
 
 func (a *App) GetGroup(id string) (*model.Group, *model.AppError) {
-	result := <-a.Srv.Store.Group().Get(id)
+	return a.Srv.Store.Group().Get(id)
-	if result.Err != nil {
-		return nil, result.Err
-	}
-	return result.Data.(*model.Group), nil
 }
 
 func (a *App) GetGroupByRemoteID(remoteID string, groupSource model.GroupSource) (*model.Group, *model.AppError) {
-	result := <-a.Srv.Store.Group().GetByRemoteID(remoteID, groupSource)
+	return a.Srv.Store.Group().GetByRemoteID(remoteID, groupSource)
-	if result.Err != nil {
-		return nil, result.Err
-	}
-	return result.Data.(*model.Group), nil
 }
 
 func (a *App) GetGroupsBySource(groupSource model.GroupSource) ([]*model.Group, *model.AppError) {
-	result := <-a.Srv.Store.Group().GetAllBySource(groupSource)
+	return a.Srv.Store.Group().GetAllBySource(groupSource)
-	if result.Err != nil {
-		return nil, result.Err
-	}
-	return result.Data.([]*model.Group), nil
 }
 
 func (a *App) CreateGroup(group *model.Group) (*model.Group, *model.AppError) {
-	result := <-a.Srv.Store.Group().Create(group)
+	return a.Srv.Store.Group().Create(group)
-	if result.Err != nil {
-		return nil, result.Err
-	}
-	return result.Data.(*model.Group), nil
 }
 
 func (a *App) UpdateGroup(group *model.Group) (*model.Group, *model.AppError) {
-	result := <-a.Srv.Store.Group().Update(group)
+	return a.Srv.Store.Group().Update(group)
-	if result.Err != nil {
-		return nil, result.Err
-	}
-	return result.Data.(*model.Group), nil
 }
 
 func (a *App) DeleteGroup(groupID string) (*model.Group, *model.AppError) {
-	result := <-a.Srv.Store.Group().Delete(groupID)
+	return a.Srv.Store.Group().Delete(groupID)
-	if result.Err != nil {
-		return nil, result.Err
-	}
-	return result.Data.(*model.Group), nil
 }
 
 func (a *App) GetGroupMemberUsers(groupID string) ([]*model.User, *model.AppError) {

store/sqlstore/group_store.go

@@ -84,53 +84,39 @@ func (s *SqlGroupStore) CreateIndexesIfNotExists() {
 	s.CreateIndexIfNotExists("idx_usergroups_delete_at", "UserGroups", "DeleteAt")
 }
 
-func (s *SqlGroupStore) Create(group *model.Group) store.StoreChannel {
+func (s *SqlGroupStore) Create(group *model.Group) (*model.Group, *model.AppError) {
-	return store.Do(func(result *store.StoreResult) {
+	if len(group.Id) != 0 {
+		return nil, model.NewAppError("SqlGroupStore.GroupCreate", "model.group.id.app_error", nil, "", http.StatusBadRequest)
+	}
 
-		if len(group.Id) != 0 {
+	if err := group.IsValidForCreate(); err != nil {
-			result.Err = model.NewAppError("SqlGroupStore.GroupCreate", "model.group.id.app_error", nil, "", http.StatusBadRequest)
+		return nil, err
-			return
+	}
+
+	group.Id = model.NewId()
+	group.CreateAt = model.GetMillis()
+	group.UpdateAt = group.CreateAt
+
+	if err := s.GetMaster().Insert(group); err != nil {
+		if IsUniqueConstraintError(err, []string{"Name", "groups_name_key"}) {
+			return nil, model.NewAppError("SqlGroupStore.GroupCreate", "store.sql_group.unique_constraint", nil, err.Error(), http.StatusInternalServerError)
 		}
+		return nil, model.NewAppError("SqlGroupStore.GroupCreate", "store.insert_error", nil, err.Error(), http.StatusInternalServerError)
+	}
 
-		if err := group.IsValidForCreate(); err != nil {
+	return group, nil
-			result.Err = err
-			return
-		}
-
-		group.Id = model.NewId()
-		group.CreateAt = model.GetMillis()
-		group.UpdateAt = group.CreateAt
-
-		if err := s.GetMaster().Insert(group); err != nil {
-			if IsUniqueConstraintError(err, []string{"Name", "groups_name_key"}) {
-				result.Err = model.NewAppError("SqlGroupStore.GroupCreate", "store.sql_group.unique_constraint", nil, err.Error(), http.StatusInternalServerError)
-			} else {
-				result.Err = model.NewAppError("SqlGroupStore.GroupCreate", "store.insert_error", nil, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		}
-
-		result.Data = group
-		return
-	})
 }
 
-func (s *SqlGroupStore) Get(groupId string) store.StoreChannel {
+func (s *SqlGroupStore) Get(groupId string) (*model.Group, *model.AppError) {
-	return store.Do(func(result *store.StoreResult) {
+	var group *model.Group
-
+	if err := s.GetReplica().SelectOne(&group, "SELECT * from UserGroups WHERE Id = :Id", map[string]interface{}{"Id": groupId}); err != nil {
-		var group *model.Group
+		if err == sql.ErrNoRows {
-		if err := s.GetReplica().SelectOne(&group, "SELECT * from UserGroups WHERE Id = :Id", map[string]interface{}{"Id": groupId}); err != nil {
+			return nil, model.NewAppError("SqlGroupStore.GroupGet", "store.sql_group.no_rows", nil, err.Error(), http.StatusNotFound)
-			if err == sql.ErrNoRows {
-				result.Err = model.NewAppError("SqlGroupStore.GroupGet", "store.sql_group.no_rows", nil, err.Error(), http.StatusNotFound)
-			} else {
-				result.Err = model.NewAppError("SqlGroupStore.GroupGet", "store.select_error", nil, err.Error(), http.StatusInternalServerError)
-			}
-			return
 		}
+		return nil, model.NewAppError("SqlGroupStore.GroupGet", "store.select_error", nil, err.Error(), http.StatusInternalServerError)
+	}
 
-		result.Data = group
+	return group, nil
-		return
-	})
 }
 
 func (s *SqlGroupStore) GetByIDs(groupIDs []string) ([]*model.Group, *model.AppError) {
@@ -146,108 +132,79 @@ func (s *SqlGroupStore) GetByIDs(groupIDs []string) ([]*model.Group, *model.AppE
 	return groups, nil
 }
 
-func (s *SqlGroupStore) GetByRemoteID(remoteID string, groupSource model.GroupSource) store.StoreChannel {
+func (s *SqlGroupStore) GetByRemoteID(remoteID string, groupSource model.GroupSource) (*model.Group, *model.AppError) {
-	return store.Do(func(result *store.StoreResult) {
+	var group *model.Group
-
+	if err := s.GetReplica().SelectOne(&group, "SELECT * from UserGroups WHERE RemoteId = :RemoteId AND Source = :Source", map[string]interface{}{"RemoteId": remoteID, "Source": groupSource}); err != nil {
-		var group *model.Group
+		if err == sql.ErrNoRows {
-		if err := s.GetReplica().SelectOne(&group, "SELECT * from UserGroups WHERE RemoteId = :RemoteId AND Source = :Source", map[string]interface{}{"RemoteId": remoteID, "Source": groupSource}); err != nil {
+			return nil, model.NewAppError("SqlGroupStore.GroupGetByRemoteID", "store.sql_group.no_rows", nil, err.Error(), http.StatusNotFound)
-			if err == sql.ErrNoRows {
-				result.Err = model.NewAppError("SqlGroupStore.GroupGetByRemoteID", "store.sql_group.no_rows", nil, err.Error(), http.StatusNotFound)
-			} else {
-				result.Err = model.NewAppError("SqlGroupStore.GroupGetByRemoteID", "store.select_error", nil, err.Error(), http.StatusInternalServerError)
-			}
-			return
 		}
+		return nil, model.NewAppError("SqlGroupStore.GroupGetByRemoteID", "store.select_error", nil, err.Error(), http.StatusInternalServerError)
+	}
 
-		result.Data = group
+	return group, nil
-		return
-	})
 }
 
-func (s *SqlGroupStore) GetAllBySource(groupSource model.GroupSource) store.StoreChannel {
+func (s *SqlGroupStore) GetAllBySource(groupSource model.GroupSource) ([]*model.Group, *model.AppError) {
-	return store.Do(func(result *store.StoreResult) {
+	var groups []*model.Group
 
-		var groups []*model.Group
+	if _, err := s.GetReplica().Select(&groups, "SELECT * from UserGroups WHERE DeleteAt = 0 AND Source = :Source", map[string]interface{}{"Source": groupSource}); err != nil {
+		return nil, model.NewAppError("SqlGroupStore.GroupGetAllBySource", "store.select_error", nil, err.Error(), http.StatusInternalServerError)
+	}
 
-		if _, err := s.GetReplica().Select(&groups, "SELECT * from UserGroups WHERE DeleteAt = 0 AND Source = :Source", map[string]interface{}{"Source": groupSource}); err != nil {
+	return groups, nil
-			result.Err = model.NewAppError("SqlGroupStore.GroupGetAllBySource", "store.select_error", nil, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		result.Data = groups
-
-		return
-	})
 }
 
-func (s *SqlGroupStore) Update(group *model.Group) store.StoreChannel {
+func (s *SqlGroupStore) Update(group *model.Group) (*model.Group, *model.AppError) {
-	return store.Do(func(result *store.StoreResult) {
+	var retrievedGroup *model.Group
-
+	if err := s.GetMaster().SelectOne(&retrievedGroup, "SELECT * FROM UserGroups WHERE Id = :Id", map[string]interface{}{"Id": group.Id}); err != nil {
-		var retrievedGroup *model.Group
+		if err == sql.ErrNoRows {
-		if err := s.GetMaster().SelectOne(&retrievedGroup, "SELECT * FROM UserGroups WHERE Id = :Id", map[string]interface{}{"Id": group.Id}); err != nil {
+			return nil, model.NewAppError("SqlGroupStore.GroupUpdate", "store.sql_group.no_rows", nil, "id="+group.Id+","+err.Error(), http.StatusNotFound)
-			if err == sql.ErrNoRows {
-				result.Err = model.NewAppError("SqlGroupStore.GroupUpdate", "store.sql_group.no_rows", nil, "id="+group.Id+","+err.Error(), http.StatusNotFound)
-			} else {
-				result.Err = model.NewAppError("SqlGroupStore.GroupUpdate", "store.select_error", nil, "id="+group.Id+","+err.Error(), http.StatusInternalServerError)
-			}
-			return
 		}
+		return nil, model.NewAppError("SqlGroupStore.GroupUpdate", "store.select_error", nil, "id="+group.Id+","+err.Error(), http.StatusInternalServerError)
+	}
 
-		// If updating DeleteAt it can only be to 0
+	// If updating DeleteAt it can only be to 0
-		if group.DeleteAt != retrievedGroup.DeleteAt && group.DeleteAt != 0 {
+	if group.DeleteAt != retrievedGroup.DeleteAt && group.DeleteAt != 0 {
-			result.Err = model.NewAppError("SqlGroupStore.GroupUpdate", "model.group.delete_at.app_error", nil, "", http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlGroupStore.GroupUpdate", "model.group.delete_at.app_error", nil, "", http.StatusInternalServerError)
-			return
+	}
-		}
 
-		// Reset these properties, don't update them based on input
+	// Reset these properties, don't update them based on input
-		group.CreateAt = retrievedGroup.CreateAt
+	group.CreateAt = retrievedGroup.CreateAt
-		group.UpdateAt = model.GetMillis()
+	group.UpdateAt = model.GetMillis()
 
-		if err := group.IsValidForUpdate(); err != nil {
+	if err := group.IsValidForUpdate(); err != nil {
-			result.Err = err
+		return nil, err
-			return
+	}
-		}
 
-		rowsChanged, err := s.GetMaster().Update(group)
+	rowsChanged, err := s.GetMaster().Update(group)
-		if err != nil {
+	if err != nil {
-			result.Err = model.NewAppError("SqlGroupStore.GroupUpdate", "store.update_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlGroupStore.GroupUpdate", "store.update_error", nil, err.Error(), http.StatusInternalServerError)
-			return
+	}
-		}
+	if rowsChanged != 1 {
-		if rowsChanged != 1 {
+		return nil, model.NewAppError("SqlGroupStore.GroupUpdate", "store.sql_group.no_rows_changed", nil, "", http.StatusInternalServerError)
-			result.Err = model.NewAppError("SqlGroupStore.GroupUpdate", "store.sql_group.no_rows_changed", nil, "", http.StatusInternalServerError)
+	}
-			return
-		}
 
-		result.Data = group
+	return group, nil
-		return
-	})
 }
 
-func (s *SqlGroupStore) Delete(groupID string) store.StoreChannel {
+func (s *SqlGroupStore) Delete(groupID string) (*model.Group, *model.AppError) {
-	return store.Do(func(result *store.StoreResult) {
+	var group *model.Group
-
+	if err := s.GetReplica().SelectOne(&group, "SELECT * from UserGroups WHERE Id = :Id AND DeleteAt = 0", map[string]interface{}{"Id": groupID}); err != nil {
-		var group *model.Group
+		if err == sql.ErrNoRows {
-		if err := s.GetReplica().SelectOne(&group, "SELECT * from UserGroups WHERE Id = :Id AND DeleteAt = 0", map[string]interface{}{"Id": groupID}); err != nil {
+			return nil, model.NewAppError("SqlGroupStore.GroupDelete", "store.sql_group.no_rows", nil, "Id="+groupID+", "+err.Error(), http.StatusNotFound)
-			if err == sql.ErrNoRows {
-				result.Err = model.NewAppError("SqlGroupStore.GroupDelete", "store.sql_group.no_rows", nil, "Id="+groupID+", "+err.Error(), http.StatusNotFound)
-			} else {
-				result.Err = model.NewAppError("SqlGroupStore.GroupDelete", "store.select_error", nil, err.Error(), http.StatusInternalServerError)
-			}
-
-			return
 		}
+		return nil, model.NewAppError("SqlGroupStore.GroupDelete", "store.select_error", nil, err.Error(), http.StatusInternalServerError)
+	}
 
-		time := model.GetMillis()
+	time := model.GetMillis()
-		group.DeleteAt = time
+	group.DeleteAt = time
-		group.UpdateAt = time
+	group.UpdateAt = time
 
-		if _, err := s.GetMaster().Update(group); err != nil {
+	if _, err := s.GetMaster().Update(group); err != nil {
-			result.Err = model.NewAppError("SqlGroupStore.GroupDelete", "store.update_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlGroupStore.GroupDelete", "store.update_error", nil, err.Error(), http.StatusInternalServerError)
-		}
+	}
 
-		result.Data = group
+	return group, nil
-		return
-	})
 }
 
 func (s *SqlGroupStore) GetMemberUsers(groupID string) store.StoreChannel {

store/store.go

@@ -573,13 +573,13 @@ type UserTermsOfServiceStore interface {
 }
 
 type GroupStore interface {
-	Create(group *model.Group) StoreChannel
+	Create(group *model.Group) (*model.Group, *model.AppError)
-	Get(groupID string) StoreChannel
+	Get(groupID string) (*model.Group, *model.AppError)
 	GetByIDs(groupIDs []string) ([]*model.Group, *model.AppError)
-	GetByRemoteID(remoteID string, groupSource model.GroupSource) StoreChannel
+	GetByRemoteID(remoteID string, groupSource model.GroupSource) (*model.Group, *model.AppError)
-	GetAllBySource(groupSource model.GroupSource) StoreChannel
+	GetAllBySource(groupSource model.GroupSource) ([]*model.Group, *model.AppError)
-	Update(group *model.Group) StoreChannel
+	Update(group *model.Group) (*model.Group, *model.AppError)
-	Delete(groupID string) StoreChannel
+	Delete(groupID string) (*model.Group, *model.AppError)
 
 	GetMemberUsers(groupID string) StoreChannel
 	GetMemberUsersPage(groupID string, offset int, limit int) StoreChannel

store/storetest/channel_store.go

@@ -1113,7 +1113,9 @@ func testChannelStoreGetAllChannels(t *testing.T, ss store.Store, s SqlSupplier)
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	store.Must(ss.Group().Create(group))
+	_, err = ss.Group().Create(group)
+	require.Nil(t, err)
+
 	_, err = ss.Group().CreateGroupSyncable(model.NewGroupChannel(group.Id, c1.Id, true))
 	require.Nil(t, err)
 
@@ -2457,7 +2459,9 @@ func testChannelStoreSearchAllChannels(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	store.Must(ss.Group().Create(group))
+	_, err = ss.Group().Create(group)
+	require.Nil(t, err)
+
 	_, err = ss.Group().CreateGroupSyncable(model.NewGroupChannel(group.Id, o7.Id, true))
 	require.Nil(t, err)
 

store/storetest/group_store.go

@@ -61,9 +61,8 @@ func testGroupStoreCreate(t *testing.T, ss store.Store) {
 	}
 
 	// Happy path
-	res1 := <-ss.Group().Create(g1)
+	d1, err := ss.Group().Create(g1)
-	require.Nil(t, res1.Err)
+	require.Nil(t, err)
-	d1 := res1.Data.(*model.Group)
 	require.Len(t, d1.Id, 26)
 	require.Equal(t, g1.Name, d1.Name)
 	require.Equal(t, g1.DisplayName, d1.DisplayName)
@@ -80,17 +79,17 @@ func testGroupStoreCreate(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res2 := <-ss.Group().Create(g2)
+	data, err := ss.Group().Create(g2)
-	require.Nil(t, res2.Data)
+	require.Nil(t, data)
-	require.NotNil(t, res2.Err)
+	require.NotNil(t, err)
-	require.Equal(t, res2.Err.Id, "model.group.name.app_error")
+	require.Equal(t, err.Id, "model.group.name.app_error")
 
 	g2.Name = model.NewId()
 	g2.DisplayName = ""
-	res3 := <-ss.Group().Create(g2)
+	data, err = ss.Group().Create(g2)
-	require.Nil(t, res3.Data)
+	require.Nil(t, data)
-	require.NotNil(t, res3.Err)
+	require.NotNil(t, err)
-	require.Equal(t, res3.Err.Id, "model.group.display_name.app_error")
+	require.Equal(t, err.Id, "model.group.display_name.app_error")
 
 	// Won't accept a duplicate name
 	g4 := &model.Group{
@@ -99,17 +98,17 @@ func testGroupStoreCreate(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res5 := <-ss.Group().Create(g4)
+	_, err = ss.Group().Create(g4)
-	require.Nil(t, res5.Err)
+	require.Nil(t, err)
 	g4b := &model.Group{
 		Name:        g4.Name,
 		DisplayName: model.NewId(),
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res5b := <-ss.Group().Create(g4b)
+	data, err = ss.Group().Create(g4b)
-	require.Nil(t, res5b.Data)
+	require.Nil(t, data)
-	require.Equal(t, res5b.Err.Id, "store.sql_group.unique_constraint")
+	require.Equal(t, err.Id, "store.sql_group.unique_constraint")
 
 	// Fields cannot be greater than max values
 	g5 := &model.Group{
@@ -156,15 +155,13 @@ func testGroupStoreGet(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res1 := <-ss.Group().Create(g1)
+	d1, err := ss.Group().Create(g1)
-	require.Nil(t, res1.Err)
+	require.Nil(t, err)
-	d1 := res1.Data.(*model.Group)
 	require.Len(t, d1.Id, 26)
 
 	// Get the group
-	res2 := <-ss.Group().Get(d1.Id)
+	d2, err := ss.Group().Get(d1.Id)
-	require.Nil(t, res2.Err)
+	require.Nil(t, err)
-	d2 := res2.Data.(*model.Group)
 	require.Equal(t, d1.Id, d2.Id)
 	require.Equal(t, d1.Name, d2.Name)
 	require.Equal(t, d1.DisplayName, d2.DisplayName)
@@ -175,9 +172,9 @@ func testGroupStoreGet(t *testing.T, ss store.Store) {
 	require.Equal(t, d1.DeleteAt, d2.DeleteAt)
 
 	// Get an invalid group
-	res3 := <-ss.Group().Get(model.NewId())
+	_, err = ss.Group().Get(model.NewId())
-	require.NotNil(t, res3.Err)
+	require.NotNil(t, err)
-	require.Equal(t, res3.Err.Id, "store.sql_group.no_rows")
+	require.Equal(t, err.Id, "store.sql_group.no_rows")
 }
 
 func testGroupStoreGetByIDs(t *testing.T, ss store.Store) {
@@ -192,9 +189,8 @@ func testGroupStoreGetByIDs(t *testing.T, ss store.Store) {
 			Source:      model.GroupSourceLdap,
 			RemoteId:    model.NewId(),
 		}
-		res := <-ss.Group().Create(group)
+		group, err := ss.Group().Create(group)
-		require.Nil(t, res.Err)
+		require.Nil(t, err)
-		group = res.Data.(*model.Group)
 		switch i {
 		case 0:
 			group1 = group
@@ -223,15 +219,13 @@ func testGroupStoreGetByRemoteID(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res1 := <-ss.Group().Create(g1)
+	d1, err := ss.Group().Create(g1)
-	require.Nil(t, res1.Err)
+	require.Nil(t, err)
-	d1 := res1.Data.(*model.Group)
 	require.Len(t, d1.Id, 26)
 
 	// Get the group
-	res2 := <-ss.Group().GetByRemoteID(d1.RemoteId, model.GroupSourceLdap)
+	d2, err := ss.Group().GetByRemoteID(d1.RemoteId, model.GroupSourceLdap)
-	require.Nil(t, res2.Err)
+	require.Nil(t, err)
-	d2 := res2.Data.(*model.Group)
 	require.Equal(t, d1.Id, d2.Id)
 	require.Equal(t, d1.Name, d2.Name)
 	require.Equal(t, d1.DisplayName, d2.DisplayName)
@@ -242,9 +236,9 @@ func testGroupStoreGetByRemoteID(t *testing.T, ss store.Store) {
 	require.Equal(t, d1.DeleteAt, d2.DeleteAt)
 
 	// Get an invalid group
-	res3 := <-ss.Group().GetByRemoteID(model.NewId(), model.GroupSource("fake"))
+	_, err = ss.Group().GetByRemoteID(model.NewId(), model.GroupSource("fake"))
-	require.NotNil(t, res3.Err)
+	require.NotNil(t, err)
-	require.Equal(t, res3.Err.Id, "store.sql_group.no_rows")
+	require.Equal(t, err.Id, "store.sql_group.no_rows")
 }
 
 func testGroupStoreGetAllByType(t *testing.T, ss store.Store) {
@@ -262,13 +256,13 @@ func testGroupStoreGetAllByType(t *testing.T, ss store.Store) {
 			RemoteId:    model.NewId(),
 		}
 		groups = append(groups, g)
-		res := <-ss.Group().Create(g)
+		_, err := ss.Group().Create(g)
-		require.Nil(t, res.Err)
+		require.Nil(t, err)
 	}
 
 	// Returns all the groups
-	res1 := <-ss.Group().GetAllBySource(model.GroupSourceLdap)
+	d1, err := ss.Group().GetAllBySource(model.GroupSourceLdap)
-	d1 := res1.Data.([]*model.Group)
+	require.Nil(t, err)
 	require.Condition(t, func() bool { return len(d1) >= numGroups })
 	for _, expectedGroup := range groups {
 		present := false
@@ -293,9 +287,8 @@ func testGroupStoreUpdate(t *testing.T, ss store.Store) {
 	}
 
 	// Create a group
-	res := <-ss.Group().Create(g1)
+	d1, err := ss.Group().Create(g1)
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	d1 := res.Data.(*model.Group)
 
 	// Update happy path
 	g1Update := &model.Group{}
@@ -305,9 +298,8 @@ func testGroupStoreUpdate(t *testing.T, ss store.Store) {
 	g1Update.Description = model.NewId()
 	g1Update.RemoteId = model.NewId()
 
-	res2 := <-ss.Group().Update(g1Update)
+	ud1, err := ss.Group().Update(g1Update)
-	require.Nil(t, res2.Err)
+	require.Nil(t, err)
-	ud1 := res2.Data.(*model.Group)
 	// Not changed...
 	require.Equal(t, d1.Id, ud1.Id)
 	require.Equal(t, d1.CreateAt, ud1.CreateAt)
@@ -321,7 +313,7 @@ func testGroupStoreUpdate(t *testing.T, ss store.Store) {
 	require.Equal(t, g1Update.RemoteId, ud1.RemoteId)
 
 	// Requires name and display name
-	res3 := <-ss.Group().Update(&model.Group{
+	data, err := ss.Group().Update(&model.Group{
 		Id:          d1.Id,
 		Name:        "",
 		DisplayName: model.NewId(),
@@ -329,20 +321,20 @@ func testGroupStoreUpdate(t *testing.T, ss store.Store) {
 		RemoteId:    model.NewId(),
 		Description: model.NewId(),
 	})
-	require.Nil(t, res3.Data)
+	require.Nil(t, data)
-	require.NotNil(t, res3.Err)
+	require.NotNil(t, err)
-	require.Equal(t, res3.Err.Id, "model.group.name.app_error")
+	require.Equal(t, err.Id, "model.group.name.app_error")
 
-	res4 := <-ss.Group().Update(&model.Group{
+	data, err = ss.Group().Update(&model.Group{
 		Id:          d1.Id,
 		Name:        model.NewId(),
 		DisplayName: "",
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	})
-	require.Nil(t, res4.Data)
+	require.Nil(t, data)
-	require.NotNil(t, res4.Err)
+	require.NotNil(t, err)
-	require.Equal(t, res4.Err.Id, "model.group.display_name.app_error")
+	require.Equal(t, err.Id, "model.group.display_name.app_error")
 
 	// Create another Group
 	g2 := &model.Group{
@@ -352,12 +344,11 @@ func testGroupStoreUpdate(t *testing.T, ss store.Store) {
 		Description: model.NewId(),
 		RemoteId:    model.NewId(),
 	}
-	res5 := <-ss.Group().Create(g2)
+	d2, err := ss.Group().Create(g2)
-	require.Nil(t, res5.Err)
+	require.Nil(t, err)
-	d2 := res5.Data.(*model.Group)
 
 	// Can't update the name to be a duplicate of an existing group's name
-	res6 := <-ss.Group().Update(&model.Group{
+	_, err = ss.Group().Update(&model.Group{
 		Id:          d2.Id,
 		Name:        g1Update.Name,
 		DisplayName: model.NewId(),
@@ -365,25 +356,24 @@ func testGroupStoreUpdate(t *testing.T, ss store.Store) {
 		Description: model.NewId(),
 		RemoteId:    model.NewId(),
 	})
-	require.Equal(t, res6.Err.Id, "store.update_error")
+	require.Equal(t, err.Id, "store.update_error")
 
 	// Cannot update CreateAt
 	someVal := model.GetMillis()
 	d1.CreateAt = someVal
-	res7 := <-ss.Group().Update(d1)
+	d3, err := ss.Group().Update(d1)
-	d3 := res7.Data.(*model.Group)
+	require.Nil(t, err)
 	require.NotEqual(t, someVal, d3.CreateAt)
 
 	// Cannot update DeleteAt to non-zero
 	d1.DeleteAt = 1
-	res9 := <-ss.Group().Update(d1)
+	_, err = ss.Group().Update(d1)
-	require.Equal(t, "model.group.delete_at.app_error", res9.Err.Id)
+	require.Equal(t, "model.group.delete_at.app_error", err.Id)
 
 	//...except for 0 for DeleteAt
 	d1.DeleteAt = 0
-	res8 := <-ss.Group().Update(d1)
+	d4, err := ss.Group().Update(d1)
-	require.Nil(t, res8.Err)
+	require.Nil(t, err)
-	d4 := res8.Data.(*model.Group)
 	require.Zero(t, d4.DeleteAt)
 }
 
@@ -397,43 +387,42 @@ func testGroupStoreDelete(t *testing.T, ss store.Store) {
 		RemoteId:    model.NewId(),
 	}
 
-	res1 := <-ss.Group().Create(g1)
+	d1, err := ss.Group().Create(g1)
-	require.Nil(t, res1.Err)
+	require.Nil(t, err)
-	d1 := res1.Data.(*model.Group)
 	require.Len(t, d1.Id, 26)
 
 	// Check the group is retrievable
-	res2 := <-ss.Group().Get(d1.Id)
+	_, err = ss.Group().Get(d1.Id)
-	require.Nil(t, res2.Err)
+	require.Nil(t, err)
 
 	// Get the before count
-	res7 := <-ss.Group().GetAllBySource(model.GroupSourceLdap)
+	d7, err := ss.Group().GetAllBySource(model.GroupSourceLdap)
-	d7 := res7.Data.([]*model.Group)
+	require.Nil(t, err)
 	beforeCount := len(d7)
 
 	// Delete the group
-	res3 := <-ss.Group().Delete(d1.Id)
+	_, err = ss.Group().Delete(d1.Id)
-	require.Nil(t, res3.Err)
+	require.Nil(t, err)
 
 	// Check the group is deleted
-	res4 := <-ss.Group().Get(d1.Id)
+	d4, err := ss.Group().Get(d1.Id)
-	d4 := res4.Data.(*model.Group)
+	require.Nil(t, err)
 	require.NotZero(t, d4.DeleteAt)
 
 	// Check the after count
-	res5 := <-ss.Group().GetAllBySource(model.GroupSourceLdap)
+	d5, err := ss.Group().GetAllBySource(model.GroupSourceLdap)
-	d5 := res5.Data.([]*model.Group)
+	require.Nil(t, err)
 	afterCount := len(d5)
 	require.Condition(t, func() bool { return beforeCount == afterCount+1 })
 
 	// Try and delete a nonexistent group
-	res6 := <-ss.Group().Delete(model.NewId())
+	_, err = ss.Group().Delete(model.NewId())
-	require.NotNil(t, res6.Err)
+	require.NotNil(t, err)
-	require.Equal(t, res6.Err.Id, "store.sql_group.no_rows")
+	require.Equal(t, err.Id, "store.sql_group.no_rows")
 
 	// Cannot delete again
-	res8 := <-ss.Group().Delete(d1.Id)
+	_, err = ss.Group().Delete(d1.Id)
-	require.Equal(t, res8.Err.Id, "store.sql_group.no_rows")
+	require.Equal(t, err.Id, "store.sql_group.no_rows")
 }
 
 func testGroupGetMemberUsers(t *testing.T, ss store.Store) {
@@ -445,15 +434,14 @@ func testGroupGetMemberUsers(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res := <-ss.Group().Create(g1)
+	group, err := ss.Group().Create(g1)
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group := res.Data.(*model.Group)
 
 	u1 := &model.User{
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
-	res = <-ss.User().Save(u1)
+	res := <-ss.User().Save(u1)
 	require.Nil(t, res.Err)
 	user1 := res.Data.(*model.User)
 
@@ -499,15 +487,14 @@ func testGroupGetMemberUsersPage(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res := <-ss.Group().Create(g1)
+	group, err := ss.Group().Create(g1)
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group := res.Data.(*model.Group)
 
 	u1 := &model.User{
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
-	res = <-ss.User().Save(u1)
+	res := <-ss.User().Save(u1)
 	require.Nil(t, res.Err)
 	user1 := res.Data.(*model.User)
 
@@ -566,9 +553,8 @@ func testGroupCreateOrRestoreMember(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res1 := <-ss.Group().Create(g1)
+	group, err := ss.Group().Create(g1)
-	require.Nil(t, res1.Err)
+	require.Nil(t, err)
-	group := res1.Data.(*model.Group)
 
 	// Create user
 	u1 := &model.User{
@@ -623,9 +609,8 @@ func testGroupDeleteMember(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res1 := <-ss.Group().Create(g1)
+	group, err := ss.Group().Create(g1)
-	require.Nil(t, res1.Err)
+	require.Nil(t, err)
-	group := res1.Data.(*model.Group)
 
 	// Create user
 	u1 := &model.User{
@@ -675,9 +660,8 @@ func testCreateGroupSyncable(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res4 := <-ss.Group().Create(g1)
+	group, err := ss.Group().Create(g1)
-	require.Nil(t, res4.Err)
+	require.Nil(t, err)
-	group := res4.Data.(*model.Group)
 
 	// Create Team
 	t1 := &model.Team{
@@ -713,9 +697,8 @@ func testGetGroupSyncable(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res1 := <-ss.Group().Create(g1)
+	group, err := ss.Group().Create(g1)
-	require.Nil(t, res1.Err)
+	require.Nil(t, err)
-	group := res1.Data.(*model.Group)
 
 	// Create Team
 	t1 := &model.Team{
@@ -758,9 +741,8 @@ func testGetAllGroupSyncablesByGroup(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res1 := <-ss.Group().Create(g)
+	group, err := ss.Group().Create(g)
-	require.Nil(t, res1.Err)
+	require.Nil(t, err)
-	group := res1.Data.(*model.Group)
 
 	groupTeams := []*model.GroupSyncable{}
 
@@ -777,11 +759,13 @@ func testGetAllGroupSyncablesByGroup(t *testing.T, ss store.Store) {
 			Email:           "success+" + model.NewId() + "@simulator.amazonses.com",
 			Type:            model.TEAM_OPEN,
 		}
-		team, err := ss.Team().Save(t1)
+		var team *model.Team
+		team, err = ss.Team().Save(t1)
 		require.Nil(t, err)
 
 		// create groupteam
-		groupTeam, err := ss.Group().CreateGroupSyncable(model.NewGroupTeam(group.Id, team.Id, false))
+		var groupTeam *model.GroupSyncable
+		groupTeam, err = ss.Group().CreateGroupSyncable(model.NewGroupTeam(group.Id, team.Id, false))
 		require.Nil(t, err)
 		groupTeams = append(groupTeams, groupTeam)
 	}
@@ -810,9 +794,8 @@ func testUpdateGroupSyncable(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res4 := <-ss.Group().Create(g1)
+	group, err := ss.Group().Create(g1)
-	require.Nil(t, res4.Err)
+	require.Nil(t, err)
-	group := res4.Data.(*model.Group)
 
 	// Create Team
 	t1 := &model.Team{
@@ -877,9 +860,8 @@ func testDeleteGroupSyncable(t *testing.T, ss store.Store) {
 		Source:      model.GroupSourceLdap,
 		RemoteId:    model.NewId(),
 	}
-	res1 := <-ss.Group().Create(g1)
+	group, err := ss.Group().Create(g1)
-	require.Nil(t, res1.Err)
+	require.Nil(t, err)
-	group := res1.Data.(*model.Group)
 
 	// Create Team
 	t1 := &model.Team{
@@ -926,21 +908,20 @@ func testDeleteGroupSyncable(t *testing.T, ss store.Store) {
 
 func testPendingAutoAddTeamMembers(t *testing.T, ss store.Store) {
 	// Create Group
-	res := <-ss.Group().Create(&model.Group{
+	group, err := ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "TeamMembersToAdd Test Group",
 		RemoteId:    model.NewId(),
 		Source:      model.GroupSourceLdap,
 	})
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group := res.Data.(*model.Group)
 
 	// Create User
 	user := &model.User{
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
-	res = <-ss.User().Save(user)
+	res := <-ss.User().Save(user)
 	require.Nil(t, res.Err)
 	user = res.Data.(*model.User)
 
@@ -959,7 +940,7 @@ func testPendingAutoAddTeamMembers(t *testing.T, ss store.Store) {
 		Email:           "success+" + model.NewId() + "@simulator.amazonses.com",
 		Type:            model.TEAM_OPEN,
 	}
-	team, err := ss.Team().Save(team)
+	team, err = ss.Team().Save(team)
 	require.Nil(t, err)
 
 	// Create GroupTeam
@@ -1020,15 +1001,16 @@ func testPendingAutoAddTeamMembers(t *testing.T, ss store.Store) {
 	require.Len(t, teamMembers, 1)
 
 	// No result if Group deleted
-	res = <-ss.Group().Delete(group.Id)
+	_, err = ss.Group().Delete(group.Id)
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
 	teamMembers, err = ss.Group().TeamMembersToAdd(0)
 	require.Nil(t, err)
 	require.Len(t, teamMembers, 0)
 
 	// reset state of group and verify
 	group.DeleteAt = 0
-	res = <-ss.Group().Update(group)
+	_, err = ss.Group().Update(group)
+	require.Nil(t, err)
 	teamMembers, err = ss.Group().TeamMembersToAdd(0)
 	require.Nil(t, err)
 	require.Len(t, teamMembers, 1)
@@ -1089,21 +1071,20 @@ func testPendingAutoAddTeamMembers(t *testing.T, ss store.Store) {
 
 func testPendingAutoAddChannelMembers(t *testing.T, ss store.Store) {
 	// Create Group
-	res := <-ss.Group().Create(&model.Group{
+	group, err := ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "ChannelMembersToAdd Test Group",
 		RemoteId:    model.NewId(),
 		Source:      model.GroupSourceLdap,
 	})
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group := res.Data.(*model.Group)
 
 	// Create User
 	user := &model.User{
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
-	res = <-ss.User().Save(user)
+	res := <-ss.User().Save(user)
 	require.Nil(t, res.Err)
 	user = res.Data.(*model.User)
 
@@ -1118,7 +1099,7 @@ 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.
 	}
-	channel, err := ss.Channel().Save(channel, 9999)
+	channel, err = ss.Channel().Save(channel, 9999)
 	require.Nil(t, err)
 
 	// Create GroupChannel
@@ -1179,15 +1160,16 @@ func testPendingAutoAddChannelMembers(t *testing.T, ss store.Store) {
 	require.Len(t, channelMembers, 1)
 
 	// No result if Group deleted
-	res = <-ss.Group().Delete(group.Id)
+	_, err = ss.Group().Delete(group.Id)
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
 	channelMembers, err = ss.Group().ChannelMembersToAdd(0)
 	require.Nil(t, err)
 	require.Len(t, channelMembers, 0)
 
 	// reset state of group and verify
 	group.DeleteAt = 0
-	res = <-ss.Group().Update(group)
+	_, err = ss.Group().Update(group)
+	require.Nil(t, err)
 	channelMembers, err = ss.Group().ChannelMembersToAdd(0)
 	require.Nil(t, err)
 	require.Len(t, channelMembers, 1)
@@ -1420,14 +1402,13 @@ type removalsData struct {
 
 func pendingMemberRemovalsDataSetup(t *testing.T, ss store.Store) *removalsData {
 	// create group
-	res := <-ss.Group().Create(&model.Group{
+	group, err := ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "Pending[Channel|Team]MemberRemovals Test Group",
 		RemoteId:    model.NewId(),
 		Source:      model.GroupSourceLdap,
 	})
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group := res.Data.(*model.Group)
 
 	// create users
 	// userA will get removed from the group
@@ -1435,7 +1416,7 @@ func pendingMemberRemovalsDataSetup(t *testing.T, ss store.Store) *removalsData
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
-	res = <-ss.User().Save(userA)
+	res := <-ss.User().Save(userA)
 	require.Nil(t, res.Err)
 	userA = res.Data.(*model.User)
 
@@ -1472,7 +1453,7 @@ func pendingMemberRemovalsDataSetup(t *testing.T, ss store.Store) *removalsData
 		Type:             model.CHANNEL_PRIVATE,
 		GroupConstrained: model.NewBool(true),
 	}
-	channelConstrained, err := ss.Channel().Save(channelConstrained, 9999)
+	channelConstrained, err = ss.Channel().Save(channelConstrained, 9999)
 	require.Nil(t, err)
 
 	channelUnconstrained := &model.Channel{
@@ -1587,23 +1568,21 @@ func testGetGroupsByChannel(t *testing.T, ss store.Store) {
 	require.Nil(t, err)
 
 	// Create Groups 1 and 2
-	res := <-ss.Group().Create(&model.Group{
+	group1, err := ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "group-1",
 		RemoteId:    model.NewId(),
 		Source:      model.GroupSourceLdap,
 	})
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group1 := res.Data.(*model.Group)
 
-	res = <-ss.Group().Create(&model.Group{
+	group2, err := ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "group-2",
 		RemoteId:    model.NewId(),
 		Source:      model.GroupSourceLdap,
 	})
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group2 := res.Data.(*model.Group)
 
 	// And associate them with Channel1
 	for _, g := range []*model.Group{group1, group2} {
@@ -1627,14 +1606,13 @@ func testGetGroupsByChannel(t *testing.T, ss store.Store) {
 	require.Nil(t, err)
 
 	// Create Group3
-	res = <-ss.Group().Create(&model.Group{
+	group3, err := ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "group-3",
 		RemoteId:    model.NewId(),
 		Source:      model.GroupSourceLdap,
 	})
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group3 := res.Data.(*model.Group)
 
 	// And associate it to Channel2
 	_, err = ss.Group().CreateGroupSyncable(&model.GroupSyncable{
@@ -1650,7 +1628,7 @@ func testGetGroupsByChannel(t *testing.T, ss store.Store) {
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
-	res = <-ss.User().Save(u1)
+	res := <-ss.User().Save(u1)
 	require.Nil(t, res.Err)
 	user1 := res.Data.(*model.User)
 	<-ss.Group().UpsertMember(group1.Id, user1.Id)
@@ -1784,23 +1762,21 @@ func testGetGroupsByTeam(t *testing.T, ss store.Store) {
 	require.Nil(t, err)
 
 	// Create Groups 1 and 2
-	res := <-ss.Group().Create(&model.Group{
+	group1, err := ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "group-1",
 		RemoteId:    model.NewId(),
 		Source:      model.GroupSourceLdap,
 	})
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group1 := res.Data.(*model.Group)
 
-	res = <-ss.Group().Create(&model.Group{
+	group2, err := ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "group-2",
 		RemoteId:    model.NewId(),
 		Source:      model.GroupSourceLdap,
 	})
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group2 := res.Data.(*model.Group)
 
 	// And associate them with Team1
 	for _, g := range []*model.Group{group1, group2} {
@@ -1828,14 +1804,13 @@ func testGetGroupsByTeam(t *testing.T, ss store.Store) {
 	require.Nil(t, err)
 
 	// Create Group3
-	res = <-ss.Group().Create(&model.Group{
+	group3, err := ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "group-3",
 		RemoteId:    model.NewId(),
 		Source:      model.GroupSourceLdap,
 	})
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group3 := res.Data.(*model.Group)
 
 	// And associate it to Team2
 	_, err = ss.Group().CreateGroupSyncable(&model.GroupSyncable{
@@ -1851,7 +1826,7 @@ func testGetGroupsByTeam(t *testing.T, ss store.Store) {
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
-	res = <-ss.User().Save(u1)
+	res := <-ss.User().Save(u1)
 	require.Nil(t, res.Err)
 	user1 := res.Data.(*model.User)
 	<-ss.Group().UpsertMember(group1.Id, user1.Id)
@@ -1996,23 +1971,21 @@ func testGetGroups(t *testing.T, ss store.Store) {
 	require.Nil(t, err)
 
 	// Create Groups 1 and 2
-	res := <-ss.Group().Create(&model.Group{
+	group1, err := ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "group-1",
 		RemoteId:    model.NewId(),
 		Source:      model.GroupSourceLdap,
 	})
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group1 := res.Data.(*model.Group)
 
-	res = <-ss.Group().Create(&model.Group{
+	group2, err := ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "group-2",
 		RemoteId:    model.NewId(),
 		Source:      model.GroupSourceLdap,
 	})
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group2 := res.Data.(*model.Group)
 
 	// And associate them with Team1
 	for _, g := range []*model.Group{group1, group2} {
@@ -2050,14 +2023,13 @@ func testGetGroups(t *testing.T, ss store.Store) {
 	require.Nil(t, err)
 
 	// Create Group3
-	res = <-ss.Group().Create(&model.Group{
+	group3, err := ss.Group().Create(&model.Group{
 		Name:        model.NewId(),
 		DisplayName: "group-3",
 		RemoteId:    model.NewId(),
 		Source:      model.GroupSourceLdap,
 	})
-	require.Nil(t, res.Err)
+	require.Nil(t, err)
-	group3 := res.Data.(*model.Group)
 
 	// And associate it to Team2
 	_, err = ss.Group().CreateGroupSyncable(&model.GroupSyncable{
@@ -2093,7 +2065,7 @@ func testGetGroups(t *testing.T, ss store.Store) {
 		Email:    MakeEmail(),
 		Username: model.NewId(),
 	}
-	res = <-ss.User().Save(u1)
+	res := <-ss.User().Save(u1)
 	require.Nil(t, res.Err)
 	user1 := res.Data.(*model.User)
 	<-ss.Group().UpsertMember(group1.Id, user1.Id)
@@ -2286,9 +2258,8 @@ func testTeamMembersMinusGroupMembers(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			RemoteId:    model.NewId(),
 		}
-		res := <-ss.Group().Create(group)
+		group, err := ss.Group().Create(group)
-		require.Nil(t, res.Err)
+		require.Nil(t, err)
-		group = res.Data.(*model.Group)
 		groups = append(groups, group)
 	}
 
@@ -2440,9 +2411,8 @@ func testChannelMembersMinusGroupMembers(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			RemoteId:    model.NewId(),
 		}
-		res := <-ss.Group().Create(group)
+		group, err := ss.Group().Create(group)
-		require.Nil(t, res.Err)
+		require.Nil(t, err)
-		group = res.Data.(*model.Group)
 		groups = append(groups, group)
 	}
 

store/storetest/mocks/GroupStore.go

@@ -181,19 +181,28 @@ func (_m *GroupStore) CountTeamMembersMinusGroupMembers(teamID string, groupIDs
 }
 
 // Create provides a mock function with given fields: group
-func (_m *GroupStore) Create(group *model.Group) store.StoreChannel {
+func (_m *GroupStore) Create(group *model.Group) (*model.Group, *model.AppError) {
 	ret := _m.Called(group)
 
-	var r0 store.StoreChannel
+	var r0 *model.Group
-	if rf, ok := ret.Get(0).(func(*model.Group) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(*model.Group) *model.Group); ok {
 		r0 = rf(group)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.Group)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(*model.Group) *model.AppError); ok {
+		r1 = rf(group)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // CreateGroupSyncable provides a mock function with given fields: groupSyncable
@@ -222,19 +231,28 @@ func (_m *GroupStore) CreateGroupSyncable(groupSyncable *model.GroupSyncable) (*
 }
 
 // Delete provides a mock function with given fields: groupID
-func (_m *GroupStore) Delete(groupID string) store.StoreChannel {
+func (_m *GroupStore) Delete(groupID string) (*model.Group, *model.AppError) {
 	ret := _m.Called(groupID)
 
-	var r0 store.StoreChannel
+	var r0 *model.Group
-	if rf, ok := ret.Get(0).(func(string) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(string) *model.Group); ok {
 		r0 = rf(groupID)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.Group)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+		r1 = rf(groupID)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // DeleteGroupSyncable provides a mock function with given fields: groupID, syncableID, syncableType
@@ -279,35 +297,53 @@ func (_m *GroupStore) DeleteMember(groupID string, userID string) store.StoreCha
 }
 
 // Get provides a mock function with given fields: groupID
-func (_m *GroupStore) Get(groupID string) store.StoreChannel {
+func (_m *GroupStore) Get(groupID string) (*model.Group, *model.AppError) {
 	ret := _m.Called(groupID)
 
-	var r0 store.StoreChannel
+	var r0 *model.Group
-	if rf, ok := ret.Get(0).(func(string) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(string) *model.Group); ok {
 		r0 = rf(groupID)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.Group)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+		r1 = rf(groupID)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // GetAllBySource provides a mock function with given fields: groupSource
-func (_m *GroupStore) GetAllBySource(groupSource model.GroupSource) store.StoreChannel {
+func (_m *GroupStore) GetAllBySource(groupSource model.GroupSource) ([]*model.Group, *model.AppError) {
 	ret := _m.Called(groupSource)
 
-	var r0 store.StoreChannel
+	var r0 []*model.Group
-	if rf, ok := ret.Get(0).(func(model.GroupSource) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(model.GroupSource) []*model.Group); ok {
 		r0 = rf(groupSource)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).([]*model.Group)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(model.GroupSource) *model.AppError); ok {
+		r1 = rf(groupSource)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // GetAllGroupSyncablesByGroupId provides a mock function with given fields: groupID, syncableType
@@ -361,19 +397,28 @@ func (_m *GroupStore) GetByIDs(groupIDs []string) ([]*model.Group, *model.AppErr
 }
 
 // GetByRemoteID provides a mock function with given fields: remoteID, groupSource
-func (_m *GroupStore) GetByRemoteID(remoteID string, groupSource model.GroupSource) store.StoreChannel {
+func (_m *GroupStore) GetByRemoteID(remoteID string, groupSource model.GroupSource) (*model.Group, *model.AppError) {
 	ret := _m.Called(remoteID, groupSource)
 
-	var r0 store.StoreChannel
+	var r0 *model.Group
-	if rf, ok := ret.Get(0).(func(string, model.GroupSource) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(string, model.GroupSource) *model.Group); ok {
 		r0 = rf(remoteID, groupSource)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.Group)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string, model.GroupSource) *model.AppError); ok {
+		r1 = rf(remoteID, groupSource)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // GetGroupSyncable provides a mock function with given fields: groupID, syncableID, syncableType
@@ -600,19 +645,28 @@ func (_m *GroupStore) TeamMembersToRemove() ([]*model.TeamMember, *model.AppErro
 }
 
 // Update provides a mock function with given fields: group
-func (_m *GroupStore) Update(group *model.Group) store.StoreChannel {
+func (_m *GroupStore) Update(group *model.Group) (*model.Group, *model.AppError) {
 	ret := _m.Called(group)
 
-	var r0 store.StoreChannel
+	var r0 *model.Group
-	if rf, ok := ret.Get(0).(func(*model.Group) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(*model.Group) *model.Group); ok {
 		r0 = rf(group)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.Group)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(*model.Group) *model.AppError); ok {
+		r1 = rf(group)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // UpdateGroupSyncable provides a mock function with given fields: groupSyncable

store/storetest/user_store.go

@@ -1125,12 +1125,13 @@ func testUserStoreGetProfilesNotInChannel(t *testing.T, ss store.Store) {
 	})
 
 	// create a group
-	group := store.Must(ss.Group().Create(&model.Group{
+	group, err := ss.Group().Create(&model.Group{
 		Name:        "n_" + model.NewId(),
 		DisplayName: "dn_" + model.NewId(),
 		Source:      model.GroupSourceLdap,
 		RemoteId:    "ri_" + model.NewId(),
-	})).(*model.Group)
+	})
+	require.Nil(t, err)
 
 	// add two members to the group
 	for _, u := range []*model.User{u1, u2} {
@@ -3455,12 +3456,13 @@ func testUserStoreGetProfilesNotInTeam(t *testing.T, ss store.Store) {
 	})
 
 	// create a group
-	group := store.Must(ss.Group().Create(&model.Group{
+	group, err := ss.Group().Create(&model.Group{
 		Name:        "n_" + model.NewId(),
 		DisplayName: "dn_" + model.NewId(),
 		Source:      model.GroupSourceLdap,
 		RemoteId:    "ri_" + model.NewId(),
-	})).(*model.Group)
+	})
+	require.Nil(t, err)
 
 	// add two members to the group
 	for _, u := range []*model.User{u1, u2} {
@@ -3755,14 +3757,14 @@ func testUserStoreGetTeamGroupUsers(t *testing.T, ss store.Store) {
 	var testGroups []*model.Group
 	for i := 0; i < 2; i++ {
 		id = model.NewId()
-		res = <-ss.Group().Create(&model.Group{
+		var group *model.Group
+		group, err = ss.Group().Create(&model.Group{
 			Name:        "n_" + id,
 			DisplayName: "dn_" + id,
 			Source:      model.GroupSourceLdap,
 			RemoteId:    "ri_" + id,
 		})
-		require.Nil(t, res.Err)
+		require.Nil(t, err)
-		group := res.Data.(*model.Group)
 		require.NotNil(t, group)
 		testGroups = append(testGroups, group)
 	}
@@ -3877,14 +3879,14 @@ func testUserStoreGetChannelGroupUsers(t *testing.T, ss store.Store) {
 	var testGroups []*model.Group
 	for i := 0; i < 2; i++ {
 		id = model.NewId()
-		res = <-ss.Group().Create(&model.Group{
+		var group *model.Group
+		group, err = ss.Group().Create(&model.Group{
 			Name:        "n_" + id,
 			DisplayName: "dn_" + id,
 			Source:      model.GroupSourceLdap,
 			RemoteId:    "ri_" + id,
 		})
-		require.Nil(t, res.Err)
+		require.Nil(t, err)
-		group := res.Data.(*model.Group)
 		require.NotNil(t, group)
 		testGroups = append(testGroups, group)
 	}