router_test.go

// Copyright (c) 2012-2016 The Revel Framework Authors, All rights reserved.
// Revel Framework source code and usage is governed by a MIT style
// license that can be found in the LICENSE file.

package revel

import (
	"bufio"
	"bytes"
	"fmt"
	"net/http"
	"net/url"
	"strings"
	"testing"
)

// Data-driven tests that check that a given routes-file line translates into
// the expected Route object.
var routeTestCases = map[string]*Route{
	"get / Application.Index": {
		Method:      "GET",
		Path:        "/",
		Action:      "Application.Index",
		FixedParams: []string{},
	},

	"post /app/:id Application.SaveApp": {
		Method:      "POST",
		Path:        "/app/:id",
		Action:      "Application.SaveApp",
		FixedParams: []string{},
	},

	"get /app/ Application.List": {
		Method:      "GET",
		Path:        "/app/",
		Action:      "Application.List",
		FixedParams: []string{},
	},

	`get /app/:appId/ Application.Show`: {
		Method:      "GET",
		Path:        `/app/:appId/`,
		Action:      "Application.Show",
		FixedParams: []string{},
	},

	`get /app-wild/*appId/ Application.WildShow`: {
		Method:      "GET",
		Path:        `/app-wild/*appId/`,
		Action:      "Application.WildShow",
		FixedParams: []string{},
	},

	`GET /public/:filepath   Static.Serve("public")`: {
		Method: "GET",
		Path:   "/public/:filepath",
		Action: "Static.Serve",
		FixedParams: []string{
			"public",
		},
	},

	`GET /javascript/:filepath Static.Serve("public/js")`: {
		Method: "GET",
		Path:   "/javascript/:filepath",
		Action: "Static.Serve",
		FixedParams: []string{
			"public",
		},
	},

	"* /apps/:id/:action Application.:action": {
		Method:      "*",
		Path:        "/apps/:id/:action",
		Action:      "Application.:action",
		FixedParams: []string{},
	},

	"* /:controller/:action :controller.:action": {
		Method:      "*",
		Path:        "/:controller/:action",
		Action:      ":controller.:action",
		FixedParams: []string{},
	},

	`GET / Application.Index("Test", "Test2")`: {
		Method: "GET",
		Path:   "/",
		Action: "Application.Index",
		FixedParams: []string{
			"Test",
			"Test2",
		},
	},
}

// Run the test cases above.
func TestComputeRoute(t *testing.T) {
	for routeLine, expected := range routeTestCases {
		method, path, action, fixedArgs, found := parseRouteLine(routeLine)
		if !found {
			t.Error("Failed to parse route line:", routeLine)
			continue
		}
		actual := NewRoute(appModule, method, path, action, fixedArgs, "", 0)
		eq(t, "Method", actual.Method, expected.Method)
		eq(t, "Path", actual.Path, expected.Path)
		eq(t, "Action", actual.Action, expected.Action)
		if t.Failed() {
			t.Fatal("Failed on route:", routeLine)
		}
	}
}

// Router Tests

const TestRoutes = `
# This is a comment
GET   		/                   Application.Index
GET   		/test/              Application.Index("Test", "Test2")
GET   		/app/:id/           Application.Show
GET   		/app-wild/*id/		Application.WildShow
POST  		/app/:id            Application.Save
PATCH 		/app/:id/           Application.Update
PROPFIND	/app/:id			Application.WebDevMethodPropFind
MKCOL		/app/:id			Application.WebDevMethodMkCol
COPY		/app/:id			Application.WebDevMethodCopy
MOVE		/app/:id			Application.WebDevMethodMove
PROPPATCH	/app/:id			Application.WebDevMethodPropPatch
LOCK		/app/:id			Application.WebDevMethodLock
UNLOCK		/app/:id			Application.WebDevMethodUnLock
TRACE		/app/:id			Application.WebDevMethodTrace
PURGE		/app/:id			Application.CacheMethodPurge
GET   /javascript/:filepath      App\Static.Serve("public/js")
GET   /public/*filepath          Static.Serve("public")
*     /:controller/:action       :controller.:action

GET   /favicon.ico               404
`

