Merge pull request #104 from Digitalxero/method-to-get-url-template

[feature] GetHostTemplate and GetPathTemplate return the template used to build the route.

mux_test.go

@@ -32,6 +32,8 @@ type routeTest struct {
 	vars           map[string]string // the expected vars of the match
 	host           string            // the expected host of the match
 	path           string            // the expected path of the match
+	path_template  string            // the expected path template to match
+	host_template  string            // the expected host template to match
 	shouldMatch    bool              // whether the request is expected to match the route at all
 	shouldRedirect bool              // whether the request should result in a redirect
 }
@@ -113,116 +115,129 @@ func TestHost(t *testing.T) {
 			shouldMatch: false,
 		},
 		{
-			title:       "Host route with pattern, match",
-			route:       new(Route).Host("aaa.{v1:[a-z]{3}}.ccc"),
-			request:     newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:        map[string]string{"v1": "bbb"},
-			host:        "aaa.bbb.ccc",
-			path:        "",
-			shouldMatch: true,
-		},
-		{
-			title:       "Host route with pattern, additional capturing group, match",
-			route:       new(Route).Host("aaa.{v1:[a-z]{2}(b|c)}.ccc"),
-			request:     newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:        map[string]string{"v1": "bbb"},
-			host:        "aaa.bbb.ccc",
-			path:        "",
-			shouldMatch: true,
-		},
-		{
-			title:       "Host route with pattern, wrong host in request URL",
-			route:       new(Route).Host("aaa.{v1:[a-z]{3}}.ccc"),
-			request:     newRequest("GET", "http://aaa.222.ccc/111/222/333"),
-			vars:        map[string]string{"v1": "bbb"},
-			host:        "aaa.bbb.ccc",
-			path:        "",
-			shouldMatch: false,
-		},
-		{
-			title:       "Host route with multiple patterns, match",
-			route:       new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}"),
-			request:     newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:        map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc"},
-			host:        "aaa.bbb.ccc",
-			path:        "",
-			shouldMatch: true,
-		},
-		{
-			title:       "Host route with multiple patterns, wrong host in request URL",
-			route:       new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}"),
-			request:     newRequest("GET", "http://aaa.222.ccc/111/222/333"),
-			vars:        map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc"},
-			host:        "aaa.bbb.ccc",
-			path:        "",
-			shouldMatch: false,
-		},
-		{
-			title:       "Host route with hyphenated name and pattern, match",
-			route:       new(Route).Host("aaa.{v-1:[a-z]{3}}.ccc"),
-			request:     newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:        map[string]string{"v-1": "bbb"},
-			host:        "aaa.bbb.ccc",
-			path:        "",
-			shouldMatch: true,
-		},
-		{
-			title:       "Host route with hyphenated name and pattern, additional capturing group, match",
-			route:       new(Route).Host("aaa.{v-1:[a-z]{2}(b|c)}.ccc"),
-			request:     newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:        map[string]string{"v-1": "bbb"},
-			host:        "aaa.bbb.ccc",
-			path:        "",
-			shouldMatch: true,
-		},
-		{
-			title:       "Host route with multiple hyphenated names and patterns, match",
-			route:       new(Route).Host("{v-1:[a-z]{3}}.{v-2:[a-z]{3}}.{v-3:[a-z]{3}}"),
-			request:     newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:        map[string]string{"v-1": "aaa", "v-2": "bbb", "v-3": "ccc"},
-			host:        "aaa.bbb.ccc",
-			path:        "",
-			shouldMatch: true,
-		},
-		{
-			title:       "Path route with single pattern with pipe, match",
-			route:       new(Route).Path("/{category:a|b/c}"),
-			request:     newRequest("GET", "http://localhost/a"),
-			vars:        map[string]string{"category": "a"},
-			host:        "",
-			path:        "/a",
-			shouldMatch: true,
-		},
-		{
-			title:       "Path route with single pattern with pipe, match",
-			route:       new(Route).Path("/{category:a|b/c}"),
-			request:     newRequest("GET", "http://localhost/b/c"),
-			vars:        map[string]string{"category": "b/c"},
-			host:        "",
-			path:        "/b/c",
-			shouldMatch: true,
-		},
-		{
-			title:       "Path route with multiple patterns with pipe, match",
-			route:       new(Route).Path("/{category:a|b/c}/{product}/{id:[0-9]+}"),
-			request:     newRequest("GET", "http://localhost/a/product_name/1"),
-			vars:        map[string]string{"category": "a", "product": "product_name", "id": "1"},
-			host:        "",
-			path:        "/a/product_name/1",
-			shouldMatch: true,
-		},
-		{
-			title:       "Path route with multiple patterns with pipe, match",
-			route:       new(Route).Path("/{category:a|b/c}/{product}/{id:[0-9]+}"),
-			request:     newRequest("GET", "http://localhost/b/c/product_name/1"),
-			vars:        map[string]string{"category": "b/c", "product": "product_name", "id": "1"},
-			host:        "",
-			path:        "/b/c/product_name/1",
-			shouldMatch: true,
+			title:         "Host route with pattern, match",
+			route:         new(Route).Host("aaa.{v1:[a-z]{3}}.ccc"),
+			request:       newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:          map[string]string{"v1": "bbb"},
+			host:          "aaa.bbb.ccc",
+			path:          "",
+			host_template: `aaa.{v1:[a-z]{3}}.ccc`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Host route with pattern, additional capturing group, match",
+			route:         new(Route).Host("aaa.{v1:[a-z]{2}(b|c)}.ccc"),
+			request:       newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:          map[string]string{"v1": "bbb"},
+			host:          "aaa.bbb.ccc",
+			path:          "",
+			host_template: `aaa.{v1:[a-z]{2}(b|c)}.ccc`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Host route with pattern, wrong host in request URL",
+			route:         new(Route).Host("aaa.{v1:[a-z]{3}}.ccc"),
+			request:       newRequest("GET", "http://aaa.222.ccc/111/222/333"),
+			vars:          map[string]string{"v1": "bbb"},
+			host:          "aaa.bbb.ccc",
+			path:          "",
+			host_template: `aaa.{v1:[a-z]{3}}.ccc`,
+			shouldMatch:   false,
+		},
+		{
+			title:         "Host route with multiple patterns, match",
+			route:         new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}"),
+			request:       newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:          map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc"},
+			host:          "aaa.bbb.ccc",
+			path:          "",
+			host_template: `{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Host route with multiple patterns, wrong host in request URL",
+			route:         new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}"),
+			request:       newRequest("GET", "http://aaa.222.ccc/111/222/333"),
+			vars:          map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc"},
+			host:          "aaa.bbb.ccc",
+			path:          "",
+			host_template: `{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}`,
+			shouldMatch:   false,
+		},
+		{
+			title:         "Host route with hyphenated name and pattern, match",
+			route:         new(Route).Host("aaa.{v-1:[a-z]{3}}.ccc"),
+			request:       newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:          map[string]string{"v-1": "bbb"},
+			host:          "aaa.bbb.ccc",
+			path:          "",
+			host_template: `aaa.{v-1:[a-z]{3}}.ccc`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Host route with hyphenated name and pattern, additional capturing group, match",
+			route:         new(Route).Host("aaa.{v-1:[a-z]{2}(b|c)}.ccc"),
+			request:       newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:          map[string]string{"v-1": "bbb"},
+			host:          "aaa.bbb.ccc",
+			path:          "",
+			host_template: `aaa.{v-1:[a-z]{2}(b|c)}.ccc`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Host route with multiple hyphenated names and patterns, match",
+			route:         new(Route).Host("{v-1:[a-z]{3}}.{v-2:[a-z]{3}}.{v-3:[a-z]{3}}"),
+			request:       newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:          map[string]string{"v-1": "aaa", "v-2": "bbb", "v-3": "ccc"},
+			host:          "aaa.bbb.ccc",
+			path:          "",
+			host_template: `{v-1:[a-z]{3}}.{v-2:[a-z]{3}}.{v-3:[a-z]{3}}`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Path route with single pattern with pipe, match",
+			route:         new(Route).Path("/{category:a|b/c}"),
+			request:       newRequest("GET", "http://localhost/a"),
+			vars:          map[string]string{"category": "a"},
+			host:          "",
+			path:          "/a",
+			path_template: `/{category:a|b/c}`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Path route with single pattern with pipe, match",
+			route:         new(Route).Path("/{category:a|b/c}"),
+			request:       newRequest("GET", "http://localhost/b/c"),
+			vars:          map[string]string{"category": "b/c"},
+			host:          "",
+			path:          "/b/c",
+			path_template: `/{category:a|b/c}`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Path route with multiple patterns with pipe, match",
+			route:         new(Route).Path("/{category:a|b/c}/{product}/{id:[0-9]+}"),
+			request:       newRequest("GET", "http://localhost/a/product_name/1"),
+			vars:          map[string]string{"category": "a", "product": "product_name", "id": "1"},
+			host:          "",
+			path:          "/a/product_name/1",
+			path_template: `/{category:a|b/c}/{product}/{id:[0-9]+}`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Path route with multiple patterns with pipe, match",
+			route:         new(Route).Path("/{category:a|b/c}/{product}/{id:[0-9]+}"),
+			request:       newRequest("GET", "http://localhost/b/c/product_name/1"),
+			vars:          map[string]string{"category": "b/c", "product": "product_name", "id": "1"},
+			host:          "",
+			path:          "/b/c/product_name/1",
+			path_template: `/{category:a|b/c}/{product}/{id:[0-9]+}`,
+			shouldMatch:   true,
 		},
 	}
 	for _, test := range tests {
 		testRoute(t, test)
+		testTemplate(t, test)
 	}
 }
 
@@ -247,22 +262,24 @@ func TestPath(t *testing.T) {
 			shouldMatch: true,
 		},
 		{
-			title:       "Path route, do not match with trailing slash in path",
-			route:       new(Route).Path("/111/"),
-			request:     newRequest("GET", "http://localhost/111"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "/111",
-			shouldMatch: false,
+			title:         "Path route, do not match with trailing slash in path",
+			route:         new(Route).Path("/111/"),
+			request:       newRequest("GET", "http://localhost/111"),
+			vars:          map[string]string{},
+			host:          "",
+			path:          "/111",
+			path_template: `/111/`,
+			shouldMatch:   false,
 		},
 		{
-			title:       "Path route, do not match with trailing slash in request",
-			route:       new(Route).Path("/111"),
-			request:     newRequest("GET", "http://localhost/111/"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "/111/",
-			shouldMatch: false,
+			title:         "Path route, do not match with trailing slash in request",
+			route:         new(Route).Path("/111"),
+			request:       newRequest("GET", "http://localhost/111/"),
+			vars:          map[string]string{},
+			host:          "",
+			path:          "/111/",
+			path_template: `/111`,
+			shouldMatch:   false,
 		},
 		{
 			title:       "Path route, wrong path in request in request URL",
@@ -274,81 +291,90 @@ func TestPath(t *testing.T) {
 			shouldMatch: false,
 		},
 		{
-			title:       "Path route with pattern, match",
-			route:       new(Route).Path("/111/{v1:[0-9]{3}}/333"),
-			request:     newRequest("GET", "http://localhost/111/222/333"),
-			vars:        map[string]string{"v1": "222"},
-			host:        "",
-			path:        "/111/222/333",
-			shouldMatch: true,
-		},
-		{
-			title:       "Path route with pattern, URL in request does not match",
-			route:       new(Route).Path("/111/{v1:[0-9]{3}}/333"),
-			request:     newRequest("GET", "http://localhost/111/aaa/333"),
-			vars:        map[string]string{"v1": "222"},
-			host:        "",
-			path:        "/111/222/333",
-			shouldMatch: false,
-		},
-		{
-			title:       "Path route with multiple patterns, match",
-			route:       new(Route).Path("/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}"),
-			request:     newRequest("GET", "http://localhost/111/222/333"),
-			vars:        map[string]string{"v1": "111", "v2": "222", "v3": "333"},
-			host:        "",
-			path:        "/111/222/333",
-			shouldMatch: true,
-		},
-		{
-			title:       "Path route with multiple patterns, URL in request does not match",
-			route:       new(Route).Path("/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}"),
-			request:     newRequest("GET", "http://localhost/111/aaa/333"),
-			vars:        map[string]string{"v1": "111", "v2": "222", "v3": "333"},
-			host:        "",
-			path:        "/111/222/333",
-			shouldMatch: false,
-		},
-		{
-			title:       "Path route with multiple patterns with pipe, match",
-			route:       new(Route).Path("/{category:a|(b/c)}/{product}/{id:[0-9]+}"),
-			request:     newRequest("GET", "http://localhost/a/product_name/1"),
-			vars:        map[string]string{"category": "a", "product": "product_name", "id": "1"},
-			host:        "",
-			path:        "/a/product_name/1",
-			shouldMatch: true,
-		},
-		{
-			title:       "Path route with hyphenated name and pattern, match",
-			route:       new(Route).Path("/111/{v-1:[0-9]{3}}/333"),
-			request:     newRequest("GET", "http://localhost/111/222/333"),
-			vars:        map[string]string{"v-1": "222"},
-			host:        "",
-			path:        "/111/222/333",
-			shouldMatch: true,
-		},
-		{
-			title:       "Path route with multiple hyphenated names and patterns, match",
-			route:       new(Route).Path("/{v-1:[0-9]{3}}/{v-2:[0-9]{3}}/{v-3:[0-9]{3}}"),
-			request:     newRequest("GET", "http://localhost/111/222/333"),
-			vars:        map[string]string{"v-1": "111", "v-2": "222", "v-3": "333"},
-			host:        "",
-			path:        "/111/222/333",
-			shouldMatch: true,
-		},
-		{
-			title:       "Path route with multiple hyphenated names and patterns with pipe, match",
-			route:       new(Route).Path("/{product-category:a|(b/c)}/{product-name}/{product-id:[0-9]+}"),
-			request:     newRequest("GET", "http://localhost/a/product_name/1"),
-			vars:        map[string]string{"product-category": "a", "product-name": "product_name", "product-id": "1"},
-			host:        "",
-			path:        "/a/product_name/1",
-			shouldMatch: true,
+			title:         "Path route with pattern, match",
+			route:         new(Route).Path("/111/{v1:[0-9]{3}}/333"),
+			request:       newRequest("GET", "http://localhost/111/222/333"),
+			vars:          map[string]string{"v1": "222"},
+			host:          "",
+			path:          "/111/222/333",
+			path_template: `/111/{v1:[0-9]{3}}/333`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Path route with pattern, URL in request does not match",
+			route:         new(Route).Path("/111/{v1:[0-9]{3}}/333"),
+			request:       newRequest("GET", "http://localhost/111/aaa/333"),
+			vars:          map[string]string{"v1": "222"},
+			host:          "",
+			path:          "/111/222/333",
+			path_template: `/111/{v1:[0-9]{3}}/333`,
+			shouldMatch:   false,
+		},
+		{
+			title:         "Path route with multiple patterns, match",
+			route:         new(Route).Path("/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}"),
+			request:       newRequest("GET", "http://localhost/111/222/333"),
+			vars:          map[string]string{"v1": "111", "v2": "222", "v3": "333"},
+			host:          "",
+			path:          "/111/222/333",
+			path_template: `/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Path route with multiple patterns, URL in request does not match",
+			route:         new(Route).Path("/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}"),
+			request:       newRequest("GET", "http://localhost/111/aaa/333"),
+			vars:          map[string]string{"v1": "111", "v2": "222", "v3": "333"},
+			host:          "",
+			path:          "/111/222/333",
+			path_template: `/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}`,
+			shouldMatch:   false,
+		},
+		{
+			title:         "Path route with multiple patterns with pipe, match",
+			route:         new(Route).Path("/{category:a|(b/c)}/{product}/{id:[0-9]+}"),
+			request:       newRequest("GET", "http://localhost/a/product_name/1"),
+			vars:          map[string]string{"category": "a", "product": "product_name", "id": "1"},
+			host:          "",
+			path:          "/a/product_name/1",
+			path_template: `/{category:a|(b/c)}/{product}/{id:[0-9]+}`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Path route with hyphenated name and pattern, match",
+			route:         new(Route).Path("/111/{v-1:[0-9]{3}}/333"),
+			request:       newRequest("GET", "http://localhost/111/222/333"),
+			vars:          map[string]string{"v-1": "222"},
+			host:          "",
+			path:          "/111/222/333",
+			path_template: `/111/{v-1:[0-9]{3}}/333`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Path route with multiple hyphenated names and patterns, match",
+			route:         new(Route).Path("/{v-1:[0-9]{3}}/{v-2:[0-9]{3}}/{v-3:[0-9]{3}}"),
+			request:       newRequest("GET", "http://localhost/111/222/333"),
+			vars:          map[string]string{"v-1": "111", "v-2": "222", "v-3": "333"},
+			host:          "",
+			path:          "/111/222/333",
+			path_template: `/{v-1:[0-9]{3}}/{v-2:[0-9]{3}}/{v-3:[0-9]{3}}`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Path route with multiple hyphenated names and patterns with pipe, match",
+			route:         new(Route).Path("/{product-category:a|(b/c)}/{product-name}/{product-id:[0-9]+}"),
+			request:       newRequest("GET", "http://localhost/a/product_name/1"),
+			vars:          map[string]string{"product-category": "a", "product-name": "product_name", "product-id": "1"},
+			host:          "",
+			path:          "/a/product_name/1",
+			path_template: `/{product-category:a|(b/c)}/{product-name}/{product-id:[0-9]+}`,
+			shouldMatch:   true,
 		},
 	}
 
 	for _, test := range tests {
 		testRoute(t, test)
+		testTemplate(t, test)
 	}
 }
 
