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.
532 lines
11 KiB
532 lines
11 KiB
// Copyright 2015 The Tango Authors. All rights reserved. |
|
// Use of this source code is governed by a BSD-style |
|
// license that can be found in the LICENSE file. |
|
|
|
package tango |
|
|
|
import ( |
|
"bytes" |
|
"encoding/xml" |
|
"errors" |
|
"net/http" |
|
"net/http/httptest" |
|
"strings" |
|
"testing" |
|
) |
|
|
|
type MyReturn struct { |
|
} |
|
|
|
func (m MyReturn) Get() string { |
|
return "string return" |
|
} |
|
|
|
func (m MyReturn) Post() []byte { |
|
return []byte("bytes return") |
|
} |
|
|
|
func (m MyReturn) Put() error { |
|
return errors.New("error return") |
|
} |
|
|
|
func TestReturn(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Any("/", new(MyReturn)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, buff.String(), "string return") |
|
|
|
buff.Reset() |
|
req, err = http.NewRequest("POST", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, buff.String(), "bytes return") |
|
} |
|
|
|
func TestReturnPut(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Any("/", new(MyReturn)) |
|
|
|
req, err := http.NewRequest("PUT", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusInternalServerError) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, buff.String(), "error return") |
|
} |
|
|
|
type MyReturn2 struct { |
|
} |
|
|
|
func (m MyReturn2) Any() string { |
|
return "string return" |
|
} |
|
|
|
func TestReturn2(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Any("/", new(MyReturn2)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, buff.String(), "string return") |
|
|
|
buff.Reset() |
|
req, err = http.NewRequest("POST", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, buff.String(), "string return") |
|
} |
|
|
|
type MyReturn3 struct { |
|
JSON |
|
} |
|
|
|
func (m MyReturn3) Any() interface{} { |
|
return map[string]interface{}{ |
|
"a": "b", |
|
} |
|
} |
|
|
|
func TestReturn3(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Any("/", new(MyReturn3)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `{"a":"b"}`) |
|
|
|
buff.Reset() |
|
req, err = http.NewRequest("POST", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `{"a":"b"}`) |
|
} |
|
|
|
type MyReturn4 struct { |
|
JSON |
|
} |
|
|
|
func (m MyReturn4) Any() interface{} { |
|
return map[string]interface{}{ |
|
"a": "b", |
|
} |
|
} |
|
|
|
func TestReturn4(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Group("/1", func(g *Group) { |
|
g.Any("/", new(MyReturn4)) |
|
}) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/1", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `{"a":"b"}`) |
|
|
|
buff.Reset() |
|
req, err = http.NewRequest("POST", "http://localhost:8000/1", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `{"a":"b"}`) |
|
} |
|
|
|
type JSONReturn struct { |
|
JSON |
|
} |
|
|
|
func (JSONReturn) Get() interface{} { |
|
return map[string]interface{}{ |
|
"test1": 1, |
|
"test2": "2", |
|
"test3": true, |
|
} |
|
} |
|
|
|
func TestReturnJson1(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Get("/", new(JSONReturn)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `{"test1":1,"test2":"2","test3":true}`) |
|
} |
|
|
|
type JSONErrReturn struct { |
|
JSON |
|
} |
|
|
|
func (JSONErrReturn) Get() error { |
|
return errors.New("error") |
|
} |
|
|
|
func TestReturnJsonError(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Get("/", new(JSONErrReturn)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `{"err":"error"}`) |
|
} |
|
|
|
type JSONErrReturn2 struct { |
|
JSON |
|
} |
|
|
|
func (JSONErrReturn2) Get() error { |
|
return Abort(http.StatusInternalServerError, "error") |
|
} |
|
|
|
func TestReturnJsonError2(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Get("/", new(JSONErrReturn2)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusInternalServerError) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `{"err":"error"}`) |
|
} |
|
|
|
type JSONErrReturn3 struct { |
|
JSON |
|
} |
|
|
|
type MyError struct { |
|
} |
|
|
|
func (m *MyError) Error() string { |
|
return "error" |
|
} |
|
|
|
func (m *MyError) ErrorCode() int { |
|
return 1 |
|
} |
|
|
|
func (JSONErrReturn3) Get() error { |
|
return &MyError{} |
|
} |
|
|
|
func TestReturnJsonError3(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Get("/", new(JSONErrReturn3)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `{"err":"error","err_code":1}`) |
|
} |
|
|
|
type JSONReturn1 struct { |
|
JSON |
|
} |
|
|
|
func (JSONReturn1) Get() string { |
|
return "return" |
|
} |
|
|
|
func TestReturnJson2(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Get("/", new(JSONReturn1)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `{"content":"return"}`) |
|
} |
|
|
|
type JSONReturn2 struct { |
|
JSON |
|
} |
|
|
|
func (JSONReturn2) Get() []byte { |
|
return []byte("return") |
|
} |
|
|
|
func TestReturnJson3(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Get("/", new(JSONReturn2)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `{"content":"return"}`) |
|
} |
|
|
|
type JSONReturn3 struct { |
|
JSON |
|
} |
|
|
|
func (JSONReturn3) Get() (int, interface{}) { |
|
if true { |
|
return 201, map[string]string{ |
|
"say": "Hello tango!", |
|
} |
|
} |
|
return 500, errors.New("something error") |
|
} |
|
|
|
func TestReturnJson4(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Get("/", new(JSONReturn3)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, 201) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `{"say":"Hello tango!"}`) |
|
} |
|
|
|
type XMLReturn struct { |
|
XML |
|
} |
|
|
|
type Address struct { |
|
City, State string |
|
} |
|
type Person struct { |
|
XMLName xml.Name `xml:"person"` |
|
ID int `xml:"id,attr"` |
|
FirstName string `xml:"name>first"` |
|
LastName string `xml:"name>last"` |
|
Age int `xml:"age"` |
|
Height float32 `xml:"height,omitempty"` |
|
Married bool |
|
Address |
|
Comment string `xml:",comment"` |
|
} |
|
|
|
func (XMLReturn) Get() interface{} { |
|
v := &Person{ID: 13, FirstName: "John", LastName: "Doe", Age: 42} |
|
v.Comment = " Need more details. " |
|
v.Address = Address{"Hanga Roa", "Easter Island"} |
|
return v |
|
} |
|
|
|
func TestReturnXML(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Get("/", new(XMLReturn)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, buff.String(), `<person id="13"><name><first>John</first><last>Doe</last></name><age>42</age><Married>false</Married><City>Hanga Roa</City><State>Easter Island</State><!-- Need more details. --></person>`) |
|
} |
|
|
|
type XMLErrReturn struct { |
|
XML |
|
} |
|
|
|
func (XMLErrReturn) Get() error { |
|
return errors.New("error") |
|
} |
|
|
|
func TestReturnXmlError(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Get("/", new(XMLErrReturn)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, http.StatusOK) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `<err><content>error</content></err>`) |
|
} |
|
|
|
type JSONReturn7 struct { |
|
JSON |
|
} |
|
|
|
func (JSONReturn7) Get() (int, interface{}) { |
|
return 201, "sss" |
|
} |
|
|
|
func TestReturn7(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Get("/", new(JSONReturn7)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, 201) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `{"content":"sss"}`) |
|
} |
|
|
|
type Return8 struct { |
|
} |
|
|
|
func (Return8) Get() (int, interface{}) { |
|
return 403, "xxx" |
|
} |
|
|
|
func TestReturn8(t *testing.T) { |
|
buff := bytes.NewBufferString("") |
|
recorder := httptest.NewRecorder() |
|
recorder.Body = buff |
|
|
|
o := Classic() |
|
o.Get("/", new(Return8)) |
|
|
|
req, err := http.NewRequest("GET", "http://localhost:8000/", nil) |
|
if err != nil { |
|
t.Error(err) |
|
} |
|
|
|
o.ServeHTTP(recorder, req) |
|
expect(t, recorder.Code, 403) |
|
refute(t, len(buff.String()), 0) |
|
expect(t, strings.TrimSpace(buff.String()), `xxx`) |
|
}
|
|
|