proxy: Convert peeker tests to use `grpc_testing` test service

We have defined our own gRPC test service in order to assert behaviour
with various kinds of RPCs. This isn't really necessary though given
that the grpc-go package already provides a test service that can be
used exactly for these purposes.

Convert the peeker tests to use the `grpc_testing.TestService`.

2 files changed, 50 insertions, 44 deletions

diff --git a/internal/praefect/grpc-proxy/proxy/peeker_test.go b/internal/praefect/grpc-proxy/proxy/peeker_test.go
index 1297c734b..286072641 100644
--- a/internal/praefect/grpc-proxy/proxy/peeker_test.go
+++ b/internal/praefect/grpc-proxy/proxy/peeker_test.go
@@ -10,8 +10,8 @@ import (
 	"github.com/stretchr/testify/require"
 	"gitlab.com/gitlab-org/gitaly/v15/internal/metadata"
 	"gitlab.com/gitlab-org/gitaly/v15/internal/praefect/grpc-proxy/proxy"
-	testservice "gitlab.com/gitlab-org/gitaly/v15/internal/praefect/grpc-proxy/testdata"
 	"gitlab.com/gitlab-org/gitaly/v15/internal/testhelper"
+	"google.golang.org/grpc/test/grpc_testing"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -23,11 +23,15 @@ func TestStreamPeeking(t *testing.T) {
 
 	backendCC, backendSrvr := newBackendPinger(t, ctx)
 
-	requestSent := &testservice.PingRequest{
-		Value: "hi",
+	requestSent := &grpc_testing.StreamingOutputCallRequest{
+		Payload: &grpc_testing.Payload{
+			Body: []byte("hi"),
+		},
 	}
-	responseSent := &testservice.PingResponse{
-		Counter: 1,
+	responseSent := &grpc_testing.StreamingOutputCallResponse{
+		Payload: &grpc_testing.Payload{
+			Body: []byte("bye"),
+		},
 	}
 
 	// We create a director that's peeking into the message in order to assert that the peeked
@@ -36,20 +40,20 @@ func TestStreamPeeking(t *testing.T) {
 		peekedMessage, err := peeker.Peek()
 		require.NoError(t, err)
 
-		var peekedRequest testservice.PingRequest
+		var peekedRequest grpc_testing.StreamingOutputCallRequest
 		require.NoError(t, proto.Unmarshal(peekedMessage, &peekedRequest))
 		testhelper.ProtoEqual(t, requestSent, &peekedRequest)
 
 		return proxy.NewStreamParameters(proxy.Destination{
-			Ctx: metadata.IncomingToOutgoing(ctx),
+			Ctx:  metadata.IncomingToOutgoing(ctx),
 			Conn: backendCC,
-			Msg: peekedMessage,
+			Msg:  peekedMessage,
 		}, nil, nil, nil), nil
 	}
 
 	// The backend is supposed to still receive the message as expected without any modification
 	// to it.
-	backendSrvr.pingStream = func(stream testservice.TestService_PingStreamServer) error {
+	backendSrvr.fullDuplexCall = func(stream grpc_testing.TestService_FullDuplexCallServer) error {
 		requestReceived, err := stream.Recv()
 		require.NoError(t, err)
 		testhelper.ProtoEqual(t, requestSent, requestReceived)
@@ -57,11 +61,11 @@ func TestStreamPeeking(t *testing.T) {
 		return stream.Send(responseSent)
 	}
 
-	proxyConn := newProxy(t, ctx, director, "mwitkow.testproto.TestService", "PingStream")
-	proxyClient := testservice.NewTestServiceClient(proxyConn)
+	proxyConn := newProxy(t, ctx, director, "grpc_testing.TestService", "FullDuplexCall")
+	proxyClient := grpc_testing.NewTestServiceClient(proxyConn)
 
 	// Send the request on the stream and close the writing side.
-	proxyStream, err := proxyClient.PingStream(ctx)
+	proxyStream, err := proxyClient.FullDuplexCall(ctx)
 	require.NoError(t, err)
 	require.NoError(t, proxyStream.Send(requestSent))
 	require.NoError(t, proxyStream.CloseSend())
@@ -80,14 +84,20 @@ func TestStreamInjecting(t *testing.T) {
 
 	backendCC, backendSrvr := newBackendPinger(t, ctx)
 
-	requestSent := &testservice.PingRequest{
-		Value: "hi",
+	requestSent := &grpc_testing.StreamingOutputCallRequest{
+		Payload: &grpc_testing.Payload{
+			Body: []byte("hi"),
+		},
 	}
-	requestReplaced := &testservice.PingRequest{
-		Value: "bye",
+	requestReplaced := &grpc_testing.StreamingOutputCallRequest{
+		Payload: &grpc_testing.Payload{
+			Body: []byte("replaced"),
+		},
 	}
-	responseSent := &testservice.PingResponse{
-		Counter: 1,
+	responseSent := &grpc_testing.StreamingOutputCallResponse{
+		Payload: &grpc_testing.Payload{
+			Body: []byte("bye"),
+		},
 	}
 
 	// We create a director that peeks the incoming request and in fact changes its values. This
@@ -97,7 +107,7 @@ func TestStreamInjecting(t *testing.T) {
 		require.NoError(t, err)
 
 		// Assert that we get the expected original ping request.
-		var peekedRequest testservice.PingRequest
+		var peekedRequest grpc_testing.StreamingOutputCallRequest
 		require.NoError(t, proto.Unmarshal(peekedMessage, &peekedRequest))
 		testhelper.ProtoEqual(t, requestSent, &peekedRequest)
 
@@ -106,14 +116,14 @@ func TestStreamInjecting(t *testing.T) {
 		require.NoError(t, err)
 
 		return proxy.NewStreamParameters(proxy.Destination{
-			Ctx: metadata.IncomingToOutgoing(ctx),
+			Ctx:  metadata.IncomingToOutgoing(ctx),
 			Conn: backendCC,
-			Msg: replacedMessage,
+			Msg:  replacedMessage,
 		}, nil, nil, nil), nil
 	}
 
 	// Upon receiving the request the backend server should only ever see the changed request.
-	backendSrvr.pingStream = func(stream testservice.TestService_PingStreamServer) error {
+	backendSrvr.fullDuplexCall = func(stream grpc_testing.TestService_FullDuplexCallServer) error {
 		requestReceived, err := stream.Recv()
 		require.NoError(t, err)
 		testhelper.ProtoEqual(t, requestReplaced, requestReceived)
@@ -121,10 +131,10 @@ func TestStreamInjecting(t *testing.T) {
 		return stream.Send(responseSent)
 	}
 
-	proxyConn := newProxy(t, ctx, director, "mwitkow.testproto.TestService", "PingStream")
-	proxyClient := testservice.NewTestServiceClient(proxyConn)
+	proxyConn := newProxy(t, ctx, director, "grpc_testing.TestService", "FullDuplexCall")
+	proxyClient := grpc_testing.NewTestServiceClient(proxyConn)
 
-	proxyStream, err := proxyClient.PingStream(ctx)
+	proxyStream, err := proxyClient.FullDuplexCall(ctx)
 	require.NoError(t, err)
 	defer func() {
 		require.NoError(t, proxyStream.CloseSend())
diff --git a/internal/praefect/grpc-proxy/proxy/testhelper_test.go b/internal/praefect/grpc-proxy/proxy/testhelper_test.go
index 0b0efa104..5faf4ce49 100644
--- a/internal/praefect/grpc-proxy/proxy/testhelper_test.go
+++ b/internal/praefect/grpc-proxy/proxy/testhelper_test.go
@@ -9,10 +9,10 @@ import (
 
 	"github.com/stretchr/testify/require"
 	"gitlab.com/gitlab-org/gitaly/v15/internal/praefect/grpc-proxy/proxy"
-	testservice "gitlab.com/gitlab-org/gitaly/v15/internal/praefect/grpc-proxy/testdata"
 	"gitlab.com/gitlab-org/gitaly/v15/internal/testhelper"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/test/grpc_testing"
 )
 
 func TestMain(m *testing.M) {
@@ -32,7 +32,7 @@ func newBackendPinger(tb testing.TB, ctx context.Context) (*grpc.ClientConn, *in
 	srvr := grpc.NewServer()
 	listener := newListener(tb)
 
-	testservice.RegisterTestServiceServer(srvr, ip)
+	grpc_testing.RegisterTestServiceServer(srvr, ip)
 
 	done := make(chan struct{})
 	go func() {
@@ -94,30 +94,26 @@ func newProxy(tb testing.TB, ctx context.Context, director proxy.StreamDirector,
 // interceptPinger allows an RPC to be intercepted with a custom
 // function defined in each unit test
 type interceptPinger struct {
-	testservice.UnimplementedTestServiceServer
-	pingStream func(testservice.TestService_PingStreamServer) error
-	pingEmpty  func(context.Context, *testservice.Empty) (*testservice.PingResponse, error)
-	ping       func(context.Context, *testservice.PingRequest) (*testservice.PingResponse, error)
-	pingError  func(context.Context, *testservice.PingRequest) (*testservice.Empty, error)
-	pingList   func(*testservice.PingRequest, testservice.TestService_PingListServer) error
-}
+	grpc_testing.UnimplementedTestServiceServer
 
-func (ip *interceptPinger) PingStream(stream testservice.TestService_PingStreamServer) error {
-	return ip.pingStream(stream)
+	fullDuplexCall      func(grpc_testing.TestService_FullDuplexCallServer) error
+	emptyCall           func(context.Context, *grpc_testing.Empty) (*grpc_testing.Empty, error)
+	unaryCall           func(context.Context, *grpc_testing.SimpleRequest) (*grpc_testing.SimpleResponse, error)
+	streamingOutputCall func(*grpc_testing.StreamingOutputCallRequest, grpc_testing.TestService_StreamingOutputCallServer) error
 }
 
-func (ip *interceptPinger) PingEmpty(ctx context.Context, req *testservice.Empty) (*testservice.PingResponse, error) {
-	return ip.pingEmpty(ctx, req)
+func (ip *interceptPinger) FullDuplexCall(stream grpc_testing.TestService_FullDuplexCallServer) error {
+	return ip.fullDuplexCall(stream)
 }
 
-func (ip *interceptPinger) Ping(ctx context.Context, req *testservice.PingRequest) (*testservice.PingResponse, error) {
-	return ip.ping(ctx, req)
+func (ip *interceptPinger) EmptyCall(ctx context.Context, req *grpc_testing.Empty) (*grpc_testing.Empty, error) {
+	return ip.emptyCall(ctx, req)
 }
 
-func (ip *interceptPinger) PingError(ctx context.Context, req *testservice.PingRequest) (*testservice.Empty, error) {
-	return ip.pingError(ctx, req)
+func (ip *interceptPinger) UnaryCall(ctx context.Context, req *grpc_testing.SimpleRequest) (*grpc_testing.SimpleResponse, error) {
+	return ip.unaryCall(ctx, req)
 }
 
-func (ip *interceptPinger) PingList(req *testservice.PingRequest, stream testservice.TestService_PingListServer) error {
-	return ip.pingList(req, stream)
+func (ip *interceptPinger) StreamingOutputCall(req *grpc_testing.StreamingOutputCallRequest, stream grpc_testing.TestService_StreamingOutputCallServer) error {
+	return ip.streamingOutputCall(req, stream)
 }