Update client test

client/client_test.go

@@ -1,4 +1,4 @@
-//go:build amd64
+//TODO(Krapie) go:build amd64
 
 /*
  * Copyright 2021 The Yorkie Authors. All rights reserved.
@@ -19,61 +19,51 @@
 package client_test
 
 import (
+	"connectrpc.com/connect"
 	"context"
+	"github.com/yorkie-team/yorkie/api/yorkie/v1/v1connect"
+	"net/http"
+	"net/http/httptest"
 	"reflect"
 	"testing"
 
 	"github.com/rs/xid"
 	"github.com/stretchr/testify/assert"
 	monkey "github.com/undefinedlabs/go-mpatch"
-	"golang.org/x/net/nettest"
-	"google.golang.org/grpc"
-	grpcmetadata "google.golang.org/grpc/metadata"
-
 	"github.com/yorkie-team/yorkie/api/types"
 	api "github.com/yorkie-team/yorkie/api/yorkie/v1"
 	"github.com/yorkie-team/yorkie/client"
 )
 
 type testYorkieServer struct {
-	grpcServer   *grpc.Server
-	yorkieServer *api.UnimplementedYorkieServiceServer
+	httpServer   *httptest.Server
+	yorkieServer *v1connect.UnimplementedYorkieServiceHandler
 }
 
 // dialTestYorkieServer creates a new instance of testYorkieServer and
 // dials it with LocalListener.
-func dialTestYorkieServer(t *testing.T) (*testYorkieServer, string) {
-	yorkieServer := &api.UnimplementedYorkieServiceServer{}
-	grpcServer := grpc.NewServer()
-	api.RegisterYorkieServiceServer(grpcServer, yorkieServer)
+func dialTestYorkieServer() (*testYorkieServer, string) {
+	yorkieServer := &v1connect.UnimplementedYorkieServiceHandler{}
+	mux := http.NewServeMux()
+	mux.Handle(v1connect.NewYorkieServiceHandler(yorkieServer, nil))
+	httpServer := httptest.NewUnstartedServer(mux)
 
 	testYorkieServer := &testYorkieServer{
-		grpcServer:   grpcServer,
+		httpServer:   httpServer,
 		yorkieServer: yorkieServer,
 	}
 
-	return testYorkieServer, testYorkieServer.listenAndServe(t)
+	return testYorkieServer, testYorkieServer.listenAndServe()
 }
 
-func (s *testYorkieServer) listenAndServe(t *testing.T) string {
-	lis, err := nettest.NewLocalListener("tcp")
-	if err != nil {
-		t.Fatalf("failed to listen: %v", err)
-	}
-
-	go func() {
-		if err := s.grpcServer.Serve(lis); err != nil {
-			if err != grpc.ErrServerStopped {
-				t.Error(err)
-			}
-		}
-	}()
+func (s *testYorkieServer) listenAndServe() string {
+	s.httpServer.Start()
 
-	return lis.Addr().String()
+	return s.httpServer.URL
 }
 
 func (s *testYorkieServer) Stop() {
-	s.grpcServer.Stop()
+	s.httpServer.Close()
 }
 
 func TestClient(t *testing.T) {
@@ -87,7 +77,7 @@ func TestClient(t *testing.T) {
 	t.Run("x-shard-key test", func(t *testing.T) {
 		dummyID := types.ID("000000000000000000000000")
 
-		testServer, addr := dialTestYorkieServer(t)
+		testServer, addr := dialTestYorkieServer()
 		defer testServer.Stop()
 
 		cli, err := client.Dial(addr, client.WithAPIKey("dummy-api-key"))
@@ -98,21 +88,20 @@ func TestClient(t *testing.T) {
 			reflect.TypeOf(testServer.yorkieServer),
 			"ActivateClient",
 			func(
-				m *api.UnimplementedYorkieServiceServer,
+				m *v1connect.UnimplementedYorkieServiceHandler,
 				ctx context.Context,
-				req *api.ActivateClientRequest,
-			) (*api.ActivateClientResponse, error) {
+				req *connect.Request[api.ActivateClientRequest],
+			) (*connect.Response[api.ActivateClientResponse], error) {
 				assert.NoError(t, patch.Unpatch())
 				defer func() {
 					assert.NoError(t, patch.Patch())
 				}()
 
-				data, _ := grpcmetadata.FromIncomingContext(ctx)
-				assert.Equal(t, "dummy-api-key", data[types.ShardKey][0])
+				assert.Equal(t, "dummy-api-key", req.Header().Get(types.ShardKey))
 
-				return &api.ActivateClientResponse{
+				return connect.NewResponse(&api.ActivateClientResponse{
 					ClientId: dummyID.String(),
-				}, nil
+				}), nil
 			},
 		)
 		assert.NoError(t, err)

server/backend/database/change_info.go

@@ -34,6 +34,9 @@ import (
 // ErrEncodeOperationFailed is returned when encoding operations failed.
 var ErrEncodeOperationFailed = errors.New("encode operations failed")
 
+// ErrDecodeOperationFailed is returned when decoding operations failed.
+var ErrDecodeOperationFailed = errors.New("decode operations failed")
+
 // ChangeInfo is a structure representing information of a change.
 type ChangeInfo struct {
 	ID             types.ID `bson:"_id"`
@@ -94,7 +97,7 @@ func (i *ChangeInfo) ToChange() (*change.Change, error) {
 	for _, bytesOp := range i.Operations {
 		pbOp := api.Operation{}
 		if err := proto.Unmarshal(bytesOp, &pbOp); err != nil {
-			return nil, err
+			return nil, ErrDecodeOperationFailed
 		}
 		pbOps = append(pbOps, &pbOp)
 	}

server/packs/serverpacks.go

@@ -98,7 +98,7 @@ func (p *ServerPack) ToPBChangePack() (*api.ChangePack, error) {
 		for _, bytesOp := range info.Operations {
 			pbOp := api.Operation{}
 			if err := proto.Unmarshal(bytesOp, &pbOp); err != nil {
-				return nil, err
+				return nil, database.ErrDecodeOperationFailed
 			}
 			pbOps = append(pbOps, &pbOp)
 		}

server/rpc/connecthelper/logging.go

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-// Package grpchelper provides helper functions for gRPC.
+// Package connecthelper provides helper functions for gRPC.
 package connecthelper
 
 import (

server/rpc/server.go

@@ -73,6 +73,7 @@ func NewServer(conf *Config, be *backend.Backend) (*Server, error) {
 
 	interceptor := connect.WithInterceptors(
 		connecthelper.NewLoggingInterceptor(),
+		// TODO(krapie): update prometehus metrics server to http server
 		// be.Metrics.ServerMetrics()
 		interceptors.NewAdminAuthInterceptor(be, tokenManager),
 		interceptors.NewContextInterceptor(be),
@@ -157,10 +158,17 @@ func (s *Server) listenAndServe() error {
 func (s *Server) Shutdown(graceful bool) {
 	s.yorkieServiceCancel()
 
+	// TODO(krapie): find graceful way to shutdown http server
 	if graceful {
-		s.httpServer.Shutdown(context.Background())
+		err := s.httpServer.Shutdown(context.Background())
+		if err != nil {
+			return
+		}
 	} else {
-		s.httpServer.Shutdown(context.Background())
+		err := s.httpServer.Shutdown(context.Background())
+		if err != nil {
+			return
+		}
 	}
 }