func TestUnionFromWireInconsistencies(t *testing.T) {
tests := []struct {
desc string
input wire.Value
success *tu.Document
failure string
}{
{
desc: "multiple recognized fields",
input: wire.NewValueStruct(wire.Struct{Fields: []wire.Field{
{ID: 1, Value: wire.NewValueBinary([]byte{1, 2, 3})},
{ID: 2, Value: wire.NewValueString("hello")},
}}),
failure: "should have exactly one field: got 2 fields",
},
{
desc: "recognized and unrecognized fields",
input: wire.NewValueStruct(wire.Struct{Fields: []wire.Field{
{ID: 1, Value: wire.NewValueBinary([]byte{1, 2, 3})},
{ID: 3, Value: wire.NewValueString("hello")},
}}),
success: &tu.Document{Pdf: []byte{1, 2, 3}},
},
{
desc: "recognized field duplicates",
input: wire.NewValueStruct(wire.Struct{Fields: []wire.Field{
{ID: 1, Value: wire.NewValueBinary([]byte{1, 2, 3})},
{ID: 1, Value: wire.NewValueBinary([]byte{4, 5, 6})},
}}),
success: &tu.Document{Pdf: []byte{4, 5, 6}},
},
{
desc: "only unrecognized fields",
input: wire.NewValueStruct(wire.Struct{Fields: []wire.Field{
{ID: 2, Value: wire.NewValueI32(42)}, // also a type mismatch
{ID: 3, Value: wire.NewValueString("hello")},
}}),
failure: "should have exactly one field: got 0 fields",
},
{
desc: "no fields",
input: wire.NewValueStruct(wire.Struct{}),
failure: "should have exactly one field: got 0 fields",
},
}
for _, tt := range tests {
var o tu.Document
err := o.FromWire(tt.input)
if tt.success != nil {
if assert.NoError(t, err, tt.desc) {
assert.Equal(t, tt.success, &o, tt.desc)
}
} else {
if assert.Error(t, err, tt.desc) {
assert.Contains(t, err.Error(), tt.failure, tt.desc)
}
}
}
}
func (v *KeyValue_SetValue_Args) ToWire() (wire.Value, error) {
var (
fields [2]wire.Field
i int = 0
w wire.Value
err error
)
if v.Key != nil {
w, err = wire.NewValueString(*(v.Key)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
}
if v.Value != nil {
w, err = wire.NewValueString(*(v.Value)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *ThriftTest_TestMultiException_Args) ToWire() (wire.Value, error) {
var (
fields [2]wire.Field
i int = 0
w wire.Value
err error
)
if v.Arg0 != nil {
w, err = wire.NewValueString(*(v.Arg0)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
}
if v.Arg1 != nil {
w, err = wire.NewValueString(*(v.Arg1)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *Function) ToWire() (wire.Value, error) {
var (
fields [6]wire.Field
i int = 0
w wire.Value
err error
)
w, err = wire.NewValueString(v.Name), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
w, err = wire.NewValueString(v.ThriftName), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
if v.Arguments == nil {
return w, errors.New("field Arguments of Function is required")
}
w, err = wire.NewValueList(_List_Argument_ValueList(v.Arguments)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 3, Value: w}
i++
if v.ReturnType != nil {
w, err = v.ReturnType.ToWire()
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 4, Value: w}
i++
}
if v.Exceptions != nil {
w, err = wire.NewValueList(_List_Argument_ValueList(v.Exceptions)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 5, Value: w}
i++
}
if v.OneWay != nil {
w, err = wire.NewValueBool(*(v.OneWay)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 6, Value: w}
i++
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *PrimitiveRequiredStruct) ToWire() (wire.Value, error) {
var (
fields [8]wire.Field
i int = 0
w wire.Value
err error
)
w, err = wire.NewValueBool(v.BoolField), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
w, err = wire.NewValueI8(v.ByteField), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
w, err = wire.NewValueI16(v.Int16Field), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 3, Value: w}
i++
w, err = wire.NewValueI32(v.Int32Field), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 4, Value: w}
i++
w, err = wire.NewValueI64(v.Int64Field), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 5, Value: w}
i++
w, err = wire.NewValueDouble(v.DoubleField), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 6, Value: w}
i++
w, err = wire.NewValueString(v.StringField), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 7, Value: w}
i++
if v.BinaryField == nil {
return w, errors.New("field BinaryField of PrimitiveRequiredStruct is required")
}
w, err = wire.NewValueBinary(v.BinaryField), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 8, Value: w}
i++
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *KeyValue_GetValue_Result) ToWire() (wire.Value, error) {
var (
fields [2]wire.Field
i int = 0
w wire.Value
err error
)
if v.Success != nil {
w, err = wire.NewValueString(*(v.Success)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 0, Value: w}
i++
}
if v.DoesNotExist != nil {
w, err = v.DoesNotExist.ToWire()
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
}
if i != 1 {
return wire.Value{}, fmt.Errorf("KeyValue_GetValue_Result should have exactly one field: got %v fields", i)
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *Document) ToWire() (wire.Value, error) {
var (
fields [2]wire.Field
i int = 0
w wire.Value
err error
)
if v.Pdf != nil {
w, err = v.Pdf.ToWire()
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
}
if v.PlainText != nil {
w, err = wire.NewValueString(*(v.PlainText)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
}
if i != 1 {
return wire.Value{}, fmt.Errorf("Document should have exactly one field: got %v fields", i)
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *UnionCollision2) ToWire() (wire.Value, error) {
var (
fields [2]wire.Field
i int = 0
w wire.Value
err error
)
if v.CollisionField != nil {
w, err = wire.NewValueBool(*(v.CollisionField)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
}
if v.CollisionField2 != nil {
w, err = wire.NewValueString(*(v.CollisionField2)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
}
if i != 1 {
return wire.Value{}, fmt.Errorf("UnionCollision2 should have exactly one field: got %v fields", i)
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *TApplicationException) ToWire() (wire.Value, error) {
var (
fields [2]wire.Field
i int = 0
w wire.Value
err error
)
if v.Message != nil {
w, err = wire.NewValueString(*(v.Message)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
}
if v.Type != nil {
w, err = v.Type.ToWire()
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func TestStructFromWireUnrecognizedField(t *testing.T) {
tests := []struct {
desc string
give wire.Value
want ts.ContactInfo
wantError string
}{
{
desc: "unknown field",
give: wire.NewValueStruct(wire.Struct{Fields: []wire.Field{
{ID: 1, Value: wire.NewValueString("foo")},
{ID: 2, Value: wire.NewValueI32(42)},
}}),
want: ts.ContactInfo{EmailAddress: "foo"},
},
{
desc: "only unknown field",
give: wire.NewValueStruct(wire.Struct{Fields: []wire.Field{
{ID: 2, Value: wire.NewValueString("bar")},
}}),
wantError: "field EmailAddress of ContactInfo is required",
},
{
desc: "wrong type for recognized field",
give: wire.NewValueStruct(wire.Struct{Fields: []wire.Field{
{ID: 1, Value: wire.NewValueI32(42)},
{ID: 1, Value: wire.NewValueString("foo")},
}}),
want: ts.ContactInfo{EmailAddress: "foo"},
},
}
for _, tt := range tests {
var o ts.ContactInfo
err := o.FromWire(tt.give)
if tt.wantError != "" {
if assert.Error(t, err, tt.desc) {
assert.Contains(t, err.Error(), tt.wantError)
}
} else {
if assert.NoError(t, err, tt.desc) {
assert.Equal(t, tt.want, o)
}
}
}
}
func (m _Map_String_String_MapItemList) ForEach(f func(wire.MapItem) error) error {
for k, v := range m {
kw, err := wire.NewValueString(k), error(nil)
if err != nil {
return err
}
vw, err := wire.NewValueString(v), error(nil)
if err != nil {
return err
}
err = f(wire.MapItem{Key: kw, Value: vw})
if err != nil {
return err
}
}
return nil
}
func (v *Service) ToWire() (wire.Value, error) {
var (
fields [5]wire.Field
i int = 0
w wire.Value
err error
)
w, err = wire.NewValueString(v.Name), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 7, Value: w}
i++
w, err = wire.NewValueString(v.ThriftName), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
if v.ParentID != nil {
w, err = v.ParentID.ToWire()
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 4, Value: w}
i++
}
if v.Functions == nil {
return w, errors.New("field Functions of Service is required")
}
w, err = wire.NewValueList(_List_Function_ValueList(v.Functions)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 5, Value: w}
i++
w, err = v.ModuleID.ToWire()
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 6, Value: w}
i++
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func TestTypedefString(t *testing.T) {
tests := []struct {
x td.State
v wire.Value
}{
{
td.State("hello"),
wire.NewValueString("hello"),
},
{
td.State("world"),
wire.NewValueString("world"),
},
}
for _, tt := range tests {
assertRoundTrip(t, &tt.x, tt.v, "State")
}
}
func (v *Module) ToWire() (wire.Value, error) {
var (
fields [2]wire.Field
i int = 0
w wire.Value
err error
)
w, err = wire.NewValueString(v.ImportPath), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
w, err = wire.NewValueString(v.Directory), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *ArbitraryValue) ToWire() (wire.Value, error) {
var (
fields [5]wire.Field
i int = 0
w wire.Value
err error
)
if v.BoolValue != nil {
w, err = wire.NewValueBool(*(v.BoolValue)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
}
if v.Int64Value != nil {
w, err = wire.NewValueI64(*(v.Int64Value)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
}
if v.StringValue != nil {
w, err = wire.NewValueString(*(v.StringValue)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 3, Value: w}
i++
}
if v.ListValue != nil {
w, err = wire.NewValueList(_List_ArbitraryValue_ValueList(v.ListValue)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 4, Value: w}
i++
}
if v.MapValue != nil {
w, err = wire.NewValueMap(_Map_String_ArbitraryValue_MapItemList(v.MapValue)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 5, Value: w}
i++
}
if i != 1 {
return wire.Value{}, fmt.Errorf("ArbitraryValue should have exactly one field: got %v fields", i)
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v _List_String_ValueList) ForEach(f func(wire.Value) error) error {
for _, x := range v {
w, err := wire.NewValueString(x), error(nil)
if err != nil {
return err
}
err = f(w)
if err != nil {
return err
}
}
return nil
}
func (v *HandshakeResponse) ToWire() (wire.Value, error) {
var (
fields [4]wire.Field
i int = 0
w wire.Value
err error
)
w, err = wire.NewValueString(v.Name), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
w, err = wire.NewValueI32(v.APIVersion), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
if v.Features == nil {
return w, errors.New("field Features of HandshakeResponse is required")
}
w, err = wire.NewValueList(_List_Feature_ValueList(v.Features)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 3, Value: w}
i++
if v.LibraryVersion != nil {
w, err = wire.NewValueString(*(v.LibraryVersion)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 4, Value: w}
i++
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *DoesNotExistException) ToWire() (wire.Value, error) {
var (
fields [2]wire.Field
i int = 0
w wire.Value
err error
)
w, err = wire.NewValueString(v.Key), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
if v.Error2 != nil {
w, err = wire.NewValueString(*(v.Error2)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *Pong) ToWire() (wire.Value, error) {
var (
fields [1]wire.Field
i int = 0
w wire.Value
err error
)
w, err = wire.NewValueString(v.Boop), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *ContactInfo) ToWire() (wire.Value, error) {
var (
fields [1]wire.Field
i int = 0
w wire.Value
err error
)
w, err = wire.NewValueString(v.EmailAddress), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *ThriftTest_TestString_Args) ToWire() (wire.Value, error) {
var (
fields [1]wire.Field
i int = 0
w wire.Value
err error
)
if v.Thing != nil {
w, err = wire.NewValueString(*(v.Thing)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *Oneway_Echo_Args) ToWire() (wire.Value, error) {
var (
fields [1]wire.Field
i int = 0
w wire.Value
err error
)
if v.Token != nil {
w, err = wire.NewValueString(*(v.Token)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *InternalError) ToWire() (wire.Value, error) {
var (
fields [1]wire.Field
i int = 0
w wire.Value
err error
)
if v.Message != nil {
w, err = wire.NewValueString(*(v.Message)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *ThriftTest_TestString_Result) ToWire() (wire.Value, error) {
var (
fields [1]wire.Field
i int = 0
w wire.Value
err error
)
if v.Success != nil {
w, err = wire.NewValueString(*(v.Success)), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 0, Value: w}
i++
}
if i != 1 {
return wire.Value{}, fmt.Errorf("ThriftTest_TestString_Result should have exactly one field: got %v fields", i)
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func TestBasicException(t *testing.T) {
tests := []struct {
s tx.DoesNotExistException
v wire.Value
}{
{
tx.DoesNotExistException{Key: "foo"},
wire.NewValueStruct(wire.Struct{Fields: []wire.Field{
{ID: 1, Value: wire.NewValueString("foo")},
}}),
},
}
for _, tt := range tests {
assertRoundTrip(t, &tt.s, tt.v, "DoesNotExistException")
err := error(&tt.s) // should implement the error interface
assert.Equal(t, "DoesNotExistException{Key: foo}", err.Error())
}
}
func (m _Map_String_Binary_MapItemList) ForEach(f func(wire.MapItem) error) error {
for k, v := range m {
if v == nil {
return fmt.Errorf("invalid [%v]: value is nil", k)
}
kw, err := wire.NewValueString(k), error(nil)
if err != nil {
return err
}
vw, err := wire.NewValueBinary(v), error(nil)
if err != nil {
return err
}
err = f(wire.MapItem{Key: kw, Value: vw})
if err != nil {
return err
}
}
return nil
}
func (v *EchoResponse) ToWire() (wire.Value, error) {
var (
fields [2]wire.Field
i int = 0
w wire.Value
err error
)
w, err = wire.NewValueString(v.Message), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
w, err = wire.NewValueI16(v.Count), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (v *StructCollision2) ToWire() (wire.Value, error) {
var (
fields [2]wire.Field
i int = 0
w wire.Value
err error
)
w, err = wire.NewValueBool(v.CollisionField), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
w, err = wire.NewValueString(v.CollisionField2), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}
func (m _Map_Binary_String_MapItemList) ForEach(f func(wire.MapItem) error) error {
for _, i := range m {
k := i.Key
v := i.Value
if k == nil {
return fmt.Errorf("invalid map key: value is nil")
}
kw, err := wire.NewValueBinary(k), error(nil)
if err != nil {
return err
}
vw, err := wire.NewValueString(v), error(nil)
if err != nil {
return err
}
err = f(wire.MapItem{Key: kw, Value: vw})
if err != nil {
return err
}
}
return nil
}
func (v *User) ToWire() (wire.Value, error) {
var (
fields [2]wire.Field
i int = 0
w wire.Value
err error
)
w, err = wire.NewValueString(v.Name), error(nil)
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 1, Value: w}
i++
if v.Contact != nil {
w, err = v.Contact.ToWire()
if err != nil {
return w, err
}
fields[i] = wire.Field{ID: 2, Value: w}
i++
}
return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}