var routeMatchTestCases = map[*http.Request]*RouteMatch{
	{
		Method: "GET",
		URL:    &url.URL{Path: "/"},
	}: {
		ControllerName: "application",
		MethodName:     "Index",
		FixedParams:    []string{},
		Params:         map[string][]string{},
	},

	{
		Method: "GET",
		URL:    &url.URL{Path: "/test/"},
	}: {
		ControllerName: "application",
		MethodName:     "Index",
		FixedParams:    []string{"Test", "Test2"},
		Params:         map[string][]string{},
	},

	{
		Method: "GET",
		URL:    &url.URL{Path: "/app/123"},
	}: {
		ControllerName: "application",
		MethodName:     "Show",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "PATCH",
		URL:    &url.URL{Path: "/app/123"},
	}: {
		ControllerName: "application",
		MethodName:     "Update",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "POST",
		URL:    &url.URL{Path: "/app/123"},
	}: {
		ControllerName: "application",
		MethodName:     "Save",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "GET",
		URL:    &url.URL{Path: "/app/123/"},
	}: {
		ControllerName: "application",
		MethodName:     "Show",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "GET",
		URL:    &url.URL{Path: "/public/css/style.css"},
	}: {
		ControllerName: "static",
		MethodName:     "Serve",
		FixedParams:    []string{"public"},
		Params:         map[string][]string{"filepath": {"css/style.css"}},
	},

	{
		Method: "GET",
		URL:    &url.URL{Path: "/javascript/sessvars.js"},
	}: {
		ControllerName: "static",
		MethodName:     "Serve",
		FixedParams:    []string{"public/js"},
		Params:         map[string][]string{"filepath": {"sessvars.js"}},
	},

	{
		Method: "GET",
		URL:    &url.URL{Path: "/Implicit/Route"},
	}: {
		ControllerName: "implicit",
		MethodName:     "Route",
		FixedParams:    []string{},
		Params: map[string][]string{
			"METHOD":     {"GET"},
			"controller": {"Implicit"},
			"action":     {"Route"},
		},
	},

	{
		Method: "GET",
		URL:    &url.URL{Path: "/favicon.ico"},
	}: {
		ControllerName: "",
		MethodName:     "",
		Action:         "404",
		FixedParams:    []string{},
		Params:         map[string][]string{},
	},

	{
		Method: "POST",
		URL:    &url.URL{Path: "/app/123"},
		Header: http.Header{"X-Http-Method-Override": []string{"PATCH"}},
	}: {
		ControllerName: "application",
		MethodName:     "Update",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "GET",
		URL:    &url.URL{Path: "/app/123"},
		Header: http.Header{"X-Http-Method-Override": []string{"PATCH"}},
	}: {
		ControllerName: "application",
		MethodName:     "Show",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "PATCH",
		URL:    &url.URL{Path: "/app/123"},
	}: {
		ControllerName: "application",
		MethodName:     "Update",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "PROPFIND",
		URL:    &url.URL{Path: "/app/123"},
	}: {
		ControllerName: "application",
		MethodName:     "WebDevMethodPropFind",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "MKCOL",
		URL:    &url.URL{Path: "/app/123"},
	}: {
		ControllerName: "application",
		MethodName:     "WebDevMethodMkCol",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "COPY",
		URL:    &url.URL{Path: "/app/123"},
	}: {
		ControllerName: "application",
		MethodName:     "WebDevMethodCopy",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "MOVE",
		URL:    &url.URL{Path: "/app/123"},
	}: {
		ControllerName: "application",
		MethodName:     "WebDevMethodMove",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "PROPPATCH",
		URL:    &url.URL{Path: "/app/123"},
	}: {
		ControllerName: "application",
		MethodName:     "WebDevMethodPropPatch",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},
	{
		Method: "LOCK",
		URL:    &url.URL{Path: "/app/123"},
	}: {
		ControllerName: "application",
		MethodName:     "WebDevMethodLock",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "UNLOCK",
		URL:    &url.URL{Path: "/app/123"},
	}: {
		ControllerName: "application",
		MethodName:     "WebDevMethodUnLock",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "TRACE",
		URL:    &url.URL{Path: "/app/123"},
	}: {
		ControllerName: "application",
		MethodName:     "WebDevMethodTrace",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},

	{
		Method: "PURGE",
		URL:    &url.URL{Path: "/app/123"},
	}: {
		ControllerName: "application",
		MethodName:     "CacheMethodPurge",
		FixedParams:    []string{},
		Params:         map[string][]string{"id": {"123"}},
	},
}

func TestRouteMatches(t *testing.T) {
	initControllers()
	BasePath = "/BasePath"
	router := NewRouter("")
	router.Routes, _ = parseRoutes(appModule, "", "", TestRoutes, false)
	if err := router.updateTree(); err != nil {
		t.Errorf("updateTree failed: %s", err)
	}
	for req, expected := range routeMatchTestCases {
		t.Log("Routing:", req.Method, req.URL)

		context := NewGoContext(nil)
		context.Request.SetRequest(req)
		c := NewTestController(nil, req)

		actual := router.Route(c.Request)
		if !eq(t, "Found route", actual != nil, expected != nil) {
			continue
		}
		if expected.ControllerName != "" {
			eq(t, "ControllerName", actual.ControllerName, appModule.Namespace()+expected.ControllerName)
		} else {
			eq(t, "ControllerName", actual.ControllerName, expected.ControllerName)
		}

		eq(t, "MethodName", actual.MethodName, strings.ToLower(expected.MethodName))
		eq(t, "len(Params)", len(actual.Params), len(expected.Params))
		for key, actualValue := range actual.Params {
			eq(t, "Params "+key, actualValue[0], expected.Params[key][0])
		}
		eq(t, "len(FixedParams)", len(actual.FixedParams), len(expected.FixedParams))
		for i, actualValue := range actual.FixedParams {
			eq(t, "FixedParams", actualValue, expected.FixedParams[i])
		}
	}
}

