chore(binding): Update priority of the parameter

Change-Id: I9245ba0c2bc05d46b254af914e3f06f0930c3640

Author: andeya

binding/README.md

@@ -97,15 +97,14 @@ The parameter position in HTTP request:
 - Expression `required` or `req` indicates that the parameter is required
 - If no position is tagged, try bind parameters from the body when the request has body,
 <br>otherwise try bind from the URL query
-- When there are multiple tags, the order in which to try to bind is:
+- When there are multiple tags or no tags, the order in which to try to bind is:
   1. path
-  2. query
-  3. raw_body
-  4. form
-  5. protobuf
-  6. json
-  7. header
-  8. cookie
+  2. form
+  3. query
+  4. cookie
+  5. header
+  6. protobuf
+  7. json
 
 ## Type Unmarshalor
 

binding/bind.go

@@ -129,53 +129,25 @@ func (b *Binding) bind(structPointer interface{}, req *http.Request, pathParams
 		for i, info := range param.tagInfos {
 			var found bool
 			switch info.paramIn {
-			case query:
-				found, err = param.bindQuery(info, expr, queryValues)
 			case path:
 				found, err = param.bindPath(info, expr, pathParams)
-			case header:
-				found, err = param.bindHeader(info, expr, req.Header)
+			case query:
+				found, err = param.bindQuery(info, expr, queryValues)
 			case cookie:
 				err = param.bindCookie(info, expr, cookies)
 				found = err == nil
-			case raw_body:
-				err = param.bindRawBody(info, expr, bodyBytes)
-				found = err == nil
+			case header:
+				found, err = param.bindHeader(info, expr, req.Header)
 			case form, json, protobuf:
 				if info.paramIn == in(bodyCodec) {
 					found, err = param.bindOrRequireBody(info, expr, bodyCodec, bodyString, postForm)
 				} else if info.required {
 					found = false
 					err = info.requiredError
 				}
-			case auto:
-				// Try bind parameters from the body when the request has body,
-				// otherwise try bind from the URL query
-				if len(bodyBytes) == 0 {
-					if !param.omitIns[query] {
-						if queryValues == nil {
-							queryValues = req.URL.Query()
-						}
-						found, err = param.bindQuery(info, expr, queryValues)
-					}
-				} else {
-					switch bodyCodec {
-					case bodyForm:
-						if !param.omitIns[form] {
-							found, err = param.bindMapStrings(info, expr, postForm)
-						}
-					case bodyJSON:
-						if !param.omitIns[json] {
-							err = param.checkRequireJSON(info, expr, bodyString, false)
-							found = err == nil
-						}
-					case bodyProtobuf:
-						if !param.omitIns[protobuf] {
-							err = param.checkRequireProtobuf(info, expr, false)
-							found = err == nil
-						}
-					}
-				}
+			case raw_body:
+				err = param.bindRawBody(info, expr, bodyBytes)
+				found = err == nil
 			}
 			if found && err == nil {
 				break
@@ -236,36 +208,27 @@ func (b *Binding) getOrPrepareReceiver(value reflect.Value) (*receiver, error) {
 		tagInfos := [maxIn]*tagInfo{}
 	L:
 		for _, tagKV := range tagKVs {
-			paramIn := auto
+			paramIn := undefined
 			switch tagKV.name {
 			case b.config.Validator:
 				recv.hasVd = true
 				continue L
-
-			case b.config.Query:
-				recv.hasQuery = true
-				paramIn = query
 			case b.config.PathParam:
-				recv.hasPath = true
 				paramIn = path
-			case b.config.Header:
-				paramIn = header
-			case b.config.Cookie:
-				recv.hasCookie = true
-				paramIn = cookie
-			case b.config.RawBody:
-				recv.hasBody = true
-				paramIn = raw_body
 			case b.config.FormBody:
-				recv.hasBody = true
 				paramIn = form
+			case b.config.Query:
+				paramIn = query
+			case b.config.Cookie:
+				paramIn = cookie
+			case b.config.Header:
+				paramIn = header
 			case b.config.protobufBody:
-				recv.hasBody = true
 				paramIn = protobuf
 			case b.config.jsonBody:
-				recv.hasBody = true
 				paramIn = json
-
+			case b.config.RawBody:
+				paramIn = raw_body
 			default:
 				continue L
 			}
@@ -275,18 +238,26 @@ func (b *Binding) getOrPrepareReceiver(value reflect.Value) (*receiver, error) {
 			if info != nil {
 				if info.paramName == "-" {
 					p.omitIns[in(i)] = true
+					recv.assginIn(in(i), false)
 				} else {
 					info.paramIn = in(i)
 					p.tagInfos = append(p.tagInfos, info)
+					recv.assginIn(in(i), true)
 				}
 			}
 		}
 		if len(p.tagInfos) == 0 {
-			p.tagInfos = append(p.tagInfos, &tagInfo{
-				paramIn:   auto,
-				paramName: p.structField.Name,
-			})
-			recv.hasBody = true
+			for _, i := range sortedDefaultIn {
+				if p.omitIns[i] {
+					recv.assginIn(i, false)
+					continue
+				}
+				p.tagInfos = append(p.tagInfos, &tagInfo{
+					paramIn:   i,
+					paramName: p.structField.Name,
+				})
+				recv.assginIn(i, true)
+			}
 		}
 		if !recv.hasVd {
 			_, recv.hasVd = tagKVs.lookup(b.config.Validator)

binding/bind_test.go

@@ -67,7 +67,7 @@ func TestQueryString(t *testing.T) {
 	assert.EqualError(t, err, "binding X.E: parameter type does not match binding data")
 	binder.SetLooseZeroMode(true)
 	err = binder.BindAndValidate(recv, req, nil)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, 0, ***(*(**recv.X).E)[0])
 	assert.Equal(t, 2, ***(*(**recv.X).E)[1])
 	assert.Equal(t, []string{"a1", "a2"}, (**recv.X).A)
@@ -106,7 +106,7 @@ func TestQueryNum(t *testing.T) {
 	recv := new(Recv)
 	binder := binding.New(nil)
 	err := binder.BindAndValidate(recv, req, nil)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, []int{11, 12}, (**recv.X).A)
 	assert.Equal(t, int32(21), (**recv.X).B)
 	assert.Equal(t, &[]uint16{31, 32}, (**recv.X).C)
@@ -139,7 +139,7 @@ func TestHeaderString(t *testing.T) {
 	recv := new(Recv)
 	binder := binding.New(nil)
 	err := binder.BindAndValidate(recv, req, nil)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, []string{"a1", "a2"}, (**recv.X).A)
 	assert.Equal(t, "b1", (**recv.X).B)
 	assert.Equal(t, []string{"c1", "c2"}, *(**recv.X).C)
@@ -172,7 +172,7 @@ func TestHeaderNum(t *testing.T) {
 	recv := new(Recv)
 	binder := binding.New(nil)
 	err := binder.BindAndValidate(recv, req, nil)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, []int{11, 12}, (**recv.X).A)
 	assert.Equal(t, int32(21), (**recv.X).B)
 	assert.Equal(t, &[]uint16{31, 32}, (**recv.X).C)
@@ -206,7 +206,7 @@ func TestCookieString(t *testing.T) {
 	recv := new(Recv)
 	binder := binding.New(nil)
 	err := binder.BindAndValidate(recv, req, nil)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, []string{"a1", "a2"}, (**recv.X).A)
 	assert.Equal(t, "b1", (**recv.X).B)
 	assert.Equal(t, []string{"c1", "c2"}, *(**recv.X).C)
@@ -240,7 +240,7 @@ func TestCookieNum(t *testing.T) {
 	recv := new(Recv)
 	binder := binding.New(nil)
 	err := binder.BindAndValidate(recv, req, nil)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, []int{11, 12}, (**recv.X).A)
 	assert.Equal(t, int32(21), (**recv.X).B)
 	assert.Equal(t, &[]uint16{31, 32}, (**recv.X).C)
@@ -281,7 +281,7 @@ func TestFormString(t *testing.T) {
 		recv := new(Recv)
 		binder := binding.New(nil)
 		err := binder.BindAndValidate(recv, req, nil)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		assert.Equal(t, []string{"a1", "a2"}, (**recv.X).A)
 		assert.Equal(t, "b1", (**recv.X).B)
 		assert.Equal(t, []string{"c1", "c2"}, *(**recv.X).C)
@@ -323,7 +323,7 @@ func TestFormNum(t *testing.T) {
 		recv := new(Recv)
 		binder := binding.New(nil)
 		err := binder.BindAndValidate(recv, req, nil)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		assert.Equal(t, []int{11, 12}, (**recv.X).A)
 		assert.Equal(t, int32(-21), (**recv.X).B)
 		assert.Equal(t, &[]uint16{31, 32}, (**recv.X).C)
@@ -490,7 +490,7 @@ func TestPath(t *testing.T) {
 	recv := new(Recv)
 	binder := binding.New(nil)
 	err := binder.BindAndValidate(recv, req, new(testPathParams))
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, []string{"a1"}, (**recv.X).A)
 	assert.Equal(t, int32(-21), (**recv.X).B)
 	assert.Equal(t, &[]uint16{31}, (**recv.X).C)
@@ -504,40 +504,48 @@ func TestAuto(t *testing.T) {
 		A string `vd:"$!=''"`
 		B string
 		C string
-		D string `form:"D,required" query:"D,required"`
+		D string `query:"D,required" form:"D,required"`
+		E string `cookie:"e" json:"e"`
 	}
 	query := make(url.Values)
 	query.Add("A", "a")
 	query.Add("B", "b")
 	query.Add("C", "c")
-	query.Add("D", "d")
-	req := newRequest("http://localhost/?"+query.Encode(), nil, nil, nil)
+	query.Add("D", "d-from-query")
+	contentType, bodyReader, err := httpbody.NewJSONBody(map[string]string{"e": "e-from-jsonbody"})
+	assert.NoError(t, err)
+	header := make(http.Header)
+	header.Set("Content-Type", contentType)
+	req := newRequest("http://localhost/?"+query.Encode(), header, []*http.Cookie{
+		{Name: "e", Value: "e-from-cookie"},
+	}, bodyReader)
 	recv := new(Recv)
 	binder := binding.New(nil)
-	err := binder.BindAndValidate(recv, req, nil)
-	assert.Nil(t, err)
+	err = binder.BindAndValidate(recv, req, nil)
+	assert.NoError(t, err)
 	assert.Equal(t, "a", recv.A)
 	assert.Equal(t, "b", recv.B)
 	assert.Equal(t, "c", recv.C)
-	assert.Equal(t, "d", recv.D)
+	assert.Equal(t, "d-from-query", recv.D)
+	assert.Equal(t, "e-from-cookie", recv.E)
 
 	query = make(url.Values)
-	query.Add("A", "a")
-	query.Add("D", "d")
+	query.Add("D", "d-from-query")
 	form := make(url.Values)
 	form.Add("B", "b")
 	form.Add("C", "c")
-	contentType, bodyReader := httpbody.NewFormBody2(form, nil)
-	header := make(http.Header)
+	form.Add("D", "d-from-form")
+	contentType, bodyReader = httpbody.NewFormBody2(form, nil)
+	header = make(http.Header)
 	header.Set("Content-Type", contentType)
 	req = newRequest("http://localhost/?"+query.Encode(), header, nil, bodyReader)
 	recv = new(Recv)
 	err = binder.Bind(recv, req, nil)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, "", recv.A)
 	assert.Equal(t, "b", recv.B)
 	assert.Equal(t, "c", recv.C)
-	assert.Equal(t, "d", recv.D)
+	assert.Equal(t, "d-from-form", recv.D)
 	err = binder.Validate(recv)
 	assert.EqualError(t, err, "validating A: fail")
 }
@@ -560,15 +568,15 @@ func TestTypeUnmarshal(t *testing.T) {
 	recv := new(Recv)
 	binder := binding.New(nil)
 	err := binder.BindAndValidate(recv, req, nil)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	t1, err := time.Parse(time.RFC3339, "2019-09-03T18:05:24+08:00")
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, t1, recv.A)
 	t21, err := time.Parse(time.RFC3339, "2019-09-04T14:05:24+08:00")
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, t21, *recv.B)
 	t22, err := time.Parse(time.RFC3339, "2019-09-04T18:05:24+08:00")
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, []time.Time{t21, t22}, recv.C)
 	t.Logf("%v", recv)
 }

binding/param_info.go

@@ -73,6 +73,9 @@ func (p *paramInfo) bindRawBody(info *tagInfo, expr *tagexpr.TagExpr, bodyBytes
 }
 
 func (p *paramInfo) bindPath(info *tagInfo, expr *tagexpr.TagExpr, pathParams PathParams) (bool, error) {
+	if pathParams == nil {
+		return false, nil
+	}
 	r, found := pathParams.Get(info.paramName)
 	if !found {
 		if info.required {