[public-api] Implement experimental ListTeams

Author: easyCZ

components/public-api-server/go.mod

@@ -14,6 +14,7 @@ require (
 	github.com/google/uuid v1.1.2
 	github.com/gorilla/handlers v1.5.1
 	github.com/grpc-ecosystem/go-grpc-middleware v1.3.0
+	github.com/hashicorp/golang-lru v0.5.4
 	github.com/prometheus/client_golang v1.13.0
 	github.com/relvacode/iso8601 v1.1.0
 	github.com/sirupsen/logrus v1.8.1
@@ -34,7 +35,6 @@ require (
 	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/gorilla/websocket v1.5.0 // indirect
 	github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0 // indirect
-	github.com/hashicorp/golang-lru v0.5.4 // indirect
 	github.com/heptiolabs/healthcheck v0.0.0-20211123025425-613501dd5deb // indirect
 	github.com/inconshreveable/mousetrap v1.0.0 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect

components/public-api-server/go.sum

@@ -7,8 +7,8 @@ package apiv1
 import (
 	"context"
 	"fmt"
+	
 	protocol "github.com/gitpod-io/gitpod/gitpod-protocol"
-
 	connect "github.com/bufbuild/connect-go"
 	"github.com/gitpod-io/gitpod/common-go/log"
 	"github.com/gitpod-io/gitpod/public-api-server/pkg/auth"
@@ -38,38 +38,82 @@ func (s *TeamService) CreateTeam(ctx context.Context, req *connect.Request[v1.Cr
 		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("Name is a required argument when creating a team."))
 	}
 
-	server, err := s.connectionPool.Get(ctx, token)
+	conn, err := s.connectionPool.Get(ctx, token)
 	if err != nil {
 		log.Log.WithError(err).Error("Failed to get connection to server.")
 		return nil, connect.NewError(connect.CodeInternal, err)
 	}
 
-	team, err := server.CreateTeam(ctx, req.Msg.GetName())
+	created, err := conn.CreateTeam(ctx, req.Msg.GetName())
 	if err != nil {
+		log.WithError(err).Error("Failed to create team.")
 		return nil, proxy.ConvertError(err)
 	}
 
-	members, err := server.GetTeamMembers(ctx, team.ID)
+	team, err := s.toTeamAPIResponse(ctx, conn, created)
+	if err != nil {
+		log.WithError(err).Error("Failed to populate team with details.")
+		return nil, err
+	}
+
+	return connect.NewResponse(&v1.CreateTeamResponse{
+		Team: team,
+	}), nil
+}
+
+func (s *TeamService) ListTeams(ctx context.Context, req *connect.Request[v1.ListTeamsRequest]) (*connect.Response[v1.ListTeamsResponse], error) {
+	token := auth.TokenFromContext(ctx)
+
+	conn, err := s.connectionPool.Get(ctx, token)
 	if err != nil {
+		log.Log.WithError(err).Error("Failed to get connection to server.")
+		return nil, connect.NewError(connect.CodeInternal, err)
+	}
+
+	teams, err := conn.GetTeams(ctx)
+	if err != nil {
+		log.WithError(err).Error("Failed to list teams from server.")
 		return nil, proxy.ConvertError(err)
 	}
 
-	invite, err := server.GetGenericInvite(ctx, team.ID)
+	var response []*v1.Team
+	for _, t := range teams {
+		team, err := s.toTeamAPIResponse(ctx, conn, t)
+		if err != nil {
+			log.WithError(err).Error("Failed to populate team with details.")
+			return nil, err
+		}
+
+		response = append(response, team)
+	}
+
+	return connect.NewResponse(&v1.ListTeamsResponse{
+		Teams: response,
+	}), nil
+}
+
+func (s *TeamService) toTeamAPIResponse(ctx context.Context, conn protocol.APIInterface, team *protocol.Team) (*v1.Team, error) {
+	members, err := conn.GetTeamMembers(ctx, team.ID)
 	if err != nil {
+		log.WithError(err).Error("Failed to get team members.")
 		return nil, proxy.ConvertError(err)
 	}
 
-	return connect.NewResponse(&v1.CreateTeamResponse{
-		Team: &v1.Team{
-			Id:      team.ID,
-			Name:    team.Name,
-			Slug:    team.Slug,
-			Members: teamMembersToAPIResponse(members),
-			TeamInvitation: &v1.TeamInvitation{
-				Id: invite.ID,
-			},
+	invite, err := conn.GetGenericInvite(ctx, team.ID)
+	if err != nil {
+		log.WithError(err).Error("Failed to get generic invite.")
+		return nil, proxy.ConvertError(err)
+	}
+
+	return &v1.Team{
+		Id:      team.ID,
+		Name:    team.Name,
+		Slug:    team.Slug,
+		Members: teamMembersToAPIResponse(members),
+		TeamInvitation: &v1.TeamInvitation{
+			Id: invite.ID,
 		},
-	}), nil
+	}, nil
 }
 
 func teamMembersToAPIResponse(members []*protocol.TeamMemberInfo) []*v1.TeamMember {

components/public-api-server/pkg/apiv1/team.go

@@ -7,6 +7,11 @@ package apiv1
 import (
 	"context"
 	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
 	"github.com/bufbuild/connect-go"
 	protocol "github.com/gitpod-io/gitpod/gitpod-protocol"
 	"github.com/gitpod-io/gitpod/public-api-server/pkg/auth"
@@ -17,10 +22,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/testing/protocmp"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
 )
 
 func TestTeamsService_CreateTeam(t *testing.T) {
@@ -116,6 +117,101 @@ func TestTeamsService_CreateTeam(t *testing.T) {
 	})
 }
 
+func TestTeamsService_ListTeams(t *testing.T) {
+	t.Run("returns teams with members and invite", func(t *testing.T) {
+		ctx := context.Background()
+		serverMock, client := setupTeamService(t)
+
+		teamMembers := []*protocol.TeamMemberInfo{
+			{
+				UserId:       uuid.New().String(),
+				FullName:     "Alice Alice",
+				PrimaryEmail: "[email protected]",
+				AvatarUrl:    "",
+				Role:         protocol.TeamMember_Owner,
+				MemberSince:  "",
+			}, {
+				UserId:       uuid.New().String(),
+				FullName:     "Bob Bob",
+				PrimaryEmail: "[email protected]",
+				AvatarUrl:    "",
+				Role:         protocol.TeamMember_Member,
+				MemberSince:  "",
+			},
+		}
+		teams := []*protocol.Team{
+			{
+				ID:   uuid.New().String(),
+				Name: "Team A",
+				Slug: "team_a",
+			}, {
+				ID:   uuid.New().String(),
+				Name: "Team B",
+				Slug: "team_ba",
+			},
+		}
+		inviteID := uuid.New().String()
+
+		serverMock.EXPECT().GetTeams(gomock.Any()).Return(teams, nil)
+
+		// Mocks for populating team A details
+		serverMock.EXPECT().GetTeamMembers(gomock.Any(), teams[0].ID).Return(teamMembers, nil)
+		serverMock.EXPECT().GetGenericInvite(gomock.Any(), teams[0].ID).Return(&protocol.TeamMembershipInvite{
+			ID:     inviteID,
+			TeamID: teams[0].ID,
+		}, nil)
+		// Mock for populating team B details
+		serverMock.EXPECT().GetTeamMembers(gomock.Any(), teams[1].ID).Return(teamMembers, nil)
+		serverMock.EXPECT().GetGenericInvite(gomock.Any(), teams[1].ID).Return(&protocol.TeamMembershipInvite{
+			ID:     inviteID,
+			TeamID: teams[1].ID,
+		}, nil)
+
+		response, err := client.ListTeams(ctx, connect.NewRequest(&v1.ListTeamsRequest{}))
+		require.NoError(t, err)
+		requireEqualProto(t, &v1.ListTeamsResponse{
+			Teams: []*v1.Team{
+				{
+					Id:   teams[0].ID,
+					Name: teams[0].Name,
+					Slug: teams[0].Slug,
+					Members: []*v1.TeamMember{
+						{
+							UserId: teamMembers[0].UserId,
+							Role:   teamRoleToAPIResponse(teamMembers[0].Role),
+						},
+						{
+							UserId: teamMembers[1].UserId,
+							Role:   teamRoleToAPIResponse(teamMembers[1].Role),
+						},
+					},
+					TeamInvitation: &v1.TeamInvitation{
+						Id: inviteID,
+					},
+				},
+				{
+					Id:   teams[1].ID,
+					Name: teams[1].Name,
+					Slug: teams[1].Slug,
+					Members: []*v1.TeamMember{
+						{
+							UserId: teamMembers[0].UserId,
+							Role:   teamRoleToAPIResponse(teamMembers[0].Role),
+						},
+						{
+							UserId: teamMembers[1].UserId,
+							Role:   teamRoleToAPIResponse(teamMembers[1].Role),
+						},
+					},
+					TeamInvitation: &v1.TeamInvitation{
+						Id: inviteID,
+					},
+				},
+			},
+		}, response.Msg)
+	})
+}
+
 func setupTeamService(t *testing.T) (*protocol.MockAPIInterface, v1connect.TeamsServiceClient) {
 	t.Helper()