You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
188 lines
5.4 KiB
188 lines
5.4 KiB
package jsontypes_test
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/tendermint/tendermint/internal/jsontypes"
|
|
)
|
|
|
|
type testPtrType struct {
|
|
Field string `json:"field"`
|
|
}
|
|
|
|
func (*testPtrType) TypeTag() string { return "test/PointerType" }
|
|
func (t *testPtrType) Value() string { return t.Field }
|
|
|
|
type testBareType struct {
|
|
Field string `json:"field"`
|
|
}
|
|
|
|
func (testBareType) TypeTag() string { return "test/BareType" }
|
|
func (t testBareType) Value() string { return t.Field }
|
|
|
|
type fielder interface{ Value() string }
|
|
|
|
func TestRoundTrip(t *testing.T) {
|
|
t.Run("MustRegister_ok", func(t *testing.T) {
|
|
defer func() {
|
|
if x := recover(); x != nil {
|
|
t.Fatalf("Registration panicked: %v", x)
|
|
}
|
|
}()
|
|
jsontypes.MustRegister((*testPtrType)(nil))
|
|
jsontypes.MustRegister(testBareType{})
|
|
})
|
|
|
|
t.Run("MustRegister_fail", func(t *testing.T) {
|
|
defer func() {
|
|
if x := recover(); x != nil {
|
|
t.Logf("Got expected panic: %v", x)
|
|
}
|
|
}()
|
|
jsontypes.MustRegister((*testPtrType)(nil))
|
|
t.Fatal("Registration should not have succeeded")
|
|
})
|
|
|
|
t.Run("Marshal_nilTagged", func(t *testing.T) {
|
|
bits, err := jsontypes.Marshal(nil)
|
|
if err != nil {
|
|
t.Fatalf("Marshal failed: %v", err)
|
|
}
|
|
if got := string(bits); got != "null" {
|
|
t.Errorf("Marshal nil: got %#q, want null", got)
|
|
}
|
|
})
|
|
|
|
t.Run("RoundTrip_pointerType", func(t *testing.T) {
|
|
const wantEncoded = `{"type":"test/PointerType","value":{"field":"hello"}}`
|
|
|
|
obj := testPtrType{Field: "hello"}
|
|
bits, err := jsontypes.Marshal(&obj)
|
|
if err != nil {
|
|
t.Fatalf("Marshal %T failed: %v", obj, err)
|
|
}
|
|
if got := string(bits); got != wantEncoded {
|
|
t.Errorf("Marshal %T: got %#q, want %#q", obj, got, wantEncoded)
|
|
}
|
|
|
|
var cmp testPtrType
|
|
if err := jsontypes.Unmarshal(bits, &cmp); err != nil {
|
|
t.Errorf("Unmarshal %#q failed: %v", string(bits), err)
|
|
}
|
|
if obj != cmp {
|
|
t.Errorf("Unmarshal %#q: got %+v, want %+v", string(bits), cmp, obj)
|
|
}
|
|
})
|
|
|
|
t.Run("RoundTrip_bareType", func(t *testing.T) {
|
|
const wantEncoded = `{"type":"test/BareType","value":{"field":"hello"}}`
|
|
|
|
obj := testBareType{Field: "hello"}
|
|
bits, err := jsontypes.Marshal(&obj)
|
|
if err != nil {
|
|
t.Fatalf("Marshal %T failed: %v", obj, err)
|
|
}
|
|
if got := string(bits); got != wantEncoded {
|
|
t.Errorf("Marshal %T: got %#q, want %#q", obj, got, wantEncoded)
|
|
}
|
|
|
|
var cmp testBareType
|
|
if err := jsontypes.Unmarshal(bits, &cmp); err != nil {
|
|
t.Errorf("Unmarshal %#q failed: %v", string(bits), err)
|
|
}
|
|
if obj != cmp {
|
|
t.Errorf("Unmarshal %#q: got %+v, want %+v", string(bits), cmp, obj)
|
|
}
|
|
})
|
|
|
|
t.Run("Unmarshal_nilPointer", func(t *testing.T) {
|
|
var obj *testBareType
|
|
|
|
// Unmarshaling to a nil pointer target should report an error.
|
|
if err := jsontypes.Unmarshal([]byte(`null`), obj); err == nil {
|
|
t.Errorf("Unmarshal nil: got %+v, wanted error", obj)
|
|
} else {
|
|
t.Logf("Unmarshal correctly failed: %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("Unmarshal_bareType", func(t *testing.T) {
|
|
const want = "foobar"
|
|
const input = `{"type":"test/BareType","value":{"field":"` + want + `"}}`
|
|
|
|
var obj testBareType
|
|
if err := jsontypes.Unmarshal([]byte(input), &obj); err != nil {
|
|
t.Fatalf("Unmarshal failed: %v", err)
|
|
}
|
|
if obj.Field != want {
|
|
t.Errorf("Unmarshal result: got %q, want %q", obj.Field, want)
|
|
}
|
|
})
|
|
|
|
t.Run("Unmarshal_bareType_interface", func(t *testing.T) {
|
|
const want = "foobar"
|
|
const input = `{"type":"test/BareType","value":{"field":"` + want + `"}}`
|
|
|
|
var obj fielder
|
|
if err := jsontypes.Unmarshal([]byte(input), &obj); err != nil {
|
|
t.Fatalf("Unmarshal failed: %v", err)
|
|
}
|
|
if got := obj.Value(); got != want {
|
|
t.Errorf("Unmarshal result: got %q, want %q", got, want)
|
|
}
|
|
})
|
|
|
|
t.Run("Unmarshal_pointerType", func(t *testing.T) {
|
|
const want = "bazquux"
|
|
const input = `{"type":"test/PointerType","value":{"field":"` + want + `"}}`
|
|
|
|
var obj testPtrType
|
|
if err := jsontypes.Unmarshal([]byte(input), &obj); err != nil {
|
|
t.Fatalf("Unmarshal failed: %v", err)
|
|
}
|
|
if obj.Field != want {
|
|
t.Errorf("Unmarshal result: got %q, want %q", obj.Field, want)
|
|
}
|
|
})
|
|
|
|
t.Run("Unmarshal_pointerType_interface", func(t *testing.T) {
|
|
const want = "foobar"
|
|
const input = `{"type":"test/PointerType","value":{"field":"` + want + `"}}`
|
|
|
|
var obj fielder
|
|
if err := jsontypes.Unmarshal([]byte(input), &obj); err != nil {
|
|
t.Fatalf("Unmarshal failed: %v", err)
|
|
}
|
|
if got := obj.Value(); got != want {
|
|
t.Errorf("Unmarshal result: got %q, want %q", got, want)
|
|
}
|
|
})
|
|
|
|
t.Run("Unmarshal_unknownTypeTag", func(t *testing.T) {
|
|
const input = `{"type":"test/Nonesuch","value":null}`
|
|
|
|
// An unregistered type tag in a valid envelope should report an error.
|
|
var obj interface{}
|
|
if err := jsontypes.Unmarshal([]byte(input), &obj); err == nil {
|
|
t.Errorf("Unmarshal: got %+v, wanted error", obj)
|
|
} else {
|
|
t.Logf("Unmarshal correctly failed: %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("Unmarshal_similarTarget", func(t *testing.T) {
|
|
const want = "zootie-zoot-zoot"
|
|
const input = `{"type":"test/PointerType","value":{"field":"` + want + `"}}`
|
|
|
|
// The target has a compatible (i.e., assignable) shape to the registered
|
|
// type. This should work even though it's not the original named type.
|
|
var cmp struct {
|
|
Field string `json:"field"`
|
|
}
|
|
if err := jsontypes.Unmarshal([]byte(input), &cmp); err != nil {
|
|
t.Errorf("Unmarshal %#q failed: %v", input, err)
|
|
} else if cmp.Field != want {
|
|
t.Errorf("Unmarshal result: got %q, want %q", cmp.Field, want)
|
|
}
|
|
})
|
|
}
|