1
2
3 package jwa_test
4
5 import (
6 "testing"
7
8 "github.com/lestrrat-go/jwx/jwa"
9 "github.com/stretchr/testify/assert"
10 )
11
12 func TestContentEncryptionAlgorithm(t *testing.T) {
13 t.Parallel()
14 t.Run(`accept jwa constant A128CBC_HS256`, func(t *testing.T) {
15 t.Parallel()
16 var dst jwa.ContentEncryptionAlgorithm
17 if !assert.NoError(t, dst.Accept(jwa.A128CBC_HS256), `accept is successful`) {
18 return
19 }
20 if !assert.Equal(t, jwa.A128CBC_HS256, dst, `accepted value should be equal to constant`) {
21 return
22 }
23 })
24 t.Run(`accept the string A128CBC-HS256`, func(t *testing.T) {
25 t.Parallel()
26 var dst jwa.ContentEncryptionAlgorithm
27 if !assert.NoError(t, dst.Accept("A128CBC-HS256"), `accept is successful`) {
28 return
29 }
30 if !assert.Equal(t, jwa.A128CBC_HS256, dst, `accepted value should be equal to constant`) {
31 return
32 }
33 })
34 t.Run(`accept fmt.Stringer for A128CBC-HS256`, func(t *testing.T) {
35 t.Parallel()
36 var dst jwa.ContentEncryptionAlgorithm
37 if !assert.NoError(t, dst.Accept(stringer{src: "A128CBC-HS256"}), `accept is successful`) {
38 return
39 }
40 if !assert.Equal(t, jwa.A128CBC_HS256, dst, `accepted value should be equal to constant`) {
41 return
42 }
43 })
44 t.Run(`stringification for A128CBC-HS256`, func(t *testing.T) {
45 t.Parallel()
46 if !assert.Equal(t, "A128CBC-HS256", jwa.A128CBC_HS256.String(), `stringified value matches`) {
47 return
48 }
49 })
50 t.Run(`accept jwa constant A128GCM`, func(t *testing.T) {
51 t.Parallel()
52 var dst jwa.ContentEncryptionAlgorithm
53 if !assert.NoError(t, dst.Accept(jwa.A128GCM), `accept is successful`) {
54 return
55 }
56 if !assert.Equal(t, jwa.A128GCM, dst, `accepted value should be equal to constant`) {
57 return
58 }
59 })
60 t.Run(`accept the string A128GCM`, func(t *testing.T) {
61 t.Parallel()
62 var dst jwa.ContentEncryptionAlgorithm
63 if !assert.NoError(t, dst.Accept("A128GCM"), `accept is successful`) {
64 return
65 }
66 if !assert.Equal(t, jwa.A128GCM, dst, `accepted value should be equal to constant`) {
67 return
68 }
69 })
70 t.Run(`accept fmt.Stringer for A128GCM`, func(t *testing.T) {
71 t.Parallel()
72 var dst jwa.ContentEncryptionAlgorithm
73 if !assert.NoError(t, dst.Accept(stringer{src: "A128GCM"}), `accept is successful`) {
74 return
75 }
76 if !assert.Equal(t, jwa.A128GCM, dst, `accepted value should be equal to constant`) {
77 return
78 }
79 })
80 t.Run(`stringification for A128GCM`, func(t *testing.T) {
81 t.Parallel()
82 if !assert.Equal(t, "A128GCM", jwa.A128GCM.String(), `stringified value matches`) {
83 return
84 }
85 })
86 t.Run(`accept jwa constant A192CBC_HS384`, func(t *testing.T) {
87 t.Parallel()
88 var dst jwa.ContentEncryptionAlgorithm
89 if !assert.NoError(t, dst.Accept(jwa.A192CBC_HS384), `accept is successful`) {
90 return
91 }
92 if !assert.Equal(t, jwa.A192CBC_HS384, dst, `accepted value should be equal to constant`) {
93 return
94 }
95 })
96 t.Run(`accept the string A192CBC-HS384`, func(t *testing.T) {
97 t.Parallel()
98 var dst jwa.ContentEncryptionAlgorithm
99 if !assert.NoError(t, dst.Accept("A192CBC-HS384"), `accept is successful`) {
100 return
101 }
102 if !assert.Equal(t, jwa.A192CBC_HS384, dst, `accepted value should be equal to constant`) {
103 return
104 }
105 })
106 t.Run(`accept fmt.Stringer for A192CBC-HS384`, func(t *testing.T) {
107 t.Parallel()
108 var dst jwa.ContentEncryptionAlgorithm
109 if !assert.NoError(t, dst.Accept(stringer{src: "A192CBC-HS384"}), `accept is successful`) {
110 return
111 }
112 if !assert.Equal(t, jwa.A192CBC_HS384, dst, `accepted value should be equal to constant`) {
113 return
114 }
115 })
116 t.Run(`stringification for A192CBC-HS384`, func(t *testing.T) {
117 t.Parallel()
118 if !assert.Equal(t, "A192CBC-HS384", jwa.A192CBC_HS384.String(), `stringified value matches`) {
119 return
120 }
121 })
122 t.Run(`accept jwa constant A192GCM`, func(t *testing.T) {
123 t.Parallel()
124 var dst jwa.ContentEncryptionAlgorithm
125 if !assert.NoError(t, dst.Accept(jwa.A192GCM), `accept is successful`) {
126 return
127 }
128 if !assert.Equal(t, jwa.A192GCM, dst, `accepted value should be equal to constant`) {
129 return
130 }
131 })
132 t.Run(`accept the string A192GCM`, func(t *testing.T) {
133 t.Parallel()
134 var dst jwa.ContentEncryptionAlgorithm
135 if !assert.NoError(t, dst.Accept("A192GCM"), `accept is successful`) {
136 return
137 }
138 if !assert.Equal(t, jwa.A192GCM, dst, `accepted value should be equal to constant`) {
139 return
140 }
141 })
142 t.Run(`accept fmt.Stringer for A192GCM`, func(t *testing.T) {
143 t.Parallel()
144 var dst jwa.ContentEncryptionAlgorithm
145 if !assert.NoError(t, dst.Accept(stringer{src: "A192GCM"}), `accept is successful`) {
146 return
147 }
148 if !assert.Equal(t, jwa.A192GCM, dst, `accepted value should be equal to constant`) {
149 return
150 }
151 })
152 t.Run(`stringification for A192GCM`, func(t *testing.T) {
153 t.Parallel()
154 if !assert.Equal(t, "A192GCM", jwa.A192GCM.String(), `stringified value matches`) {
155 return
156 }
157 })
158 t.Run(`accept jwa constant A256CBC_HS512`, func(t *testing.T) {
159 t.Parallel()
160 var dst jwa.ContentEncryptionAlgorithm
161 if !assert.NoError(t, dst.Accept(jwa.A256CBC_HS512), `accept is successful`) {
162 return
163 }
164 if !assert.Equal(t, jwa.A256CBC_HS512, dst, `accepted value should be equal to constant`) {
165 return
166 }
167 })
168 t.Run(`accept the string A256CBC-HS512`, func(t *testing.T) {
169 t.Parallel()
170 var dst jwa.ContentEncryptionAlgorithm
171 if !assert.NoError(t, dst.Accept("A256CBC-HS512"), `accept is successful`) {
172 return
173 }
174 if !assert.Equal(t, jwa.A256CBC_HS512, dst, `accepted value should be equal to constant`) {
175 return
176 }
177 })
178 t.Run(`accept fmt.Stringer for A256CBC-HS512`, func(t *testing.T) {
179 t.Parallel()
180 var dst jwa.ContentEncryptionAlgorithm
181 if !assert.NoError(t, dst.Accept(stringer{src: "A256CBC-HS512"}), `accept is successful`) {
182 return
183 }
184 if !assert.Equal(t, jwa.A256CBC_HS512, dst, `accepted value should be equal to constant`) {
185 return
186 }
187 })
188 t.Run(`stringification for A256CBC-HS512`, func(t *testing.T) {
189 t.Parallel()
190 if !assert.Equal(t, "A256CBC-HS512", jwa.A256CBC_HS512.String(), `stringified value matches`) {
191 return
192 }
193 })
194 t.Run(`accept jwa constant A256GCM`, func(t *testing.T) {
195 t.Parallel()
196 var dst jwa.ContentEncryptionAlgorithm
197 if !assert.NoError(t, dst.Accept(jwa.A256GCM), `accept is successful`) {
198 return
199 }
200 if !assert.Equal(t, jwa.A256GCM, dst, `accepted value should be equal to constant`) {
201 return
202 }
203 })
204 t.Run(`accept the string A256GCM`, func(t *testing.T) {
205 t.Parallel()
206 var dst jwa.ContentEncryptionAlgorithm
207 if !assert.NoError(t, dst.Accept("A256GCM"), `accept is successful`) {
208 return
209 }
210 if !assert.Equal(t, jwa.A256GCM, dst, `accepted value should be equal to constant`) {
211 return
212 }
213 })
214 t.Run(`accept fmt.Stringer for A256GCM`, func(t *testing.T) {
215 t.Parallel()
216 var dst jwa.ContentEncryptionAlgorithm
217 if !assert.NoError(t, dst.Accept(stringer{src: "A256GCM"}), `accept is successful`) {
218 return
219 }
220 if !assert.Equal(t, jwa.A256GCM, dst, `accepted value should be equal to constant`) {
221 return
222 }
223 })
224 t.Run(`stringification for A256GCM`, func(t *testing.T) {
225 t.Parallel()
226 if !assert.Equal(t, "A256GCM", jwa.A256GCM.String(), `stringified value matches`) {
227 return
228 }
229 })
230 t.Run(`bail out on random integer value`, func(t *testing.T) {
231 t.Parallel()
232 var dst jwa.ContentEncryptionAlgorithm
233 if !assert.Error(t, dst.Accept(1), `accept should fail`) {
234 return
235 }
236 })
237 t.Run(`do not accept invalid (totally made up) string value`, func(t *testing.T) {
238 t.Parallel()
239 var dst jwa.ContentEncryptionAlgorithm
240 if !assert.Error(t, dst.Accept(`totallyInvfalidValue`), `accept should fail`) {
241 return
242 }
243 })
244 t.Run(`check list of elements`, func(t *testing.T) {
245 t.Parallel()
246 var expected = map[jwa.ContentEncryptionAlgorithm]struct{}{
247 jwa.A128CBC_HS256: {},
248 jwa.A128GCM: {},
249 jwa.A192CBC_HS384: {},
250 jwa.A192GCM: {},
251 jwa.A256CBC_HS512: {},
252 jwa.A256GCM: {},
253 }
254 for _, v := range jwa.ContentEncryptionAlgorithms() {
255 if _, ok := expected[v]; !assert.True(t, ok, `%s should be in the expected list`, v) {
256 return
257 }
258 delete(expected, v)
259 }
260 if !assert.Len(t, expected, 0) {
261 return
262 }
263 })
264 }
265
View as plain text