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 }