feat: migrate DeleteGroup API to Connect RPC

Author: rohilsurana

internal/api/v1beta1connect/group.go

@@ -415,6 +415,29 @@ func (h *ConnectHandler) DisableGroup(ctx context.Context, request *connect.Requ
 	return connect.NewResponse(&frontierv1beta1.DisableGroupResponse{}), nil
 }
 
+func (h *ConnectHandler) DeleteGroup(ctx context.Context, request *connect.Request[frontierv1beta1.DeleteGroupRequest]) (*connect.Response[frontierv1beta1.DeleteGroupResponse], error) {
+	_, err := h.orgService.Get(ctx, request.Msg.GetOrgId())
+	if err != nil {
+		switch {
+		case errors.Is(err, organization.ErrDisabled):
+			return nil, connect.NewError(connect.CodeNotFound, ErrOrgDisabled)
+		case errors.Is(err, organization.ErrNotExist):
+			return nil, connect.NewError(connect.CodeNotFound, ErrOrgNotFound)
+		default:
+			return nil, connect.NewError(connect.CodeInternal, ErrInternalServerError)
+		}
+	}
+	if err := h.groupService.Delete(ctx, request.Msg.GetId()); err != nil {
+		switch {
+		case errors.Is(err, group.ErrNotExist):
+			return nil, connect.NewError(connect.CodeNotFound, ErrGroupNotFound)
+		default:
+			return nil, connect.NewError(connect.CodeInternal, ErrInternalServerError)
+		}
+	}
+	return connect.NewResponse(&frontierv1beta1.DeleteGroupResponse{}), nil
+}
+
 func transformGroupToPB(grp group.Group) (frontierv1beta1.Group, error) {
 	metaData, err := grp.Metadata.ToStructPB()
 	if err != nil {

internal/api/v1beta1connect/group_test.go

@@ -1573,3 +1573,88 @@ func TestConnectHandler_DisableGroup(t *testing.T) {
 		})
 	}
 }
+
+func TestConnectHandler_DeleteGroup(t *testing.T) {
+	randomID := utils.NewString()
+	tests := []struct {
+		name    string
+		setup   func(gs *mocks.GroupService, os *mocks.OrganizationService)
+		request *connect.Request[frontierv1beta1.DeleteGroupRequest]
+		want    *connect.Response[frontierv1beta1.DeleteGroupResponse]
+		wantErr error
+	}{
+		{
+			name: "should return error if organization does not exist",
+			setup: func(gs *mocks.GroupService, os *mocks.OrganizationService) {
+				os.EXPECT().Get(mock.Anything, testOrgID).Return(organization.Organization{}, organization.ErrNotExist)
+			},
+			request: connect.NewRequest(&frontierv1beta1.DeleteGroupRequest{
+				Id:    randomID,
+				OrgId: testOrgID,
+			}),
+			want:    nil,
+			wantErr: connect.NewError(connect.CodeNotFound, ErrOrgNotFound),
+		},
+		{
+			name: "should return error if organization is disabled",
+			setup: func(gs *mocks.GroupService, os *mocks.OrganizationService) {
+				os.EXPECT().Get(mock.Anything, testOrgID).Return(organization.Organization{}, organization.ErrDisabled)
+			},
+			request: connect.NewRequest(&frontierv1beta1.DeleteGroupRequest{
+				Id:    randomID,
+				OrgId: testOrgID,
+			}),
+			want:    nil,
+			wantErr: connect.NewError(connect.CodeNotFound, ErrOrgDisabled),
+		},
+		{
+			name: "should return error if group does not exist",
+			setup: func(gs *mocks.GroupService, os *mocks.OrganizationService) {
+				os.EXPECT().Get(mock.Anything, testOrgID).Return(organization.Organization{ID: testOrgID}, nil)
+				gs.EXPECT().Delete(mock.Anything, randomID).Return(group.ErrNotExist)
+			},
+			request: connect.NewRequest(&frontierv1beta1.DeleteGroupRequest{
+				Id:    randomID,
+				OrgId: testOrgID,
+			}),
+			want:    nil,
+			wantErr: connect.NewError(connect.CodeNotFound, ErrGroupNotFound),
+		},
+		{
+			name: "should delete group successfully",
+			setup: func(gs *mocks.GroupService, os *mocks.OrganizationService) {
+				os.EXPECT().Get(mock.Anything, testOrgID).Return(organization.Organization{ID: testOrgID}, nil)
+				gs.EXPECT().Delete(mock.Anything, randomID).Return(nil)
+			},
+			request: connect.NewRequest(&frontierv1beta1.DeleteGroupRequest{
+				Id:    randomID,
+				OrgId: testOrgID,
+			}),
+			want:    connect.NewResponse(&frontierv1beta1.DeleteGroupResponse{}),
+			wantErr: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockGroupSvc := new(mocks.GroupService)
+			mockOrgSvc := new(mocks.OrganizationService)
+			if tt.setup != nil {
+				tt.setup(mockGroupSvc, mockOrgSvc)
+			}
+			h := ConnectHandler{
+				groupService: mockGroupSvc,
+				orgService:   mockOrgSvc,
+			}
+			got, err := h.DeleteGroup(context.Background(), tt.request)
+			if tt.wantErr != nil {
+				assert.Error(t, err)
+				assert.Equal(t, tt.wantErr.(*connect.Error).Code(), err.(*connect.Error).Code())
+				assert.Equal(t, tt.wantErr.(*connect.Error).Message(), err.(*connect.Error).Message())
+			} else {
+				assert.NoError(t, err)
+				assert.EqualValues(t, tt.want, got)
+			}
+		})
+	}
+}