// Reverse Routing

type ReverseRouteArgs struct {
	action string
	args   map[string]string
}

var reverseRoutingTestCases = map[*ReverseRouteArgs]*ActionDefinition{
	{
		action: "Application.Index",
		args:   map[string]string{},
	}: {
		URL:    "/",
		Method: "GET",
		Star:   false,
		Action: "Application.Index",
	},

	{
		action: "Application.Show",
		args:   map[string]string{"id": "123"},
	}: {
		URL:    "/app/123/",
		Method: "GET",
		Star:   false,
		Action: "Application.Show",
	},

	{
		action: "Implicit.Route",
		args:   map[string]string{},
	}: {
		URL:    "/implicit/route",
		Method: "GET",
		Star:   true,
		Action: "Implicit.Route",
	},

	{
		action: "Application.Save",
		args:   map[string]string{"id": "123", "c": "http://continue"},
	}: {
		URL:    "/app/123?c=http%3A%2F%2Fcontinue",
		Method: "POST",
		Star:   false,
		Action: "Application.Save",
	},

	{
		action: "Application.WildShow",
		args:   map[string]string{"id": "123"},
	}: {
		URL:    "/app-wild/123/",
		Method: "GET",
		Star:   false,
		Action: "Application.WildShow",
	},

	{
		action: "Application.WebDevMethodPropFind",
		args:   map[string]string{"id": "123"},
	}: {
		URL:    "/app/123",
		Method: "PROPFIND",
		Star:   false,
		Action: "Application.WebDevMethodPropFind",
	},
	{
		action: "Application.WebDevMethodMkCol",
		args:   map[string]string{"id": "123"},
	}: {
		URL:    "/app/123",
		Method: "MKCOL",
		Star:   false,
		Action: "Application.WebDevMethodMkCol",
	},
	{
		action: "Application.WebDevMethodCopy",
		args:   map[string]string{"id": "123"},
	}: {
		URL:    "/app/123",
		Method: "COPY",
		Star:   false,
		Action: "Application.WebDevMethodCopy",
	},
	{
		action: "Application.WebDevMethodMove",
		args:   map[string]string{"id": "123"},
	}: {
		URL:    "/app/123",
		Method: "MOVE",
		Star:   false,
		Action: "Application.WebDevMethodMove",
	},
	{
		action: "Application.WebDevMethodPropPatch",
		args:   map[string]string{"id": "123"},
	}: {
		URL:    "/app/123",
		Method: "PROPPATCH",
		Star:   false,
		Action: "Application.WebDevMethodPropPatch",
	},
	{
		action: "Application.WebDevMethodLock",
		args:   map[string]string{"id": "123"},
	}: {
		URL:    "/app/123",
		Method: "LOCK",
		Star:   false,
		Action: "Application.WebDevMethodLock",
	},
	{
		action: "Application.WebDevMethodUnLock",
		args:   map[string]string{"id": "123"},
	}: {
		URL:    "/app/123",
		Method: "UNLOCK",
		Star:   false,
		Action: "Application.WebDevMethodUnLock",
	},
	{
		action: "Application.WebDevMethodTrace",
		args:   map[string]string{"id": "123"},
	}: {
		URL:    "/app/123",
		Method: "TRACE",
		Star:   false,
		Action: "Application.WebDevMethodTrace",
	},
	{
		action: "Application.CacheMethodPurge",
		args:   map[string]string{"id": "123"},
	}: {
		URL:    "/app/123",
		Method: "PURGE",
		Star:   false,
		Action: "Application.CacheMethodPurge",
	},
}

func initControllers() {
	registerControllers()
}

func TestReverseRouting(t *testing.T) {
	initControllers()
	router := NewRouter("")
	router.Routes, _ = parseRoutes(appModule, "", "", TestRoutes, false)
	for routeArgs, expected := range reverseRoutingTestCases {
		actual := router.Reverse(routeArgs.action, routeArgs.args)
		if !eq(t, fmt.Sprintf("Found route %s %s", routeArgs.action, actual), actual != nil, expected != nil) {
			continue
		}
		eq(t, "Url", actual.URL, expected.URL)
		eq(t, "Method", actual.Method, expected.Method)
		eq(t, "Star", actual.Star, expected.Star)
		eq(t, "Action", actual.Action, expected.Action)
	}
}

