added a couple tests for request parsing that don't rely on giant parser test dataset

request/request_test.go

@@ -1,42 +1,84 @@
 package request
 
-// import (
-// 	"fmt"
-// 	"github.com/dgrijalva/jwt-go"
-// 	"net/http"
-// 	"reflect"
-// 	"testing"
-// )
-//
-// func TestParseRequest(t *testing.T) {
-// 	// Bearer token request
-// 	for _, data := range jwtTestData {
-// 		// FIXME: custom parsers are not supported by this helper.  skip tests that require them
-// 		if data.parser != nil {
-// 			t.Logf("Skipping [%v].  Custom parsers are not supported by ParseRequest", data.name)
-// 			continue
-// 		}
-//
-// 		if data.tokenString == "" {
-// 			data.tokenString = makeSample(data.claims)
-// 		}
-//
-// 		r, _ := http.NewRequest("GET", "/", nil)
-// 		r.Header.Set("Authorization", fmt.Sprintf("Bearer %v", data.tokenString))
-// 		token, err := ParseFromRequestWithClaims(r, data.keyfunc, &jwt.MapClaims{})
-//
-// 		if token == nil {
-// 			t.Errorf("[%v] Token was not found: %v", data.name, err)
-// 			continue
-// 		}
-// 		if !reflect.DeepEqual(&data.claims, token.Claims) {
-// 			t.Errorf("[%v] Claims mismatch. Expecting: %v  Got: %v", data.name, data.claims, token.Claims)
-// 		}
-// 		if data.valid && err != nil {
-// 			t.Errorf("[%v] Error while verifying token: %v", data.name, err)
-// 		}
-// 		if !data.valid && err == nil {
-// 			t.Errorf("[%v] Invalid token passed validation", data.name)
-// 		}
-// 	}
-// }
+import (
+	"fmt"
+	"github.com/dgrijalva/jwt-go"
+	"github.com/dgrijalva/jwt-go/test"
+	"net/http"
+	"net/url"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var requestTestData = []struct {
+	name    string
+	claims  jwt.MapClaims
+	headers map[string]string
+	query   url.Values
+	valid   bool
+}{
+	{
+		"oauth bearer token - header",
+		jwt.MapClaims{"foo": "bar"},
+		map[string]string{"Authorization": "Bearer %v"},
+		url.Values{},
+		true,
+	},
+	{
+		"oauth bearer token - url",
+		jwt.MapClaims{"foo": "bar"},
+		map[string]string{},
+		url.Values{"access_token": {"%v"}},
+		true,
+	},
+}
+
+func TestParseRequest(t *testing.T) {
+	// load keys from disk
+	privateKey := test.LoadRSAPrivateKeyFromDisk("../test/sample_key")
+	publicKey := test.LoadRSAPublicKeyFromDisk("../test/sample_key.pub")
+	keyfunc := func(*jwt.Token) (interface{}, error) {
+		return publicKey, nil
+	}
+
+	// Bearer token request
+	for _, data := range requestTestData {
+		// Make token from claims
+		tokenString := test.MakeSampleToken(data.claims, privateKey)
+
+		// Make query string
+		for k, vv := range data.query {
+			for i, v := range vv {
+				if strings.Contains(v, "%v") {
+					data.query[k][i] = fmt.Sprintf(v, tokenString)
+				}
+			}
+		}
+
+		// Make request from test struct
+		r, _ := http.NewRequest("GET", fmt.Sprintf("/?%v", data.query.Encode()), nil)
+		for k, v := range data.headers {
+			if strings.Contains(v, "%v") {
+				r.Header.Set(k, fmt.Sprintf(v, tokenString))
+			} else {
+				r.Header.Set(k, tokenString)
+			}
+		}
+		token, err := ParseFromRequestWithClaims(r, keyfunc, &jwt.MapClaims{})
+
+		if token == nil {
+			t.Errorf("[%v] Token was not found: %v", data.name, err)
+			continue
+		}
+		if !reflect.DeepEqual(&data.claims, token.Claims) {
+			t.Errorf("[%v] Claims mismatch. Expecting: %v  Got: %v", data.name, data.claims, token.Claims)
+		}
+		if data.valid && err != nil {
+			t.Errorf("[%v] Error while verifying token: %v", data.name, err)
+		}
+		if !data.valid && err == nil {
+			t.Errorf("[%v] Invalid token passed validation", data.name)
+		}
+	}
+}