@@ -382,108 +408,126 @@ func TestPathPrefix(t *testing.T) {
 			shouldMatch: false,
 		},
 		{
-			title:       "PathPrefix route with pattern, match",
-			route:       new(Route).PathPrefix("/111/{v1:[0-9]{3}}"),
-			request:     newRequest("GET", "http://localhost/111/222/333"),
-			vars:        map[string]string{"v1": "222"},
-			host:        "",
-			path:        "/111/222",
-			shouldMatch: true,
-		},
-		{
-			title:       "PathPrefix route with pattern, URL prefix in request does not match",
-			route:       new(Route).PathPrefix("/111/{v1:[0-9]{3}}"),
-			request:     newRequest("GET", "http://localhost/111/aaa/333"),
-			vars:        map[string]string{"v1": "222"},
-			host:        "",
-			path:        "/111/222",
-			shouldMatch: false,
-		},
-		{
-			title:       "PathPrefix route with multiple patterns, match",
-			route:       new(Route).PathPrefix("/{v1:[0-9]{3}}/{v2:[0-9]{3}}"),
-			request:     newRequest("GET", "http://localhost/111/222/333"),
-			vars:        map[string]string{"v1": "111", "v2": "222"},
-			host:        "",
-			path:        "/111/222",
-			shouldMatch: true,
-		},
-		{
-			title:       "PathPrefix route with multiple patterns, URL prefix in request does not match",
-			route:       new(Route).PathPrefix("/{v1:[0-9]{3}}/{v2:[0-9]{3}}"),
-			request:     newRequest("GET", "http://localhost/111/aaa/333"),
-			vars:        map[string]string{"v1": "111", "v2": "222"},
-			host:        "",
-			path:        "/111/222",
-			shouldMatch: false,
+			title:         "PathPrefix route with pattern, match",
+			route:         new(Route).PathPrefix("/111/{v1:[0-9]{3}}"),
+			request:       newRequest("GET", "http://localhost/111/222/333"),
+			vars:          map[string]string{"v1": "222"},
+			host:          "",
+			path:          "/111/222",
+			path_template: `/111/{v1:[0-9]{3}}`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "PathPrefix route with pattern, URL prefix in request does not match",
+			route:         new(Route).PathPrefix("/111/{v1:[0-9]{3}}"),
+			request:       newRequest("GET", "http://localhost/111/aaa/333"),
+			vars:          map[string]string{"v1": "222"},
+			host:          "",
+			path:          "/111/222",
+			path_template: `/111/{v1:[0-9]{3}}`,
+			shouldMatch:   false,
+		},
+		{
+			title:         "PathPrefix route with multiple patterns, match",
+			route:         new(Route).PathPrefix("/{v1:[0-9]{3}}/{v2:[0-9]{3}}"),
+			request:       newRequest("GET", "http://localhost/111/222/333"),
+			vars:          map[string]string{"v1": "111", "v2": "222"},
+			host:          "",
+			path:          "/111/222",
+			path_template: `/{v1:[0-9]{3}}/{v2:[0-9]{3}}`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "PathPrefix route with multiple patterns, URL prefix in request does not match",
+			route:         new(Route).PathPrefix("/{v1:[0-9]{3}}/{v2:[0-9]{3}}"),
+			request:       newRequest("GET", "http://localhost/111/aaa/333"),
+			vars:          map[string]string{"v1": "111", "v2": "222"},
+			host:          "",
+			path:          "/111/222",
+			path_template: `/{v1:[0-9]{3}}/{v2:[0-9]{3}}`,
+			shouldMatch:   false,
 		},
 	}
 
 	for _, test := range tests {
 		testRoute(t, test)
+		testTemplate(t, test)
 	}
 }
 
 func TestHostPath(t *testing.T) {
 	tests := []routeTest{
 		{
-			title:       "Host and Path route, match",
-			route:       new(Route).Host("aaa.bbb.ccc").Path("/111/222/333"),
-			request:     newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			shouldMatch: true,
-		},
-		{
-			title:       "Host and Path route, wrong host in request URL",
-			route:       new(Route).Host("aaa.bbb.ccc").Path("/111/222/333"),
-			request:     newRequest("GET", "http://aaa.222.ccc/111/222/333"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			shouldMatch: false,
-		},
-		{
-			title:       "Host and Path route with pattern, match",
-			route:       new(Route).Host("aaa.{v1:[a-z]{3}}.ccc").Path("/111/{v2:[0-9]{3}}/333"),
-			request:     newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:        map[string]string{"v1": "bbb", "v2": "222"},
-			host:        "aaa.bbb.ccc",
-			path:        "/111/222/333",
-			shouldMatch: true,
-		},
-		{
-			title:       "Host and Path route with pattern, URL in request does not match",
-			route:       new(Route).Host("aaa.{v1:[a-z]{3}}.ccc").Path("/111/{v2:[0-9]{3}}/333"),
-			request:     newRequest("GET", "http://aaa.222.ccc/111/222/333"),
-			vars:        map[string]string{"v1": "bbb", "v2": "222"},
-			host:        "aaa.bbb.ccc",
-			path:        "/111/222/333",
-			shouldMatch: false,
-		},
-		{
-			title:       "Host and Path route with multiple patterns, match",
-			route:       new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}").Path("/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}"),
-			request:     newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:        map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc", "v4": "111", "v5": "222", "v6": "333"},
-			host:        "aaa.bbb.ccc",
-			path:        "/111/222/333",
-			shouldMatch: true,
-		},
-		{
-			title:       "Host and Path route with multiple patterns, URL in request does not match",
-			route:       new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}").Path("/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}"),
-			request:     newRequest("GET", "http://aaa.222.ccc/111/222/333"),
-			vars:        map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc", "v4": "111", "v5": "222", "v6": "333"},
-			host:        "aaa.bbb.ccc",
-			path:        "/111/222/333",
-			shouldMatch: false,
+			title:         "Host and Path route, match",
+			route:         new(Route).Host("aaa.bbb.ccc").Path("/111/222/333"),
+			request:       newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:          map[string]string{},
+			host:          "",
+			path:          "",
+			path_template: `/111/222/333`,
+			host_template: `aaa.bbb.ccc`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Host and Path route, wrong host in request URL",
+			route:         new(Route).Host("aaa.bbb.ccc").Path("/111/222/333"),
+			request:       newRequest("GET", "http://aaa.222.ccc/111/222/333"),
+			vars:          map[string]string{},
+			host:          "",
+			path:          "",
+			path_template: `/111/222/333`,
+			host_template: `aaa.bbb.ccc`,
+			shouldMatch:   false,
+		},
+		{
+			title:         "Host and Path route with pattern, match",
+			route:         new(Route).Host("aaa.{v1:[a-z]{3}}.ccc").Path("/111/{v2:[0-9]{3}}/333"),
+			request:       newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:          map[string]string{"v1": "bbb", "v2": "222"},
+			host:          "aaa.bbb.ccc",
+			path:          "/111/222/333",
+			path_template: `/111/{v2:[0-9]{3}}/333`,
+			host_template: `aaa.{v1:[a-z]{3}}.ccc`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Host and Path route with pattern, URL in request does not match",
+			route:         new(Route).Host("aaa.{v1:[a-z]{3}}.ccc").Path("/111/{v2:[0-9]{3}}/333"),
+			request:       newRequest("GET", "http://aaa.222.ccc/111/222/333"),
+			vars:          map[string]string{"v1": "bbb", "v2": "222"},
+			host:          "aaa.bbb.ccc",
+			path:          "/111/222/333",
+			path_template: `/111/{v2:[0-9]{3}}/333`,
+			host_template: `aaa.{v1:[a-z]{3}}.ccc`,
+			shouldMatch:   false,
+		},
+		{
+			title:         "Host and Path route with multiple patterns, match",
+			route:         new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}").Path("/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}"),
+			request:       newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:          map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc", "v4": "111", "v5": "222", "v6": "333"},
+			host:          "aaa.bbb.ccc",
+			path:          "/111/222/333",
+			path_template: `/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}`,
+			host_template: `{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}`,
+			shouldMatch:   true,
+		},
+		{
+			title:         "Host and Path route with multiple patterns, URL in request does not match",
+			route:         new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}").Path("/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}"),
+			request:       newRequest("GET", "http://aaa.222.ccc/111/222/333"),
+			vars:          map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc", "v4": "111", "v5": "222", "v6": "333"},
+			host:          "aaa.bbb.ccc",
+			path:          "/111/222/333",
+			path_template: `/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}`,
+			host_template: `{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}`,
+			shouldMatch:   false,
 		},
 	}
 
 	for _, test := range tests {
 		testRoute(t, test)
+		testTemplate(t, test)
 	}
 }
 
