func Test_Context_RedirectWithAbort(t *testing.T) {
recorder := httptest.NewRecorder()
request, _ := http.NewRequest("GET", "/path/to/resource?key=url_value&test=url_true", nil)
location := "https://www.example.com"
assertion := assert.New(t)
ctx := NewContext(newMockServer())
ctx.Request = request
ctx.Response = &Response{
ResponseWriter: recorder,
}
ctx.handlers = []Middleware{
func(ctx *Context) {
ctx.Redirect(location)
ctx.Next()
},
func(ctx *Context) {
ctx.Render(NewDefaultRender(ctx.Response), "next render")
},
}
ctx.Next()
assertion.Equal(location, recorder.Header().Get("Location"))
assertion.NotContains(recorder.Body.String(), "next render")
}
func Test_RouteMockHandle(t *testing.T) {
server := newMockServer()
route := NewAppRoute("/", server)
response := httptest.NewRecorder()
assertion := assert.New(t)
// mock handler
route.MockHandle("GET", "/mock", response, func(ctx *Context) {
ctx.Text("MOCK")
})
// start server
ts := httptest.NewServer(server)
defer ts.Close()
// testing by http request
request, _ := http.NewRequest("GET", ts.URL+"/mock", nil)
res, err := http.DefaultClient.Do(request)
assertion.Nil(err)
body, err := ioutil.ReadAll(res.Body)
res.Body.Close()
assertion.Nil(err)
assertion.Empty(body)
assertion.Equal(http.StatusOK, response.Code)
assertion.Equal("MOCK", response.Body.String())
}
func Test_MultipartRequest(t *testing.T) {
assertion := assert.New(t)
method := "put"
uri := "/put/multipart"
filename := "gopher.png"
file := filepath.Clean("./fixtures/gopher.png")
params := map[string]string{"form_key": "form_value"}
server := newMockServer(method, uri, func(w http.ResponseWriter, r *http.Request) {
assertion.Equal(method, r.Method)
assertion.Equal("/put/multipart", r.RequestURI)
assertion.Equal("form_value", r.FormValue("form_key"))
freader, fheader, ferr := r.FormFile("filename")
assertion.Nil(ferr)
assertion.Equal(filename, fheader.Filename)
fb, _ := ioutil.ReadAll(freader)
b, _ := ioutil.ReadFile(file)
assertion.Equal(b, fb)
w.Header().Set("x-request-method", r.Method)
w.WriteHeader(http.StatusNoContent)
w.Write([]byte(""))
})
ts := httptest.NewServer(server)
defer ts.Close()
client := New(ts.URL, false)
client.NewMultipartRequest(t, method, uri, "gopher.png", file, params)
client.AssertStatus(http.StatusNoContent)
client.AssertHeader("x-request-method", method)
client.AssertEmpty()
}
func Test_NewJsonResponder(t *testing.T) {
assertion := assert.New(t)
code := 200
header := http.Header{
"Content-Type": []string{"text/plain"},
"X-Testing": []string{"testing"},
}
body := struct {
Name string `json:"name"`
}{"testing"}
rawurl := "https://example.com"
rawbody := `{"name":"testing"}`
responder := NewJsonResponder(code, header, body)
request, _ := http.NewRequest("GET", rawurl, nil)
response, err := responder.RoundTrip(request)
assertion.Nil(err)
assertion.Equal(code, response.StatusCode)
assertion.Equal("application/json", response.Header.Get("Content-Type"))
assertion.Equal(strconv.Itoa(len(rawbody)), response.Header.Get("Content-Length"))
b, _ := ioutil.ReadAll(response.Body)
response.Body.Close()
assertion.Equal(rawbody, string(b))
}
func Test_PutForm(t *testing.T) {
assertion := assert.New(t)
method := "PUT"
uri := "/put?key"
params := url.Values{"form_key": []string{"form_value"}}
server := newMockServer(method, uri, func(w http.ResponseWriter, r *http.Request) {
assertion.Equal(method, r.Method)
assertion.Equal(uri, r.RequestURI)
assertion.Equal("application/x-www-form-urlencoded", r.Header.Get("Content-Type"))
assertion.Equal("form_value", r.FormValue("form_key"))
_, ok := r.URL.Query()["key"]
assertion.True(ok)
assertion.Empty(r.FormValue("key"))
w.Header().Set("x-request-method", r.Method)
w.WriteHeader(http.StatusOK)
w.Write([]byte(method + " " + uri + " OK!"))
})
ts := httptest.NewServer(server)
defer ts.Close()
client := New(ts.URL, false)
client.PutForm(t, uri, params)
client.AssertOK()
client.AssertHeader("x-request-method", method)
client.AssertContains("PUT /put?key OK!")
}
func Test_NewXmlResponderWithError(t *testing.T) {
assertion := assert.New(t)
code := 200
header := http.Header{
"Content-Type": []string{"text/plain"},
"X-Testing": []string{"testing"},
}
body := struct {
XMLName xml.Name
Ch chan<- bool `xml:"Channel"`
}{
XMLName: xml.Name{
Space: "http://xmlns.example.com",
Local: "Responder",
},
Ch: make(chan<- bool, 1),
}
rawurl := "https://exmaple.com"
responder := NewXmlResponder(code, header, body)
request, _ := http.NewRequest("GET", rawurl, nil)
response, err := responder.RoundTrip(request)
assertion.NotNil(err)
assertion.Nil(response)
}
func Test_NewResponder(t *testing.T) {
assertion := assert.New(t)
code := 200
header := http.Header{
"Content-Type": []string{"text/plain"},
"X-Testing": []string{"testing"},
}
body := "Hello, world!"
rawurl := "https://example.com"
responder := NewResponder(code, header, body)
assertion.Implements((*http.RoundTripper)(nil), responder)
request, _ := http.NewRequest("GET", rawurl, nil)
response, err := responder.RoundTrip(request)
assertion.Nil(err)
assertion.Equal(code, response.StatusCode)
assertion.Equal(strconv.Itoa(len(body)), response.Header.Get("Content-Length"))
assertion.NotNil(response.Request)
b, err := ioutil.ReadAll(response.Body)
response.Body.Close()
assertion.Nil(err)
assertion.Equal(body, string(b))
}
func Test_NewXmlResponder(t *testing.T) {
assertion := assert.New(t)
code := 200
header := http.Header{
"Content-Type": []string{"text/plain"},
"X-Testing": []string{"testing"},
}
body := struct {
XMLName xml.Name
Name string `xml:"Name"`
}{
XMLName: xml.Name{
Space: "http://xmlns.example.com",
Local: "Responder",
},
Name: "testing",
}
rawurl := "https://exmpale.com"
rawbody := `<Responder xmlns="http://xmlns.example.com"><Name>testing</Name></Responder>`
responder := NewXmlResponder(code, header, body)
request, _ := http.NewRequest("GET", rawurl, nil)
response, err := responder.RoundTrip(request)
assertion.Nil(err)
assertion.Equal(code, response.StatusCode)
assertion.Equal("text/xml", response.Header.Get("Content-Type"))
assertion.Equal(strconv.Itoa(len(rawbody)), response.Header.Get("Content-Length"))
b, _ := ioutil.ReadAll(response.Body)
response.Body.Close()
assertion.Equal(rawbody, string(b))
}
func Test_FilterRequest(t *testing.T) {
assertion := assert.New(t)
method := "GET"
uri := "/request/filter"
server := newMockServer(method, uri, func(w http.ResponseWriter, r *http.Request) {
assertion.Equal(method, r.Method)
assertion.Equal("/request/filter", r.RequestURI)
assertion.Equal("request filter", r.Header.Get("X-Filtered-Header"))
w.WriteHeader(http.StatusOK)
w.Write([]byte(""))
})
ts := httptest.NewServer(server)
defer ts.Close()
request, _ := http.NewRequest(method, ts.URL+"/request/filter", nil)
client := New(ts.URL, false)
client.NewFilterRequest(t, request, func(r *http.Request) error {
r.Header.Add("X-Filtered-Header", "request filter")
return nil
})
client.AssertOK()
client.AssertEmpty()
}
func Test_NewAppServer(t *testing.T) {
assertion := assert.New(t)
server := newMockServer()
assertion.Implements((*http.Handler)(nil), server)
assertion.IsType(&Context{}, server.pool.Get())
}
func Test_Context_RequestHeader(t *testing.T) {
recorder := httptest.NewRecorder()
request, _ := http.NewRequest("GET", "https://www.example.com/resource?key=url_value&test=url_true", nil)
request.Header.Add("X-Canonical-Key", "Canonical-Value")
request.Header["x-normal-key"] = []string{"normal value"}
params := NewAppParams(request, httprouter.Params{})
assertion := assert.New(t)
server := newMockServer()
ctx := server.new(recorder, request, params, nil)
assertion.True(ctx.HasRawHeader("X-Canonical-Key"))
assertion.False(ctx.HasRawHeader("x-canonical-key"))
assertion.True(ctx.HasHeader("X-Canonical-Key"))
assertion.True(ctx.HasHeader("x-canonical-key"))
assertion.True(ctx.HasRawHeader("x-normal-key"))
assertion.False(ctx.HasRawHeader("X-Normal-Key"))
assertion.False(ctx.HasHeader("x-normal-key"))
assertion.False(ctx.HasHeader("X-Normal-Key"))
assertion.Equal("Canonical-Value", ctx.RawHeader("X-Canonical-Key"))
assertion.Empty(ctx.RawHeader("x-canonical-key"))
assertion.Equal("Canonical-Value", ctx.Header("X-Canonical-Key"))
assertion.Equal("Canonical-Value", ctx.Header("x-canonical-key"))
assertion.Equal("normal value", ctx.RawHeader("x-normal-key"))
assertion.Empty(ctx.RawHeader("X-Normal-Key"))
assertion.Empty(ctx.Header("x-normal-key"))
assertion.Empty(ctx.Header("X-Normal-Key"))
}
func Test_MitmTransportPauseAndResume(t *testing.T) {
assertion := assert.New(t)
mt := NewMitmTransport()
mt.StubDefaultTransport(t)
defer mt.UnstubDefaultTransport()
// mocks
mt.MockRequest("GET", "https://example.com/").WithResponse(101, nil, "GET OK").AnyTimes()
// response with mocked
response, err := http.Get("mitm://example.com")
assertion.Nil(err)
assertion.Equal(101, response.StatusCode)
// paused and response with real github server
mt.Pause()
response, err = http.Get("mitm://example.com")
assertion.Nil(err)
assertion.Equal(200, response.StatusCode)
// resume and response with mock again
mt.Resume()
response, err = http.Get("mitm://example.com")
assertion.Nil(err)
assertion.Equal(101, response.StatusCode)
}
func Test_AppParamsXml(t *testing.T) {
str := `<Params>
<Key>xml_value</Key>
<Test>true</Test>
</Params>`
request, _ := http.NewRequest("POST", "/path/to/resource?key=url_value&test=url_true", strings.NewReader(str))
request.Header.Set("Content-Type", "application/json")
routeParams := httprouter.Params{
httprouter.Param{"test", "route_true"},
}
assertion := assert.New(t)
p := NewAppParams(request, routeParams)
var params struct {
XMLName xml.Name `xml:"Params"`
Key string `xml:"Key"`
Test bool `xml:"Test"`
}
err := p.Xml(¶ms)
assertion.Nil(err)
assertion.Equal("xml_value", params.Key)
assertion.True(params.Test)
}
func Test_MitmTransportWithTimesError(t *testing.T) {
mt := NewMitmTransport().StubDefaultTransport(t)
defer mt.UnstubDefaultTransport()
assertion := assert.New(t)
type result struct {
Code int `json:"code"`
Name string `json:"name"`
}
// mocks
mt.MockRequest("GET", "http://example.com").WithJsonResponse(200, nil, result{
Code: 200,
Name: "OK",
}).Times(3)
// GET mitm://example.com
for i := 0; i < 3; i++ {
response, err := http.Get("mitm://example.com")
assertion.Nil(err)
assertion.Equal(200, response.StatusCode)
b, err := ioutil.ReadAll(response.Body)
response.Body.Close()
assertion.Nil(err)
assertion.Equal(`{"code":200,"name":"OK"}`, string(b))
}
}
func Test_AppParamsGob(t *testing.T) {
type data struct {
Key string `bson:"key"`
Test bool `bson:"test"`
}
var buf bytes.Buffer
assertion := assert.New(t)
params := data{
Key: "gob_value",
Test: true,
}
err := gob.NewEncoder(&buf).Encode(params)
assertion.Nil(err)
request, _ := http.NewRequest("POST", "/path/to/resource?key=url_value&test=url_true", strings.NewReader(buf.String()))
request.Header.Set("Content-Type", "application/gob")
p := NewAppParams(request, httprouter.Params{})
var temp data
err = p.Gob(&temp)
assertion.Nil(err)
assertion.Equal("gob_value", temp.Key)
assertion.True(temp.Test)
}
func Test_NewObjectId(t *testing.T) {
assertion := assert.New(t)
// Generate 10 ids
ids := make([]ObjectId, 10)
for i := 0; i < 10; i++ {
ids[i] = NewObjectId()
}
for i := 1; i < 10; i++ {
id := ids[i]
prevId := ids[i-1]
// Test for uniqueness among all other 9 generated ids
for j, tid := range ids {
if j != i {
assertion.NotEqual(id, tid)
}
}
// Check that timestamp was incremented and is within 30 seconds of the previous one
assertion.InDelta(prevId.Time().Second(), id.Time().Second(), 0.1)
// Check that machine ids are the same
assertion.Equal(prevId.Machine(), id.Machine())
// Check that pids are the same
assertion.Equal(prevId.Pid(), id.Pid())
// Test for proper increment
assertion.Equal(1, int(id.Counter()-prevId.Counter()))
}
}
func Test_ConfigSection(t *testing.T) {
assertion := assert.New(t)
config, _ := newMockConfig("application.json")
section := config.Section()
assertion.NotNil(section.Server)
assertion.NotNil(section.Logger)
}
func Test_NewConfigWithoutName(t *testing.T) {
assertion := assert.New(t)
config, _ := NewStringAppConfig(`{
"mode": "test"
}`)
assertion.Equal("GOGO", config.Name)
}
func Test_NewConfigWithoutMode(t *testing.T) {
assertion := assert.New(t)
config, _ := NewStringAppConfig(`{
"name": "testing"
}`)
assertion.Equal(Development, config.Mode)
}
func Test_NewResponse(t *testing.T) {
recorder := httptest.NewRecorder()
assertion := assert.New(t)
response := NewResponse(recorder)
assertion.Implements((*Responser)(nil), response)
assertion.Equal(http.StatusOK, response.Status())
assertion.Equal(noneHeaderFlushed, response.Size())
}
func Test_ConfigSetMode(t *testing.T) {
assertion := assert.New(t)
config, _ := newMockConfig("application.json")
assertion.Equal(Test, config.Mode)
config.SetMode(Production)
assertion.Equal(Production, config.Mode)
}
func Test_NewConfig(t *testing.T) {
assertion := assert.New(t)
config, err := newMockConfig("application.json")
assertion.Nil(err)
assertion.Equal(Test, config.Mode)
assertion.Equal("gogo", config.Name)
assertion.NotEmpty(config.Sections)
}
func Test_ResponseWriteHeader(t *testing.T) {
recorder := httptest.NewRecorder()
assertion := assert.New(t)
response := NewResponse(recorder)
response.WriteHeader(http.StatusRequestTimeout)
assertion.Equal(http.StatusRequestTimeout, response.Status())
assertion.Equal(noneHeaderFlushed, response.Size())
}
func Test_NewObjectIdWithTime(t *testing.T) {
ts := time.Unix(12345678, 0)
id := NewObjectIdWithTime(ts)
assertion := assert.New(t)
assertion.Equal(ts, id.Time())
assertion.Equal([]byte{0x00, 0x00, 0x00}, id.Machine())
assertion.EqualValues(0, id.Pid())
assertion.EqualValues(0, id.Counter())
}
func Test_Level_ResolveLevelByName(t *testing.T) {
assertion := assert.New(t)
for level, name := range levels {
assertion.Equal(level, ResolveLevelByName(name))
}
assertion.Equal(lmin, ResolveLevelByName("UNKNOWN"))
}
func Test_MitmTransportStubDefaultTransport(t *testing.T) {
assertion := assert.New(t)
mt := NewMitmTransport()
defer mt.UnstubDefaultTransport()
mt.StubDefaultTransport(t)
assertion.Equal(mt, http.DefaultTransport)
}
func Test_AppParamsHasQuery(t *testing.T) {
request, _ := http.NewRequest("GET", "/path/to/resource?test&key=url_value", nil)
assertion := assert.New(t)
p := NewAppParams(request, httprouter.Params{})
assertion.True(p.HasQuery("test"))
assertion.True(p.HasQuery("key"))
assertion.False(p.HasQuery("un-existed-key"))
}
func Test_NewContext(t *testing.T) {
assertion := assert.New(t)
server := newMockServer()
ctx := NewContext(server)
assertion.Equal(server, ctx.Server)
assertion.EqualValues(-1, ctx.index)
// settings
assertion.Empty(ctx.settings)
value, ok := ctx.Get("unknownSetting")
assertion.False(ok)
assertion.Empty(value)
ctx.Set("middlewareKey", "middlewareValue")
assertion.Equal(1, len(ctx.settings))
value, ok = ctx.Get("middlewareKey")
assertion.True(ok)
assertion.Equal("middlewareValue", value)
// MustGet
assertion.Equal("middlewareValue", ctx.MustGet("middlewareKey"))
assertion.Panics(func() {
ctx.MustGet("unknownSetting")
})
// final settings
assertion.Empty(ctx.frozenSettings)
value, ok = ctx.GetFinal("unknownFinalSetting")
assertion.False(ok)
assertion.Empty(value)
err := ctx.SetFinal("middlewareFinalKey", "middlewareFinalValue")
assertion.Nil(err)
assertion.Equal(1, len(ctx.frozenSettings))
value, ok = ctx.GetFinal("middlewareFinalKey")
assertion.True(ok)
assertion.Equal("middlewareFinalValue", value)
err = ctx.SetFinal("middlewareFinalKey", "newMiddlewareFinalValue")
assertion.EqualError(err, ErrSettingsKey.Error())
assertion.Equal(1, len(ctx.frozenSettings))
value, ok = ctx.GetFinal("middlewareFinalKey")
assertion.True(ok)
assertion.Equal("middlewareFinalValue", value)
// MustSetFinal
assertion.Panics(func() {
ctx.MustSetFinal("middlewareFinalKey", "newMiddlewareFinalValue")
})
// MusetGetFinal
assertion.Panics(func() {
ctx.MustGetFinal("unknownMiddlewareFinalKey")
})
}
func Test_NewAppRoute(t *testing.T) {
prefix := "/prefix"
server := newMockServer()
assertion := assert.New(t)
route := NewAppRoute(prefix, server)
assertion.Empty(route.handlers)
assertion.Equal(prefix, route.prefix)
assertion.Equal(server, route.server)
}
func Test_TimeoutResponser(t *testing.T) {
assertion := assert.New(t)
assertion.Implements((*http.RoundTripper)(nil), RefusedResponser)
request, _ := http.NewRequest("GET", "https://example.com", nil)
response, err := TimeoutResponser.RoundTrip(request)
assertion.EqualError(err, ErrTimeout.Error())
assertion.Nil(response)
}