129 lines
3.2 KiB
Go
129 lines
3.2 KiB
Go
package jsonrpc2
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestAnyMessage(t *testing.T) {
|
|
tests := map[string]struct {
|
|
request, response, invalid bool
|
|
}{
|
|
// Single messages
|
|
`{}`: {invalid: true},
|
|
`{"foo":"bar"}`: {invalid: true},
|
|
`{"method":"m"}`: {request: true},
|
|
`{"result":123}`: {response: true},
|
|
`{"result":null}`: {response: true},
|
|
`{"error":{"code":456,"message":"m"}}`: {response: true},
|
|
}
|
|
for s, want := range tests {
|
|
var m anyMessage
|
|
if err := json.Unmarshal([]byte(s), &m); err != nil {
|
|
if !want.invalid {
|
|
t.Errorf("%s: error: %v", s, err)
|
|
}
|
|
continue
|
|
}
|
|
if (m.request != nil) != want.request {
|
|
t.Errorf("%s: got request %v, want %v", s, m.request != nil, want.request)
|
|
}
|
|
if (m.response != nil) != want.response {
|
|
t.Errorf("%s: got response %v, want %v", s, m.response != nil, want.response)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRequest_MarshalUnmarshalJSON(t *testing.T) {
|
|
null := json.RawMessage("null")
|
|
obj := json.RawMessage(`{"foo":"bar"}`)
|
|
tests := []struct {
|
|
data []byte
|
|
want Request
|
|
}{
|
|
{
|
|
data: []byte(`{"method":"m","params":{"foo":"bar"},"id":123,"jsonrpc":"2.0"}`),
|
|
want: Request{ID: ID{Num: 123}, Method: "m", Params: &obj},
|
|
},
|
|
{
|
|
data: []byte(`{"method":"m","params":null,"id":123,"jsonrpc":"2.0"}`),
|
|
want: Request{ID: ID{Num: 123}, Method: "m", Params: &null},
|
|
},
|
|
{
|
|
data: []byte(`{"method":"m","id":123,"jsonrpc":"2.0"}`),
|
|
want: Request{ID: ID{Num: 123}, Method: "m", Params: nil},
|
|
},
|
|
}
|
|
for _, test := range tests {
|
|
var got Request
|
|
if err := json.Unmarshal(test.data, &got); err != nil {
|
|
t.Error(err)
|
|
continue
|
|
}
|
|
if !reflect.DeepEqual(got, test.want) {
|
|
t.Errorf("%q: got %+v, want %+v", test.data, got, test.want)
|
|
continue
|
|
}
|
|
data, err := json.Marshal(got)
|
|
if err != nil {
|
|
t.Error(err)
|
|
continue
|
|
}
|
|
if !bytes.Equal(data, test.data) {
|
|
t.Errorf("got JSON %q, want %q", data, test.data)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestResponse_MarshalUnmarshalJSON(t *testing.T) {
|
|
null := json.RawMessage("null")
|
|
obj := json.RawMessage(`{"foo":"bar"}`)
|
|
tests := []struct {
|
|
data []byte
|
|
want Response
|
|
error bool
|
|
}{
|
|
{
|
|
data: []byte(`{"id":123,"result":{"foo":"bar"},"jsonrpc":"2.0"}`),
|
|
want: Response{ID: ID{Num: 123}, Result: &obj},
|
|
},
|
|
{
|
|
data: []byte(`{"id":123,"result":null,"jsonrpc":"2.0"}`),
|
|
want: Response{ID: ID{Num: 123}, Result: &null},
|
|
},
|
|
{
|
|
data: []byte(`{"id":123,"jsonrpc":"2.0"}`),
|
|
want: Response{ID: ID{Num: 123}, Result: nil},
|
|
error: true, // either result or error field must be set
|
|
},
|
|
}
|
|
for _, test := range tests {
|
|
var got Response
|
|
if err := json.Unmarshal(test.data, &got); err != nil {
|
|
t.Error(err)
|
|
continue
|
|
}
|
|
if !reflect.DeepEqual(got, test.want) {
|
|
t.Errorf("%q: got %+v, want %+v", test.data, got, test.want)
|
|
continue
|
|
}
|
|
data, err := json.Marshal(got)
|
|
if err != nil {
|
|
if test.error {
|
|
continue
|
|
}
|
|
t.Error(err)
|
|
continue
|
|
}
|
|
if test.error {
|
|
t.Errorf("%q: expected error", test.data)
|
|
continue
|
|
}
|
|
if !bytes.Equal(data, test.data) {
|
|
t.Errorf("got JSON %q, want %q", data, test.data)
|
|
}
|
|
}
|
|
}
|