mirror of https://github.com/gogits/gogs.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
701 lines
16 KiB
701 lines
16 KiB
// Copyright 2013 The Martini Contrib Authors. All rights reserved. |
|
// Copyright 2014 The Gogs Authors. All rights reserved. |
|
// Use of this source code is governed by a MIT-style |
|
// license that can be found in the LICENSE file. |
|
|
|
package middleware |
|
|
|
import ( |
|
"bytes" |
|
"mime/multipart" |
|
"net/http" |
|
"net/http/httptest" |
|
"strconv" |
|
"strings" |
|
"testing" |
|
|
|
"github.com/codegangsta/martini" |
|
) |
|
|
|
func TestBind(t *testing.T) { |
|
testBind(t, false) |
|
} |
|
|
|
func TestBindWithInterface(t *testing.T) { |
|
testBind(t, true) |
|
} |
|
|
|
func TestMultipartBind(t *testing.T) { |
|
index := 0 |
|
for test, expectStatus := range bindMultipartTests { |
|
handler := func(post BlogPost, errors Errors) { |
|
handle(test, t, index, post, errors) |
|
} |
|
recorder := testMultipart(t, test, Bind(BlogPost{}), handler, index) |
|
|
|
if recorder.Code != expectStatus { |
|
t.Errorf("On test case %v, got status code %d but expected %d", test, recorder.Code, expectStatus) |
|
} |
|
|
|
index++ |
|
} |
|
} |
|
|
|
func TestForm(t *testing.T) { |
|
testForm(t, false) |
|
} |
|
|
|
func TestFormWithInterface(t *testing.T) { |
|
testForm(t, true) |
|
} |
|
|
|
func TestEmptyForm(t *testing.T) { |
|
testEmptyForm(t) |
|
} |
|
|
|
func TestMultipartForm(t *testing.T) { |
|
for index, test := range multipartformTests { |
|
handler := func(post BlogPost, errors Errors) { |
|
handle(test, t, index, post, errors) |
|
} |
|
testMultipart(t, test, MultipartForm(BlogPost{}), handler, index) |
|
} |
|
} |
|
|
|
func TestMultipartFormWithInterface(t *testing.T) { |
|
for index, test := range multipartformTests { |
|
handler := func(post Modeler, errors Errors) { |
|
post.Create(test, t, index) |
|
} |
|
testMultipart(t, test, MultipartForm(BlogPost{}, (*Modeler)(nil)), handler, index) |
|
} |
|
} |
|
|
|
func TestJson(t *testing.T) { |
|
testJson(t, false) |
|
} |
|
|
|
func TestJsonWithInterface(t *testing.T) { |
|
testJson(t, true) |
|
} |
|
|
|
func TestEmptyJson(t *testing.T) { |
|
testEmptyJson(t) |
|
} |
|
|
|
func TestValidate(t *testing.T) { |
|
handlerMustErr := func(errors Errors) { |
|
if errors.Count() == 0 { |
|
t.Error("Expected at least one error, got 0") |
|
} |
|
} |
|
handlerNoErr := func(errors Errors) { |
|
if errors.Count() > 0 { |
|
t.Error("Expected no errors, got", errors.Count()) |
|
} |
|
} |
|
|
|
performValidationTest(&BlogPost{"", "...", 0, 0, []int{}}, handlerMustErr, t) |
|
performValidationTest(&BlogPost{"Good Title", "Good content", 0, 0, []int{}}, handlerNoErr, t) |
|
|
|
performValidationTest(&User{Name: "Jim", Home: Address{"", ""}}, handlerMustErr, t) |
|
performValidationTest(&User{Name: "Jim", Home: Address{"required", ""}}, handlerNoErr, t) |
|
} |
|
|
|
func handle(test testCase, t *testing.T, index int, post BlogPost, errors Errors) { |
|
assertEqualField(t, "Title", index, test.ref.Title, post.Title) |
|
assertEqualField(t, "Content", index, test.ref.Content, post.Content) |
|
assertEqualField(t, "Views", index, test.ref.Views, post.Views) |
|
|
|
for i := range test.ref.Multiple { |
|
if i >= len(post.Multiple) { |
|
t.Errorf("Expected: %v (size %d) to have same size as: %v (size %d)", post.Multiple, len(post.Multiple), test.ref.Multiple, len(test.ref.Multiple)) |
|
break |
|
} |
|
if test.ref.Multiple[i] != post.Multiple[i] { |
|
t.Errorf("Expected: %v to deep equal: %v", post.Multiple, test.ref.Multiple) |
|
break |
|
} |
|
} |
|
|
|
if test.ok && errors.Count() > 0 { |
|
t.Errorf("%+v should be OK (0 errors), but had errors: %+v", test, errors) |
|
} else if !test.ok && errors.Count() == 0 { |
|
t.Errorf("%+v should have errors, but was OK (0 errors)", test) |
|
} |
|
} |
|
|
|
func handleEmpty(test emptyPayloadTestCase, t *testing.T, index int, section BlogSection, errors Errors) { |
|
assertEqualField(t, "Title", index, test.ref.Title, section.Title) |
|
assertEqualField(t, "Content", index, test.ref.Content, section.Content) |
|
|
|
if test.ok && errors.Count() > 0 { |
|
t.Errorf("%+v should be OK (0 errors), but had errors: %+v", test, errors) |
|
} else if !test.ok && errors.Count() == 0 { |
|
t.Errorf("%+v should have errors, but was OK (0 errors)", test) |
|
} |
|
} |
|
|
|
func testBind(t *testing.T, withInterface bool) { |
|
index := 0 |
|
for test, expectStatus := range bindTests { |
|
m := martini.Classic() |
|
recorder := httptest.NewRecorder() |
|
handler := func(post BlogPost, errors Errors) { handle(test, t, index, post, errors) } |
|
binding := Bind(BlogPost{}) |
|
|
|
if withInterface { |
|
handler = func(post BlogPost, errors Errors) { |
|
post.Create(test, t, index) |
|
} |
|
binding = Bind(BlogPost{}, (*Modeler)(nil)) |
|
} |
|
|
|
switch test.method { |
|
case "GET": |
|
m.Get(route, binding, handler) |
|
case "POST": |
|
m.Post(route, binding, handler) |
|
} |
|
|
|
req, err := http.NewRequest(test.method, test.path, strings.NewReader(test.payload)) |
|
req.Header.Add("Content-Type", test.contentType) |
|
|
|
if err != nil { |
|
t.Error(err) |
|
} |
|
m.ServeHTTP(recorder, req) |
|
|
|
if recorder.Code != expectStatus { |
|
t.Errorf("On test case %v, got status code %d but expected %d", test, recorder.Code, expectStatus) |
|
} |
|
|
|
index++ |
|
} |
|
} |
|
|
|
func testJson(t *testing.T, withInterface bool) { |
|
for index, test := range jsonTests { |
|
recorder := httptest.NewRecorder() |
|
handler := func(post BlogPost, errors Errors) { handle(test, t, index, post, errors) } |
|
binding := Json(BlogPost{}) |
|
|
|
if withInterface { |
|
handler = func(post BlogPost, errors Errors) { |
|
post.Create(test, t, index) |
|
} |
|
binding = Bind(BlogPost{}, (*Modeler)(nil)) |
|
} |
|
|
|
m := martini.Classic() |
|
switch test.method { |
|
case "GET": |
|
m.Get(route, binding, handler) |
|
case "POST": |
|
m.Post(route, binding, handler) |
|
case "PUT": |
|
m.Put(route, binding, handler) |
|
case "DELETE": |
|
m.Delete(route, binding, handler) |
|
} |
|
|
|
req, err := http.NewRequest(test.method, route, strings.NewReader(test.payload)) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
m.ServeHTTP(recorder, req) |
|
} |
|
} |
|
|
|
func testEmptyJson(t *testing.T) { |
|
for index, test := range emptyPayloadTests { |
|
recorder := httptest.NewRecorder() |
|
handler := func(section BlogSection, errors Errors) { handleEmpty(test, t, index, section, errors) } |
|
binding := Json(BlogSection{}) |
|
|
|
m := martini.Classic() |
|
switch test.method { |
|
case "GET": |
|
m.Get(route, binding, handler) |
|
case "POST": |
|
m.Post(route, binding, handler) |
|
case "PUT": |
|
m.Put(route, binding, handler) |
|
case "DELETE": |
|
m.Delete(route, binding, handler) |
|
} |
|
|
|
req, err := http.NewRequest(test.method, route, strings.NewReader(test.payload)) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
m.ServeHTTP(recorder, req) |
|
} |
|
} |
|
|
|
func testForm(t *testing.T, withInterface bool) { |
|
for index, test := range formTests { |
|
recorder := httptest.NewRecorder() |
|
handler := func(post BlogPost, errors Errors) { handle(test, t, index, post, errors) } |
|
binding := Form(BlogPost{}) |
|
|
|
if withInterface { |
|
handler = func(post BlogPost, errors Errors) { |
|
post.Create(test, t, index) |
|
} |
|
binding = Form(BlogPost{}, (*Modeler)(nil)) |
|
} |
|
|
|
m := martini.Classic() |
|
switch test.method { |
|
case "GET": |
|
m.Get(route, binding, handler) |
|
case "POST": |
|
m.Post(route, binding, handler) |
|
} |
|
|
|
req, err := http.NewRequest(test.method, test.path, nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
m.ServeHTTP(recorder, req) |
|
} |
|
} |
|
|
|
func testEmptyForm(t *testing.T) { |
|
for index, test := range emptyPayloadTests { |
|
recorder := httptest.NewRecorder() |
|
handler := func(section BlogSection, errors Errors) { handleEmpty(test, t, index, section, errors) } |
|
binding := Form(BlogSection{}) |
|
|
|
m := martini.Classic() |
|
switch test.method { |
|
case "GET": |
|
m.Get(route, binding, handler) |
|
case "POST": |
|
m.Post(route, binding, handler) |
|
} |
|
|
|
req, err := http.NewRequest(test.method, test.path, nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
m.ServeHTTP(recorder, req) |
|
} |
|
} |
|
|
|
func testMultipart(t *testing.T, test testCase, middleware martini.Handler, handler martini.Handler, index int) *httptest.ResponseRecorder { |
|
recorder := httptest.NewRecorder() |
|
|
|
m := martini.Classic() |
|
m.Post(route, middleware, handler) |
|
|
|
body := &bytes.Buffer{} |
|
writer := multipart.NewWriter(body) |
|
writer.WriteField("title", test.ref.Title) |
|
writer.WriteField("content", test.ref.Content) |
|
writer.WriteField("views", strconv.Itoa(test.ref.Views)) |
|
if len(test.ref.Multiple) != 0 { |
|
for _, value := range test.ref.Multiple { |
|
writer.WriteField("multiple", strconv.Itoa(value)) |
|
} |
|
} |
|
|
|
req, err := http.NewRequest(test.method, test.path, body) |
|
req.Header.Add("Content-Type", writer.FormDataContentType()) |
|
|
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
err = writer.Close() |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
m.ServeHTTP(recorder, req) |
|
|
|
return recorder |
|
} |
|
|
|
func assertEqualField(t *testing.T, fieldname string, testcasenumber int, expected interface{}, got interface{}) { |
|
if expected != got { |
|
t.Errorf("%s: expected=%s, got=%s in test case %d\n", fieldname, expected, got, testcasenumber) |
|
} |
|
} |
|
|
|
func performValidationTest(data interface{}, handler func(Errors), t *testing.T) { |
|
recorder := httptest.NewRecorder() |
|
m := martini.Classic() |
|
m.Get(route, Validate(data), handler) |
|
|
|
req, err := http.NewRequest("GET", route, nil) |
|
if err != nil { |
|
t.Error("HTTP error:", err) |
|
} |
|
|
|
m.ServeHTTP(recorder, req) |
|
} |
|
|
|
func (self BlogPost) Validate(errors *Errors, req *http.Request) { |
|
if len(self.Title) < 4 { |
|
errors.Fields["Title"] = "Too short; minimum 4 characters" |
|
} |
|
if len(self.Content) > 1024 { |
|
errors.Fields["Content"] = "Too long; maximum 1024 characters" |
|
} |
|
if len(self.Content) < 5 { |
|
errors.Fields["Content"] = "Too short; minimum 5 characters" |
|
} |
|
} |
|
|
|
func (self BlogPost) Create(test testCase, t *testing.T, index int) { |
|
assertEqualField(t, "Title", index, test.ref.Title, self.Title) |
|
assertEqualField(t, "Content", index, test.ref.Content, self.Content) |
|
assertEqualField(t, "Views", index, test.ref.Views, self.Views) |
|
|
|
for i := range test.ref.Multiple { |
|
if i >= len(self.Multiple) { |
|
t.Errorf("Expected: %v (size %d) to have same size as: %v (size %d)", self.Multiple, len(self.Multiple), test.ref.Multiple, len(test.ref.Multiple)) |
|
break |
|
} |
|
if test.ref.Multiple[i] != self.Multiple[i] { |
|
t.Errorf("Expected: %v to deep equal: %v", self.Multiple, test.ref.Multiple) |
|
break |
|
} |
|
} |
|
} |
|
|
|
func (self BlogSection) Create(test emptyPayloadTestCase, t *testing.T, index int) { |
|
// intentionally left empty |
|
} |
|
|
|
type ( |
|
testCase struct { |
|
method string |
|
path string |
|
payload string |
|
contentType string |
|
ok bool |
|
ref *BlogPost |
|
} |
|
|
|
emptyPayloadTestCase struct { |
|
method string |
|
path string |
|
payload string |
|
contentType string |
|
ok bool |
|
ref *BlogSection |
|
} |
|
|
|
Modeler interface { |
|
Create(test testCase, t *testing.T, index int) |
|
} |
|
|
|
BlogPost struct { |
|
Title string `form:"title" json:"title" binding:"required"` |
|
Content string `form:"content" json:"content"` |
|
Views int `form:"views" json:"views"` |
|
internal int `form:"-"` |
|
Multiple []int `form:"multiple"` |
|
} |
|
|
|
BlogSection struct { |
|
Title string `form:"title" json:"title"` |
|
Content string `form:"content" json:"content"` |
|
} |
|
|
|
User struct { |
|
Name string `json:"name" binding:"required"` |
|
Home Address `json:"address" binding:"required"` |
|
} |
|
|
|
Address struct { |
|
Street1 string `json:"street1" binding:"required"` |
|
Street2 string `json:"street2"` |
|
} |
|
) |
|
|
|
var ( |
|
bindTests = map[testCase]int{ |
|
// These should bail at the deserialization/binding phase |
|
testCase{ |
|
"POST", |
|
path, |
|
`{ bad JSON `, |
|
"application/json", |
|
false, |
|
new(BlogPost), |
|
}: http.StatusBadRequest, |
|
testCase{ |
|
"POST", |
|
path, |
|
`not multipart but has content-type`, |
|
"multipart/form-data", |
|
false, |
|
new(BlogPost), |
|
}: http.StatusBadRequest, |
|
testCase{ |
|
"POST", |
|
path, |
|
`no content-type and not URL-encoded or JSON"`, |
|
"", |
|
false, |
|
new(BlogPost), |
|
}: http.StatusBadRequest, |
|
|
|
// These should deserialize, then bail at the validation phase |
|
testCase{ |
|
"POST", |
|
path + "?title= This is wrong ", |
|
`not URL-encoded but has content-type`, |
|
"x-www-form-urlencoded", |
|
false, |
|
new(BlogPost), |
|
}: 422, // according to comments in Form() -> although the request is not url encoded, ParseForm does not complain |
|
testCase{ |
|
"GET", |
|
path + "?content=This+is+the+content", |
|
``, |
|
"x-www-form-urlencoded", |
|
false, |
|
&BlogPost{Title: "", Content: "This is the content"}, |
|
}: 422, |
|
testCase{ |
|
"GET", |
|
path + "", |
|
`{"content":"", "title":"Blog Post Title"}`, |
|
"application/json", |
|
false, |
|
&BlogPost{Title: "Blog Post Title", Content: ""}, |
|
}: 422, |
|
|
|
// These should succeed |
|
testCase{ |
|
"GET", |
|
path + "", |
|
`{"content":"This is the content", "title":"Blog Post Title"}`, |
|
"application/json", |
|
true, |
|
&BlogPost{Title: "Blog Post Title", Content: "This is the content"}, |
|
}: http.StatusOK, |
|
testCase{ |
|
"GET", |
|
path + "?content=This+is+the+content&title=Blog+Post+Title", |
|
``, |
|
"", |
|
true, |
|
&BlogPost{Title: "Blog Post Title", Content: "This is the content"}, |
|
}: http.StatusOK, |
|
testCase{ |
|
"GET", |
|
path + "?content=This is the content&title=Blog+Post+Title", |
|
`{"content":"This is the content", "title":"Blog Post Title"}`, |
|
"", |
|
true, |
|
&BlogPost{Title: "Blog Post Title", Content: "This is the content"}, |
|
}: http.StatusOK, |
|
testCase{ |
|
"GET", |
|
path + "", |
|
`{"content":"This is the content", "title":"Blog Post Title"}`, |
|
"", |
|
true, |
|
&BlogPost{Title: "Blog Post Title", Content: "This is the content"}, |
|
}: http.StatusOK, |
|
} |
|
|
|
bindMultipartTests = map[testCase]int{ |
|
// This should deserialize, then bail at the validation phase |
|
testCase{ |
|
"POST", |
|
path, |
|
"", |
|
"multipart/form-data", |
|
false, |
|
&BlogPost{Title: "", Content: "This is the content"}, |
|
}: 422, |
|
// This should succeed |
|
testCase{ |
|
"POST", |
|
path, |
|
"", |
|
"multipart/form-data", |
|
true, |
|
&BlogPost{Title: "This is the Title", Content: "This is the content"}, |
|
}: http.StatusOK, |
|
} |
|
|
|
formTests = []testCase{ |
|
{ |
|
"GET", |
|
path + "?content=This is the content", |
|
"", |
|
"", |
|
false, |
|
&BlogPost{Title: "", Content: "This is the content"}, |
|
}, |
|
{ |
|
"POST", |
|
path + "?content=This+is+the+content&title=Blog+Post+Title&views=3", |
|
"", |
|
"", |
|
false, // false because POST requests should have a body, not just a query string |
|
&BlogPost{Title: "Blog Post Title", Content: "This is the content", Views: 3}, |
|
}, |
|
{ |
|
"GET", |
|
path + "?content=This+is+the+content&title=Blog+Post+Title&views=3&multiple=5&multiple=10&multiple=15&multiple=20", |
|
"", |
|
"", |
|
true, |
|
&BlogPost{Title: "Blog Post Title", Content: "This is the content", Views: 3, Multiple: []int{5, 10, 15, 20}}, |
|
}, |
|
} |
|
|
|
multipartformTests = []testCase{ |
|
{ |
|
"POST", |
|
path, |
|
"", |
|
"multipart/form-data", |
|
false, |
|
&BlogPost{Title: "", Content: "This is the content"}, |
|
}, |
|
{ |
|
"POST", |
|
path, |
|
"", |
|
"multipart/form-data", |
|
false, |
|
&BlogPost{Title: "Blog Post Title", Views: 3}, |
|
}, |
|
{ |
|
"POST", |
|
path, |
|
"", |
|
"multipart/form-data", |
|
true, |
|
&BlogPost{Title: "Blog Post Title", Content: "This is the content", Views: 3, Multiple: []int{5, 10, 15, 20}}, |
|
}, |
|
} |
|
|
|
emptyPayloadTests = []emptyPayloadTestCase{ |
|
{ |
|
"GET", |
|
"", |
|
"", |
|
"", |
|
true, |
|
&BlogSection{}, |
|
}, |
|
{ |
|
"POST", |
|
"", |
|
"", |
|
"", |
|
true, |
|
&BlogSection{}, |
|
}, |
|
{ |
|
"PUT", |
|
"", |
|
"", |
|
"", |
|
true, |
|
&BlogSection{}, |
|
}, |
|
{ |
|
"DELETE", |
|
"", |
|
"", |
|
"", |
|
true, |
|
&BlogSection{}, |
|
}, |
|
} |
|
|
|
jsonTests = []testCase{ |
|
// bad requests |
|
{ |
|
"GET", |
|
"", |
|
`{blah blah blah}`, |
|
"", |
|
false, |
|
&BlogPost{}, |
|
}, |
|
{ |
|
"POST", |
|
"", |
|
`{asdf}`, |
|
"", |
|
false, |
|
&BlogPost{}, |
|
}, |
|
{ |
|
"PUT", |
|
"", |
|
`{blah blah blah}`, |
|
"", |
|
false, |
|
&BlogPost{}, |
|
}, |
|
{ |
|
"DELETE", |
|
"", |
|
`{;sdf _SDf- }`, |
|
"", |
|
false, |
|
&BlogPost{}, |
|
}, |
|
|
|
// Valid-JSON requests |
|
{ |
|
"GET", |
|
"", |
|
`{"content":"This is the content"}`, |
|
"", |
|
false, |
|
&BlogPost{Title: "", Content: "This is the content"}, |
|
}, |
|
{ |
|
"POST", |
|
"", |
|
`{}`, |
|
"application/json", |
|
false, |
|
&BlogPost{Title: "", Content: ""}, |
|
}, |
|
{ |
|
"POST", |
|
"", |
|
`{"content":"This is the content", "title":"Blog Post Title"}`, |
|
"", |
|
true, |
|
&BlogPost{Title: "Blog Post Title", Content: "This is the content"}, |
|
}, |
|
{ |
|
"PUT", |
|
"", |
|
`{"content":"This is the content", "title":"Blog Post Title"}`, |
|
"", |
|
true, |
|
&BlogPost{Title: "Blog Post Title", Content: "This is the content"}, |
|
}, |
|
{ |
|
"DELETE", |
|
"", |
|
`{"content":"This is the content", "title":"Blog Post Title"}`, |
|
"", |
|
true, |
|
&BlogPost{Title: "Blog Post Title", Content: "This is the content"}, |
|
}, |
|
} |
|
) |
|
|
|
const ( |
|
route = "/blogposts/create" |
|
path = "http://localhost:3000" + route |
|
)
|
|
|