feat: migrate GetProjectResource API to Connect RPC

Author: rohilsurana

internal/api/v1beta1connect/errors.go

@@ -46,4 +46,5 @@ var (
 	ErrBillingProviderNotSupported = errors.New("provider not supported")
 	ErrInsufficientCredits         = errors.New("insufficient credits")
 	ErrAlreadyApplied              = errors.New("credits already applied")
+	ErrResourceNotFound            = errors.New("resource doesn't exist")
 )

internal/api/v1beta1connect/resource.go

@@ -124,6 +124,29 @@ func (h *ConnectHandler) CreateProjectResource(ctx context.Context, request *con
 	}), nil
 }
 
+func (h *ConnectHandler) GetProjectResource(ctx context.Context, request *connect.Request[frontierv1beta1.GetProjectResourceRequest]) (*connect.Response[frontierv1beta1.GetProjectResourceResponse], error) {
+	fetchedResource, err := h.resourceService.Get(ctx, request.Msg.GetId())
+	if err != nil {
+		switch {
+		case errors.Is(err, resource.ErrNotExist),
+			errors.Is(err, resource.ErrInvalidUUID),
+			errors.Is(err, resource.ErrInvalidID):
+			return nil, connect.NewError(connect.CodeNotFound, ErrResourceNotFound)
+		default:
+			return nil, connect.NewError(connect.CodeInternal, ErrInternalServerError)
+		}
+	}
+
+	resourcePB, err := transformResourceToPB(fetchedResource)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, ErrInternalServerError)
+	}
+
+	return connect.NewResponse(&frontierv1beta1.GetProjectResourceResponse{
+		Resource: resourcePB,
+	}), nil
+}
+
 func transformResourceToPB(from resource.Resource) (*frontierv1beta1.Resource, error) {
 	var metadata *structpb.Struct
 	var err error

internal/api/v1beta1connect/resource_test.go

@@ -368,3 +368,103 @@ func TestConnectHandler_CreateProjectResource(t *testing.T) {
 		})
 	}
 }
+
+func TestConnectHandler_GetProjectResource(t *testing.T) {
+	tests := []struct {
+		name    string
+		setup   func(rs *mocks.ResourceService)
+		request *connect.Request[frontierv1beta1.GetProjectResourceRequest]
+		want    *connect.Response[frontierv1beta1.GetProjectResourceResponse]
+		wantErr error
+	}{
+		{
+			name: "should return internal error if resource service returns error",
+			setup: func(rs *mocks.ResourceService) {
+				rs.EXPECT().Get(mock.AnythingOfType("context.backgroundCtx"), testResource.ID).Return(resource.Resource{}, errors.New("test error"))
+			},
+			request: connect.NewRequest(&frontierv1beta1.GetProjectResourceRequest{
+				Id: testResource.ID,
+			}),
+			want:    nil,
+			wantErr: connect.NewError(connect.CodeInternal, ErrInternalServerError),
+		},
+		{
+			name: "should return not found error if id is empty",
+			setup: func(rs *mocks.ResourceService) {
+				rs.EXPECT().Get(mock.AnythingOfType("context.backgroundCtx"), "").Return(resource.Resource{}, resource.ErrInvalidID)
+			},
+			request: connect.NewRequest(&frontierv1beta1.GetProjectResourceRequest{}),
+			want:    nil,
+			wantErr: connect.NewError(connect.CodeNotFound, ErrNotFound),
+		},
+		{
+			name: "should return not found error if id is not uuid",
+			setup: func(rs *mocks.ResourceService) {
+				rs.EXPECT().Get(mock.AnythingOfType("context.backgroundCtx"), "some-id").Return(resource.Resource{}, resource.ErrInvalidUUID)
+			},
+			request: connect.NewRequest(&frontierv1beta1.GetProjectResourceRequest{
+				Id: "some-id",
+			}),
+			want:    nil,
+			wantErr: connect.NewError(connect.CodeNotFound, ErrNotFound),
+		},
+		{
+			name: "should return not found error if resource not exist",
+			setup: func(rs *mocks.ResourceService) {
+				rs.EXPECT().Get(mock.AnythingOfType("context.backgroundCtx"), testResource.ID).Return(resource.Resource{}, resource.ErrNotExist)
+			},
+			request: connect.NewRequest(&frontierv1beta1.GetProjectResourceRequest{
+				Id: testResource.ID,
+			}),
+			want:    nil,
+			wantErr: connect.NewError(connect.CodeNotFound, ErrNotFound),
+		},
+		{
+			name: "should return success if resource service returns resource",
+			setup: func(rs *mocks.ResourceService) {
+				rs.EXPECT().Get(mock.AnythingOfType("context.backgroundCtx"), testResource.ID).Return(testResource, nil)
+			},
+			request: connect.NewRequest(&frontierv1beta1.GetProjectResourceRequest{
+				Id: testResource.ID,
+			}),
+			want: connect.NewResponse(&frontierv1beta1.GetProjectResourceResponse{
+				Resource: testResourcePB,
+			}),
+			wantErr: nil,
+		},
+		{
+			name: "should return internal error if transform fails",
+			setup: func(rs *mocks.ResourceService) {
+				invalidResource := testResource
+				invalidResource.Metadata = map[string]interface{}{
+					"invalid": func() {}, // functions can't be marshaled
+				}
+				rs.EXPECT().Get(mock.AnythingOfType("context.backgroundCtx"), testResource.ID).Return(invalidResource, nil)
+			},
+			request: connect.NewRequest(&frontierv1beta1.GetProjectResourceRequest{
+				Id: testResource.ID,
+			}),
+			want:    nil,
+			wantErr: connect.NewError(connect.CodeInternal, ErrInternalServerError),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockResourceSrv := new(mocks.ResourceService)
+			if tt.setup != nil {
+				tt.setup(mockResourceSrv)
+			}
+			h := ConnectHandler{resourceService: mockResourceSrv}
+			resp, err := h.GetProjectResource(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, resp)
+			}
+		})
+	}
+}