71e9170d05
The server unit test now manually mocks much of the generated code for a given service, including back registration of the service. We avoid having a package-level global descriptor in favor of a closures for the handler dispatch function. Signed-off-by: Stephen J Day <stephen.day@docker.com>
117 lines
2.7 KiB
Go
117 lines
2.7 KiB
Go
package mgrpc
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/gogo/protobuf/proto"
|
|
)
|
|
|
|
const serviceName = "testService"
|
|
|
|
// testingService is our prototype service definition for use in testing the full model.
|
|
//
|
|
// Typically, this is generated. We define it here to ensure that that package
|
|
// primitive has what is required for generated code.
|
|
type testingService interface {
|
|
Test(ctx context.Context, req *testPayload) (*testPayload, error)
|
|
}
|
|
|
|
type testingClient struct {
|
|
client *Client
|
|
}
|
|
|
|
func newTestingClient(client *Client) *testingClient {
|
|
return &testingClient{
|
|
client: client,
|
|
}
|
|
}
|
|
|
|
func (tc *testingClient) Test(ctx context.Context, req *testPayload) (*testPayload, error) {
|
|
resp, err := tc.client.Call(ctx, serviceName, "Test", req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return resp.(*testPayload), nil
|
|
}
|
|
|
|
type testPayload struct {
|
|
Foo string `protobuf:"bytes,1,opt,name=foo,proto3"`
|
|
}
|
|
|
|
func (r *testPayload) Reset() { *r = testPayload{} }
|
|
func (r *testPayload) String() string { return fmt.Sprintf("%+#v", r) }
|
|
func (r *testPayload) ProtoMessage() {}
|
|
|
|
// testingServer is what would be implemented by the user of this package.
|
|
type testingServer struct {
|
|
payload *testPayload
|
|
}
|
|
|
|
func (s *testingServer) Test(ctx context.Context, req *testPayload) (*testPayload, error) {
|
|
return s.payload, nil
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterType((*testPayload)(nil), "testPayload")
|
|
proto.RegisterType((*Request)(nil), "Request")
|
|
proto.RegisterType((*Response)(nil), "Response")
|
|
}
|
|
|
|
func TestServer(t *testing.T) {
|
|
var (
|
|
ctx = context.Background()
|
|
server = NewServer()
|
|
expectedResponse = &testPayload{Foo: "baz"}
|
|
testImpl = &testingServer{payload: expectedResponse}
|
|
)
|
|
|
|
// more mocking of what is generated code. Unlike grpc, we register with a
|
|
// closure so that the descriptor is allocated only on registration.
|
|
registerTestingService := func(srv *Server, svc testingService) error {
|
|
return srv.Register(serviceName, map[string]Handler{
|
|
"Test": HandlerFunc(func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return svc.Test(ctx, req.(*testPayload))
|
|
}),
|
|
})
|
|
}
|
|
|
|
if err := registerTestingService(server, testImpl); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
listener, err := net.Listen("tcp", ":0")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer listener.Close()
|
|
|
|
go server.Serve(listener)
|
|
defer server.Shutdown(ctx)
|
|
|
|
conn, err := net.Dial("tcp", listener.Addr().String())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer conn.Close()
|
|
|
|
client := newTestingClient(NewClient(conn))
|
|
|
|
tp := &testPayload{
|
|
Foo: "bar",
|
|
}
|
|
|
|
resp, err := client.Test(ctx, tp)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(resp, expectedResponse) {
|
|
t.Fatalf("unexpected response: %+#v != %+#v", resp, expectedResponse)
|
|
}
|
|
}
|