func TestRouterServeFiles(t *testing.T) {
router := New()
recv := catchPanic(func() {
router.ServeFiles("/noFilepath", os.TempDir())
})
if recv == nil {
t.Fatal("registering path not ending with '*filepath' did not panic")
}
body := []byte("fake ico")
ioutil.WriteFile(os.TempDir()+"/favicon.ico", body, 0644)
router.ServeFiles("/*filepath", os.TempDir())
s := &fasthttp.Server{
Handler: router.Handler,
}
rw := &readWriter{}
ch := make(chan error)
rw.r.WriteString(string("GET /favicon.ico HTTP/1.1\r\n\r\n"))
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(500 * time.Millisecond):
t.Fatalf("timeout")
}
br := bufio.NewReader(&rw.w)
var resp fasthttp.Response
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if resp.Header.StatusCode() != 200 {
t.Fatalf("Unexpected status code %d. Expected %d", resp.Header.StatusCode(), 423)
}
if !bytes.Equal(resp.Body(), body) {
t.Fatalf("Unexpected body %q. Expected %q", resp.Body(), string(body))
}
}
func TestRouterNotFound(t *testing.T) {
handlerFunc := func(_ *fasthttp.RequestCtx, _ Params) {}
router := New()
router.GET("/path", handlerFunc)
router.GET("/dir/", handlerFunc)
router.GET("/", handlerFunc)
testRoutes := []struct {
route string
code int
}{
{"/path/", 301}, // TSR -/
{"/dir", 301}, // TSR +/
{"/", 200}, // TSR +/
{"/PATH", 301}, // Fixed Case
{"/DIR", 301}, // Fixed Case
{"/PATH/", 301}, // Fixed Case -/
{"/DIR/", 301}, // Fixed Case +/
{"/../path", 200}, // CleanPath
{"/nope", 404}, // NotFound
}
s := &fasthttp.Server{
Handler: router.Handler,
}
rw := &readWriter{}
br := bufio.NewReader(&rw.w)
var resp fasthttp.Response
ch := make(chan error)
for _, tr := range testRoutes {
rw.r.WriteString(fmt.Sprintf("GET %s HTTP/1.1\r\n\r\n", tr.route))
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if !(resp.Header.StatusCode() == tr.code) {
t.Errorf("NotFound handling route %s failed: Code=%d want=%d",
tr.route, resp.Header.StatusCode(), tr.code)
}
}
// Test custom not found handler
var notFound bool
router.NotFound = fasthttp.RequestHandler(func(ctx *fasthttp.RequestCtx) {
ctx.SetStatusCode(404)
notFound = true
})
rw.r.WriteString("GET /nope HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if !(resp.Header.StatusCode() == 404 && notFound == true) {
t.Errorf("Custom NotFound handler failed: Code=%d, Header=%v", resp.Header.StatusCode(), string(resp.Header.Peek("Location")))
}
// Test other method than GET (want 307 instead of 301)
router.PATCH("/path", handlerFunc)
rw.r.WriteString("PATCH /path/ HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if !(resp.Header.StatusCode() == 307) {
t.Errorf("Custom NotFound handler failed: Code=%d, Header=%v", resp.Header.StatusCode(), string(resp.Header.Peek("Location")))
}
// Test special case where no node for the prefix "/" exists
router = New()
router.GET("/a", handlerFunc)
s.Handler = router.Handler
rw.r.WriteString("GET / HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if !(resp.Header.StatusCode() == 404) {
t.Errorf("NotFound handling route / failed: Code=%d", resp.Header.StatusCode())
}
}
func TestRouterOPTIONS(t *testing.T) {
// TODO: because fasthttp is not support OPTIONS method now,
// these test cases will be used in the future.
handlerFunc := func(_ *fasthttp.RequestCtx, _ Params) {}
router := New()
router.POST("/path", handlerFunc)
// test not allowed
// * (server)
s := &fasthttp.Server{
Handler: router.Handler,
}
rw := &readWriter{}
ch := make(chan error)
rw.r.WriteString("OPTIONS * HTTP/1.1\r\nHost:\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
br := bufio.NewReader(&rw.w)
var resp fasthttp.Response
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if resp.Header.StatusCode() != fasthttp.StatusOK {
t.Errorf("OPTIONS handling failed: Code=%d, Header=%v",
resp.Header.StatusCode(), resp.Header.String())
} else if allow := string(resp.Header.Peek("Allow")); allow != "POST, OPTIONS" {
t.Error("unexpected Allow header value: " + allow)
}
// path
rw.r.WriteString("OPTIONS /path HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if resp.Header.StatusCode() != fasthttp.StatusOK {
t.Errorf("OPTIONS handling failed: Code=%d, Header=%v",
resp.Header.StatusCode(), resp.Header.String())
} else if allow := string(resp.Header.Peek("Allow")); allow != "POST, OPTIONS" {
t.Error("unexpected Allow header value: " + allow)
}
rw.r.WriteString("OPTIONS /doesnotexist HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if !(resp.Header.StatusCode() == fasthttp.StatusNotFound) {
t.Errorf("OPTIONS handling failed: Code=%d, Header=%v",
resp.Header.StatusCode(), resp.Header.String())
}
// add another method
router.GET("/path", handlerFunc)
// test again
// * (server)
rw.r.WriteString("OPTIONS * HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if resp.Header.StatusCode() != fasthttp.StatusOK {
t.Errorf("OPTIONS handling failed: Code=%d, Header=%v",
resp.Header.StatusCode(), resp.Header.String())
} else if allow := string(resp.Header.Peek("Allow")); allow != "POST, GET, OPTIONS" && allow != "GET, POST, OPTIONS" {
t.Error("unexpected Allow header value: " + allow)
}
// path
rw.r.WriteString("OPTIONS /path HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if resp.Header.StatusCode() != fasthttp.StatusOK {
t.Errorf("OPTIONS handling failed: Code=%d, Header=%v",
resp.Header.StatusCode(), resp.Header.String())
} else if allow := string(resp.Header.Peek("Allow")); allow != "POST, GET, OPTIONS" && allow != "GET, POST, OPTIONS" {
t.Error("unexpected Allow header value: " + allow)
}
// custom handler
var custom bool
router.OPTIONS("/path", func(_ *fasthttp.RequestCtx, _ Params) {
custom = true
})
// test again
// * (server)
rw.r.WriteString("OPTIONS * HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if resp.Header.StatusCode() != fasthttp.StatusOK {
t.Errorf("OPTIONS handling failed: Code=%d, Header=%v",
resp.Header.StatusCode(), resp.Header.String())
} else if allow := string(resp.Header.Peek("Allow")); allow != "POST, GET, OPTIONS" && allow != "GET, POST, OPTIONS" {
t.Error("unexpected Allow header value: " + allow)
}
if custom {
t.Error("custom handler called on *")
}
// path
rw.r.WriteString("OPTIONS /path HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if resp.Header.StatusCode() != fasthttp.StatusOK {
t.Errorf("OPTIONS handling failed: Code=%d, Header=%v",
resp.Header.StatusCode(), resp.Header.String())
}
if !custom {
t.Error("custom handler not called")
}
}
func TestRouterNotAllowed(t *testing.T) {
handlerFunc := func(_ *fasthttp.RequestCtx, _ Params) {}
router := New()
router.POST("/path", handlerFunc)
// Test not allowed
s := &fasthttp.Server{
Handler: router.Handler,
}
rw := &readWriter{}
ch := make(chan error)
rw.r.WriteString("GET /path HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
br := bufio.NewReader(&rw.w)
var resp fasthttp.Response
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if !(resp.Header.StatusCode() == fasthttp.StatusMethodNotAllowed) {
t.Errorf("NotAllowed handling failed: Code=%d, Header=%v", resp.Header.StatusCode(), resp.Header)
} else if allow := string(resp.Header.Peek("Allow")); allow != "POST, OPTIONS" {
t.Error("unexpected Allow header value: " + allow)
}
// add another method
router.DELETE("/path", handlerFunc)
router.OPTIONS("/path", handlerFunc) // must be ignored
// test again
rw.r.WriteString("GET /path HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if !(resp.Header.StatusCode() == fasthttp.StatusMethodNotAllowed) {
t.Errorf("NotAllowed handling failed: Code=%d, Header=%v", resp.Header.StatusCode(), resp.Header)
} else if allow := string(resp.Header.Peek("Allow")); allow != "POST, DELETE, OPTIONS" && allow != "DELETE, POST, OPTIONS" {
t.Error("unexpected Allow header value: " + allow)
}
responseText := "custom method"
router.MethodNotAllowed = fasthttp.RequestHandler(func(ctx *fasthttp.RequestCtx) {
ctx.SetStatusCode(fasthttp.StatusTeapot)
ctx.Write([]byte(responseText))
})
rw.r.WriteString("GET /path HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if !bytes.Equal(resp.Body(), []byte(responseText)) {
t.Errorf("unexpected response got %q want %q", string(resp.Body()), responseText)
}
if resp.Header.StatusCode() != fasthttp.StatusTeapot {
t.Errorf("unexpected response code %d want %d", resp.Header.StatusCode(), fasthttp.StatusTeapot)
}
if allow := string(resp.Header.Peek("Allow")); allow != "POST, DELETE, OPTIONS" && allow != "DELETE, POST, OPTIONS" {
t.Error("unexpected Allow header value: " + allow)
}
}
func TestRouterChaining(t *testing.T) {
router1 := New()
router2 := New()
router1.NotFound = router2.Handler
fooHit := false
router1.POST("/foo", func(ctx *fasthttp.RequestCtx, _ Params) {
fooHit = true
ctx.SetStatusCode(fasthttp.StatusOK)
})
barHit := false
router2.POST("/bar", func(ctx *fasthttp.RequestCtx, _ Params) {
barHit = true
ctx.SetStatusCode(fasthttp.StatusOK)
})
s := &fasthttp.Server{
Handler: router1.Handler,
}
rw := &readWriter{}
ch := make(chan error)
rw.r.WriteString("POST /foo HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
br := bufio.NewReader(&rw.w)
var resp fasthttp.Response
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if !(resp.Header.StatusCode() == fasthttp.StatusOK && fooHit) {
t.Errorf("Regular routing failed with router chaining.")
t.FailNow()
}
rw.r.WriteString("POST /bar HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if !(resp.Header.StatusCode() == fasthttp.StatusOK && barHit) {
t.Errorf("Chained routing failed with router chaining.")
t.FailNow()
}
rw.r.WriteString("POST /qax HTTP/1.1\r\n\r\n")
go func() {
ch <- s.ServeConn(rw)
}()
select {
case err := <-ch:
if err != nil {
t.Fatalf("return error %s", err)
}
case <-time.After(100 * time.Millisecond):
t.Fatalf("timeout")
}
if err := resp.Read(br); err != nil {
t.Fatalf("Unexpected error when reading response: %s", err)
}
if !(resp.Header.StatusCode() == fasthttp.StatusNotFound) {
t.Errorf("NotFound behavior failed with router chaining.")
t.FailNow()
}
}
