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`)
|
|
}
|