// ToTransportRequest fills the given transport request with information from
// the given ReqMeta.
func ToTransportRequest(reqMeta yarpc.CallReqMeta, req *transport.Request) {
if reqMeta == nil {
return
}
req.Procedure = reqMeta.GetProcedure()
req.ShardKey = reqMeta.GetShardKey()
req.RoutingKey = reqMeta.GetRoutingKey()
req.RoutingDelegate = reqMeta.GetRoutingDelegate()
req.Headers = transport.Headers(reqMeta.GetHeaders())
}
func TestCall(t *testing.T) {
mockCtrl := gomock.NewController(t)
defer mockCtrl.Finish()
ctx := context.Background()
caller := "caller"
service := "service"
tests := []struct {
procedure string
headers yarpc.Headers
body []byte
responseBody [][]byte
want []byte
wantErr string
wantHeaders yarpc.Headers
}{
{
procedure: "foo",
body: []byte{1, 2, 3},
responseBody: [][]byte{{4}, {5}, {6}},
want: []byte{4, 5, 6},
},
{
procedure: "bar",
body: []byte{1, 2, 3},
responseBody: [][]byte{{4}, {5}, nil, {6}},
wantErr: "error set by user",
},
{
procedure: "headers",
headers: yarpc.NewHeaders().With("x", "y"),
body: []byte{},
responseBody: [][]byte{},
want: []byte{},
wantHeaders: yarpc.NewHeaders().With("a", "b"),
},
}
for _, tt := range tests {
outbound := transporttest.NewMockUnaryOutbound(mockCtrl)
client := New(channel.MultiOutbound(caller, service,
transport.Outbounds{
Unary: outbound,
}))
writer, responseBody := testreader.ChunkReader()
for _, chunk := range tt.responseBody {
writer <- chunk
}
close(writer)
outbound.EXPECT().Call(gomock.Any(),
transporttest.NewRequestMatcher(t,
&transport.Request{
Caller: caller,
Service: service,
Procedure: tt.procedure,
Headers: transport.Headers(tt.headers),
Encoding: Encoding,
Body: bytes.NewReader(tt.body),
}),
).Return(
&transport.Response{
Body: ioutil.NopCloser(responseBody),
Headers: transport.Headers(tt.wantHeaders),
}, nil)
resBody, res, err := client.Call(
ctx,
yarpc.NewReqMeta().Procedure(tt.procedure).Headers(tt.headers),
tt.body)
if tt.wantErr != "" {
if assert.Error(t, err) {
assert.Equal(t, err.Error(), tt.wantErr)
}
} else {
if assert.NoError(t, err) {
assert.Equal(t, tt.want, resBody)
assert.Equal(t, tt.wantHeaders, res.Headers())
}
}
}
}
func TestCallOneway(t *testing.T) {
mockCtrl := gomock.NewController(t)
defer mockCtrl.Finish()
ctx := context.Background()
caller := "caller"
service := "service"
tests := []struct {
procedure string
headers yarpc.Headers
body []byte
wantErr string
wantHeaders yarpc.Headers
}{
{
procedure: "foo",
body: []byte{1, 2, 3},
},
{
procedure: "headers",
headers: yarpc.NewHeaders().With("x", "y"),
body: []byte{},
},
}
for _, tt := range tests {
outbound := transporttest.NewMockOnewayOutbound(mockCtrl)
client := New(channel.MultiOutbound(caller, service,
transport.Outbounds{
Oneway: outbound,
}))
outbound.EXPECT().CallOneway(gomock.Any(),
transporttest.NewRequestMatcher(t,
&transport.Request{
Caller: caller,
Service: service,
Procedure: tt.procedure,
Headers: transport.Headers(tt.headers),
Encoding: Encoding,
Body: bytes.NewReader(tt.body),
}),
).Return(&successAck{}, nil)
ack, err := client.CallOneway(
ctx,
yarpc.NewReqMeta().Procedure(tt.procedure).Headers(tt.headers),
tt.body)
if tt.wantErr != "" {
if assert.Error(t, err) {
assert.Equal(t, err.Error(), tt.wantErr)
}
} else {
assert.Equal(t, "success", ack.String())
}
}
}
// ToTransportResponseWriter fills the given transport response with
// information from the given ResMeta.
func ToTransportResponseWriter(resMeta yarpc.ResMeta, w transport.ResponseWriter) {
if hs := resMeta.GetHeaders(); hs.Len() > 0 {
w.AddHeaders(transport.Headers(resMeta.GetHeaders()))
}
}
func TestCall(t *testing.T) {
mockCtrl := gomock.NewController(t)
defer mockCtrl.Finish()
ctx := context.Background()
caller := "caller"
service := "service"
tests := []struct {
procedure string
headers yarpc.Headers
body interface{}
encodedRequest string
encodedResponse string
// whether the outbound receives the request
noCall bool
// Either want, or wantType and wantErr must be set.
want interface{} // expected response body
wantHeaders yarpc.Headers
wantType reflect.Type // type of response body
wantErr string // error message
}{
{
procedure: "foo",
body: []string{"foo", "bar"},
encodedRequest: `["foo","bar"]`,
encodedResponse: `{"success": true}`,
want: map[string]interface{}{"success": true},
},
{
procedure: "bar",
body: []int{1, 2, 3},
encodedRequest: `[1,2,3]`,
encodedResponse: `invalid JSON`,
wantType: _typeOfMapInterface,
wantErr: `failed to decode "json" response body for procedure "bar" of service "service"`,
},
{
procedure: "baz",
body: func() {}, // funcs cannot be json.Marshal'ed
noCall: true,
wantType: _typeOfMapInterface,
wantErr: `failed to encode "json" request body for procedure "baz" of service "service"`,
},
{
procedure: "requestHeaders",
headers: yarpc.NewHeaders().With("user-id", "42"),
body: map[string]interface{}{},
encodedRequest: "{}",
encodedResponse: "{}",
want: map[string]interface{}{},
wantHeaders: yarpc.NewHeaders().With("success", "true"),
},
}
for _, tt := range tests {
outbound := transporttest.NewMockUnaryOutbound(mockCtrl)
client := New(channel.MultiOutbound(caller, service,
transport.Outbounds{
Unary: outbound,
}))
if !tt.noCall {
outbound.EXPECT().Call(gomock.Any(),
transporttest.NewRequestMatcher(t,
&transport.Request{
Caller: caller,
Service: service,
Procedure: tt.procedure,
Encoding: Encoding,
Headers: transport.Headers(tt.headers),
Body: bytes.NewReader([]byte(tt.encodedRequest)),
}),
).Return(
&transport.Response{
Body: ioutil.NopCloser(
bytes.NewReader([]byte(tt.encodedResponse))),
Headers: transport.Headers(tt.wantHeaders),
}, nil)
}
var wantType reflect.Type
if tt.want != nil {
wantType = reflect.TypeOf(tt.want)
} else {
require.NotNil(t, tt.wantType, "wantType is required if want is nil")
wantType = tt.wantType
}
resBody := reflect.Zero(wantType).Interface()
res, err := client.Call(
ctx,
yarpc.NewReqMeta().Procedure(tt.procedure).Headers(tt.headers),
tt.body,
&resBody,
)
if tt.wantErr != "" {
if assert.Error(t, err) {
assert.Contains(t, err.Error(), tt.wantErr)
}
} else {
if assert.NoError(t, err) {
assert.Equal(t, tt.wantHeaders, res.Headers())
assert.Equal(t, tt.want, resBody)
}
}
}
}
func TestCallOneway(t *testing.T) {
mockCtrl := gomock.NewController(t)
defer mockCtrl.Finish()
ctx := context.Background()
caller := "caller"
service := "service"
tests := []struct {
procedure string
headers yarpc.Headers
body interface{}
encodedRequest string
// whether the outbound receives the request
noCall bool
wantErr string // error message
}{
{
procedure: "foo",
body: []string{"foo", "bar"},
encodedRequest: `["foo","bar"]` + "\n",
},
{
procedure: "baz",
body: func() {}, // funcs cannot be json.Marshal'ed
noCall: true,
wantErr: `failed to encode "json" request body for procedure "baz" of service "service"`,
},
{
procedure: "requestHeaders",
headers: yarpc.NewHeaders().With("user-id", "42"),
body: map[string]interface{}{},
encodedRequest: "{}\n",
},
}
for _, tt := range tests {
outbound := transporttest.NewMockOnewayOutbound(mockCtrl)
client := New(channel.MultiOutbound(caller, service,
transport.Outbounds{
Oneway: outbound,
}))
if !tt.noCall {
reqMatcher := transporttest.NewRequestMatcher(t,
&transport.Request{
Caller: caller,
Service: service,
Procedure: tt.procedure,
Encoding: Encoding,
Headers: transport.Headers(tt.headers),
Body: bytes.NewReader([]byte(tt.encodedRequest)),
})
if tt.wantErr != "" {
outbound.
EXPECT().
CallOneway(gomock.Any(), reqMatcher).
Return(nil, errors.New(tt.wantErr))
} else {
outbound.
EXPECT().
CallOneway(gomock.Any(), reqMatcher).
Return(&successAck{}, nil)
}
}
ack, err := client.CallOneway(
ctx,
yarpc.NewReqMeta().Procedure(tt.procedure).Headers(tt.headers),
tt.body)
if tt.wantErr != "" {
assert.Error(t, err)
assert.Contains(t, err.Error(), tt.wantErr)
} else {
assert.NoError(t, err, "")
assert.Equal(t, ack.String(), "success")
}
}
}