@@ -541,6 +585,7 @@ func TestHeaders(t *testing.T) {
 
 	for _, test := range tests {
 		testRoute(t, test)
+		testTemplate(t, test)
 	}
 
 }
@@ -578,6 +623,7 @@ func TestMethods(t *testing.T) {
 
 	for _, test := range tests {
 		testRoute(t, test)
+		testTemplate(t, test)
 	}
 }
 
@@ -593,22 +639,26 @@ func TestQueries(t *testing.T) {
 			shouldMatch: true,
 		},
 		{
-			title:       "Queries route, match with a query string",
-			route:       new(Route).Host("www.example.com").Path("/api").Queries("foo", "bar", "baz", "ding"),
-			request:     newRequest("GET", "http://www.example.com/api?foo=bar&baz=ding"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			shouldMatch: true,
+			title:         "Queries route, match with a query string",
+			route:         new(Route).Host("www.example.com").Path("/api").Queries("foo", "bar", "baz", "ding"),
+			request:       newRequest("GET", "http://www.example.com/api?foo=bar&baz=ding"),
+			vars:          map[string]string{},
+			host:          "",
+			path:          "",
+			path_template: `/api`,
+			host_template: `www.example.com`,
+			shouldMatch:   true,
 		},
 		{
-			title:       "Queries route, match with a query string out of order",
-			route:       new(Route).Host("www.example.com").Path("/api").Queries("foo", "bar", "baz", "ding"),
-			request:     newRequest("GET", "http://www.example.com/api?baz=ding&foo=bar"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			shouldMatch: true,
+			title:         "Queries route, match with a query string out of order",
+			route:         new(Route).Host("www.example.com").Path("/api").Queries("foo", "bar", "baz", "ding"),
+			request:       newRequest("GET", "http://www.example.com/api?baz=ding&foo=bar"),
+			vars:          map[string]string{},
+			host:          "",
+			path:          "",
+			path_template: `/api`,
+			host_template: `www.example.com`,
+			shouldMatch:   true,
 		},
 		{
 			title:       "Queries route, bad query",
@@ -803,6 +853,7 @@ func TestQueries(t *testing.T) {
 
 	for _, test := range tests {
 		testRoute(t, test)
+		testTemplate(t, test)
 	}
 }
 
@@ -839,6 +890,7 @@ func TestSchemes(t *testing.T) {
 	}
 	for _, test := range tests {
 		testRoute(t, test)
+		testTemplate(t, test)
 	}
 }
 
@@ -873,6 +925,7 @@ func TestMatcherFunc(t *testing.T) {
 
 	for _, test := range tests {
 		testRoute(t, test)
+		testTemplate(t, test)
 	}
 }
 
@@ -885,9 +938,10 @@ func TestBuildVarsFunc(t *testing.T) {
 				vars["v2"] = "a"
 				return vars
 			}),
-			request:     newRequest("GET", "http://localhost/111/2"),
-			path:        "/111/3a",
-			shouldMatch: true,
+			request:       newRequest("GET", "http://localhost/111/2"),
+			path:          "/111/3a",
+			path_template: `/111/{v1:\d}{v2:.*}`,
+			shouldMatch:   true,
 		},
 		{
 			title: "BuildVarsFunc set on route and parent route",
@@ -898,14 +952,16 @@ func TestBuildVarsFunc(t *testing.T) {
 				vars["v2"] = "b"
 				return vars
 			}),