func BenchmarkRouter(b *testing.B) {
	router := NewRouter("")
	router.Routes, _ = parseRoutes(nil, "", "", TestRoutes, false)
	if err := router.updateTree(); err != nil {
		b.Errorf("updateTree failed: %s", err)
	}
	b.ResetTimer()
	for i := 0; i < b.N/len(routeMatchTestCases); i++ {
		for req := range routeMatchTestCases {
			c := NewTestController(nil, req)
			r := router.Route(c.Request)
			if r == nil {
				b.Errorf("Request not found: %s", req.URL.Path)
			}
		}
	}
}

// The benchmark from github.com/ant0ine/go-urlrouter.
func BenchmarkLargeRouter(b *testing.B) {
	router := NewRouter("")

	routePaths := []string{
		"/",
		"/signin",
		"/signout",
		"/profile",
		"/settings",
		"/upload/*file",
	}
	for i := 0; i < 10; i++ {
		for j := 0; j < 5; j++ {
			routePaths = append(routePaths, fmt.Sprintf("/resource%d/:id/property%d", i, j))
		}
		routePaths = append(routePaths, fmt.Sprintf("/resource%d/:id", i))
		routePaths = append(routePaths, fmt.Sprintf("/resource%d", i))
	}
	routePaths = append(routePaths, "/:any")

	for _, p := range routePaths {
		router.Routes = append(router.Routes,
			NewRoute(appModule, "GET", p, "Controller.Action", "", "", 0))
	}
	if err := router.updateTree(); err != nil {
		b.Errorf("updateTree failed: %s", err)
	}

	requestUrls := []string{
		"http://example.org/",
		"http://example.org/resource9/123",
		"http://example.org/resource9/123/property1",
		"http://example.org/doesnotexist",
	}
	var reqs []*http.Request
	for _, url := range requestUrls {
		req, _ := http.NewRequest("GET", url, nil)
		reqs = append(reqs, req)
	}

	b.ResetTimer()

	for i := 0; i < b.N/len(reqs); i++ {
		for _, req := range reqs {
			c := NewTestController(nil, req)
			route := router.Route(c.Request)
			if route == nil {
				b.Errorf("Failed to route: %s", req.URL.Path)
			}
		}
	}
}

func BenchmarkRouterFilter(b *testing.B) {
	startFakeBookingApp()
	controllers := []*Controller{
		NewTestController(nil, showRequest),
		NewTestController(nil, staticRequest),
	}
	for _, c := range controllers {
		c.Params = &Params{}
		ParseParams(c.Params, c.Request)
	}

	b.ResetTimer()
	for i := 0; i < b.N/len(controllers); i++ {
		for _, c := range controllers {
			RouterFilter(c, NilChain)
		}
	}
}

func TestOverrideMethodFilter(t *testing.T) {
	req, _ := http.NewRequest("POST", "/hotels/3", strings.NewReader("_method=put"))
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value")
	c := NewTestController(nil, req)

	if HTTPMethodOverride(c, NilChain); c.Request.Method != "PUT" {
		t.Errorf("Expected to override current method '%s' in route, found '%s' instead", "", c.Request.Method)
	}
}

// Helpers

func eq(t *testing.T, name string, a, b interface{}) bool {
	if a != b {
		t.Error(name, ": (actual)", a, " != ", b, "(expected)")
		return false
	}
	return true
}

var validMethod_tests = []struct {
	in   string
	want bool
}{
	{"OPTIONS", true},
	{"GET", true},
	{"HEAD", true},
	{"POST", true},
	{"PUT", true},
	{"DELETE", true},
	{"TRACE", true},
	{"CONNECT", true},
	{"RANDOMSTRING", true},
	{"BAD/STRING", false},
	{"", false},
	{"UNDERSCORE_FINE", true},
	{"BAD SPACE", false},
	{" ", false},
	{"A ", false},
	{" A", false},
}

func Test_validMethod(t *testing.T) {
	for _, tt := range validMethod_tests {
		got := validMethod(tt.in)
		if tt.want != got {
			t.Errorf("validMethod(%q) = %t, want %t", tt.in, got, tt.want)
		}
	}
}

func Test_validMethod_againtsNetHttp(t *testing.T) {
	for i := 0; i < 256; i++ {
		s := string(byte(i))
		for _, in := range []string{s, s + "A", "A" + s, s + "A" + s, "A" + s + "A"} {

			_, err := http.ReadRequest(bufio.NewReader(bytes.NewBuffer([]byte(in + " / HTTP/1.0\r\nHost: a\r\n\r\n"))))
			got := validMethod(in)
			if (err == nil) != got {
				t.Errorf("validMethod(%q) = %t, http.ReadRequest(...) = %v", in, got, err)
			}

		}
	}

}