Merge remote-tracking branch 'origin/master' into develop

Author: mozillazg

.bumpversion.cfg

@@ -1,7 +1,7 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 0.3.0
+current_version = 0.3.1
 
 [bumpversion:file:encode.go]
 

.github/workflows/main.yml

@@ -13,7 +13,7 @@ jobs:
  strategy:
  fail-fast: false
  matrix:
- go: ['1.11', '1.12', '1.13', '1.14', '1.15', '1.16', '1.17']
+ go: ['1.11', '1.12', '1.13', '1.14', '1.15', '1.16', '1.17', '1.18']
 
  steps:
  - uses: actions/setup-go@v1

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.3.1] (2022-04-09)
+
+* fix Decode: don't fill value for struct fields that don't exist in header
+
+
 ## [0.3.0] (2021-01-24)
 
 * add `func Decode(header http.Header, v interface{}) error` to support decoding headers into struct
@@ -21,3 +26,4 @@
 [0.2.0]: https://github.com/mozillazg/go-httpheader/compare/v0.1.0...v0.2.0
 [0.2.1]: https://github.com/mozillazg/go-httpheader/compare/v0.2.0...v0.2.1
 [0.3.0]: https://github.com/mozillazg/go-httpheader/compare/v0.2.1...v0.3.0
+[0.3.1]: https://github.com/mozillazg/go-httpheader/compare/v0.3.0...v0.3.1

decode.go