-			request:     newRequest("GET", "http://localhost/1/a"),
-			path:        "/2/b",
-			shouldMatch: true,
+			request:       newRequest("GET", "http://localhost/1/a"),
+			path:          "/2/b",
+			path_template: `/{v1:\d}/{v2:\w}`,
+			shouldMatch:   true,
 		},
 	}
 
 	for _, test := range tests {
 		testRoute(t, test)
+		testTemplate(t, test)
 	}
 }
 
@@ -915,41 +971,48 @@ func TestSubRouter(t *testing.T) {
 
 	tests := []routeTest{
 		{
-			route:       subrouter1.Path("/{v2:[a-z]+}"),
-			request:     newRequest("GET", "http://aaa.google.com/bbb"),
-			vars:        map[string]string{"v1": "aaa", "v2": "bbb"},
-			host:        "aaa.google.com",
-			path:        "/bbb",
-			shouldMatch: true,
-		},
-		{
-			route:       subrouter1.Path("/{v2:[a-z]+}"),
-			request:     newRequest("GET", "http://111.google.com/111"),
-			vars:        map[string]string{"v1": "aaa", "v2": "bbb"},
-			host:        "aaa.google.com",
-			path:        "/bbb",
-			shouldMatch: false,
-		},
-		{
-			route:       subrouter2.Path("/baz/{v2}"),
-			request:     newRequest("GET", "http://localhost/foo/bar/baz/ding"),
-			vars:        map[string]string{"v1": "bar", "v2": "ding"},
-			host:        "",
-			path:        "/foo/bar/baz/ding",
-			shouldMatch: true,
-		},
-		{
-			route:       subrouter2.Path("/baz/{v2}"),
-			request:     newRequest("GET", "http://localhost/foo/bar"),
-			vars:        map[string]string{"v1": "bar", "v2": "ding"},
-			host:        "",
-			path:        "/foo/bar/baz/ding",
-			shouldMatch: false,
+			route:         subrouter1.Path("/{v2:[a-z]+}"),
+			request:       newRequest("GET", "http://aaa.google.com/bbb"),
+			vars:          map[string]string{"v1": "aaa", "v2": "bbb"},
+			host:          "aaa.google.com",
+			path:          "/bbb",
+			path_template: `/{v2:[a-z]+}`,
+			host_template: `{v1:[a-z]+}.google.com`,
+			shouldMatch:   true,
+		},
+		{
+			route:         subrouter1.Path("/{v2:[a-z]+}"),
+			request:       newRequest("GET", "http://111.google.com/111"),
+			vars:          map[string]string{"v1": "aaa", "v2": "bbb"},
+			host:          "aaa.google.com",
+			path:          "/bbb",
+			path_template: `/{v2:[a-z]+}`,
+			host_template: `{v1:[a-z]+}.google.com`,
+			shouldMatch:   false,
+		},
+		{
+			route:         subrouter2.Path("/baz/{v2}"),
+			request:       newRequest("GET", "http://localhost/foo/bar/baz/ding"),
+			vars:          map[string]string{"v1": "bar", "v2": "ding"},
+			host:          "",
+			path:          "/foo/bar/baz/ding",
+			path_template: `/foo/{v1}/baz/{v2}`,
+			shouldMatch:   true,
+		},
+		{
+			route:         subrouter2.Path("/baz/{v2}"),
+			request:       newRequest("GET", "http://localhost/foo/bar"),
+			vars:          map[string]string{"v1": "bar", "v2": "ding"},
+			host:          "",
+			path:          "/foo/bar/baz/ding",
+			path_template: `/foo/{v1}/baz/{v2}`,
+			shouldMatch:   false,
 		},
 	}
 
 	for _, test := range tests {
 		testRoute(t, test)
+		testTemplate(t, test)
 	}
 }
 
