1 package jwk_test
2
3 import (
4 "context"
5 "fmt"
6 "testing"
7
8 "github.com/lestrrat-go/jwx/jwa"
9 "github.com/lestrrat-go/jwx/jwk"
10 "github.com/stretchr/testify/assert"
11 )
12
13 func TestHeader(t *testing.T) {
14 t.Parallel()
15
16 t.Run("Roundtrip", func(t *testing.T) {
17 t.Parallel()
18
19 values := map[string]interface{}{
20 jwk.KeyIDKey: "helloworld01",
21 jwk.KeyOpsKey: jwk.KeyOperationList{jwk.KeyOpSign},
22 jwk.KeyUsageKey: "sig",
23 jwk.X509CertThumbprintKey: "thumbprint",
24 jwk.X509CertThumbprintS256Key: "thumbprint256",
25 jwk.X509URLKey: "cert1",
26 "private": "boofoo",
27 }
28
29 h, err := jwk.New([]byte("dummy"))
30 if !assert.NoError(t, err, `jwk.New should succeed`) {
31 return
32 }
33
34 for k, v := range values {
35 if !assert.NoError(t, h.Set(k, v), "Set works for '%s'", k) {
36 return
37 }
38
39 got, ok := h.Get(k)
40 if !assert.True(t, ok, "Get works for '%s'", k) {
41 return
42 }
43
44 if !assert.Equal(t, v, got, "values match '%s'", k) {
45 return
46 }
47
48 if !assert.NoError(t, h.Set(k, v), "Set works for '%s'", k) {
49 return
50 }
51 }
52
53 t.Run("Private params", func(t *testing.T) {
54 t.Parallel()
55 pp, err := h.AsMap(context.Background())
56 if !assert.NoError(t, err, `h.AsMap should succeed`) {
57 return
58 }
59
60 v, ok := pp["private"]
61 if !assert.True(t, ok, "key 'private' should exists") {
62 return
63 }
64
65 if !assert.Equal(t, v, "boofoo", "value for 'private' should match") {
66 return
67 }
68 })
69 })
70 t.Run("RoundtripError", func(t *testing.T) {
71 t.Parallel()
72 type dummyStruct struct {
73 dummy1 int
74 dummy2 float64
75 }
76 dummy := &dummyStruct{1, 3.4}
77 values := map[string]interface{}{
78 jwk.AlgorithmKey: dummy,
79 jwk.KeyIDKey: dummy,
80 jwk.KeyUsageKey: dummy,
81 jwk.KeyOpsKey: dummy,
82 jwk.X509CertChainKey: dummy,
83 jwk.X509CertThumbprintKey: dummy,
84 jwk.X509CertThumbprintS256Key: dummy,
85 jwk.X509URLKey: dummy,
86 }
87
88 h, err := jwk.New([]byte("dummy"))
89 if !assert.NoError(t, err, `jwk.New should succeed`) {
90 return
91 }
92 for k, v := range values {
93 err := h.Set(k, v)
94 if err == nil {
95 t.Fatalf("Setting %s value should have failed", k)
96 }
97 }
98 if !assert.NoError(t, h.Set("Default", dummy), `Setting "Default" should succeed`) {
99 return
100 }
101 if h.Algorithm() != "" {
102 t.Fatalf("Algorithm should be empty string")
103 }
104 if h.KeyID() != "" {
105 t.Fatalf("KeyID should be empty string")
106 }
107 if h.KeyUsage() != "" {
108 t.Fatalf("KeyUsage should be empty string")
109 }
110 if h.KeyOps() != nil {
111 t.Fatalf("KeyOps should be empty string")
112 }
113 })
114
115 t.Run("Algorithm", func(t *testing.T) {
116 t.Parallel()
117 h, err := jwk.New([]byte("dummy"))
118 if !assert.NoError(t, err, `jwk.New should succeed`) {
119 return
120 }
121 for _, value := range []interface{}{jwa.RS256, jwa.RSA1_5} {
122 if !assert.NoError(t, h.Set(jwk.AlgorithmKey, value), "Set for alg should succeed") {
123 return
124 }
125
126 got, ok := h.Get("alg")
127 if !assert.True(t, ok, "Get for alg should succeed") {
128 return
129 }
130
131 if !assert.Equal(t, value.(fmt.Stringer).String(), got, "values match") {
132 return
133 }
134 }
135 })
136 }
137
View as plain text