1 // Copyright 2021 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 //
15 ////////////////////////////////////////////////////////////////////////////////
16
17 #include "tink/jwt/raw_jwt.h"
18
19 #include <string>
20 #include <vector>
21
22 #include "gtest/gtest.h"
23 #include "absl/strings/escaping.h"
24 #include "absl/time/time.h"
25 #include "tink/util/test_matchers.h"
26 #include "tink/util/test_util.h"
27
28 using ::crypto::tink::test::IsOk;
29 using ::crypto::tink::test::IsOkAndHolds;
30 using ::testing::IsEmpty;
31 using ::testing::Not;
32 using ::testing::UnorderedElementsAreArray;
33
34 namespace crypto {
35 namespace tink {
36
TEST(RawJwt,GetTypeHeaderIssuerSubjectJwtIdOK)37 TEST(RawJwt, GetTypeHeaderIssuerSubjectJwtIdOK) {
38 util::StatusOr<RawJwt> jwt = RawJwtBuilder()
39 .SetTypeHeader("typeHeader")
40 .SetIssuer("issuer")
41 .SetSubject("subject")
42 .SetJwtId("jwt_id")
43 .WithoutExpiration()
44 .Build();
45 ASSERT_THAT(jwt, IsOk());
46
47 EXPECT_TRUE(jwt->HasTypeHeader());
48 EXPECT_THAT(jwt->GetTypeHeader(), IsOkAndHolds("typeHeader"));
49 EXPECT_TRUE(jwt->HasIssuer());
50 EXPECT_THAT(jwt->GetIssuer(), IsOkAndHolds("issuer"));
51 EXPECT_TRUE(jwt->HasSubject());
52 EXPECT_THAT(jwt->GetSubject(), IsOkAndHolds("subject"));
53 EXPECT_TRUE(jwt->HasJwtId());
54 EXPECT_THAT(jwt->GetJwtId(), IsOkAndHolds("jwt_id"));
55 }
56
TEST(RawJwt,TimestampsOK)57 TEST(RawJwt, TimestampsOK) {
58 absl::Time nbf = absl::FromUnixSeconds(1234567890);
59 absl::Time iat = absl::FromUnixSeconds(1234567891);
60 absl::Time exp = absl::FromUnixSeconds(1234567892);
61 util::StatusOr<RawJwt> jwt = RawJwtBuilder()
62 .SetNotBefore(nbf)
63 .SetIssuedAt(iat)
64 .SetExpiration(exp)
65 .Build();
66 ASSERT_THAT(jwt, IsOk());
67
68 EXPECT_TRUE(jwt->HasNotBefore());
69 EXPECT_THAT(jwt->GetNotBefore(), IsOkAndHolds(nbf));
70
71 EXPECT_TRUE(jwt->HasIssuedAt());
72 EXPECT_THAT(jwt->GetIssuedAt(), IsOkAndHolds(iat));
73
74 EXPECT_TRUE(jwt->HasExpiration());
75 EXPECT_THAT(jwt->GetExpiration(), IsOkAndHolds(exp));
76 }
77
TEST(RawJwt,ExpWithMillisAlwaysRoundDown)78 TEST(RawJwt, ExpWithMillisAlwaysRoundDown) {
79 util::StatusOr<RawJwt> jwt =
80 RawJwtBuilder().SetExpiration(absl::FromUnixMillis(123999)).Build();
81 ASSERT_THAT(jwt, IsOk());
82
83 EXPECT_TRUE(jwt->HasExpiration());
84 util::StatusOr<absl::Time> exp = jwt->GetExpiration();
85 EXPECT_THAT(exp, IsOkAndHolds(absl::FromUnixSeconds(123)));
86 }
87
TEST(RawJwt,NbfWithMillisAlwaysRoundDown)88 TEST(RawJwt, NbfWithMillisAlwaysRoundDown) {
89 util::StatusOr<RawJwt> jwt = RawJwtBuilder()
90 .SetNotBefore(absl::FromUnixMillis(123999))
91 .WithoutExpiration()
92 .Build();
93 ASSERT_THAT(jwt, IsOk());
94
95 EXPECT_TRUE(jwt->HasNotBefore());
96 util::StatusOr<absl::Time> nbf = jwt->GetNotBefore();
97 EXPECT_THAT(nbf, IsOkAndHolds(absl::FromUnixSeconds(123)));
98 }
99
TEST(RawJwt,IatWithMillisAlwaysRoundDown)100 TEST(RawJwt, IatWithMillisAlwaysRoundDown) {
101 util::StatusOr<RawJwt> jwt = RawJwtBuilder()
102 .SetIssuedAt(absl::FromUnixMillis(123999))
103 .WithoutExpiration()
104 .Build();
105 ASSERT_THAT(jwt, IsOk());
106
107 EXPECT_TRUE(jwt->HasIssuedAt());
108 util::StatusOr<absl::Time> iat = jwt->GetIssuedAt();
109 EXPECT_THAT(iat, IsOkAndHolds(absl::FromUnixSeconds(123)));
110 }
111
TEST(RawJwt,LargeExpirationWorks)112 TEST(RawJwt, LargeExpirationWorks) {
113 absl::Time large = absl::FromUnixSeconds(253402300799); // year 9999
114 util::StatusOr<RawJwt> jwt = RawJwtBuilder()
115 .SetNotBefore(large)
116 .SetIssuedAt(large)
117 .SetExpiration(large)
118 .Build();
119 ASSERT_THAT(jwt, IsOk());
120
121 EXPECT_TRUE(jwt->HasExpiration());
122 EXPECT_TRUE(jwt->HasIssuedAt());
123 EXPECT_TRUE(jwt->HasNotBefore());
124 util::StatusOr<absl::Time> exp = jwt->GetExpiration();
125 EXPECT_THAT(exp, IsOkAndHolds(large));
126 util::StatusOr<absl::Time> iat = jwt->GetIssuedAt();
127 EXPECT_THAT(iat, IsOkAndHolds(large));
128 util::StatusOr<absl::Time> nbf = jwt->GetNotBefore();
129 EXPECT_THAT(nbf, IsOkAndHolds(large));
130 }
131
TEST(RawJwt,TooLargeTimestampsFail)132 TEST(RawJwt, TooLargeTimestampsFail) {
133 absl::Time too_large = absl::FromUnixSeconds(253402300800); // year 10000
134 EXPECT_FALSE(RawJwtBuilder().SetExpiration(too_large).Build().ok());
135 EXPECT_FALSE(
136 RawJwtBuilder().SetIssuedAt(too_large).WithoutExpiration().Build().ok());
137 EXPECT_FALSE(
138 RawJwtBuilder().SetNotBefore(too_large).WithoutExpiration().Build().ok());
139 }
140
TEST(RawJwt,NegativeTimestampsFail)141 TEST(RawJwt, NegativeTimestampsFail) {
142 absl::Time neg = absl::FromUnixMillis(-1);
143 EXPECT_FALSE(RawJwtBuilder().SetExpiration(neg).Build().ok());
144 EXPECT_FALSE(
145 RawJwtBuilder().SetIssuedAt(neg).WithoutExpiration().Build().ok());
146 EXPECT_FALSE(
147 RawJwtBuilder().SetNotBefore(neg).WithoutExpiration().Build().ok());
148 }
149
TEST(RawJwt,SetExpirationAndWithoutExpirationFail)150 TEST(RawJwt, SetExpirationAndWithoutExpirationFail) {
151 absl::Time exp = absl::FromUnixMillis(12345);
152 EXPECT_FALSE(
153 RawJwtBuilder().SetExpiration(exp).WithoutExpiration().Build().ok());
154 }
155
TEST(RawJwt,NeitherSetExpirationNorWithoutExpirationFail)156 TEST(RawJwt, NeitherSetExpirationNorWithoutExpirationFail) {
157 EXPECT_FALSE(RawJwtBuilder().Build().ok());
158 }
159
TEST(RawJwt,SetAudienceAndGetAudiencesOK)160 TEST(RawJwt, SetAudienceAndGetAudiencesOK) {
161 util::StatusOr<RawJwt> jwt =
162 RawJwtBuilder().SetAudience("audience").WithoutExpiration().Build();
163 ASSERT_THAT(jwt, IsOk());
164
165 std::vector<std::string> expected = {"audience"};
166 EXPECT_TRUE(jwt->HasAudiences());
167 EXPECT_THAT(jwt->GetAudiences(), IsOkAndHolds(expected));
168 }
169
TEST(RawJwt,SetAudiencesAndGetAudiencesOK)170 TEST(RawJwt, SetAudiencesAndGetAudiencesOK) {
171 util::StatusOr<RawJwt> jwt = RawJwtBuilder()
172 .SetAudiences({"audience1", "audience2"})
173 .WithoutExpiration()
174 .Build();
175 ASSERT_THAT(jwt, IsOk());
176
177 std::vector<std::string> expected = {"audience1", "audience2"};
178 EXPECT_TRUE(jwt->HasAudiences());
179 EXPECT_THAT(jwt->GetAudiences(), IsOkAndHolds(expected));
180 }
181
TEST(RawJwt,AddGetAudiencesOK)182 TEST(RawJwt, AddGetAudiencesOK) {
183 util::StatusOr<RawJwt> jwt = RawJwtBuilder()
184 .AddAudience("audience1")
185 .AddAudience("audience2")
186 .WithoutExpiration()
187 .Build();
188 ASSERT_THAT(jwt, IsOk());
189
190 std::vector<std::string> expected = {"audience1", "audience2"};
191 EXPECT_TRUE(jwt->HasAudiences());
192 EXPECT_THAT(jwt->GetAudiences(), IsOkAndHolds(expected));
193 }
194
TEST(RawJwt,SetAudienceStringAud)195 TEST(RawJwt, SetAudienceStringAud) {
196 util::StatusOr<RawJwt> jwt =
197 RawJwtBuilder().SetAudience("audience").WithoutExpiration().Build();
198 ASSERT_THAT(jwt, IsOk());
199
200 EXPECT_THAT(jwt->GetJsonPayload(), IsOkAndHolds(R"({"aud":"audience"})"));
201 }
202
TEST(RawJwt,AddAudienceListAud)203 TEST(RawJwt, AddAudienceListAud) {
204 util::StatusOr<RawJwt> jwt =
205 RawJwtBuilder().AddAudience("audience").WithoutExpiration().Build();
206 ASSERT_THAT(jwt, IsOk());
207
208 EXPECT_THAT(jwt->GetJsonPayload(), IsOkAndHolds(R"({"aud":["audience"]})"));
209 }
210
TEST(RawJwt,SetAndAddAudienceFail)211 TEST(RawJwt, SetAndAddAudienceFail) {
212 EXPECT_THAT(RawJwtBuilder()
213 .SetAudience("audience1")
214 .AddAudience("audience2")
215 .Build()
216 .status(),
217 Not(IsOk()));
218 EXPECT_THAT(RawJwtBuilder()
219 .AddAudience("audience2")
220 .SetAudience("audience1")
221 .Build()
222 .status(),
223 Not(IsOk()));
224 }
225
TEST(RawJwt,GetCustomClaimOK)226 TEST(RawJwt, GetCustomClaimOK) {
227 util::StatusOr<RawJwt> jwt =
228 RawJwtBuilder()
229 .WithoutExpiration()
230 .AddNullClaim("null_claim")
231 .AddBooleanClaim("boolean_claim", true)
232 .AddNumberClaim("number_claim", 123.456)
233 .AddStringClaim("string_claim", "a string")
234 .AddJsonObjectClaim("object_claim", R"({ "number": 123.456})")
235 .AddJsonArrayClaim("array_claim", R"([1, "one", 1.2, true])")
236 .Build();
237 ASSERT_THAT(jwt, IsOk());
238
239 EXPECT_TRUE(jwt->IsNullClaim("null_claim"));
240 EXPECT_TRUE(jwt->HasBooleanClaim("boolean_claim"));
241 EXPECT_THAT(jwt->GetBooleanClaim("boolean_claim"), IsOkAndHolds(true));
242 EXPECT_TRUE(jwt->HasNumberClaim("number_claim"));
243 EXPECT_THAT(jwt->GetNumberClaim("number_claim"), IsOkAndHolds(123.456));
244 EXPECT_TRUE(jwt->HasStringClaim("string_claim"));
245 EXPECT_THAT(jwt->GetStringClaim("string_claim"), IsOkAndHolds("a string"));
246 EXPECT_TRUE(jwt->HasJsonObjectClaim("object_claim"));
247 EXPECT_THAT(jwt->GetJsonObjectClaim("object_claim"),
248 IsOkAndHolds(R"({"number":123.456})"));
249 EXPECT_TRUE(jwt->HasJsonArrayClaim("array_claim"));
250 EXPECT_THAT(jwt->GetJsonArrayClaim("array_claim"),
251 IsOkAndHolds(R"([1,"one",1.2,true])"));
252
253 std::vector<std::string> expected_claim_names = {
254 "object_claim", "number_claim", "boolean_claim",
255 "array_claim", "null_claim", "string_claim"};
256 EXPECT_THAT(jwt->CustomClaimNames(),
257 UnorderedElementsAreArray(expected_claim_names));
258 }
259
TEST(RawJwt,HasCustomClaimIsFalseForWrongType)260 TEST(RawJwt, HasCustomClaimIsFalseForWrongType) {
261 util::StatusOr<RawJwt> jwt = RawJwtBuilder()
262 .WithoutExpiration()
263 .AddNullClaim("null_claim")
264 .AddBooleanClaim("boolean_claim", true)
265 .AddNumberClaim("number_claim", 123.456)
266 .AddStringClaim("string_claim", "a string")
267 .Build();
268 ASSERT_THAT(jwt, IsOk());
269
270 EXPECT_FALSE(jwt->IsNullClaim("boolean_claim"));
271 EXPECT_FALSE(jwt->HasBooleanClaim("number_claim"));
272 EXPECT_FALSE(jwt->HasNumberClaim("string_claim"));
273 EXPECT_FALSE(jwt->HasStringClaim("null_claim"));
274 }
275
TEST(RawJwt,HasAlwaysReturnsFalseForRegisteredClaims)276 TEST(RawJwt, HasAlwaysReturnsFalseForRegisteredClaims) {
277 absl::Time now = absl::Now();
278 util::StatusOr<RawJwt> jwt = RawJwtBuilder()
279 .SetIssuer("issuer")
280 .SetSubject("subject")
281 .SetJwtId("jwt_id")
282 .SetNotBefore(now - absl::Seconds(300))
283 .SetIssuedAt(now)
284 .SetExpiration(now + absl::Seconds(300))
285 .Build();
286 ASSERT_THAT(jwt, IsOk());
287
288 EXPECT_FALSE(jwt->HasStringClaim("iss"));
289 EXPECT_FALSE(jwt->HasStringClaim("sub"));
290 EXPECT_FALSE(jwt->HasStringClaim("jti"));
291 EXPECT_FALSE(jwt->HasNumberClaim("nbf"));
292 EXPECT_FALSE(jwt->HasNumberClaim("iat"));
293 EXPECT_FALSE(jwt->HasNumberClaim("exp"));
294
295 EXPECT_THAT(jwt->CustomClaimNames(), IsEmpty());
296 }
297
TEST(RawJwt,GetRegisteredCustomClaimNotOK)298 TEST(RawJwt, GetRegisteredCustomClaimNotOK) {
299 absl::Time now = absl::Now();
300 util::StatusOr<RawJwt> jwt = RawJwtBuilder()
301 .SetIssuer("issuer")
302 .SetSubject("subject")
303 .SetJwtId("jwt_id")
304 .SetNotBefore(now - absl::Seconds(300))
305 .SetIssuedAt(now)
306 .SetExpiration(now + absl::Seconds(300))
307 .Build();
308 ASSERT_THAT(jwt, IsOk());
309
310 EXPECT_FALSE(jwt->GetStringClaim("iss").ok());
311 EXPECT_FALSE(jwt->GetStringClaim("sub").ok());
312 EXPECT_FALSE(jwt->GetStringClaim("jti").ok());
313 EXPECT_FALSE(jwt->GetNumberClaim("nbf").ok());
314 EXPECT_FALSE(jwt->GetNumberClaim("iat").ok());
315 EXPECT_FALSE(jwt->GetNumberClaim("exp").ok());
316 }
317
TEST(RawJwt,SetRegisteredCustomClaimNotOK)318 TEST(RawJwt, SetRegisteredCustomClaimNotOK) {
319 EXPECT_FALSE(RawJwtBuilder()
320 .WithoutExpiration()
321 .AddStringClaim("iss", "issuer")
322 .Build()
323 .ok());
324 EXPECT_FALSE(RawJwtBuilder()
325 .WithoutExpiration()
326 .AddStringClaim("sub", "issuer")
327 .Build()
328 .ok());
329 EXPECT_FALSE(RawJwtBuilder()
330 .WithoutExpiration()
331 .AddStringClaim("jti", "issuer")
332 .Build()
333 .ok());
334 EXPECT_FALSE(RawJwtBuilder()
335 .WithoutExpiration()
336 .AddNumberClaim("nbf", 123)
337 .Build()
338 .ok());
339 EXPECT_FALSE(RawJwtBuilder()
340 .WithoutExpiration()
341 .AddNumberClaim("iat", 123)
342 .Build()
343 .ok());
344 EXPECT_FALSE(RawJwtBuilder()
345 .WithoutExpiration()
346 .AddNumberClaim("exp", 123)
347 .Build()
348 .ok());
349 EXPECT_FALSE(RawJwtBuilder()
350 .WithoutExpiration()
351 .AddBooleanClaim("iss", true)
352 .Build()
353 .ok());
354 EXPECT_FALSE(
355 RawJwtBuilder().WithoutExpiration().AddNullClaim("iss").Build().ok());
356 EXPECT_FALSE(RawJwtBuilder()
357 .WithoutExpiration()
358 .AddJsonObjectClaim("iss", "{\"1\": 2}")
359 .Build()
360 .ok());
361 EXPECT_FALSE(RawJwtBuilder()
362 .WithoutExpiration()
363 .AddJsonArrayClaim("iss", "[1,2]")
364 .Build()
365 .ok());
366 }
367
TEST(RawJwt,SetInvalidJsonObjectClaimNotOK)368 TEST(RawJwt, SetInvalidJsonObjectClaimNotOK) {
369 EXPECT_FALSE(RawJwtBuilder()
370 .WithoutExpiration()
371 .AddJsonObjectClaim("obj", "invalid")
372 .Build()
373 .ok());
374 EXPECT_FALSE(RawJwtBuilder()
375 .WithoutExpiration()
376 .AddJsonObjectClaim("obj", R"("string")")
377 .Build()
378 .ok());
379 EXPECT_FALSE(RawJwtBuilder()
380 .WithoutExpiration()
381 .AddJsonObjectClaim("obj", "42")
382 .Build()
383 .ok());
384 EXPECT_FALSE(RawJwtBuilder()
385 .WithoutExpiration()
386 .AddJsonObjectClaim("obj", "[1,2]")
387 .Build()
388 .ok());
389 }
390
TEST(RawJwt,SetInvalidJsonArrayClaimNotOK)391 TEST(RawJwt, SetInvalidJsonArrayClaimNotOK) {
392 EXPECT_FALSE(RawJwtBuilder()
393 .WithoutExpiration()
394 .AddJsonArrayClaim("arr", "invalid")
395 .Build()
396 .ok());
397 EXPECT_FALSE(RawJwtBuilder()
398 .WithoutExpiration()
399 .AddJsonArrayClaim("arr", R"("string")")
400 .Build()
401 .ok());
402 EXPECT_FALSE(RawJwtBuilder()
403 .WithoutExpiration()
404 .AddJsonArrayClaim("arr", "42")
405 .Build()
406 .ok());
407 EXPECT_FALSE(RawJwtBuilder()
408 .WithoutExpiration()
409 .AddJsonArrayClaim("arr", R"({"1": 2})")
410 .Build()
411 .ok());
412 }
413
TEST(RawJwt,EmptyTokenHasAndIsReturnsFalse)414 TEST(RawJwt, EmptyTokenHasAndIsReturnsFalse) {
415 util::StatusOr<RawJwt> jwt = RawJwtBuilder().WithoutExpiration().Build();
416 ASSERT_THAT(jwt, IsOk());
417
418 EXPECT_FALSE(jwt->HasTypeHeader());
419 EXPECT_FALSE(jwt->HasIssuer());
420 EXPECT_FALSE(jwt->HasSubject());
421 EXPECT_FALSE(jwt->HasAudiences());
422 EXPECT_FALSE(jwt->HasJwtId());
423 EXPECT_FALSE(jwt->HasExpiration());
424 EXPECT_FALSE(jwt->HasNotBefore());
425 EXPECT_FALSE(jwt->HasIssuedAt());
426 EXPECT_FALSE(jwt->IsNullClaim("null_claim"));
427 EXPECT_FALSE(jwt->HasBooleanClaim("boolean_claim"));
428 EXPECT_FALSE(jwt->HasNumberClaim("number_claim"));
429 EXPECT_FALSE(jwt->HasStringClaim("string_claim"));
430 EXPECT_FALSE(jwt->HasJsonObjectClaim("object_claim"));
431 EXPECT_FALSE(jwt->HasJsonArrayClaim("array_claim"));
432 }
433
TEST(RawJwt,EmptyTokenGetReturnsNotOK)434 TEST(RawJwt, EmptyTokenGetReturnsNotOK) {
435 util::StatusOr<RawJwt> jwt = RawJwtBuilder().WithoutExpiration().Build();
436 ASSERT_THAT(jwt, IsOk());
437
438 EXPECT_FALSE(jwt->GetTypeHeader().ok());
439 EXPECT_FALSE(jwt->GetIssuer().ok());
440 EXPECT_FALSE(jwt->GetSubject().ok());
441 EXPECT_FALSE(jwt->GetAudiences().ok());
442 EXPECT_FALSE(jwt->GetJwtId().ok());
443 EXPECT_FALSE(jwt->GetExpiration().ok());
444 EXPECT_FALSE(jwt->GetNotBefore().ok());
445 EXPECT_FALSE(jwt->GetIssuedAt().ok());
446 EXPECT_FALSE(jwt->IsNullClaim("null_claim"));
447 EXPECT_FALSE(jwt->GetBooleanClaim("boolean_claim").ok());
448 EXPECT_FALSE(jwt->GetNumberClaim("number_claim").ok());
449 EXPECT_FALSE(jwt->GetStringClaim("string_claim").ok());
450 EXPECT_FALSE(jwt->GetJsonObjectClaim("object_claim").ok());
451 EXPECT_FALSE(jwt->GetJsonArrayClaim("array_claim").ok());
452 }
453
TEST(RawJwt,BuildCanBeCalledTwice)454 TEST(RawJwt, BuildCanBeCalledTwice) {
455 auto builder = RawJwtBuilder()
456 .SetIssuer("issuer")
457 .SetSubject("subject")
458 .WithoutExpiration();
459 util::StatusOr<RawJwt> jwt = builder.Build();
460 ASSERT_THAT(jwt, IsOk());
461
462 builder.SetSubject("subject2");
463 util::StatusOr<RawJwt> jwt2 = builder.Build();
464 ASSERT_THAT(jwt2, IsOk());
465
466 EXPECT_THAT(jwt->GetIssuer(), IsOkAndHolds("issuer"));
467 EXPECT_THAT(jwt->GetSubject(), IsOkAndHolds("subject"));
468 EXPECT_THAT(jwt2->GetIssuer(), IsOkAndHolds("issuer"));
469 EXPECT_THAT(jwt2->GetSubject(), IsOkAndHolds("subject2"));
470 }
471
TEST(RawJwt,GetJsonPayload)472 TEST(RawJwt, GetJsonPayload) {
473 util::StatusOr<RawJwt> jwt =
474 RawJwtBuilder().SetIssuer("issuer").WithoutExpiration().Build();
475 ASSERT_THAT(jwt, IsOk());
476
477 EXPECT_THAT(jwt->GetJsonPayload(), IsOkAndHolds(R"({"iss":"issuer"})"));
478 }
479
TEST(RawJwt,IntegerIsEncodedAsInteger)480 TEST(RawJwt, IntegerIsEncodedAsInteger) {
481 util::StatusOr<RawJwt> jwt =
482 RawJwtBuilder().AddNumberClaim("num", 1).WithoutExpiration().Build();
483 ASSERT_THAT(jwt, IsOk());
484
485 EXPECT_THAT(jwt->GetJsonPayload(), IsOkAndHolds(R"({"num":1})"));
486 }
487
TEST(RawJwt,GetExpirationJsonPayload)488 TEST(RawJwt, GetExpirationJsonPayload) {
489 util::StatusOr<RawJwt> jwt =
490 RawJwtBuilder().SetExpiration(absl::FromUnixSeconds(2218027244)).Build();
491 ASSERT_THAT(jwt, IsOk());
492
493 EXPECT_THAT(jwt->GetJsonPayload(), IsOkAndHolds(R"({"exp":2218027244})"));
494 }
495
TEST(RawJwt,GetNanoExpirationJsonPayload)496 TEST(RawJwt, GetNanoExpirationJsonPayload) {
497 util::StatusOr<RawJwt> jwt =
498 RawJwtBuilder().SetExpiration(absl::FromUnixNanos(123456789012)).Build();
499 ASSERT_THAT(jwt, IsOk());
500
501 EXPECT_THAT(jwt->GetJsonPayload(), IsOkAndHolds(R"({"exp":123})"));
502 }
503
504 } // namespace tink
505 } // namespace crypto
506