github.com/jhump/protoreflect@v1.16.0/dynamic/grpcdynamic/stub_test.go (about)

     1  package grpcdynamic
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"io"
     7  	"net"
     8  	"os"
     9  	"testing"
    10  
    11  	"github.com/golang/protobuf/proto"
    12  	"google.golang.org/grpc"
    13  
    14  	"github.com/jhump/protoreflect/desc"
    15  	"github.com/jhump/protoreflect/dynamic"
    16  	"github.com/jhump/protoreflect/grpcreflect"
    17  	grpc_testing "github.com/jhump/protoreflect/internal/testprotos/grpc"
    18  	"github.com/jhump/protoreflect/internal/testutil"
    19  )
    20  
    21  var unaryMd *desc.MethodDescriptor
    22  var clientStreamingMd *desc.MethodDescriptor
    23  var serverStreamingMd *desc.MethodDescriptor
    24  var bidiStreamingMd *desc.MethodDescriptor
    25  var stub Stub
    26  
    27  func TestMain(m *testing.M) {
    28  	code := 1
    29  	defer func() {
    30  		p := recover()
    31  		if p != nil {
    32  			fmt.Fprintf(os.Stderr, "PANIC: %v\n", p)
    33  		}
    34  		os.Exit(code)
    35  	}()
    36  
    37  	// Start up a server on an ephemeral port
    38  	l, err := net.Listen("tcp", "127.0.0.1:0")
    39  	if err != nil {
    40  		panic(fmt.Sprintf("Failed to listen to port: %s", err.Error()))
    41  	}
    42  	svr := grpc.NewServer()
    43  	grpc_testing.RegisterTestServiceServer(svr, testutil.TestService{})
    44  	go svr.Serve(l)
    45  	defer svr.Stop()
    46  
    47  	svcs, err := grpcreflect.LoadServiceDescriptors(svr)
    48  	if err != nil {
    49  		panic(fmt.Sprintf("Failed to load service descriptor: %s", err.Error()))
    50  	}
    51  	sd := svcs["grpc.testing.TestService"]
    52  	unaryMd = sd.FindMethodByName("UnaryCall")
    53  	clientStreamingMd = sd.FindMethodByName("StreamingInputCall")
    54  	serverStreamingMd = sd.FindMethodByName("StreamingOutputCall")
    55  	bidiStreamingMd = sd.FindMethodByName("FullDuplexCall")
    56  
    57  	// Start up client that talks to the same port
    58  	cc, err := grpc.Dial(l.Addr().String(), grpc.WithInsecure())
    59  	if err != nil {
    60  		panic(fmt.Sprintf("Failed to create client to %s: %s", l.Addr().String(), err.Error()))
    61  	}
    62  	defer cc.Close()
    63  
    64  	stub = NewStub(cc)
    65  
    66  	code = m.Run()
    67  }
    68  
    69  var payload = &grpc_testing.Payload{
    70  	Type: grpc_testing.PayloadType_RANDOM,
    71  	Body: []byte{3, 14, 159, 2, 65, 35, 9},
    72  }
    73  
    74  func TestUnaryRpc(t *testing.T) {
    75  	resp, err := stub.InvokeRpc(context.Background(), unaryMd, &grpc_testing.SimpleRequest{Payload: payload})
    76  	testutil.Ok(t, err, "Failed to invoke unary RPC")
    77  	dm := resp.(*dynamic.Message)
    78  	fd := dm.GetMessageDescriptor().FindFieldByName("payload")
    79  	p := dm.GetField(fd)
    80  	testutil.Require(t, dynamic.MessagesEqual(p.(proto.Message), payload), "Incorrect payload returned from RPC: %v != %v", p, payload)
    81  }
    82  
    83  func TestClientStreamingRpc(t *testing.T) {
    84  	cs, err := stub.InvokeRpcClientStream(context.Background(), clientStreamingMd)
    85  	testutil.Ok(t, err, "Failed to invoke client-streaming RPC")
    86  	req := &grpc_testing.StreamingInputCallRequest{Payload: payload}
    87  	for i := 0; i < 3; i++ {
    88  		err = cs.SendMsg(req)
    89  		testutil.Ok(t, err, "Failed to send request message")
    90  	}
    91  	resp, err := cs.CloseAndReceive()
    92  	testutil.Ok(t, err, "Failed to receive response")
    93  	dm := resp.(*dynamic.Message)
    94  	fd := dm.GetMessageDescriptor().FindFieldByName("aggregated_payload_size")
    95  	sz := dm.GetField(fd)
    96  	expectedSz := 3 * len(payload.Body)
    97  	testutil.Eq(t, expectedSz, int(sz.(int32)), "Incorrect response returned from RPC")
    98  }
    99  
   100  func TestServerStreamingRpc(t *testing.T) {
   101  	ss, err := stub.InvokeRpcServerStream(context.Background(), serverStreamingMd, &grpc_testing.StreamingOutputCallRequest{
   102  		Payload: payload,
   103  		ResponseParameters: []*grpc_testing.ResponseParameters{
   104  			{}, {}, {}, // three entries means we'll get back three responses
   105  		},
   106  	})
   107  	testutil.Ok(t, err, "Failed to invoke server-streaming RPC")
   108  	for i := 0; i < 3; i++ {
   109  		resp, err := ss.RecvMsg()
   110  		testutil.Ok(t, err, "Failed to receive response message")
   111  		dm := resp.(*dynamic.Message)
   112  		fd := dm.GetMessageDescriptor().FindFieldByName("payload")
   113  		p := dm.GetField(fd)
   114  		testutil.Require(t, dynamic.MessagesEqual(p.(proto.Message), payload), "Incorrect payload returned from RPC: %v != %v", p, payload)
   115  	}
   116  	_, err = ss.RecvMsg()
   117  	testutil.Eq(t, io.EOF, err, "Incorrect number of messages in response")
   118  }
   119  
   120  func TestBidiStreamingRpc(t *testing.T) {
   121  	bds, err := stub.InvokeRpcBidiStream(context.Background(), bidiStreamingMd)
   122  	testutil.Ok(t, err)
   123  	req := &grpc_testing.StreamingOutputCallRequest{Payload: payload}
   124  	for i := 0; i < 3; i++ {
   125  		err = bds.SendMsg(req)
   126  		testutil.Ok(t, err, "Failed to send request message")
   127  		resp, err := bds.RecvMsg()
   128  		testutil.Ok(t, err, "Failed to receive response message")
   129  		dm := resp.(*dynamic.Message)
   130  		fd := dm.GetMessageDescriptor().FindFieldByName("payload")
   131  		p := dm.GetField(fd)
   132  		testutil.Require(t, dynamic.MessagesEqual(p.(proto.Message), payload), "Incorrect payload returned from RPC: %v != %v", p, payload)
   133  	}
   134  	err = bds.CloseSend()
   135  	testutil.Ok(t, err, "Failed to receive response")
   136  	_, err = bds.RecvMsg()
   137  	testutil.Eq(t, io.EOF, err, "Incorrect number of messages in response")
   138  }