@@ -20,7 +20,7 @@ type Decoder interface {
 func Decode(header http.Header, v interface{}) error {
 val := reflect.ValueOf(v)
 if val.Kind() != reflect.Ptr || val.IsNil() {
-return fmt.Errorf("v should be point and should not be nil")
+return fmt.Errorf("v should be a pointer and should not be nil")
 }
 
 for val.Kind() == reflect.Ptr {
@@ -33,7 +33,12 @@ func Decode(header http.Header, v interface{}) error {
 return parseValue(header, val)
 }
 
+// parseValue populates the struct fields in val from the header fields.
+// Embedded structs are followed recursively (using the rules defined in the
+// Values function documentation) breadth-first.
 func parseValue(header http.Header, val reflect.Value) error {
+var embedded []reflect.Value
+
 typ := val.Type()
 for i := 0; i < typ.NumField(); i++ {
 sf := typ.Field(i)
@@ -49,6 +54,8 @@ func parseValue(header http.Header, val reflect.Value) error {
 name, opts := parseTag(tag)
 if name == "" {
 if sf.Anonymous && sv.Kind() == reflect.Struct {
+// save embedded struct for later processing
+embedded = append(embedded, sv)
 continue
 }
 name = sf.Name
@@ -73,16 +80,24 @@ func parseValue(header http.Header, val reflect.Value) error {
 }
 
 if sv.Kind() == reflect.Ptr {
+valArr, exist := headerValues(header, name)
+if !exist {
+continue
+}
 ve := reflect.New(sv.Type().Elem())
-if err := fillValues(ve, opts, headerValues(header, name)); err != nil {
+if err := fillValues(ve, opts, valArr); err != nil {
 return err
 }
 sv.Set(ve)
 continue
 }
 
 if sv.Type() == timeType {
-if err := fillValues(sv, opts, headerValues(header, name)); err != nil {
+valArr, exist := headerValues(header, name)
+if !exist {
+continue
+}
+if err := fillValues(sv, opts, valArr); err != nil {
 return err
 }
 continue
@@ -95,7 +110,35 @@ func parseValue(header http.Header, val reflect.Value) error {
 continue
 }
 
-if err := fillValues(sv, opts, headerValues(header, name)); err != nil {
+if sv.Kind() != reflect.Slice && sv.Kind() != reflect.Array && sv.Kind() != reflect.Interface {
+vals := header.Values(name)
+if len(vals) > 0 {
+v := vals[0]
+vals = vals[1:]
+
+if err := fillValues(sv, opts, []string{v}); err != nil {
+return err
+}
+
+header.Del(name)
+for _, v := range vals {
+header.Add(name, v)
+}
+}
+continue
+}
+
+valArr, exist := headerValues(header, name)
+if !exist {
+continue
+}
+if err := fillValues(sv, opts, valArr); err != nil {
+return err
+}
+}
+
+for _, f := range embedded {
+if err := parseValue(header, f); err != nil {
 return err
 }
 }
@@ -249,6 +292,7 @@ func fillValues(sv reflect.Value, opts tagOptions, valArr []string) error {
 return nil
 }
 
-func headerValues(h http.Header, key string) []string {
-return textproto.MIMEHeader(h)[textproto.CanonicalMIMEHeaderKey(key)]
+func headerValues(h http.Header, key string) ([]string, bool) {
+vs, ok := textproto.MIMEHeader(h)[textproto.CanonicalMIMEHeaderKey(key)]
+return vs, ok
 }

decode_test.go

@@ -136,6 +136,7 @@ func TestDecodeHeader_UnmarshalerWithNilPointer(t *testing.T) {
 
 type simpleStruct struct {
 Foo string
+Bar int
 }
 
 type fullTypeStruct struct {
@@ -243,7 +244,7 @@ func TestDecodeHeader_more_data_type(t *testing.T) {
 t.Errorf("Decode returned error: %#v", err)
 }
 if !reflect.DeepEqual(want, got) {
-t.Errorf("want %#v, but got %#v", want, got)
+t.Errorf("want/got:\n%#v\n%#v", want, got)
 }
 }
 
@@ -388,6 +389,42 @@ func Test_fillValues_errors(t *testing.T) {
 },
 wantErr: true,
 },
+{
+name: "slice",
+args: args{
+sv: reflect.New(reflect.TypeOf([]int{})),
+opts: tagOptions{},
+valArr: []string{"a"},
+},
+wantErr: true,
+},
+{
+name: "array",
+args: args{
+sv: reflect.New(reflect.TypeOf([1]int{})),
+opts: tagOptions{},
+valArr: []string{"a"},
+},
+wantErr: true,
+},
+{
+name: "time",
+args: args{
+sv: reflect.New(reflect.TypeOf(time.Time{})),
+opts: tagOptions{},
+valArr: []string{"a"},
+},
+wantErr: true,
+},
+{
+name: "time unix",
+args: args{
+sv: reflect.New(reflect.TypeOf(time.Time{})),
+opts: tagOptions{"unix"},
+valArr: []string{"a"},
+},
+wantErr: true,
+},
 }
 for _, tt := range tests {
 t.Run(tt.name, func(t *testing.T) {
@@ -397,3 +434,114 @@ func Test_fillValues_errors(t *testing.T) {
 })
 }
 }
+
+func TestDecode_check_header_key_not_present_no_point(t *testing.T) {
+h := http.Header{}
+h.Set("Length", "100")
+
+var got fullTypeStruct
+err := Decode(h, &got)
+if err != nil {
+t.Errorf("Decode returned error: %#v", err)
+}
+
+var want fullTypeStruct
+if !reflect.DeepEqual(want, got) {
+t.Errorf("want %#v, but got %#v", want, got)
+}
+}
+
+func TestDecode_check_header_key_not_present_point(t *testing.T) {
+type testStruct struct {
+A *string
+B *fullTypeStruct
+C *int
+D *[]string
+E *[2]string
+F interface{}
+G *time.Time
+}
+h := http.Header{}
+h.Set("Length", "100")
+
+var got testStruct
+err := Decode(h, &got)
+if err != nil {
+t.Errorf("Decode returned error: %#v", err)
+}
+
+var want testStruct
+if !reflect.DeepEqual(want, got) {
+t.Errorf("want %#v, but got %#v", want, got)
+}
+if got.A != nil || got.B != nil || got.C != nil || got.D != nil || got.E != nil || got.F != nil || got.G != nil {
+t.Error("all fields should be nil")
+}
+}
+
+func TestDecode_error(t *testing.T) {
+h := http.Header{
+"Int": []string{"abc"},
+}
+var got fullTypeStruct
+err := Decode(h, &got)
+if err == nil {
+t.Errorf("expect error, got : %#v", got)
+}
+}
+
+func TestDecodeHeader_embeddedStructs(t *testing.T) {
+tests := []struct {
+in http.Header
+decode func(http.Header) (interface{}, error)
+want interface{}
+}{
+{
+http.Header{"C": []string{"foo"}},
+func(h http.Header) (interface{}, error) {
+var a A
+err := Decode(h, &a)
+return a, err
+},
+A{B{C: "foo"}},
+},
+{
+http.Header{"C": []string{"foo"}},
+func(h http.Header) (interface{}, error) {
+var d D
+err := Decode(h, &d)
+return d, err
+},
+D{B: B{C: ""}, C: "foo"},
+},
+{
+http.Header{"C": []string{"foo", "bar"}},
+func(h http.Header) (interface{}, error) {
+var d D
+err := Decode(h, &d)
+return d, err
+},
+D{B: B{C: "bar"}, C: "foo"},
+},
+{
+http.Header{"C": []string{"foo", "bar"}},
+func(h http.Header) (interface{}, error) {
+var f F
+err := Decode(h, &f)
+return f, err
+},
+F{e{B: B{C: "bar"}, C: "foo"}}, // With unexported embed
+},
+}
+
+for i, tt := range tests {
+v, err := tt.decode(tt.in)
+if err != nil {
+t.Errorf("%d. Header(%+v) returned error: %v", i, tt.in, err)
+}
+
+if !reflect.DeepEqual(tt.want, v) {
+t.Errorf("%d. Header(%+v) returned/want:\n%#+v\n%#+v", i, tt.in, v, tt.want)
+}
+}
+}

encode.go

@@ -29,7 +29,7 @@ import (
 const tagName = "header"
 
 // Version ...
-const Version = "0.3.0"
+const Version = "0.3.1"
 
 var timeType = reflect.TypeOf(time.Time{})
 var headerType = reflect.TypeOf(http.Header{})