mirror
/
gin
mirror of https://github.com/gin-gonic/gin.git
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

unify assert.Equal usage (#1327) 

* unify assert.Equal usage

* fix typo
This commit is contained in:
田欧 2018-04-20 10:27:44 +08:00 committed by Bo-Yi Wu
parent 248c522e4a
commit dfe37ea6f1
3 changed files with 110 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

164
binding/binding_test.go
View File

@ -140,26 +140,26 @@ type FooBarStructForFloat64Type struct {
} }
func TestBindingDefault(t *testing.T) { func TestBindingDefault(t *testing.T) {
assert.Equal(t, Default("GET", ""), Form) assert.Equal(t, Form, Default("GET", ""))
assert.Equal(t, Default("GET", MIMEJSON), Form) assert.Equal(t, Form, Default("GET", MIMEJSON))
assert.Equal(t, Default("POST", MIMEJSON), JSON) assert.Equal(t, JSON, Default("POST", MIMEJSON))
assert.Equal(t, Default("PUT", MIMEJSON), JSON) assert.Equal(t, JSON, Default("PUT", MIMEJSON))
assert.Equal(t, Default("POST", MIMEXML), XML) assert.Equal(t, XML, Default("POST", MIMEXML))
assert.Equal(t, Default("PUT", MIMEXML2), XML) assert.Equal(t, XML, Default("PUT", MIMEXML2))
assert.Equal(t, Default("POST", MIMEPOSTForm), Form) assert.Equal(t, Form, Default("POST", MIMEPOSTForm))
assert.Equal(t, Default("PUT", MIMEPOSTForm), Form) assert.Equal(t, Form, Default("PUT", MIMEPOSTForm))
assert.Equal(t, Default("POST", MIMEMultipartPOSTForm), Form) assert.Equal(t, Form, Default("POST", MIMEMultipartPOSTForm))
assert.Equal(t, Default("PUT", MIMEMultipartPOSTForm), Form) assert.Equal(t, Form, Default("PUT", MIMEMultipartPOSTForm))
assert.Equal(t, Default("POST", MIMEPROTOBUF), ProtoBuf) assert.Equal(t, ProtoBuf, Default("POST", MIMEPROTOBUF))
assert.Equal(t, Default("PUT", MIMEPROTOBUF), ProtoBuf) assert.Equal(t, ProtoBuf, Default("PUT", MIMEPROTOBUF))
assert.Equal(t, Default("POST", MIMEMSGPACK), MsgPack) assert.Equal(t, MsgPack, Default("POST", MIMEMSGPACK))
assert.Equal(t, Default("PUT", MIMEMSGPACK2), MsgPack) assert.Equal(t, MsgPack, Default("PUT", MIMEMSGPACK2))
} }
func TestBindingJSON(t *testing.T) { func TestBindingJSON(t *testing.T) {
@ -445,9 +445,9 @@ func TestBindingFormPost(t *testing.T) {
var obj FooBarStruct var obj FooBarStruct
FormPost.Bind(req, &obj) FormPost.Bind(req, &obj)
assert.Equal(t, FormPost.Name(), "form-urlencoded") assert.Equal(t, "form-urlencoded", FormPost.Name())
assert.Equal(t, obj.Foo, "bar") assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, obj.Bar, "foo") assert.Equal(t, "foo", obj.Bar)
} }
func TestBindingFormPostFail(t *testing.T) { func TestBindingFormPostFail(t *testing.T) {
@ -462,9 +462,9 @@ func TestBindingFormMultipart(t *testing.T) {
var obj FooBarStruct var obj FooBarStruct
FormMultipart.Bind(req, &obj) FormMultipart.Bind(req, &obj)
assert.Equal(t, FormMultipart.Name(), "multipart/form-data") assert.Equal(t, "multipart/form-data", FormMultipart.Name())
assert.Equal(t, obj.Foo, "bar") assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, obj.Bar, "foo") assert.Equal(t, "foo", obj.Bar)
} }
func TestBindingFormMultipartFail(t *testing.T) { func TestBindingFormMultipartFail(t *testing.T) {
@ -560,7 +560,7 @@ func TestExistsFails(t *testing.T) {
func testFormBinding(t *testing.T, method, path, badPath, body, badBody string) { func testFormBinding(t *testing.T, method, path, badPath, body, badBody string) {
b := Form b := Form
assert.Equal(t, b.Name(), "form") assert.Equal(t, "form", b.Name())
obj := FooBarStruct{} obj := FooBarStruct{}
req := requestWithBody(method, path, body) req := requestWithBody(method, path, body)
@ -569,8 +569,8 @@ func testFormBinding(t *testing.T, method, path, badPath, body, badBody string)
} }
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Foo, "bar") assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, obj.Bar, "foo") assert.Equal(t, "foo", obj.Bar)
obj = FooBarStruct{} obj = FooBarStruct{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -580,7 +580,7 @@ func testFormBinding(t *testing.T, method, path, badPath, body, badBody string)
func TestFormBindingFail(t *testing.T) { func TestFormBindingFail(t *testing.T) {
b := Form b := Form
assert.Equal(t, b.Name(), "form") assert.Equal(t, "form", b.Name())
obj := FooBarStruct{} obj := FooBarStruct{}
req, _ := http.NewRequest("POST", "/", nil) req, _ := http.NewRequest("POST", "/", nil)
@ -590,7 +590,7 @@ func TestFormBindingFail(t *testing.T) {
func TestFormPostBindingFail(t *testing.T) { func TestFormPostBindingFail(t *testing.T) {
b := FormPost b := FormPost
assert.Equal(t, b.Name(), "form-urlencoded") assert.Equal(t, "form-urlencoded", b.Name())
obj := FooBarStruct{} obj := FooBarStruct{}
req, _ := http.NewRequest("POST", "/", nil) req, _ := http.NewRequest("POST", "/", nil)
@ -600,7 +600,7 @@ func TestFormPostBindingFail(t *testing.T) {
func TestFormMultipartBindingFail(t *testing.T) { func TestFormMultipartBindingFail(t *testing.T) {
b := FormMultipart b := FormMultipart
assert.Equal(t, b.Name(), "multipart/form-data") assert.Equal(t, "multipart/form-data", b.Name())
obj := FooBarStruct{} obj := FooBarStruct{}
req, _ := http.NewRequest("POST", "/", nil) req, _ := http.NewRequest("POST", "/", nil)
@ -610,7 +610,7 @@ func TestFormMultipartBindingFail(t *testing.T) {
func testFormBindingForTime(t *testing.T, method, path, badPath, body, badBody string) { func testFormBindingForTime(t *testing.T, method, path, badPath, body, badBody string) {
b := Form b := Form
assert.Equal(t, b.Name(), "form") assert.Equal(t, "form", b.Name())
obj := FooBarStructForTimeType{} obj := FooBarStructForTimeType{}
req := requestWithBody(method, path, body) req := requestWithBody(method, path, body)
@ -620,10 +620,10 @@ func testFormBindingForTime(t *testing.T, method, path, badPath, body, badBody s
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.TimeFoo.Unix(), int64(1510675200)) assert.Equal(t, int64(1510675200), obj.TimeFoo.Unix())
assert.Equal(t, obj.TimeFoo.Location().String(), "Asia/Chongqing") assert.Equal(t, "Asia/Chongqing", obj.TimeFoo.Location().String())
assert.Equal(t, obj.TimeBar.Unix(), int64(-62135596800)) assert.Equal(t, int64(-62135596800), obj.TimeBar.Unix())
assert.Equal(t, obj.TimeBar.Location().String(), "UTC") assert.Equal(t, "UTC", obj.TimeBar.Location().String())
obj = FooBarStructForTimeType{} obj = FooBarStructForTimeType{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -633,7 +633,7 @@ func testFormBindingForTime(t *testing.T, method, path, badPath, body, badBody s
func testFormBindingForTimeNotFormat(t *testing.T, method, path, badPath, body, badBody string) { func testFormBindingForTimeNotFormat(t *testing.T, method, path, badPath, body, badBody string) {
b := Form b := Form
assert.Equal(t, b.Name(), "form") assert.Equal(t, "form", b.Name())
obj := FooStructForTimeTypeNotFormat{} obj := FooStructForTimeTypeNotFormat{}
req := requestWithBody(method, path, body) req := requestWithBody(method, path, body)
@ -651,7 +651,7 @@ func testFormBindingForTimeNotFormat(t *testing.T, method, path, badPath, body,
func testFormBindingForTimeFailFormat(t *testing.T, method, path, badPath, body, badBody string) { func testFormBindingForTimeFailFormat(t *testing.T, method, path, badPath, body, badBody string) {
b := Form b := Form
assert.Equal(t, b.Name(), "form") assert.Equal(t, "form", b.Name())
obj := FooStructForTimeTypeFailFormat{} obj := FooStructForTimeTypeFailFormat{}
req := requestWithBody(method, path, body) req := requestWithBody(method, path, body)
@ -669,7 +669,7 @@ func testFormBindingForTimeFailFormat(t *testing.T, method, path, badPath, body,
func testFormBindingForTimeFailLocation(t *testing.T, method, path, badPath, body, badBody string) { func testFormBindingForTimeFailLocation(t *testing.T, method, path, badPath, body, badBody string) {
b := Form b := Form
assert.Equal(t, b.Name(), "form") assert.Equal(t, "form", b.Name())
obj := FooStructForTimeTypeFailLocation{} obj := FooStructForTimeTypeFailLocation{}
req := requestWithBody(method, path, body) req := requestWithBody(method, path, body)
@ -687,7 +687,7 @@ func testFormBindingForTimeFailLocation(t *testing.T, method, path, badPath, bod
func testFormBindingInvalidName(t *testing.T, method, path, badPath, body, badBody string) { func testFormBindingInvalidName(t *testing.T, method, path, badPath, body, badBody string) {
b := Form b := Form
assert.Equal(t, b.Name(), "form") assert.Equal(t, "form", b.Name())
obj := InvalidNameType{} obj := InvalidNameType{}
req := requestWithBody(method, path, body) req := requestWithBody(method, path, body)
@ -696,7 +696,7 @@ func testFormBindingInvalidName(t *testing.T, method, path, badPath, body, badBo
} }
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.TestName, "") assert.Equal(t, "", obj.TestName)
obj = InvalidNameType{} obj = InvalidNameType{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -706,7 +706,7 @@ func testFormBindingInvalidName(t *testing.T, method, path, badPath, body, badBo
func testFormBindingInvalidName2(t *testing.T, method, path, badPath, body, badBody string) { func testFormBindingInvalidName2(t *testing.T, method, path, badPath, body, badBody string) {
b := Form b := Form
assert.Equal(t, b.Name(), "form") assert.Equal(t, "form", b.Name())
obj := InvalidNameMapType{} obj := InvalidNameMapType{}
req := requestWithBody(method, path, body) req := requestWithBody(method, path, body)
@ -724,7 +724,7 @@ func testFormBindingInvalidName2(t *testing.T, method, path, badPath, body, badB
func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody string, typ string) { func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody string, typ string) {
b := Form b := Form
assert.Equal(t, b.Name(), "form") assert.Equal(t, "form", b.Name())
req := requestWithBody(method, path, body) req := requestWithBody(method, path, body)
if method == "POST" { if method == "POST" {
@ -735,8 +735,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooBarStructForIntType{} obj := FooBarStructForIntType{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.IntFoo, int(0)) assert.Equal(t, int(0), obj.IntFoo)
assert.Equal(t, obj.IntBar, int(-12)) assert.Equal(t, int(-12), obj.IntBar)
obj = FooBarStructForIntType{} obj = FooBarStructForIntType{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -746,8 +746,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooBarStructForInt8Type{} obj := FooBarStructForInt8Type{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Int8Foo, int8(0)) assert.Equal(t, int8(0), obj.Int8Foo)
assert.Equal(t, obj.Int8Bar, int8(-12)) assert.Equal(t, int8(-12), obj.Int8Bar)
obj = FooBarStructForInt8Type{} obj = FooBarStructForInt8Type{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -757,8 +757,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooBarStructForInt16Type{} obj := FooBarStructForInt16Type{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Int16Foo, int16(0)) assert.Equal(t, int16(0), obj.Int16Foo)
assert.Equal(t, obj.Int16Bar, int16(-12)) assert.Equal(t, int16(-12), obj.Int16Bar)
obj = FooBarStructForInt16Type{} obj = FooBarStructForInt16Type{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -768,8 +768,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooBarStructForInt32Type{} obj := FooBarStructForInt32Type{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Int32Foo, int32(0)) assert.Equal(t, int32(0), obj.Int32Foo)
assert.Equal(t, obj.Int32Bar, int32(-12)) assert.Equal(t, int32(-12), obj.Int32Bar)
obj = FooBarStructForInt32Type{} obj = FooBarStructForInt32Type{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -779,8 +779,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooBarStructForInt64Type{} obj := FooBarStructForInt64Type{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Int64Foo, int64(0)) assert.Equal(t, int64(0), obj.Int64Foo)
assert.Equal(t, obj.Int64Bar, int64(-12)) assert.Equal(t, int64(-12), obj.Int64Bar)
obj = FooBarStructForInt64Type{} obj = FooBarStructForInt64Type{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -790,8 +790,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooBarStructForUintType{} obj := FooBarStructForUintType{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.UintFoo, uint(0x0)) assert.Equal(t, uint(0x0), obj.UintFoo)
assert.Equal(t, obj.UintBar, uint(0xc)) assert.Equal(t, uint(0xc), obj.UintBar)
obj = FooBarStructForUintType{} obj = FooBarStructForUintType{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -801,8 +801,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooBarStructForUint8Type{} obj := FooBarStructForUint8Type{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Uint8Foo, uint8(0x0)) assert.Equal(t, uint8(0x0), obj.Uint8Foo)
assert.Equal(t, obj.Uint8Bar, uint8(0xc)) assert.Equal(t, uint8(0xc), obj.Uint8Bar)
obj = FooBarStructForUint8Type{} obj = FooBarStructForUint8Type{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -812,8 +812,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooBarStructForUint16Type{} obj := FooBarStructForUint16Type{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Uint16Foo, uint16(0x0)) assert.Equal(t, uint16(0x0), obj.Uint16Foo)
assert.Equal(t, obj.Uint16Bar, uint16(0xc)) assert.Equal(t, uint16(0xc), obj.Uint16Bar)
obj = FooBarStructForUint16Type{} obj = FooBarStructForUint16Type{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -823,8 +823,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooBarStructForUint32Type{} obj := FooBarStructForUint32Type{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Uint32Foo, uint32(0x0)) assert.Equal(t, uint32(0x0), obj.Uint32Foo)
assert.Equal(t, obj.Uint32Bar, uint32(0xc)) assert.Equal(t, uint32(0xc), obj.Uint32Bar)
obj = FooBarStructForUint32Type{} obj = FooBarStructForUint32Type{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -834,8 +834,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooBarStructForUint64Type{} obj := FooBarStructForUint64Type{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Uint64Foo, uint64(0x0)) assert.Equal(t, uint64(0x0), obj.Uint64Foo)
assert.Equal(t, obj.Uint64Bar, uint64(0xc)) assert.Equal(t, uint64(0xc), obj.Uint64Bar)
obj = FooBarStructForUint64Type{} obj = FooBarStructForUint64Type{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -845,8 +845,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooBarStructForFloat32Type{} obj := FooBarStructForFloat32Type{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Float32Foo, float32(0.0)) assert.Equal(t, float32(0.0), obj.Float32Foo)
assert.Equal(t, obj.Float32Bar, float32(-12.34)) assert.Equal(t, float32(-12.34), obj.Float32Bar)
obj = FooBarStructForFloat32Type{} obj = FooBarStructForFloat32Type{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -856,8 +856,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooBarStructForFloat64Type{} obj := FooBarStructForFloat64Type{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Float64Foo, float64(0.0)) assert.Equal(t, float64(0.0), obj.Float64Foo)
assert.Equal(t, obj.Float64Bar, float64(-12.34)) assert.Equal(t, float64(-12.34), obj.Float64Bar)
obj = FooBarStructForFloat64Type{} obj = FooBarStructForFloat64Type{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -867,8 +867,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooBarStructForBoolType{} obj := FooBarStructForBoolType{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.BoolFoo, false) assert.False(t, obj.BoolFoo)
assert.Equal(t, obj.BoolBar, true) assert.True(t, obj.BoolBar)
obj = FooBarStructForBoolType{} obj = FooBarStructForBoolType{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -878,7 +878,7 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
obj := FooStructForSliceType{} obj := FooStructForSliceType{}
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.SliceFoo, []int{1, 2}) assert.Equal(t, []int{1, 2}, obj.SliceFoo)
obj = FooStructForSliceType{} obj = FooStructForSliceType{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -897,7 +897,7 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
func testQueryBinding(t *testing.T, method, path, badPath, body, badBody string) { func testQueryBinding(t *testing.T, method, path, badPath, body, badBody string) {
b := Query b := Query
assert.Equal(t, b.Name(), "query") assert.Equal(t, "query", b.Name())
obj := FooBarStruct{} obj := FooBarStruct{}
req := requestWithBody(method, path, body) req := requestWithBody(method, path, body)
@ -906,13 +906,13 @@ func testQueryBinding(t *testing.T, method, path, badPath, body, badBody string)
} }
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Foo, "bar") assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, obj.Bar, "foo") assert.Equal(t, "foo", obj.Bar)
} }
func testQueryBindingFail(t *testing.T, method, path, badPath, body, badBody string) { func testQueryBindingFail(t *testing.T, method, path, badPath, body, badBody string) {
b := Query b := Query
assert.Equal(t, b.Name(), "query") assert.Equal(t, "query", b.Name())
obj := FooStructForMapType{} obj := FooStructForMapType{}
req := requestWithBody(method, path, body) req := requestWithBody(method, path, body)
@ -924,13 +924,13 @@ func testQueryBindingFail(t *testing.T, method, path, badPath, body, badBody str
} }
func testBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) { func testBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
assert.Equal(t, b.Name(), name) assert.Equal(t, name, b.Name())
obj := FooStruct{} obj := FooStruct{}
req := requestWithBody("POST", path, body) req := requestWithBody("POST", path, body)
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Foo, "bar") assert.Equal(t, "bar", obj.Foo)
obj = FooStruct{} obj = FooStruct{}
req = requestWithBody("POST", badPath, badBody) req = requestWithBody("POST", badPath, badBody)
@ -939,7 +939,7 @@ func testBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody
} }
func testBodyBindingUseNumber(t *testing.T, b Binding, name, path, badPath, body, badBody string) { func testBodyBindingUseNumber(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
assert.Equal(t, b.Name(), name) assert.Equal(t, name, b.Name())
obj := FooStructUseNumber{} obj := FooStructUseNumber{}
req := requestWithBody("POST", path, body) req := requestWithBody("POST", path, body)
@ -949,7 +949,7 @@ func testBodyBindingUseNumber(t *testing.T, b Binding, name, path, badPath, body
// we hope it is int64(123) // we hope it is int64(123)
v, e := obj.Foo.(json.Number).Int64() v, e := obj.Foo.(json.Number).Int64()
assert.NoError(t, e) assert.NoError(t, e)
assert.Equal(t, v, int64(123)) assert.Equal(t, int64(123), v)
obj = FooStructUseNumber{} obj = FooStructUseNumber{}
req = requestWithBody("POST", badPath, badBody) req = requestWithBody("POST", badPath, badBody)
@ -958,7 +958,7 @@ func testBodyBindingUseNumber(t *testing.T, b Binding, name, path, badPath, body
} }
func testBodyBindingUseNumber2(t *testing.T, b Binding, name, path, badPath, body, badBody string) { func testBodyBindingUseNumber2(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
assert.Equal(t, b.Name(), name) assert.Equal(t, name, b.Name())
obj := FooStructUseNumber{} obj := FooStructUseNumber{}
req := requestWithBody("POST", path, body) req := requestWithBody("POST", path, body)
@ -967,7 +967,7 @@ func testBodyBindingUseNumber2(t *testing.T, b Binding, name, path, badPath, bod
assert.NoError(t, err) assert.NoError(t, err)
// it will return float64(123) if not use EnableDecoderUseNumber // it will return float64(123) if not use EnableDecoderUseNumber
// maybe it is not hoped // maybe it is not hoped
assert.Equal(t, obj.Foo, float64(123)) assert.Equal(t, float64(123), obj.Foo)
obj = FooStructUseNumber{} obj = FooStructUseNumber{}
req = requestWithBody("POST", badPath, badBody) req = requestWithBody("POST", badPath, badBody)
@ -976,13 +976,13 @@ func testBodyBindingUseNumber2(t *testing.T, b Binding, name, path, badPath, bod
} }
func testBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, badBody string) { func testBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
assert.Equal(t, b.Name(), name) assert.Equal(t, name, b.Name())
obj := FooStruct{} obj := FooStruct{}
req := requestWithBody("POST", path, body) req := requestWithBody("POST", path, body)
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.Error(t, err) assert.Error(t, err)
assert.Equal(t, obj.Foo, "") assert.Equal(t, "", obj.Foo)
obj = FooStruct{} obj = FooStruct{}
req = requestWithBody("POST", badPath, badBody) req = requestWithBody("POST", badPath, badBody)
@ -991,14 +991,14 @@ func testBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, bad
} }
func testProtoBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) { func testProtoBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
assert.Equal(t, b.Name(), name) assert.Equal(t, name, b.Name())
obj := example.Test{} obj := example.Test{}
req := requestWithBody("POST", path, body) req := requestWithBody("POST", path, body)
req.Header.Add("Content-Type", MIMEPROTOBUF) req.Header.Add("Content-Type", MIMEPROTOBUF)
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, *obj.Label, "yes") assert.Equal(t, "yes", *obj.Label)
obj = example.Test{} obj = example.Test{}
req = requestWithBody("POST", badPath, badBody) req = requestWithBody("POST", badPath, badBody)
@ -1014,7 +1014,7 @@ func (h hook) Read([]byte) (int, error) {
} }
func testProtoBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, badBody string) { func testProtoBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
assert.Equal(t, b.Name(), name) assert.Equal(t, name, b.Name())
obj := example.Test{} obj := example.Test{}
req := requestWithBody("POST", path, body) req := requestWithBody("POST", path, body)
@ -1032,14 +1032,14 @@ func testProtoBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body
} }
func testMsgPackBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) { func testMsgPackBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
assert.Equal(t, b.Name(), name) assert.Equal(t, name, b.Name())
obj := FooStruct{} obj := FooStruct{}
req := requestWithBody("POST", path, body) req := requestWithBody("POST", path, body)
req.Header.Add("Content-Type", MIMEMSGPACK) req.Header.Add("Content-Type", MIMEMSGPACK)
err := b.Bind(req, &obj) err := b.Bind(req, &obj)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, obj.Foo, "bar") assert.Equal(t, "bar", obj.Foo)
obj = FooStruct{} obj = FooStruct{}
req = requestWithBody("POST", badPath, badBody) req = requestWithBody("POST", badPath, badBody)

6
binding/validate_test.go
View File

@ -176,7 +176,7 @@ func TestValidatePrimitives(t *testing.T) {
obj := Object{"foo": "bar", "bar": 1} obj := Object{"foo": "bar", "bar": 1}
assert.NoError(t, validate(obj)) assert.NoError(t, validate(obj))
assert.NoError(t, validate(&obj)) assert.NoError(t, validate(&obj))
assert.Equal(t, obj, Object{"foo": "bar", "bar": 1}) assert.Equal(t, Object{"foo": "bar", "bar": 1}, obj)
obj2 := []Object{{"foo": "bar", "bar": 1}, {"foo": "bar", "bar": 1}} obj2 := []Object{{"foo": "bar", "bar": 1}, {"foo": "bar", "bar": 1}}
assert.NoError(t, validate(obj2)) assert.NoError(t, validate(obj2))
@ -185,12 +185,12 @@ func TestValidatePrimitives(t *testing.T) {
nu := 10 nu := 10
assert.NoError(t, validate(nu)) assert.NoError(t, validate(nu))
assert.NoError(t, validate(&nu)) assert.NoError(t, validate(&nu))
assert.Equal(t, nu, 10) assert.Equal(t, 10, nu)
str := "value" str := "value"
assert.NoError(t, validate(str)) assert.NoError(t, validate(str))
assert.NoError(t, validate(&str)) assert.NoError(t, validate(&str))
assert.Equal(t, str, "value") assert.Equal(t, "value", str)
} }
// structCustomValidation is a helper struct we use to check that // structCustomValidation is a helper struct we use to check that

50
render/render_test.go
View File

@ -27,7 +27,7 @@ func TestRenderMsgPack(t *testing.T) {
} }
(MsgPack{data}).WriteContentType(w) (MsgPack{data}).WriteContentType(w)
assert.Equal(t, w.Header().Get("Content-Type"), "application/msgpack; charset=utf-8") assert.Equal(t, "application/msgpack; charset=utf-8", w.Header().Get("Content-Type"))
err := (MsgPack{data}).Render(w) err := (MsgPack{data}).Render(w)
@ -41,7 +41,7 @@ func TestRenderMsgPack(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, w.Body.String(), string(buf.Bytes())) assert.Equal(t, w.Body.String(), string(buf.Bytes()))
assert.Equal(t, w.Header().Get("Content-Type"), "application/msgpack; charset=utf-8") assert.Equal(t, "application/msgpack; charset=utf-8", w.Header().Get("Content-Type"))
} }
func TestRenderJSON(t *testing.T) { func TestRenderJSON(t *testing.T) {
@ -78,8 +78,8 @@ func TestRenderIndentedJSON(t *testing.T) {
err := (IndentedJSON{data}).Render(w) err := (IndentedJSON{data}).Render(w)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, w.Body.String(), "{\n \"bar\": \"foo\",\n \"foo\": \"bar\"\n}") assert.Equal(t, "{\n \"bar\": \"foo\",\n \"foo\": \"bar\"\n}", w.Body.String())
assert.Equal(t, w.Header().Get("Content-Type"), "application/json; charset=utf-8") assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
} }
func TestRenderIndentedJSONPanics(t *testing.T) { func TestRenderIndentedJSONPanics(t *testing.T) {
@ -161,12 +161,12 @@ b:
d: [3, 4] d: [3, 4]
` `
(YAML{data}).WriteContentType(w) (YAML{data}).WriteContentType(w)
assert.Equal(t, w.Header().Get("Content-Type"), "application/x-yaml; charset=utf-8") assert.Equal(t, "application/x-yaml; charset=utf-8", w.Header().Get("Content-Type"))
err := (YAML{data}).Render(w) err := (YAML{data}).Render(w)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, w.Body.String(), "\"\\na : Easy!\\nb:\\n\\tc: 2\\n\\td: [3, 4]\\n\\t\"\n") assert.Equal(t, "\"\\na : Easy!\\nb:\\n\\tc: 2\\n\\td: [3, 4]\\n\\t\"\n", w.Body.String())
assert.Equal(t, w.Header().Get("Content-Type"), "application/x-yaml; charset=utf-8") assert.Equal(t, "application/x-yaml; charset=utf-8", w.Header().Get("Content-Type"))
} }
type fail struct{} type fail struct{}
@ -189,13 +189,13 @@ func TestRenderXML(t *testing.T) {
} }
(XML{data}).WriteContentType(w) (XML{data}).WriteContentType(w)
assert.Equal(t, w.Header().Get("Content-Type"), "application/xml; charset=utf-8") assert.Equal(t, "application/xml; charset=utf-8", w.Header().Get("Content-Type"))
err := (XML{data}).Render(w) err := (XML{data}).Render(w)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, w.Body.String(), "<map><foo>bar</foo></map>") assert.Equal(t, "<map><foo>bar</foo></map>", w.Body.String())
assert.Equal(t, w.Header().Get("Content-Type"), "application/xml; charset=utf-8") assert.Equal(t, "application/xml; charset=utf-8", w.Header().Get("Content-Type"))
} }
func TestRenderRedirect(t *testing.T) { func TestRenderRedirect(t *testing.T) {
@ -235,8 +235,8 @@ func TestRenderData(t *testing.T) {
}).Render(w) }).Render(w)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, w.Body.String(), "#!PNG some raw data") assert.Equal(t, "#!PNG some raw data", w.Body.String())
assert.Equal(t, w.Header().Get("Content-Type"), "image/png") assert.Equal(t, "image/png", w.Header().Get("Content-Type"))
} }
func TestRenderString(t *testing.T) { func TestRenderString(t *testing.T) {
@ -246,7 +246,7 @@ func TestRenderString(t *testing.T) {
Format: "hello %s %d", Format: "hello %s %d",
Data: []interface{}{}, Data: []interface{}{},
}).WriteContentType(w) }).WriteContentType(w)
assert.Equal(t, w.Header().Get("Content-Type"), "text/plain; charset=utf-8") assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
err := (String{ err := (String{
Format: "hola %s %d", Format: "hola %s %d",
@ -254,8 +254,8 @@ func TestRenderString(t *testing.T) {
}).Render(w) }).Render(w)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, w.Body.String(), "hola manu 2") assert.Equal(t, "hola manu 2", w.Body.String())
assert.Equal(t, w.Header().Get("Content-Type"), "text/plain; charset=utf-8") assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
} }
func TestRenderStringLenZero(t *testing.T) { func TestRenderStringLenZero(t *testing.T) {
@ -267,8 +267,8 @@ func TestRenderStringLenZero(t *testing.T) {
}).Render(w) }).Render(w)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, w.Body.String(), "hola %s %d") assert.Equal(t, "hola %s %d", w.Body.String())
assert.Equal(t, w.Header().Get("Content-Type"), "text/plain; charset=utf-8") assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
} }
func TestRenderHTMLTemplate(t *testing.T) { func TestRenderHTMLTemplate(t *testing.T) {
@ -283,8 +283,8 @@ func TestRenderHTMLTemplate(t *testing.T) {
err := instance.Render(w) err := instance.Render(w)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, w.Body.String(), "Hello alexandernyquist") assert.Equal(t, "Hello alexandernyquist", w.Body.String())
assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8") assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
} }
func TestRenderHTMLTemplateEmptyName(t *testing.T) { func TestRenderHTMLTemplateEmptyName(t *testing.T) {
@ -299,8 +299,8 @@ func TestRenderHTMLTemplateEmptyName(t *testing.T) {
err := instance.Render(w) err := instance.Render(w)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, w.Body.String(), "Hello alexandernyquist") assert.Equal(t, "Hello alexandernyquist", w.Body.String())
assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8") assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
} }
func TestRenderHTMLDebugFiles(t *testing.T) { func TestRenderHTMLDebugFiles(t *testing.T) {
@ -317,8 +317,8 @@ func TestRenderHTMLDebugFiles(t *testing.T) {
err := instance.Render(w) err := instance.Render(w)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, w.Body.String(), "<h1>Hello thinkerou</h1>") assert.Equal(t, "<h1>Hello thinkerou</h1>", w.Body.String())
assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8") assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
} }
func TestRenderHTMLDebugGlob(t *testing.T) { func TestRenderHTMLDebugGlob(t *testing.T) {
@ -335,8 +335,8 @@ func TestRenderHTMLDebugGlob(t *testing.T) {
err := instance.Render(w) err := instance.Render(w)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, w.Body.String(), "<h1>Hello thinkerou</h1>") assert.Equal(t, "<h1>Hello thinkerou</h1>", w.Body.String())
assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8") assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
} }
func TestRenderHTMLDebugPanics(t *testing.T) { func TestRenderHTMLDebugPanics(t *testing.T) {