Add matcher for JWTs

Author: Stein Fletcher

jsonpath_test.go

@@ -1,4 +1,4 @@
-package jsonpath
+package jsonpath_test
 
 import (
 	"bytes"
@@ -9,6 +9,8 @@ import (
 
 	"github.com/steinfletcher/apitest"
 	"github.com/stretchr/testify/assert"
+
+	jsonpath "github.com/steinfletcher/apitest-jsonpath"
 )
 
 func TestApiTest_Contains(t *testing.T) {
@@ -26,7 +28,7 @@ func TestApiTest_Contains(t *testing.T) {
 		Handler(handler).
 		Get("/hello").
 		Expect(t).
-		Assert(Contains(`$.b[? @.key=="c"].value`, "result")).
+		Assert(jsonpath.Contains(`$.b[? @.key=="c"].value`, "result")).
 		End()
 }
 
@@ -45,7 +47,7 @@ func TestApiTest_Equal_Numeric(t *testing.T) {
 		Handler(handler).
 		Get("/hello").
 		Expect(t).
-		Assert(Equal(`$.a`, float64(12345))).
+		Assert(jsonpath.Equal(`$.a`, float64(12345))).
 		End()
 }
 
@@ -64,7 +66,7 @@ func TestApiTest_Equal_String(t *testing.T) {
 		Handler(handler).
 		Get("/hello").
 		Expect(t).
-		Assert(Equal(`$.a`, "12345")).
+		Assert(jsonpath.Equal(`$.a`, "12345")).
 		End()
 }
 
@@ -83,60 +85,10 @@ func TestApiTest_Equal_Map(t *testing.T) {
 		Handler(handler).
 		Get("/hello").
 		Expect(t).
-		Assert(Equal(`$`, map[string]interface{}{"a": "hello", "b": float64(12345)})).
+		Assert(jsonpath.Equal(`$`, map[string]interface{}{"a": "hello", "b": float64(12345)})).
 		End()
 }
 
-func Test_IncludesElement(t *testing.T) {
-	list1 := []string{"Foo", "Bar"}
-	list2 := []int{1, 2}
-	simpleMap := map[interface{}]interface{}{"Foo": "Bar"}
-
-	ok, found := includesElement("Hello World", "World")
-	assertTrue(t, ok)
-	assertTrue(t, found)
-
-	ok, found = includesElement(list1, "Foo")
-	assertTrue(t, ok)
-	assertTrue(t, found)
-
-	ok, found = includesElement(list1, "Bar")
-	assertTrue(t, ok)
-	assertTrue(t, found)
-
-	ok, found = includesElement(list2, 1)
-	assertTrue(t, ok)
-	assertTrue(t, found)
-
-	ok, found = includesElement(list2, 2)
-	assertTrue(t, ok)
-	assertTrue(t, found)
-
-	ok, found = includesElement(list1, "Foo!")
-	assertTrue(t, ok)
-	assertFalse(t, found)
-
-	ok, found = includesElement(list2, 3)
-	assertTrue(t, ok)
-	assertFalse(t, found)
-
-	ok, found = includesElement(list2, "1")
-	assertTrue(t, ok)
-	assertFalse(t, found)
-
-	ok, found = includesElement(simpleMap, "Foo")
-	assertTrue(t, ok)
-	assertTrue(t, found)
-
-	ok, found = includesElement(simpleMap, "Bar")
-	assertTrue(t, ok)
-	assertFalse(t, found)
-
-	ok, found = includesElement(1433, "1")
-	assertFalse(t, ok)
-	assertFalse(t, found)
-}
-
 func TestApiTest_Len(t *testing.T) {
 	handler := http.NewServeMux()
 	handler.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
@@ -152,8 +104,8 @@ func TestApiTest_Len(t *testing.T) {
 		Handler(handler).
 		Get("/hello").
 		Expect(t).
-		Assert(Len(`$.a`, 3)).
-		Assert(Len(`$.b`, 1)).
+		Assert(jsonpath.Len(`$.a`, 3)).
+		Assert(jsonpath.Len(`$.b`, 1)).
 		End()
 }
 
@@ -172,8 +124,8 @@ func TestApiTest_GreaterThan(t *testing.T) {
 		Handler(handler).
 		Get("/hello").
 		Expect(t).
-		Assert(GreaterThan(`$.a`, 2)).
-		Assert(GreaterThan(`$.b`, 0)).
+		Assert(jsonpath.GreaterThan(`$.a`, 2)).
+		Assert(jsonpath.GreaterThan(`$.b`, 0)).
 		End()
 }
 
@@ -192,8 +144,8 @@ func TestApiTest_LessThan(t *testing.T) {
 		Handler(handler).
 		Get("/hello").
 		Expect(t).
-		Assert(LessThan(`$.a`, 4)).
-		Assert(LessThan(`$.b`, 2)).
+		Assert(jsonpath.LessThan(`$.a`, 4)).
+		Assert(jsonpath.LessThan(`$.b`, 2)).
 		End()
 }
 
@@ -212,8 +164,8 @@ func TestApiTest_Present(t *testing.T) {
 		Handler(handler).
 		Get("/hello").
 		Expect(t).
-		Assert(Present(`$.a`)).
-		Assert(NotPresent(`$.password`)).
+		Assert(jsonpath.Present(`$.a`)).
+		Assert(jsonpath.NotPresent(`$.password`)).
 		End()
 }
 
@@ -242,21 +194,21 @@ func TestApiTest_Matches(t *testing.T) {
 				Handler(handler).
 				Get("/hello").
 				Expect(t).
-				Assert(Matches(testCase[0], testCase[1])).
+				Assert(jsonpath.Matches(testCase[0], testCase[1])).
 				End()
 		})
 	}
 }
 
 func TestApiTest_Matches_FailCompile(t *testing.T) {
-	willFailToCompile := Matches(`$.b[? @.key=="c"].value`, `\`)
+	willFailToCompile := jsonpath.Matches(`$.b[? @.key=="c"].value`, `\`)
 	err := willFailToCompile(nil, nil)
 
 	assert.EqualError(t, err, `invalid pattern: '\'`)
 }
 
 func TestApiTest_Matches_FailForObject(t *testing.T) {
-	matcher := Matches(`$.anObject`, `.+`)
+	matcher := jsonpath.Matches(`$.anObject`, `.+`)
 
 	err := matcher(&http.Response{
 		Body: ioutil.NopCloser(bytes.NewBuffer([]byte(`{"anObject":{"aString":"lol"}}`))),
@@ -266,7 +218,7 @@ func TestApiTest_Matches_FailForObject(t *testing.T) {
 }
 
 func TestApiTest_Matches_FailForArray(t *testing.T) {
-	matcher := Matches(`$.aSlice`, `.+`)
+	matcher := jsonpath.Matches(`$.aSlice`, `.+`)
 
 	err := matcher(&http.Response{
 		Body: ioutil.NopCloser(bytes.NewBuffer([]byte(`{"aSlice":[1,2,3]}`))),
@@ -276,23 +228,11 @@ func TestApiTest_Matches_FailForArray(t *testing.T) {
 }
 
 func TestApiTest_Matches_FailForNilValue(t *testing.T) {
-	matcher := Matches(`$.nothingHere`, `.+`)
+	matcher := jsonpath.Matches(`$.nothingHere`, `.+`)
 
 	err := matcher(&http.Response{
 		Body: ioutil.NopCloser(bytes.NewBuffer([]byte(`{"aSlice":[1,2,3]}`))),
 	}, nil)
 
 	assert.EqualError(t, err, "no match for pattern: '$.nothingHere'")
 }
-
-func assertTrue(t *testing.T, v bool) {
-	if !v {
-		t.Error("\nexpected to be true but was false")
-	}
-}
-
-func assertFalse(t *testing.T, v bool) {
-	if v {
-		t.Error("\nexpected to be false but was true")
-	}
-}

jwt.go

@@ -0,0 +1,69 @@
+package jsonpath
+
+import (
+	"bytes"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/steinfletcher/apitest"
+)
+
+const (
+	jwtHeaderIndex  = 0
+	jwtPayloadIndex = 1
+)
+
+func JWTHeaderEqual(tokenSelector func(*http.Response) (string, error), expression string, expected interface{}) apitest.Assert {
+	return jwtEqual(tokenSelector, expression, expected, jwtHeaderIndex)
+}
+
+func JWTPayloadEqual(tokenSelector func(*http.Response) (string, error), expression string, expected interface{}) apitest.Assert {
+	return jwtEqual(tokenSelector, expression, expected, jwtPayloadIndex)
+}
+
+func jwtEqual(tokenSelector func(*http.Response) (string, error), expression string, expected interface{}, index int) apitest.Assert {
+	return func(response *http.Response, request *http.Request) error {
+		token, err := tokenSelector(response)
+		if err != nil {
+			return err
+		}
+
+		parts := strings.Split(token, ".")
+		if len(parts) != 3 {
+			splitErr := errors.New("Invalid token: token should contain header, payload and secret")
+			return splitErr
+		}
+
+		decodedPayload, PayloadErr := base64Decode(parts[index])
+		if PayloadErr != nil {
+			return fmt.Errorf("Invalid jwt: %s", PayloadErr.Error())
+		}
+
+		value, err := jsonPath(bytes.NewReader(decodedPayload), expression)
+		if err != nil {
+			return err
+		}
+
+		if !objectsAreEqual(value, expected) {
+			return errors.New(fmt.Sprintf("\"%s\" not equal to \"%s\"", value, expected))
+		}
+
+		return nil
+	}
+}
+
+func base64Decode(src string) ([]byte, error) {
+	if l := len(src) % 4; l > 0 {
+		src += strings.Repeat("=", 4-l)
+	}
+
+	decoded, err := base64.URLEncoding.DecodeString(src)
+	if err != nil {
+		errMsg := fmt.Errorf("Decoding Error %s", err)
+		return nil, errMsg
+	}
+	return decoded, nil
+}

jwt_test.go

@@ -0,0 +1,36 @@
+package jsonpath_test
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/steinfletcher/apitest"
+
+	jsonpath "github.com/steinfletcher/apitest-jsonpath"
+)
+
+const jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
+
+func TestApiTest_JWT(t *testing.T) {
+	handler := http.NewServeMux()
+	handler.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.Header().Set("Authorization", jwt)
+		w.WriteHeader(http.StatusOK)
+	})
+
+	apitest.New().
+		Handler(handler).
+		Get("/hello").
+		Expect(t).
+		Assert(jsonpath.JWTPayloadEqual(fromAuthHeader, `$.name`, "John Doe")).
+		Assert(jsonpath.JWTPayloadEqual(fromAuthHeader, `$.sub`, "1234567890")).
+		Assert(jsonpath.JWTPayloadEqual(fromAuthHeader, `$.iat`, float64(1516239022))).
+		Assert(jsonpath.JWTHeaderEqual(fromAuthHeader, `$.alg`, "HS256")).
+		Assert(jsonpath.JWTHeaderEqual(fromAuthHeader, `$.typ`, "JWT")).
+		End()
+}
+
+func fromAuthHeader(response *http.Response) (string, error) {
+	return response.Header.Get("Authorization"), nil
+}