Groups Service (#40)

2026-01-12 11:15:12 +00:00 · 2021-01-20 14:02:41 +00:00
parent 8d748ba76b
commit 2f2658da9a
12 changed files with 1990 additions and 0 deletions
--- a/groups/handler/handler.go
+++ b/groups/handler/handler.go
@@ -0,0 +1,209 @@
+package handler
+
+import (
+	"context"
+	"strings"
+
+	"github.com/google/uuid"
+	"github.com/micro/micro/v3/service/errors"
+	pb "github.com/micro/services/groups/proto"
+	"gorm.io/gorm"
+)
+
+var (
+	ErrMissingName     = errors.BadRequest("MISSING_NAME", "Missing name")
+	ErrMissingID       = errors.BadRequest("MISSING_ID", "Missing ID")
+	ErrMissingIDs      = errors.BadRequest("MISSING_IDS", "One or more IDs are required")
+	ErrMissingGroupID  = errors.BadRequest("MISSING_GROUP_ID", "Missing Group ID")
+	ErrMissingMemberID = errors.BadRequest("MISSING_MEMBER_ID", "Missing Member ID")
+	ErrNotFound        = errors.BadRequest("NOT_FOUND", "No group found with this ID")
+	ErrStore           = errors.InternalServerError("STORE_ERROR", "Error connecting to the store")
+)
+
+type Group struct {
+	ID          string
+	Name        string
+	Memberships []Membership
+}
+
+type Membership struct {
+	MemberID string `gorm:"uniqueIndex:idx_membership"`
+	GroupID  string `gorm:"uniqueIndex:idx_membership"`
+	Group    Group
+}
+
+func (g *Group) Serialize() *pb.Group {
+	memberIDs := make([]string, len(g.Memberships))
+	for i, m := range g.Memberships {
+		memberIDs[i] = m.MemberID
+	}
+	return &pb.Group{Id: g.ID, Name: g.Name, MemberIds: memberIDs}
+}
+
+type Groups struct {
+	DB *gorm.DB
+}
+
+func (g *Groups) Create(ctx context.Context, req *pb.CreateRequest, rsp *pb.CreateResponse) error {
+	// validate the request
+	if len(req.Name) == 0 {
+		return ErrMissingName
+	}
+
+	// create the group object
+	group := &Group{ID: uuid.New().String(), Name: req.Name}
+	if err := g.DB.Create(group).Error; err != nil {
+		return ErrStore
+	}
+
+	// return the group
+	rsp.Group = group.Serialize()
+	return nil
+}
+
+func (g *Groups) Read(ctx context.Context, req *pb.ReadRequest, rsp *pb.ReadResponse) error {
+	// validate the request
+	if len(req.Ids) == 0 {
+		return ErrMissingIDs
+	}
+
+	// query the database
+	var groups []Group
+	if err := g.DB.Model(&Group{}).Preload("Memberships").Where("id IN (?)", req.Ids).Find(&groups).Error; err != nil {
+		return ErrStore
+	}
+
+	// serialize the response
+	rsp.Groups = make(map[string]*pb.Group, len(groups))
+	for _, g := range groups {
+		rsp.Groups[g.ID] = g.Serialize()
+	}
+
+	return nil
+}
+
+func (g *Groups) Update(ctx context.Context, req *pb.UpdateRequest, rsp *pb.UpdateResponse) error {
+	// validate the request
+	if len(req.Id) == 0 {
+		return ErrMissingID
+	}
+	if len(req.Name) == 0 {
+		return ErrMissingName
+	}
+
+	return g.DB.Transaction(func(tx *gorm.DB) error {
+		// find the group
+		var group Group
+		if err := tx.Where(&Group{ID: req.Id}).First(&group).Error; err == gorm.ErrRecordNotFound {
+			return ErrNotFound
+		} else if err != nil {
+			return ErrStore
+		}
+
+		// update the group
+		group.Name = req.Name
+		if err := tx.Save(&group).Error; err != nil {
+			return ErrStore
+		}
+
+		// serialize the response
+		rsp.Group = group.Serialize()
+		return nil
+	})
+}
+
+func (g *Groups) Delete(ctx context.Context, req *pb.DeleteRequest, rsp *pb.DeleteResponse) error {
+	// validate the request
+	if len(req.Id) == 0 {
+		return ErrMissingID
+	}
+
+	// delete from the database
+	if err := g.DB.Delete(&Group{ID: req.Id}).Error; err == gorm.ErrRecordNotFound {
+		return nil
+	} else if err != nil {
+		return ErrStore
+	}
+
+	return nil
+}
+
+func (g *Groups) List(ctx context.Context, req *pb.ListRequest, rsp *pb.ListResponse) error {
+	if len(req.MemberId) > 0 {
+		// only list groups the user is a member of
+		var ms []Membership
+		q := g.DB.Where(&Membership{MemberID: req.MemberId}).Preload("Group.Memberships")
+		if err := q.Find(&ms).Error; err != nil {
+			return err
+		}
+		rsp.Groups = make([]*pb.Group, len(ms))
+		for i, m := range ms {
+			rsp.Groups[i] = m.Group.Serialize()
+		}
+		return nil
+	}
+
+	// load all groups
+	var groups []Group
+	if err := g.DB.Model(&Group{}).Preload("Memberships").Find(&groups).Error; err != nil {
+		return ErrStore
+	}
+
+	// serialize the response
+	rsp.Groups = make([]*pb.Group, len(groups))
+	for i, g := range groups {
+		rsp.Groups[i] = g.Serialize()
+	}
+
+	return nil
+}
+
+func (g *Groups) AddMember(ctx context.Context, req *pb.AddMemberRequest, rsp *pb.AddMemberResponse) error {
+	// validate the request
+	if len(req.GroupId) == 0 {
+		return ErrMissingGroupID
+	}
+	if len(req.MemberId) == 0 {
+		return ErrMissingMemberID
+	}
+
+	return g.DB.Transaction(func(tx *gorm.DB) error {
+		// check the group exists
+		var group Group
+		if err := tx.Where(&Group{ID: req.GroupId}).First(&group).Error; err == gorm.ErrRecordNotFound {
+			return ErrNotFound
+		} else if err != nil {
+			return err
+		}
+
+		// create the membership
+		m := &Membership{MemberID: req.MemberId, GroupID: req.GroupId}
+		err := tx.Create(m).Error
+		// check for membership already existing (unique index violation)
+		if err != nil && strings.Contains(err.Error(), "fk_groups_memberships") {
+			return nil
+		} else if err != nil {
+			return ErrStore
+		}
+
+		return nil
+	})
+}
+
+func (g *Groups) RemoveMember(ctx context.Context, req *pb.RemoveMemberRequest, rsp *pb.RemoveMemberResponse) error {
+	// validate the request
+	if len(req.GroupId) == 0 {
+		return ErrMissingGroupID
+	}
+	if len(req.MemberId) == 0 {
+		return ErrMissingMemberID
+	}
+
+	// delete the membership
+	m := &Membership{MemberID: req.MemberId, GroupID: req.GroupId}
+	if err := g.DB.Where(m).Delete(m).Error; err != nil {
+		return ErrStore
+	}
+
+	return nil
+}
--- a/groups/handler/handler_test.go
+++ b/groups/handler/handler_test.go
@@ -0,0 +1,288 @@
+package handler_test
+
+import (
+	"context"
+	"sort"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/micro/services/groups/handler"
+	pb "github.com/micro/services/groups/proto"
+	"github.com/stretchr/testify/assert"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+)
+
+func testHandler(t *testing.T) *handler.Groups {
+	// connect to the database
+	db, err := gorm.Open(postgres.Open("postgresql://postgres@localhost:5432/groups?sslmode=disable"), &gorm.Config{})
+	if err != nil {
+		t.Fatalf("Error connecting to database: %v", err)
+	}
+
+	// migrate the database
+	if err := db.AutoMigrate(&handler.Group{}, &handler.Membership{}); err != nil {
+		t.Fatalf("Error migrating database: %v", err)
+	}
+
+	// clean any data from a previous run
+	if err := db.Exec("TRUNCATE TABLE groups CASCADE").Error; err != nil {
+		t.Fatalf("Error cleaning database: %v", err)
+	}
+
+	return &handler.Groups{DB: db}
+}
+func TestCreate(t *testing.T) {
+	h := testHandler(t)
+
+	t.Run("MissingName", func(t *testing.T) {
+		err := h.Create(context.TODO(), &pb.CreateRequest{}, &pb.CreateResponse{})
+		assert.Equal(t, handler.ErrMissingName, err)
+	})
+
+	t.Run("Valid", func(t *testing.T) {
+		err := h.Create(context.TODO(), &pb.CreateRequest{
+			Name: "Doe Family Group",
+		}, &pb.CreateResponse{})
+		assert.NoError(t, err)
+	})
+}
+
+func TestUpdate(t *testing.T) {
+	h := testHandler(t)
+
+	t.Run("MissingID", func(t *testing.T) {
+		err := h.Update(context.TODO(), &pb.UpdateRequest{
+			Name: "Doe Family Group",
+		}, &pb.UpdateResponse{})
+		assert.Equal(t, handler.ErrMissingID, err)
+	})
+
+	t.Run("MissingName", func(t *testing.T) {
+		err := h.Update(context.TODO(), &pb.UpdateRequest{
+			Id: uuid.New().String(),
+		}, &pb.UpdateResponse{})
+		assert.Equal(t, handler.ErrMissingName, err)
+	})
+
+	t.Run("NotFound", func(t *testing.T) {
+		err := h.Update(context.TODO(), &pb.UpdateRequest{
+			Id:   uuid.New().String(),
+			Name: "Bar Family Group",
+		}, &pb.UpdateResponse{})
+		assert.Equal(t, handler.ErrNotFound, err)
+	})
+
+	t.Run("Valid", func(t *testing.T) {
+		// create a demo group
+		var cRsp pb.CreateResponse
+		err := h.Create(context.TODO(), &pb.CreateRequest{
+			Name: "Doe Family Group",
+		}, &cRsp)
+		assert.NoError(t, err)
+
+		err = h.Update(context.TODO(), &pb.UpdateRequest{
+			Id:   cRsp.Group.Id,
+			Name: "Bar Family Group",
+		}, &pb.UpdateResponse{})
+		assert.NoError(t, err)
+
+		var rRsp pb.ReadResponse
+		err = h.Read(context.TODO(), &pb.ReadRequest{
+			Ids: []string{cRsp.Group.Id},
+		}, &rRsp)
+		assert.NoError(t, err)
+
+		g := rRsp.Groups[cRsp.Group.Id]
+		if g == nil {
+			t.Errorf("Group not returned")
+		} else {
+			assert.Equal(t, "Bar Family Group", g.Name)
+		}
+	})
+}
+
+func TestDelete(t *testing.T) {
+	h := testHandler(t)
+
+	t.Run("MissingID", func(t *testing.T) {
+		err := h.Delete(context.TODO(), &pb.DeleteRequest{}, &pb.DeleteResponse{})
+		assert.Equal(t, handler.ErrMissingID, err)
+	})
+
+	t.Run("NotFound", func(t *testing.T) {
+		err := h.Delete(context.TODO(), &pb.DeleteRequest{
+			Id: uuid.New().String(),
+		}, &pb.DeleteResponse{})
+		assert.NoError(t, err)
+	})
+
+	// create a demo group
+	var cRsp pb.CreateResponse
+	err := h.Create(context.TODO(), &pb.CreateRequest{
+		Name: "Doe Family Group",
+	}, &cRsp)
+	assert.NoError(t, err)
+
+	t.Run("Valid", func(t *testing.T) {
+		err := h.Delete(context.TODO(), &pb.DeleteRequest{
+			Id: cRsp.Group.Id,
+		}, &pb.DeleteResponse{})
+		assert.NoError(t, err)
+
+		var rRsp pb.ReadResponse
+		err = h.Read(context.TODO(), &pb.ReadRequest{
+			Ids: []string{cRsp.Group.Id},
+		}, &rRsp)
+		assert.Nil(t, rRsp.Groups[cRsp.Group.Id])
+	})
+}
+func TestList(t *testing.T) {
+	h := testHandler(t)
+
+	// create two demo groups
+	var cRsp1 pb.CreateResponse
+	err := h.Create(context.TODO(), &pb.CreateRequest{
+		Name: "Alpha Group",
+	}, &cRsp1)
+	assert.NoError(t, err)
+
+	var cRsp2 pb.CreateResponse
+	err = h.Create(context.TODO(), &pb.CreateRequest{
+		Name: "Bravo Group",
+	}, &cRsp2)
+	assert.NoError(t, err)
+
+	// add a member to the first group
+	uid := uuid.New().String()
+	err = h.AddMember(context.TODO(), &pb.AddMemberRequest{
+		GroupId: cRsp1.Group.Id, MemberId: uid,
+	}, &pb.AddMemberResponse{})
+	assert.NoError(t, err)
+
+	t.Run("Unscoped", func(t *testing.T) {
+		var rsp pb.ListResponse
+		err = h.List(context.TODO(), &pb.ListRequest{}, &rsp)
+		assert.NoError(t, err)
+		assert.Lenf(t, rsp.Groups, 2, "Two groups should be returned")
+		if len(rsp.Groups) != 2 {
+			return
+		}
+
+		sort.Slice(rsp.Groups, func(i, j int) bool {
+			return rsp.Groups[i].Name < rsp.Groups[j].Name
+		})
+		assert.Equal(t, cRsp1.Group.Id, rsp.Groups[0].Id)
+		assert.Equal(t, cRsp1.Group.Name, rsp.Groups[0].Name)
+		assert.Len(t, rsp.Groups[0].MemberIds, 1)
+		assert.Contains(t, rsp.Groups[0].MemberIds, uid)
+		assert.Equal(t, cRsp2.Group.Id, rsp.Groups[1].Id)
+		assert.Equal(t, cRsp2.Group.Name, rsp.Groups[1].Name)
+		assert.Len(t, rsp.Groups[1].MemberIds, 0)
+	})
+
+	t.Run("Scoped", func(t *testing.T) {
+		var rsp pb.ListResponse
+		err = h.List(context.TODO(), &pb.ListRequest{MemberId: uid}, &rsp)
+		assert.NoError(t, err)
+		assert.Lenf(t, rsp.Groups, 1, "One group should be returned")
+		if len(rsp.Groups) != 1 {
+			return
+		}
+
+		assert.Equal(t, cRsp1.Group.Id, rsp.Groups[0].Id)
+		assert.Equal(t, cRsp1.Group.Name, rsp.Groups[0].Name)
+		assert.Len(t, rsp.Groups[0].MemberIds, 1)
+		assert.Contains(t, rsp.Groups[0].MemberIds, uid)
+	})
+}
+
+func TestAddMember(t *testing.T) {
+	h := testHandler(t)
+
+	t.Run("MissingGroupID", func(t *testing.T) {
+		err := h.AddMember(context.TODO(), &pb.AddMemberRequest{
+			MemberId: uuid.New().String(),
+		}, &pb.AddMemberResponse{})
+		assert.Equal(t, handler.ErrMissingGroupID, err)
+	})
+
+	t.Run("MissingMemberID", func(t *testing.T) {
+		err := h.AddMember(context.TODO(), &pb.AddMemberRequest{
+			GroupId: uuid.New().String(),
+		}, &pb.AddMemberResponse{})
+		assert.Equal(t, handler.ErrMissingMemberID, err)
+	})
+
+	t.Run("GroupNotFound", func(t *testing.T) {
+		err := h.AddMember(context.TODO(), &pb.AddMemberRequest{
+			GroupId:  uuid.New().String(),
+			MemberId: uuid.New().String(),
+		}, &pb.AddMemberResponse{})
+		assert.Equal(t, handler.ErrNotFound, err)
+	})
+
+	// create a test group
+	var cRsp pb.CreateResponse
+	err := h.Create(context.TODO(), &pb.CreateRequest{
+		Name: "Alpha Group",
+	}, &cRsp)
+	assert.NoError(t, err)
+
+	t.Run("Valid", func(t *testing.T) {
+		err := h.AddMember(context.TODO(), &pb.AddMemberRequest{
+			GroupId:  cRsp.Group.Id,
+			MemberId: uuid.New().String(),
+		}, &pb.AddMemberResponse{})
+		assert.NoError(t, err)
+	})
+
+	t.Run("Retry", func(t *testing.T) {
+		err := h.AddMember(context.TODO(), &pb.AddMemberRequest{
+			GroupId:  cRsp.Group.Id,
+			MemberId: uuid.New().String(),
+		}, &pb.AddMemberResponse{})
+		assert.NoError(t, err)
+	})
+}
+
+func TestRemoveMember(t *testing.T) {
+	h := testHandler(t)
+
+	t.Run("MissingGroupID", func(t *testing.T) {
+		err := h.RemoveMember(context.TODO(), &pb.RemoveMemberRequest{
+			MemberId: uuid.New().String(),
+		}, &pb.RemoveMemberResponse{})
+		assert.Equal(t, handler.ErrMissingGroupID, err)
+	})
+
+	t.Run("MissingMemberID", func(t *testing.T) {
+		err := h.RemoveMember(context.TODO(), &pb.RemoveMemberRequest{
+			GroupId: uuid.New().String(),
+		}, &pb.RemoveMemberResponse{})
+		assert.Equal(t, handler.ErrMissingMemberID, err)
+	})
+
+	// create a test group
+	var cRsp pb.CreateResponse
+	err := h.Create(context.TODO(), &pb.CreateRequest{
+		Name: "Alpha Group",
+	}, &cRsp)
+	assert.NoError(t, err)
+
+	t.Run("Valid", func(t *testing.T) {
+		err := h.RemoveMember(context.TODO(), &pb.RemoveMemberRequest{
+			GroupId:  cRsp.Group.Id,
+			MemberId: uuid.New().String(),
+		}, &pb.RemoveMemberResponse{})
+		assert.NoError(t, err)
+	})
+
+	t.Run("Retry", func(t *testing.T) {
+		err := h.RemoveMember(context.TODO(), &pb.RemoveMemberRequest{
+			GroupId:  cRsp.Group.Id,
+			MemberId: uuid.New().String(),
+		}, &pb.RemoveMemberResponse{})
+		assert.NoError(t, err)
+	})
+}