Merge pull request #1 from bnfinet/master

Author: mozillazg

decode.go

@@ -0,0 +1,110 @@
+package httpheader
+
+import (
+"fmt"
+"net/http"
+"reflect"
+"strconv"
+"time"
+)
+
+var decoderType = reflect.TypeOf(new(Decoder)).Elem()
+
+// Decoder is an interface implemented by any type that wishes to decode
+// itself from Header fields in a non-standard way.
+type Decoder interface {
+DecodeHeader(header http.Header, v interface{}) error
+}
+
+// DecodeHeader expects to be passed an http.Header and a struct, and parses
+// header into the struct recursively using the same rules as Header (see above)
+func DecodeHeader(header http.Header, v interface{}) error {
+val := reflect.ValueOf(v)
+for val.Kind() == reflect.Ptr {
+val = val.Elem()
+}
+
+if val.Kind() != reflect.Struct {
+return fmt.Errorf("val is not a struct %+v", val.Kind())
+}
+return parseValue(header, val)
+}
+
+func parseValue(header http.Header, val reflect.Value) error {
+typ := val.Type()
+for i := 0; i < typ.NumField(); i++ {
+sf := typ.Field(i)
+if sf.PkgPath != "" && !sf.Anonymous { // unexported
+continue
+}
+
+sv := val.Field(i)
+tag := sf.Tag.Get(tagName)
+if tag == "-" {
+continue
+}
+name, opts := parseTag(tag)
+if name == "" {
+if sf.Anonymous && sv.Kind() == reflect.Struct {
+continue
+}
+name = sf.Name
+}
+
+if opts.Contains("omitempty") && header.Get(name) == "" {
+continue
+}
+
+if sv.Type().Implements(decoderType) {
+if !reflect.Indirect(sv).IsValid() {
+sv = reflect.New(sv.Type().Elem())
+}
+
+m := sv.Interface().(Decoder)
+if err := m.DecodeHeader(header, &val); err != nil {
+return err
+}
+continue
+}
+
+// TODO: implement iterating over multiple Headers with the same name such as `Cooke:` or `Server:`
+// if sv.Kind() == reflect.Slice || sv.Kind() == reflect.Array {
+//	for k, v := range header[name] {
+
+//	}
+//	continue
+// }
+
+for sv.Kind() == reflect.Ptr {
+sv = sv.Elem()
+}
+
+if sv.Type() == timeType {
+h := header.Get(name)
+t, err := time.Parse(time.RFC1123, h)
+if err != nil {
+return err
+}
+sv.Set(reflect.ValueOf(t))
+continue
+}
+
+if sv.Kind() == reflect.Struct {
+parseValue(header, sv)
+continue
+}
+
+if sv.Kind() == reflect.Int {
+j, err := strconv.Atoi(header.Get(name))
+if err != nil {
+return err
+}
+sv.SetInt(int64(j))
+}
+
+if sv.Kind() == reflect.String {
+sv.SetString(header.Get(name))
+}
+}
+return nil
+}

decode_test.go

@@ -0,0 +1,86 @@
+package httpheader
+
+import (
+"net/http"
+"reflect"
+"testing"
+"time"
+)
+
+// Event defines a Google Calendar hook event type
+type Event string
+
+var pl *GoogleCalendarPayload
+
+// GoogleCalendar hook types
+const (
+SyncEvent Event = "sync"
+ExistsEvent Event = "exists"
+NotExistsEvent Event = "not_exists"
+)
+
+// GoogleCalendarPayload a google calendar notice
+// https://developers.google.com/calendar/v3/push
+type GoogleCalendarPayload struct {
+ChannelID string `header:"X-Goog-Channel-ID"`
+ChannelToken string `header:"X-Goog-Channel-Token,omitempty"`
+ChannelExpiration time.Time `header:"X-Goog-Channel-Expiration,omitempty"`
+ResourceID string `header:"X-Goog-Resource-ID"`
+ResourceURI string `header:"X-Goog-Resource-URI"`
+ResourceState string `header:"X-Goog-Resource-State"`
+MessageNumber int `header:"X-Goog-Message-Number"`
+}
+
+func init() {
+pl = &GoogleCalendarPayload{
+ChannelID: "channel-ID-value",
+ChannelToken: "channel-token-value",
+ResourceID: "identifier-for-the-watched-resource",
+ResourceURI: "version-specific-URI-of-the-watched-resource",
+MessageNumber: 1,
+}
+pl.ChannelExpiration, _ = time.Parse(time.RFC1123, "Tue, 19 Nov 2013 01:13:52 GMT")
+
+}
+
+func getHeader(e Event) http.Header {
+h := http.Header{}
+h.Add("X-Goog-Channel-ID", "channel-ID-value")
+h.Add("X-Goog-Channel-Token", "channel-token-value")
+h.Add("X-Goog-Channel-Expiration", "Tue, 19 Nov 2013 01:13:52 GMT")
+h.Add("X-Goog-Resource-ID", "identifier-for-the-watched-resource")
+h.Add("X-Goog-Resource-URI", "version-specific-URI-of-the-watched-resource")
+h.Add("X-Goog-Message-Number", "1")
+h.Add("X-Goog-Resource-State", string(e))
+return h
+}
+
+func TestDecodeHeader(t *testing.T) {
+type args struct {
+e Event
+}
+tests := []struct {
+name string
+args args
+wantErr bool
+}{
+{"Google Calendar sync", args{SyncEvent}, false},
+{"Google Calendar exists", args{ExistsEvent}, false},
+{"Google Calendar no exists", args{NotExistsEvent}, false},
+}
+
+for i, tt := range tests {
+t.Run(tt.name, func(t *testing.T) {
+plrun := *pl
+plrun.ResourceState = string(tt.args.e)
+gcp := GoogleCalendarPayload{}
+err := DecodeHeader(getHeader(tt.args.e), &gcp)
+if (err != nil) != tt.wantErr {
+t.Errorf("%d. DecodeHeader() error = %+v, wantErr %+v", i, err, tt.wantErr)
+}
+if !reflect.DeepEqual(gcp, plrun) {
+t.Errorf("%d. DecodeHeader() does not work as expected, \ngot %+v \nwant %+v", i, gcp, plrun)
+}
+})
+}
+}