blackteay/gin
3
0
Fork 0
mirror of https://github.com/gin-gonic/gin.git synced 2025-10-23 18:22:23 +08:00
Code Issues Projects Releases Wiki Activity

unify assert.Equal usage

Browse Source
This commit is contained in:
thinkerou 2018-04-20 07:27:38 +08:00
parent 5a1c743045
commit 1486c12e21
3 changed files with 115 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

174
binding/binding_test.go
View File

@ -145,26 +145,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) {
@ -468,9 +468,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, "foor", obj.Bar)
} }
func TestBindingDefaultValueFormPost(t *testing.T) { func TestBindingDefaultValueFormPost(t *testing.T) {
@ -478,8 +478,8 @@ func TestBindingDefaultValueFormPost(t *testing.T) {
var obj FooDefaultBarStruct var obj FooDefaultBarStruct
FormPost.Bind(req, &obj) FormPost.Bind(req, &obj)
assert.Equal(t, obj.Foo, "bar") assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, obj.Bar, "hello") assert.Equal(t, "hello", obj.Bar)
} }
func TestBindingFormPostFail(t *testing.T) { func TestBindingFormPostFail(t *testing.T) {
@ -494,9 +494,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", FormMultpart.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) {
@ -592,7 +592,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)
@ -601,8 +601,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)
@ -612,7 +612,7 @@ func testFormBinding(t *testing.T, method, path, badPath, body, badBody string)
func testFormBindingDefaultValue(t *testing.T, method, path, badPath, body, badBody string) { func testFormBindingDefaultValue(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 := FooDefaultBarStruct{} obj := FooDefaultBarStruct{}
req := requestWithBody(method, path, body) req := requestWithBody(method, path, body)
@ -621,8 +621,8 @@ func testFormBindingDefaultValue(t *testing.T, method, path, badPath, body, badB
} }
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, "hello") assert.Equal(t, "hello", obj.Bar)
obj = FooDefaultBarStruct{} obj = FooDefaultBarStruct{}
req = requestWithBody(method, badPath, badBody) req = requestWithBody(method, badPath, badBody)
@ -632,7 +632,7 @@ func testFormBindingDefaultValue(t *testing.T, method, path, badPath, body, badB
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)
@ -642,7 +642,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)
@ -652,7 +652,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)
@ -662,7 +662,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)
@ -672,10 +672,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)
@ -685,7 +685,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)
@ -703,7 +703,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)
@ -721,7 +721,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)
@ -739,7 +739,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)
@ -748,7 +748,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)
@ -758,7 +758,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)
@ -776,7 +776,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" {
@ -787,8 +787,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)
@ -798,8 +798,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)
@ -809,8 +809,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)
@ -820,8 +820,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)
@ -831,8 +831,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)
@ -842,8 +842,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)
@ -853,8 +853,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)
@ -864,8 +864,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)
@ -875,8 +875,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)
@ -886,8 +886,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)
@ -897,8 +897,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)
@ -908,8 +908,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)
@ -919,8 +919,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)
@ -930,7 +930,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)
@ -949,7 +949,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)
@ -958,13 +958,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)
@ -976,13 +976,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)
@ -991,7 +991,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)
@ -1001,7 +1001,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)
@ -1010,7 +1010,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)
@ -1019,7 +1019,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)
@ -1028,13 +1028,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)
@ -1043,14 +1043,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)
@ -1066,7 +1066,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)
@ -1084,14 +1084,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) {