@@ -1045,6 +1108,7 @@ func TestStrictSlash(t *testing.T) {
 
 	for _, test := range tests {
 		testRoute(t, test)
+		testTemplate(t, test)
 	}
 }
 
@@ -1152,14 +1216,13 @@ func TestSubrouterErrorHandling(t *testing.T) {
 // ----------------------------------------------------------------------------
 
 func getRouteTemplate(route *Route) string {
-	host, path := "none", "none"
-	if route.regexp != nil {
-		if route.regexp.host != nil {
-			host = route.regexp.host.template
-		}
-		if route.regexp.path != nil {
-			path = route.regexp.path.template
-		}
+	host, err := route.GetHostTemplate()
+	if err != nil {
+		host = "none"
+	}
+	path, err := route.GetPathTemplate()
+	if err != nil {
+		path = "none"
 	}
 	return fmt.Sprintf("Host: %v, Path: %v", host, path)
 }
@@ -1221,6 +1284,28 @@ func testRoute(t *testing.T, test routeTest) {
 	}
 }
 
+func testTemplate(t *testing.T, test routeTest) {
+	route := test.route
+	path_template := test.path_template
+	if len(path_template) == 0 {
+		path_template = test.path
+	}
+	host_template := test.host_template
+	if len(host_template) == 0 {
+		host_template = test.host
+	}
+
+	path_tmpl, path_err := route.GetPathTemplate()
+	if path_err == nil && path_tmpl != path_template {
+		t.Errorf("(%v) GetPathTemplate not equal: expected %v, got %v", test.title, path_template, path_tmpl)
+	}
+
+	host_tmpl, host_err := route.GetHostTemplate()
+	if host_err == nil && host_tmpl != host_template {
+		t.Errorf("(%v) GetHostTemplate not equal: expected %v, got %v", test.title, host_template, host_tmpl)
+	}
+}
+
 // Tests that the context is cleared or not cleared properly depending on
 // the configuration of the router
 func TestKeepContext(t *testing.T) {

route.go

@@ -534,6 +534,36 @@ func (r *Route) URLPath(pairs ...string) (*url.URL, error) {
 	}, nil
 }
 
+// GetPathTemplate returns the template used to build the
+// route match.
+// This is useful for building simple REST API documentation and for instrumentation
+// against third-party services.
+// An error will be returned if the route does not define a path.
+func (r *Route) GetPathTemplate() (string, error) {
+	if r.err != nil {
+		return "", r.err
+	}
+	if r.regexp == nil || r.regexp.path == nil {
+		return "", errors.New("mux: route doesn't have a path")
+	}
+	return r.regexp.path.template, nil
+}
+
+// GetHostTemplate returns the template used to build the
+// route match.
+// This is useful for building simple REST API documentation and for instrumentation
+// against third-party services.
+// An error will be returned if the route does not define a host.
+func (r *Route) GetHostTemplate() (string, error) {
+	if r.err != nil {
+		return "", r.err
+	}
+	if r.regexp == nil || r.regexp.host == nil {
+		return "", errors.New("mux: route doesn't have a host")
+	}
+	return r.regexp.host.template, nil
+}
+
 // prepareVars converts the route variable pairs into a map. If the route has a
 // BuildVarsFunc, it is invoked.
 func (r *Route) prepareVars(pairs ...string) (map[string]string, error) {