func TestHandlerAppendSlash(t *testing.T) {
oldAppendSetting := Settings.Bool("append_slash", false)
oldAppendRedirectSetting := Settings.Bool("append_slash_should_redirect", true)
Settings.Set("append_slash", false)
Pattern("/hello", &AppendSlashBaseHandler{})
r, _ := http.NewRequest("GET", "/hello/", nil)
rec := httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusNotFound, rec.Code)
Mux = &PatternServeMux{}
Settings.Set("append_slash", true)
Pattern("/hello", &AppendSlashBaseHandler{})
r, _ = http.NewRequest("GET", "/hello/", nil)
rec = httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusOK, rec.Code)
Mux = &PatternServeMux{}
Settings.Set("append_slash", true)
Settings.Set("append_slash_should_redirect", true)
Pattern("/hello", &AppendSlashBaseHandler{})
r, _ = http.NewRequest("GET", "/hello/", nil)
rec = httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusMovedPermanently, rec.Code)
Mux = &PatternServeMux{}
// Set it back to what it was.
Settings.Set("append_slash", oldAppendSetting)
Settings.Set("append_slash_should_redirect", oldAppendRedirectSetting)
}
func TestResponseNewSlice(t *testing.T) {
resp := NewHttpResponse([]string{"hellowww", "aaaaa"})
assert.Equal(t, `["hellowww","aaaaa"]`, resp.Content)
assert.Equal(t, 200, resp.StatusCode)
assert.Equal(t, "application/json; charset=utf-8", resp.ContentType)
}
func TestResponseNewMap(t *testing.T) {
v := map[string]interface{}{"k": "value"}
resp := NewHttpResponse(v)
assert.Equal(t, `{"k":"value"}`, resp.Content)
assert.Equal(t, 200, resp.StatusCode)
assert.Equal(t, "application/json; charset=utf-8", resp.ContentType)
}
func TestResponseNewNoParams(t *testing.T) {
resp := NewHttpResponse()
assert.Equal(t, "", resp.Content)
assert.Equal(t, 200, resp.StatusCode)
assert.Equal(t, "text/html; charset=utf-8", resp.ContentType)
assert.Equal(t, 0, len(resp.Header))
assert.Equal(t, 0, len(resp.Context))
}
func TestResponseNewThreeParams(t *testing.T) {
resp := NewHttpResponse("My Content", 202, "text/plain; charset=latin1")
assert.Equal(t, "My Content", resp.Content)
assert.Equal(t, 202, resp.StatusCode)
assert.Equal(t, "text/plain; charset=latin1", resp.ContentType)
assert.Equal(t, 0, len(resp.Header))
assert.Equal(t, 0, len(resp.Context))
}
func TestRequestFragementValue(t *testing.T) {
in, _ := http.NewRequest("GET", "example.com?foo=bar#batman", nil)
req := NewHttpRequest(in, make(url.Values))
assert.Equal(t, "batman", req.FragmentValue())
in, _ = http.NewRequest("GET", "example.com?foo=bar", nil)
req = NewHttpRequest(in, make(url.Values))
assert.Equal(t, "", req.FragmentValue())
}
func TestDictObjExists(t *testing.T) {
dictObj := NewDictObj()
dictObj.Set("a", "AAA")
dictObj.Set("b", "BBB")
assert.Equal(t, true, dictObj.Exists("a"))
assert.Equal(t, true, dictObj.Exists("b"))
assert.Equal(t, false, dictObj.Exists("c"))
}
func TestRequestNew(t *testing.T) {
b := bytes.NewBufferString("sample body here")
in, _ := http.NewRequest("GET", "http://example.com", b)
req := NewHttpRequest(in, make(url.Values))
assert.Equal(t, "sample body here", req.BodyString)
assert.Equal(t, 0, len(req.PathArgs))
assert.Equal(t, 0, len(req.Registry))
assert.Equal(t, "example.com", req.URL.Host)
assert.Equal(t, "GET", req.Method)
}
func TestServerVersionMap(t *testing.T) {
oldVer := Version
Version = "2.5.11"
vmap := VersionMap()
assert.Equal(t, 2, vmap[0])
assert.Equal(t, 5, vmap[1])
assert.Equal(t, 11, vmap[2])
Version = oldVer
}
func TestHandlerPrepareFinish(t *testing.T) {
defer func() { Mux = &PatternServeMux{} }()
Pattern("/", &PrepFinHandler{})
r, _ := http.NewRequest("GET", "/", nil)
rec := httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusOK, rec.Code)
assert.Equal(t, "NEW-PRE", rec.Body.String())
assert.Equal(t, "NEW-PRE-FIN", OneOffPreFinTestObj)
}
//---
func TestEarlyResponseMiddleware(t *testing.T) {
defer func() { Mux = &PatternServeMux{} }()
defer func() { middlewares = []MiddlewareInterface{} }()
Pattern("/", &MiddleHandler{})
Middleware(&Finishware{})
r, _ := http.NewRequest("GET", "/", nil)
rec := httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusOK, rec.Code)
assert.Equal(t, "Ending request early.", rec.Body.String())
}
func TestBasicMiddleware(t *testing.T) {
defer func() { Mux = &PatternServeMux{} }()
defer func() { middlewares = []MiddlewareInterface{} }()
Pattern("/", &MiddleHandler{})
Middleware(&Firstware{})
r, _ := http.NewRequest("GET", "/", nil)
rec := httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusOK, rec.Code)
assert.Equal(t, "bar", rec.Body.String())
assert.Equal(t, "superman", rec.Header().Get("X-post"))
}
func TestRequestIsSecure(t *testing.T) {
in, _ := http.NewRequest("GET", "http://example.com", nil)
req := NewHttpRequest(in, make(url.Values))
assert.Equal(t, false, req.IsSecure())
in, _ = http.NewRequest("GET", "https://secure-example.com", nil)
req = NewHttpRequest(in, make(url.Values))
assert.Equal(t, true, req.IsSecure())
in, _ = http.NewRequest("GET", "example.com", nil)
in.Header.Add("X-Forwarded-Proto", "httPS")
req = NewHttpRequest(in, make(url.Values))
assert.Equal(t, true, req.IsSecure())
}
func TestSettingsSetDebug(t *testing.T) {
assert.Equal(t, false, Debug)
dictObj := NewDictObj()
dictObj.Set("debug", true)
assert.Equal(t, true, Debug)
dictObj.Set("debugggger", false)
assert.Equal(t, true, Debug)
dictObj.Set("debug", false)
assert.Equal(t, false, Debug)
}
func TestDictObjJsonData(t *testing.T) {
tmp := make(map[string]interface{})
err := json.Unmarshal([]byte(`{"intOne":1,"intTwo":23456789}`), &tmp)
if err != nil {
t.Errorf("Json unmarshal error: %q", err)
}
dictObj := NewDictObj()
dictObj.Set("a", tmp["intOne"])
dictObj.Set("b", tmp["intTwo"])
assert.Equal(t, 1, dictObj.Int("a"))
assert.Equal(t, 23456789, dictObj.Int("b"))
}
func TestFinishMiddleware(t *testing.T) {
defer func() { Mux = &PatternServeMux{} }()
defer func() { middlewares = []MiddlewareInterface{} }()
Pattern("/", &MiddleHandler{})
// Finish should not allow Firstware to be called.
Middleware(&Finishware{})
Middleware(&Firstware{})
r, _ := http.NewRequest("GET", "/", nil)
rec := httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusOK, rec.Code)
assert.Equal(t, "bar", rec.Body.String())
assert.Equal(t, "FIRST", rec.Header().Get("X-post"))
}
func TestDictObjArray(t *testing.T) {
tmp := make(map[string]interface{})
err := json.Unmarshal([]byte(`{"first":["one", "two", "three"], "second":["1", "2"]}`), &tmp)
if err != nil {
t.Errorf("Json unmarshal error: %q", err)
}
dictObj := NewDictObj()
dictObj.Set("a", tmp["first"])
assert.Equal(t, tmp["first"].([]interface{}), dictObj.Array("a"))
assert.Equal(t, tmp["second"].([]interface{}), dictObj.Array("b", tmp["second"].([]interface{})))
assert.Panic(t, "Array received too many args: [2]", func() {
dictObj.Array("z", nil, nil)
})
}
func TestDictObjString(t *testing.T) {
dictObj := NewDictObj()
dictObj.Set("a", "AAA")
dictObj.Set("b", "BBB")
assert.Equal(t, "AAA", dictObj.String("a"))
assert.Equal(t, "BBB", dictObj.String("b"))
dictObj.Set("a", "not AAA")
assert.Equal(t, "not AAA", dictObj.String("a"))
assert.Equal(t, "CCC", dictObj.String("c", "CCC"))
assert.Panic(t, "String received too many args: [2]", func() {
dictObj.String("z", "default", "bad")
})
}
func TestDictObjBool(t *testing.T) {
dictObj := NewDictObj()
dictObj.Set("a", true)
dictObj.Set("b", false)
assert.Equal(t, true, dictObj.Bool("a"))
assert.Equal(t, false, dictObj.Bool("b"))
assert.Equal(t, true, dictObj.Bool("c", true))
assert.Equal(t, false, dictObj.Bool("d", false))
dictObj.Set("a", false)
assert.Equal(t, false, dictObj.Bool("a"))
assert.Panic(t, "Bool received too many args: [3]", func() {
dictObj.Bool("z", true, false, true)
})
}
func TestDictObjInt(t *testing.T) {
dictObj := NewDictObj()
dictObj.Set("a", 1)
dictObj.Set("b", 12345678901234)
assert.Equal(t, 1, dictObj.Int("a"))
assert.Equal(t, 12345678901234, dictObj.Int("b"))
dictObj.Set("a", 2)
assert.Equal(t, 2, dictObj.Int("a"))
assert.Equal(t, 55, dictObj.Int("c", 55))
assert.Panic(t, "Int received too many args: [2]", func() {
dictObj.Int("z", 12, 34)
})
}
func TestDictObjFloat(t *testing.T) {
dictObj := NewDictObj()
dictObj.Set("a", 1.0)
dictObj.Set("b", 12345678901234.56789)
assert.Equal(t, 1.0, dictObj.Float("a"))
assert.Equal(t, 12345678901234.56789, dictObj.Float("b"))
dictObj.Set("a", 222.333)
assert.Equal(t, 222.333, dictObj.Float("a"))
assert.Equal(t, 55.667788, dictObj.Float("c", 55.667788))
assert.Panic(t, "Float received too many args: [2]", func() {
dictObj.Float("z", 12.23, 33.22)
})
}
func TestHandlerErrors(t *testing.T) {
defer func() { Mux = &PatternServeMux{} }()
Pattern("/err/", &ErrHandler{})
Pattern("/custom/", &CustomErrHandler{})
r, _ := http.NewRequest("GET", "/err/", nil)
rec := httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusInternalServerError, rec.Code)
assert.Equal(t, http.StatusText(500), rec.Body.String())
r, _ = http.NewRequest("GET", "/custom/", nil)
rec = httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, 400, rec.Code)
assert.Equal(t, `{"hello": "world"}`, rec.Body.String())
assert.Equal(t, "application/json", rec.Header().Get("Content-Type"))
}
func TestRequestGetValueTypes(t *testing.T) {
in, _ := http.NewRequest("GET", "example.com?one=foo&two=222&three=11&four=2.0", nil)
req := NewHttpRequest(in, make(url.Values))
vs := req.GetString("one")
assert.Equal(t, "foo", vs)
vs = req.GetString("two")
assert.Equal(t, "222", vs)
vi := req.GetInt("three")
assert.Equal(t, int64(11), vi)
vf := req.GetFloat("four")
assert.Equal(t, 2.0, vf)
vs = req.GetString("five", "hello")
assert.Equal(t, "hello", vs)
}
func TestHandlerMethods(t *testing.T) {
defer func() { Mux = &PatternServeMux{} }()
Pattern("/", &AlmostBaseHandler{})
methods := []string{"HEAD", "GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"}
for _, meth := range methods {
r, _ := http.NewRequest(meth, "/", nil)
rec := httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusMethodNotAllowed, rec.Code)
}
}
func TestHandlerHead(t *testing.T) {
defer func() { Mux = &PatternServeMux{} }()
Pattern("/", &GetHandler{})
r, _ := http.NewRequest("GET", "/", nil)
rec := httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusOK, rec.Code)
assert.Equal(t, "hello", rec.Body.String())
getResult := rec.Body
r, _ = http.NewRequest("HEAD", "/", nil)
rec = httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusOK, rec.Code)
assert.NotEqual(t, getResult, rec.Body)
assert.Equal(t, 0, len(rec.Body.String()))
}
func TestHandlerGenericResponses(t *testing.T) {
defer func() { Mux = &PatternServeMux{} }()
Pattern("/", &GenericHandler{})
r, _ := http.NewRequest("GET", "/", nil)
rec := httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusGone, rec.Code)
r, _ = http.NewRequest("POST", "/", nil)
rec = httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusNotFound, rec.Code)
r, _ = http.NewRequest("PUT", "/", nil)
rec = httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusForbidden, rec.Code)
r, _ = http.NewRequest("DELETE", "/", nil)
rec = httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusBadRequest, rec.Code)
r, _ = http.NewRequest("PATCH", "/", nil)
rec = httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusNotModified, rec.Code)
r, _ = http.NewRequest("OPTION", "/", nil)
rec = httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusInternalServerError, rec.Code)
}
func TestRequestFormValueTypes(t *testing.T) {
in, _ := http.NewRequest("GET", "example.com", nil)
in.PostForm = make(url.Values)
in.PostForm.Add("one", "foo")
in.PostForm.Add("two", "222")
in.PostForm.Add("three", "11")
in.PostForm.Add("four", "2.0")
req := NewHttpRequest(in, make(url.Values))
vs := req.FormString("one")
assert.Equal(t, "foo", vs)
vs = req.FormString("two")
assert.Equal(t, "222", vs)
vi := req.FormInt("three")
assert.Equal(t, int64(11), vi)
vf := req.FormFloat("four")
assert.Equal(t, 2.0, vf)
vs = req.FormString("five", "hello")
assert.Equal(t, "hello", vs)
vs = req.FormString("six")
assert.Equal(t, "", vs)
vi = req.FormInt("seven")
assert.Equal(t, int64(0), vi)
vf = req.FormFloat("eight")
assert.Equal(t, 0.0, vf)
vi = req.FormInt("nine", 22)
assert.Equal(t, int64(22), vi)
vf = req.FormFloat("ten", 10.10)
assert.Equal(t, 10.10, vf)
}
func TestHandlerAllowedMethods(t *testing.T) {
defer func() { Mux = &PatternServeMux{} }()
Pattern("/allowed/", &AllowedHandler{})
r, _ := http.NewRequest("GET", "/allowed/", nil)
rec := httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusOK, rec.Code)
r, _ = http.NewRequest("POST", "/allowed/", nil)
rec = httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusOK, rec.Code)
r, _ = http.NewRequest("PUT", "/allowed/", nil)
rec = httptest.NewRecorder()
Mux.ServeHTTP(rec, r)
assert.Equal(t, http.StatusMethodNotAllowed, rec.Code)
// TODO: Still need to fix this sometime down the road.
//assert.Equal(t, "GET,POST", rec.Header().Get("Allow"))
}
func TestSettingsSetFromEnv(t *testing.T) {
dictObj := NewDictObj()
dictObj.SetFromEnv("a", "bad_key_here", true)
assert.Equal(t, true, dictObj.Bool("a"))
dictObj.SetFromEnv("a", "bad_key_here", false)
assert.Equal(t, false, dictObj.Bool("a"))
dictObj.SetFromEnv("b", "no_args")
assert.Equal(t, false, dictObj.Bool("b"))
dictObj.SetFromEnv("debug", "bad_key_here222", true)
assert.Equal(t, true, Debug)
if tempPath, ok := syscall.Getenv("PATH"); ok {
dictObj.SetFromEnv("mypath", "PATH", "NA")
assert.Equal(t, tempPath, dictObj.String("mypath", "NOT NA!!"))
}
assert.Panic(t, "SetFromEnv received too many args: [2]", func() {
dictObj.SetFromEnv("z", "bbaadddddd", false, true)
})
}
func TestRequestPathValue(t *testing.T) {
in, _ := http.NewRequest("GET", "example.com", nil)
path := make(url.Values)
path.Add(":one", "foo")
path.Add(":two", "bar")
req := NewHttpRequest(in, path)
v, ok := req.PathValue(":one")
assert.Equal(t, true, ok)
assert.Equal(t, "foo", v)
v, ok = req.PathValue(":two")
assert.Equal(t, true, ok)
assert.Equal(t, "bar", v)
v, ok = req.PathValue(":foobar")
assert.Equal(t, false, ok)
assert.Equal(t, "", v)
}