Union usability improvements

[ahawtho]

Including a NewXxxUnionTttt and/or SetTttt for each union type that sets the appropriate type enum value would significantly improve usability. Currently, many of the straightforward approaches for setting a non-default value produce panic()'s.

See the end for a strawman for starting discussion.

Schema:

{
  "type": "record",
  "name": "rec",
  "fields": [
    {
      "name": "field1",
      "type": ["null", "string"],
      "default": null
    }
  ]
}

In v10, this produces the following code:

type Rec struct {
    Field1 *Field1Union `json:"field1"`
}
//...
func NewRec() Rec {
    r := Rec{}
    r.Field1 = NewField1Union()

    r.Field1 = nil
    return r
}
//...

type Field1Union struct {
    Null      *types.NullVal
    String    string
    UnionType Field1UnionTypeEnum
}

func NewField1Union() *Field1Union {
    return &Field1Union{}
}
//...
func (_ *Field1Union) SetString(v string)  { panic("Unsupported operation") }

Test code:

func TestCreateRec(t *testing.T) {
    tests := []struct {
        name   string
        create func() structs.Rec
        want   string
    }{
        {
            name: "default struct",
            create: func() structs.Rec {
                return structs.Rec{
                    Field1: &structs.Field1Union{
                        // Default value of Field1UnionType == 0, which is invalid
                        String: "test1",
                    },
                }
            },
            want: "test1",
        },
        {
            name: "NewRec()",
            create: func() structs.Rec {
                r := structs.NewRec()
                // the Field1 struct starts as nil, so any invocations on Field1 panic
                r.Field1.String = "test2"
                return r
            },
            want: "test2",
        },
        {
            name: "NewField1Union()",
            create: func() structs.Rec {
                r := structs.NewRec()
                r.Field1 = structs.NewField1Union()
                // a union returned by NewField1Union() is always invalid due to default enum type
                r.Field1.String = "test3"
                return r
            },
            want: "test3",
        },
        {
            name: "SetString()",
            create: func() structs.Rec {
                r := structs.NewRec()
                r.Field1 = structs.NewField1Union()
                // SetString() is unsupported, so this panics.
                r.Field1.SetString("test4")
                return r
            },
            want: "test4",
        },
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            defer func() {
                e := recover()
                if e != nil {
                    t.Errorf("test panic'd: %v", e)
                }
            }()
            sr := tt.create()
            b := &bytes.Buffer{}
            err := sr.Serialize(b)
            if err != nil {
                t.Errorf("error serializing Rec: %v", err)
            }
            dr, err := structs.DeserializeRec(b)
            if err != nil {
                t.Errorf("error deserializing Rec: %v", err)
            }
            if got := dr.Field1.String; got != tt.want {
                t.Errorf("String() = %v, want %v", got, tt.want)
            }
        })
    }
}

E.g., for the example above, something like the following would improve usability:

func NewField1UnionNull() *Field1Union {
    return nil
}
func NewField1UnionString(v string) *Field1Union {
    return &Field1Union{
        String: v,
        UnionType: Field1UnionTypeEnumString,
    }
}

func (s *Field1Union) SetString(v string)  {
    s.String = v
    s.UnionType = Field1UnionTypeEnumString
}
// SetNull() can't be implemented with current generated code, but if serialization also
// supported an empty union struct, the implementation could be as follows. However, the
// current generated code provides better protection against unintentional data loss (e.g.
// a developer sets the field but not the UnionType)
func (s *Field1Union) SetNull()  {
    s.String = ""
    s.UnionType = 0
}