Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/tests/sastoken_ut/sastoken_ut.c

raw
1 // Copyright (c) Microsoft. All rights reserved.
2 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
4 #ifdef __cplusplus
5 #include <cstdlib>
6 #else
7 #include <stdlib.h>
8 #endif
9
10 static void* my_gballoc_malloc(size_t size)
11 {
12 return malloc(size);
13 }
14
15 static void my_gballoc_free(void* ptr)
16 {
17 free(ptr);
18 }
19
20 #ifdef __cplusplus
21 #include <cstdio>
22 #include <ctime>
23 #else
24 #include <stdio.h>
25 #include <time.h>
26 #endif
27
28 #include "azure_macro_utils/macro_utils.h"
29 #include "testrunnerswitcher.h"
30 #include "umock_c/umock_c.h"
31 #include "umock_c/umocktypes_charptr.h"
32 #include "umock_c/umocktypes_stdint.h"
33
34 #define ENABLE_MOCKS
35
36 #include "azure_c_shared_utility/gballoc.h"
37
38 #include "azure_c_shared_utility/hmacsha256.h"
39 #include "azure_c_shared_utility/strings.h"
40 #include "azure_c_shared_utility/buffer_.h"
41 #include "azure_c_shared_utility/crt_abstractions.h"
42 #include "azure_c_shared_utility/urlencode.h"
43 #include "azure_c_shared_utility/azure_base64.h"
44 #include "azure_c_shared_utility/agenttime.h"
45
46 #undef ENABLE_MOCKS
47
48 IMPLEMENT_UMOCK_C_ENUM_TYPE(HMACSHA256_RESULT, HMACSHA256_RESULT_VALUES);
49
50 double my_get_difftime(time_t stopTime, time_t startTime)
51 {
52 return (double)(stopTime - startTime);
53 }
54
55 STRING_HANDLE my_STRING_new(void)
56 {
57 return (STRING_HANDLE)malloc(1);
58 }
59
60 BUFFER_HANDLE my_BUFFER_new(void)
61 {
62 return (BUFFER_HANDLE)malloc(1);
63 }
64
65 STRING_HANDLE my_Base64_Encode(BUFFER_HANDLE input)
66 {
67 (void)input;
68 return (STRING_HANDLE)malloc(1);
69 }
70
71 BUFFER_HANDLE my_Azure_Base64_Decode(const char* source)
72 {
73 (void)source;
74 return (BUFFER_HANDLE)malloc(1);
75 }
76
77 STRING_HANDLE my_URL_Encode(STRING_HANDLE input)
78 {
79 (void)input;
80 return (STRING_HANDLE)malloc(1);
81 }
82
83 #include "azure_c_shared_utility/sastoken.h"
84
85 #define TEST_STRING_HANDLE (STRING_HANDLE)0x46
86 #define TEST_NULL_STRING_HANDLE (STRING_HANDLE)0x00
87 #define TEST_BUFFER_HANDLE (BUFFER_HANDLE)0x47
88 #define TEST_NULL_BUFFER_HANDLE (BUFFER_HANDLE)0x00
89 #define TEST_SCOPE_HANDLE (STRING_HANDLE)0x48
90 #define TEST_KEY_HANDLE (STRING_HANDLE)0x49
91 #define TEST_KEYNAME_HANDLE (STRING_HANDLE)0x50
92 #define TEST_HASH_HANDLE (BUFFER_HANDLE)0x51
93 #define TEST_TOBEHASHED_HANDLE (STRING_HANDLE)0x52
94 #define TEST_RESULT_HANDLE (STRING_HANDLE)0x53
95 #define TEST_BASE64SIGNATURE_HANDLE (STRING_HANDLE)0x54
96 #define TEST_URLENCODEDSIGNATURE_HANDLE (STRING_HANDLE)0x55
97 #define TEST_DECODEDKEY_HANDLE (BUFFER_HANDLE)0x56
98 #define TEST_TIME_T ((time_t)3600)
99 #define TEST_PTR_DECODEDKEY (unsigned char*)0x123
100 #define TEST_LENGTH_DECODEDKEY (size_t)32
101 #define TEST_PTR_TOBEHASHED (const char*)0x456
102 #define TEST_LENGTH_TOBEHASHED (size_t)456
103 #define TEST_EXPIRY ((uint64_t)7200)
104 #define TEST_EXPIRY_LARGE 18446744073709551615ul
105 #define TEST_EXPIRY_LARGE_STRING "18446744073709551615"
106 #define TEST_LATER_TIME (time_t) 11
107 #define TEST_EARLY_TIME (time_t) 10
108
109 static const char* TEST_STRING_VALUE = "Test string value";
110 static const char* TEST_NULL_STRING_VALUE = 0x00;
111 static char TEST_CHAR_ARRAY[10] = "ABCD";
112 static unsigned char TEST_UNSIGNED_CHAR_ARRAY[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 };
113 static char TEST_TOKEN_EXPIRATION_TIME[32] = "7200";
114 static char TEST_TOKEN_EXPIRATION_TIME_LARGE[32] = TEST_EXPIRY_LARGE_STRING;
115
116 static TEST_MUTEX_HANDLE g_testByTest;
117
118 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
119
120 #ifdef __cplusplus
121 extern "C"
122 {
123 #endif
124
125 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
126 {
127 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
128 }
129
130 #ifdef __cplusplus
131 }
132 #endif
133
134 BEGIN_TEST_SUITE(sastoken_unittests)
135
136 TEST_SUITE_INITIALIZE(TestClassInitialize)
137 {
138 int result;
139 g_testByTest = TEST_MUTEX_CREATE();
140 ASSERT_IS_NOT_NULL(g_testByTest);
141
142 umock_c_init(on_umock_c_error);
143
144 REGISTER_UMOCK_ALIAS_TYPE(time_t, long long);
145 REGISTER_UMOCK_ALIAS_TYPE(time_t*, void*);
146 REGISTER_UMOCK_ALIAS_TYPE(STRING_HANDLE, void*);
147 REGISTER_UMOCK_ALIAS_TYPE(BUFFER_HANDLE, void*);
148
149 result = umocktypes_stdint_register_types();
150 ASSERT_ARE_EQUAL(int, 0, result, "umocktypes_stdint_register_types");
151
152 result = umocktypes_charptr_register_types();
153 ASSERT_ARE_EQUAL(int, 0, result);
154 REGISTER_TYPE(HMACSHA256_RESULT, HMACSHA256_RESULT);
155
156 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
157 REGISTER_GLOBAL_MOCK_FAIL_RETURN(gballoc_malloc, NULL);
158 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
159
160 REGISTER_GLOBAL_MOCK_HOOK(STRING_new, my_STRING_new);
161 REGISTER_GLOBAL_MOCK_RETURN(STRING_concat, 0);
162 REGISTER_GLOBAL_MOCK_RETURN(STRING_concat_with_STRING, 0);
163 REGISTER_GLOBAL_MOCK_RETURN(STRING_c_str, &TEST_CHAR_ARRAY[0]);
164 REGISTER_GLOBAL_MOCK_RETURN(STRING_length, 1);
165 REGISTER_GLOBAL_MOCK_RETURN(STRING_copy, 0);
166
167 REGISTER_GLOBAL_MOCK_HOOK(BUFFER_new, my_BUFFER_new);
168 REGISTER_GLOBAL_MOCK_RETURN(BUFFER_u_char, &TEST_UNSIGNED_CHAR_ARRAY[0]);
169 REGISTER_GLOBAL_MOCK_RETURN(BUFFER_length, 1);
170
171 REGISTER_GLOBAL_MOCK_HOOK(Azure_Base64_Encode, my_Base64_Encode);
172 REGISTER_GLOBAL_MOCK_HOOK(Azure_Base64_Decode, my_Azure_Base64_Decode);
173 REGISTER_GLOBAL_MOCK_HOOK(URL_Encode, my_URL_Encode);
174 REGISTER_GLOBAL_MOCK_RETURN(HMACSHA256_ComputeHash, HMACSHA256_OK);
175 REGISTER_GLOBAL_MOCK_RETURN(uint64_tToString, 0);
176
177 REGISTER_GLOBAL_MOCK_RETURN(get_time, TEST_TIME_T);
178 REGISTER_GLOBAL_MOCK_HOOK(get_difftime, my_get_difftime);
179
180 }
181
182 TEST_SUITE_CLEANUP(TestClassCleanup)
183 {
184 umock_c_deinit();
185
186 TEST_MUTEX_DESTROY(g_testByTest);
187 }
188
189 TEST_FUNCTION_INITIALIZE(TestMethodInitialize)
190 {
191 if (TEST_MUTEX_ACQUIRE(g_testByTest))
192 {
193 ASSERT_FAIL("our mutex is ABANDONED. Failure in test framework");
194 }
195
196 umock_c_reset_all_calls();
197 }
198
199 TEST_FUNCTION_CLEANUP(TestMethodCleanup)
200 {
201 TEST_MUTEX_RELEASE(g_testByTest);
202 }
203
204 /*Tests_SRS_SASTOKEN_25_025: [**SASToken_Validate shall get the SASToken value by invoking STRING_c_str on the handle.**]***/
205 TEST_FUNCTION(SASToken_validate_null_handle_fails)
206 {
207 // arrange
208 STRING_HANDLE handle = NULL;
209 bool result;
210 STRICT_EXPECTED_CALL(STRING_c_str(TEST_NULL_STRING_HANDLE)).SetReturn(NULL);
211
212 // act
213 result = SASToken_Validate(handle);
214
215 // assert
216 ASSERT_IS_FALSE(result);
217 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
218 }
219
220 /*Tests_SRS_SASTOKEN_25_025: [**SASToken_Validate shall get the SASToken value by invoking STRING_c_str on the handle.**]***/
221 TEST_FUNCTION(SASToken_validate_null_string_valid_handle_fails)
222 {
223 // arrange
224 STRING_HANDLE handle = TEST_STRING_HANDLE;
225 bool result;
226 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_NULL_STRING_VALUE);
227
228 // act
229 result = SASToken_Validate(handle);
230
231 // assert
232 ASSERT_IS_FALSE(result);
233 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
234 }
235
236 /*Tests_SRS_SASTOKEN_25_025: [**SASToken_Validate shall get the SASToken value by invoking STRING_c_str on the handle.**]***/
237 TEST_FUNCTION(SASToken_validate_se_improper_format_1_fails)
238 {
239 // arrange
240 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr=TESTSR&sig=TESTSIG&se0123456789";
241 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
242 STRING_HANDLE handle = TEST_STRING_HANDLE;
243 bool result;
244 umock_c_reset_all_calls();
245
246 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
247 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
248
249 // act
250 result = SASToken_Validate(handle);
251
252 // assert
253 ASSERT_IS_FALSE(result);
254 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
255 }
256 /*Tests_SRS_SASTOKEN_25_027: [**If SASTOKEN does not obey the SASToken format then SASToken_Validate shall return false.**]*/
257 TEST_FUNCTION(SASToken_validate_se_improper_format_2_fails)
258 {
259 // arrange
260 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr=TESTSR&sig=TESTSIG&se";
261 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
262 STRING_HANDLE handle = TEST_STRING_HANDLE;
263 bool result;
264 umock_c_reset_all_calls();
265
266 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
267 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
268
269 // act
270 result = SASToken_Validate(handle);
271
272 // assert
273 ASSERT_IS_FALSE(result);
274 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
275 }
276
277 TEST_FUNCTION(SASToken_validate_se_improper_format_3_fails)
278 {
279 // arrange
280 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr=TESTSR&sig=TESTSIG&se=";
281 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
282 STRING_HANDLE handle = TEST_STRING_HANDLE;
283 bool result;
284 umock_c_reset_all_calls();
285
286 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
287 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
288
289 // act
290 result = SASToken_Validate(handle);
291
292 // assert
293 ASSERT_IS_FALSE(result);
294 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
295 }
296
297 TEST_FUNCTION(SASToken_validate_se_improper_format_4_fails)
298 {
299 // arrange
300 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr=TESTSR&sig=TESTSIGse=0123456789";
301 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
302 STRING_HANDLE handle = TEST_STRING_HANDLE;
303 bool result;
304 umock_c_reset_all_calls();
305
306 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
307 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
308
309 // act
310 result = SASToken_Validate(handle);
311
312 // assert
313 ASSERT_IS_FALSE(result);
314 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
315 }
316
317 TEST_FUNCTION(SASToken_validate_se_improper_format_5_fails)
318 {
319 // arrange
320 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr=TESTSR&se0123456789&sig=TESTSIG";
321 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
322 STRING_HANDLE handle = TEST_STRING_HANDLE;
323 bool result;
324 umock_c_reset_all_calls();
325
326 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
327 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
328
329 // act
330 result = SASToken_Validate(handle);
331
332 // assert
333 ASSERT_IS_FALSE(result);
334 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
335 }
336
337 /*Tests_SRS_SASTOKEN_25_028: [**SASToken_validate shall check for the presence of sr, se and sig from the token and return false if not found**]*/
338 TEST_FUNCTION(SASToken_validate_improper_format_no_se_fails)
339 {
340 // arrange
341 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr=TESTSR&sig=TESTSIG";
342 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
343 STRING_HANDLE handle = TEST_STRING_HANDLE;
344 bool result;
345 umock_c_reset_all_calls();
346
347 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
348 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
349
350 // act
351 result = SASToken_Validate(handle);
352
353 // assert
354 ASSERT_IS_FALSE(result);
355 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
356 }
357
358 TEST_FUNCTION(SASToken_validate_improper_format_no_sr_fails)
359 {
360 // arrange
361 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature se=0123456789&sig=TESTSIG";
362 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
363 STRING_HANDLE handle = TEST_STRING_HANDLE;
364 bool result;
365 umock_c_reset_all_calls();
366
367 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
368 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
369
370 // act
371 result = SASToken_Validate(handle);
372
373 // assert
374 ASSERT_IS_FALSE(result);
375 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
376 }
377
378 TEST_FUNCTION(SASToken_validate_improper_format_no_sig_fails)
379 {
380 // arrange
381 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature se=0123456789&sr=TESTSR";
382 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
383 STRING_HANDLE handle = TEST_STRING_HANDLE;
384 bool result;
385 umock_c_reset_all_calls();
386
387 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
388 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
389
390 // act
391 result = SASToken_Validate(handle);
392
393 // assert
394 ASSERT_IS_FALSE(result);
395 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
396 }
397
398 TEST_FUNCTION(SASToken_validate_sr_improper_format_1_fails)
399 {
400 // arrange
401 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature srTESTSR&sig=TESTSIG&se=0123456789";
402 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
403 STRING_HANDLE handle = TEST_STRING_HANDLE;
404 bool result;
405 umock_c_reset_all_calls();
406
407 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
408 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
409
410 // act
411 result = SASToken_Validate(handle);
412
413 // assert
414 ASSERT_IS_FALSE(result);
415 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
416 }
417
418 TEST_FUNCTION(SASToken_validate_sr_improper_format_2_fails)
419 {
420 // arrange
421 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr&sig=TESTSIG&se=0123456789";
422 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
423 STRING_HANDLE handle = TEST_STRING_HANDLE;
424 bool result;
425 umock_c_reset_all_calls();
426
427 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
428 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
429
430 // act
431 result = SASToken_Validate(handle);
432
433 // assert
434 ASSERT_IS_FALSE(result);
435 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
436 }
437
438 TEST_FUNCTION(SASToken_validate_sr_improper_format_3_fails)
439 {
440 // arrange
441 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr=&sig=TESTSIG&se=0123456789";
442 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
443 STRING_HANDLE handle = TEST_STRING_HANDLE;
444 bool result;
445 umock_c_reset_all_calls();
446
447 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
448 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
449
450 // act
451 result = SASToken_Validate(handle);
452
453 // assert
454 ASSERT_IS_FALSE(result);
455 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
456 }
457
458 TEST_FUNCTION(SASToken_validate_sr_improper_format_4_fails)
459 {
460 // arrange
461 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignaturesr=TESTSR&sig=TESTSIGse=0123456789";
462 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
463 STRING_HANDLE handle = TEST_STRING_HANDLE;
464 bool result;
465 umock_c_reset_all_calls();
466
467 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
468 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
469
470 // act
471 result = SASToken_Validate(handle);
472
473 // assert
474 ASSERT_IS_FALSE(result);
475 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
476 }
477
478 TEST_FUNCTION(SASToken_validate_sr_improper_format_5_fails)
479 {
480 // arrange
481 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature srTESTSR&se=0123456789&sig=TESTSIG";
482 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
483 STRING_HANDLE handle = TEST_STRING_HANDLE;
484 bool result;
485 umock_c_reset_all_calls();
486
487 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
488 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
489
490 // act
491 result = SASToken_Validate(handle);
492
493 // assert
494 ASSERT_IS_FALSE(result);
495 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
496 }
497
498 TEST_FUNCTION(SASToken_validate_sig_improper_format_1_fails)
499 {
500 // arrange
501 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr=TESTSR&sigTESTSIG&se=0123456789";
502 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
503 STRING_HANDLE handle = TEST_STRING_HANDLE;
504 bool result;
505 umock_c_reset_all_calls();
506
507 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
508 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
509
510 // act
511 result = SASToken_Validate(handle);
512
513 // assert
514 ASSERT_IS_FALSE(result);
515 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
516 }
517
518 TEST_FUNCTION(SASToken_validate_sig_improper_format_2_fails)
519 {
520 // arrange
521 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr=TESTSR&sig&se=0123456789";
522 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
523 STRING_HANDLE handle = TEST_STRING_HANDLE;
524 bool result;
525 umock_c_reset_all_calls();
526
527 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
528 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
529
530 // act
531 result = SASToken_Validate(handle);
532
533 // assert
534 ASSERT_IS_FALSE(result);
535 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
536 }
537
538 TEST_FUNCTION(SASToken_validate_sig_improper_format_3_fails)
539 {
540 // arrange
541 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr=TESTSR&sig=&se=0123456789";
542 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
543 STRING_HANDLE handle = TEST_STRING_HANDLE;
544 bool result;
545 umock_c_reset_all_calls();
546
547 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
548 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
549
550 // act
551 result = SASToken_Validate(handle);
552
553 // assert
554 ASSERT_IS_FALSE(result);
555 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
556 }
557
558 TEST_FUNCTION(SASToken_validate_sig_improper_format_4_fails)
559 {
560 // arrange
561 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr=TESTSRsig=TESTSIGse=0123456789";
562 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
563 STRING_HANDLE handle = TEST_STRING_HANDLE;
564 bool result;
565 umock_c_reset_all_calls();
566
567 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
568 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
569
570 // act
571 result = SASToken_Validate(handle);
572
573 // assert
574 ASSERT_IS_FALSE(result);
575 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
576 }
577
578 TEST_FUNCTION(SASToken_validate_sig_improper_format_5_fails)
579 {
580 // arrange
581 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr=TESTSR&se0123456789&sig=TESTSIG";
582 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
583 STRING_HANDLE handle = TEST_STRING_HANDLE;
584 bool result;
585 umock_c_reset_all_calls();
586
587 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
588 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
589
590 // act
591 result = SASToken_Validate(handle);
592
593 // assert
594 ASSERT_IS_FALSE(result);
595 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
596 }
597
598 /*Tests_SRS_SASTOKEN_25_030: [**SASToken_validate shall return true only if the format is obeyed and the token has not yet expired **]*/
599 TEST_FUNCTION(SASToken_validate_proper_format_1_pass)
600 {
601 // arrange
602 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature se=0123456789&sr=TESTSR&sig=TESTSIG";
603 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
604 STRING_HANDLE handle = TEST_STRING_HANDLE;
605 bool result;
606 umock_c_reset_all_calls();
607
608 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
609 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
610 EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
611 STRICT_EXPECTED_CALL(get_time(IGNORED_PTR_ARG));
612 STRICT_EXPECTED_CALL(get_difftime(IGNORED_NUM_ARG, IGNORED_NUM_ARG)).IgnoreAllArguments().SetReturn(TEST_TIME_T);
613 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)).IgnoreAllArguments();
614
615 // act
616 result = SASToken_Validate(handle);
617
618 // assert
619 ASSERT_IS_TRUE(result);
620 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
621 }
622
623 /*Tests_SRS_SASTOKEN_25_030: [**SASToken_validate shall return true only if the format is obeyed and the token has not yet expired **]*/
624 TEST_FUNCTION(SASToken_validate_proper_format_with_skn_1_pass)
625 {
626 // arrange
627 const char* TEST_INVALID_SE = "SharedAccessSignature sr=devices.net/devices/tmp_device&sig=TESTSIG&se=0123456789&skn=";
628 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
629 STRING_HANDLE handle = TEST_STRING_HANDLE;
630 bool result;
631 umock_c_reset_all_calls();
632
633 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
634 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
635 EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
636 STRICT_EXPECTED_CALL(get_time(IGNORED_PTR_ARG));
637 STRICT_EXPECTED_CALL(get_difftime(IGNORED_NUM_ARG, IGNORED_NUM_ARG)).IgnoreAllArguments().SetReturn(TEST_TIME_T);
638 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)).IgnoreAllArguments();
639
640 // act
641 result = SASToken_Validate(handle);
642
643 // assert
644 ASSERT_IS_TRUE(result);
645 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
646 }
647
648 TEST_FUNCTION(SASToken_validate_proper_format_with_skn_expired_se_fail)
649 {
650 // arrange
651 const char* TEST_INVALID_SE = "SharedAccessSignature sr=devices.net/devices/tmp_device&sig=TESTSIG&se=011&skn=";
652 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
653 STRING_HANDLE handle = TEST_STRING_HANDLE;
654 bool result;
655 umock_c_reset_all_calls();
656
657 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
658 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
659 EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
660 STRICT_EXPECTED_CALL(get_time(IGNORED_PTR_ARG));
661 STRICT_EXPECTED_CALL(get_difftime(IGNORED_NUM_ARG, IGNORED_NUM_ARG)).IgnoreAllArguments().SetReturn(TEST_TIME_T);
662 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)).IgnoreAllArguments();
663
664 // act
665 result = SASToken_Validate(handle);
666
667 // assert
668 ASSERT_IS_FALSE(result);
669 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
670 }
671
672 TEST_FUNCTION(SASToken_validate_proper_format_2_pass)
673 {
674 // arrange
675 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sr=TESTSR&se=0123456789&sig=TESTSIG";
676 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
677 STRING_HANDLE handle = TEST_STRING_HANDLE;
678 bool result;
679 umock_c_reset_all_calls();
680
681 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
682 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
683 EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
684 STRICT_EXPECTED_CALL(get_time(IGNORED_PTR_ARG));
685 STRICT_EXPECTED_CALL(get_difftime(IGNORED_NUM_ARG, IGNORED_NUM_ARG)).IgnoreAllArguments().SetReturn(TEST_TIME_T);
686 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)).IgnoreAllArguments();
687
688 // act
689 result = SASToken_Validate(handle);
690
691 // assert
692 ASSERT_IS_TRUE(result);
693 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
694 }
695
696 TEST_FUNCTION(SASToken_validate_proper_format_3_pass)
697 {
698 // arrange
699 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sig=TESTSIG&sr=TESTSR&se=0123456789";
700 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
701 STRING_HANDLE handle = TEST_STRING_HANDLE;
702 bool result;
703 umock_c_reset_all_calls();
704
705 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
706 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
707 EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
708 STRICT_EXPECTED_CALL(get_time(IGNORED_PTR_ARG));
709 STRICT_EXPECTED_CALL(get_difftime(IGNORED_NUM_ARG, IGNORED_NUM_ARG)).IgnoreAllArguments().SetReturn(TEST_TIME_T);
710 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)).IgnoreAllArguments();
711
712 // act
713 result = SASToken_Validate(handle);
714
715 // assert
716 ASSERT_IS_TRUE(result);
717 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
718 }
719
720 TEST_FUNCTION(SASToken_validate_not_expired_pass)
721 {
722 // arrange
723 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sig=TESTSIG&sr=TESTSR&se=11";
724 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
725 STRING_HANDLE handle = TEST_STRING_HANDLE;
726 bool result;
727 umock_c_reset_all_calls();
728
729 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
730 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
731 EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
732 STRICT_EXPECTED_CALL(get_time(IGNORED_PTR_ARG));
733 STRICT_EXPECTED_CALL(get_difftime(IGNORED_NUM_ARG, IGNORED_NUM_ARG)).IgnoreAllArguments().SetReturn(TEST_EARLY_TIME);
734 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)).IgnoreAllArguments();
735
736 // act
737 result = SASToken_Validate(handle);
738
739 // assert
740 ASSERT_IS_TRUE(result);
741 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
742 }
743
744 // Testing for Y2K38.
745 TEST_FUNCTION(SASToken_validate_not_expired_large_int_pass)
746 {
747 // arrange
748 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sig=TESTSIG&sr=TESTSR&se=" TEST_EXPIRY_LARGE_STRING;
749 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
750 STRING_HANDLE handle = TEST_STRING_HANDLE;
751 bool result;
752 umock_c_reset_all_calls();
753
754 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
755 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
756 EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
757 STRICT_EXPECTED_CALL(get_time(IGNORED_PTR_ARG));
758 STRICT_EXPECTED_CALL(get_difftime(IGNORED_NUM_ARG, IGNORED_NUM_ARG)).IgnoreAllArguments().SetReturn(TEST_EARLY_TIME);
759 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)).IgnoreAllArguments();
760
761 // act
762 result = SASToken_Validate(handle);
763
764 // assert
765 ASSERT_IS_TRUE(result);
766 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
767 }
768
769 /*Tests_SRS_SASTOKEN_25_029: [**SASToken_validate shall check for expiry time from token and if token has expired then would return false **]*/
770 TEST_FUNCTION(SASToken_validate_expired_fail)
771 {
772 // arrange
773 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sig=TESTSIG&sr=TESTSR&se=10";
774 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
775 STRING_HANDLE handle = TEST_STRING_HANDLE;
776 bool result;
777 umock_c_reset_all_calls();
778
779 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
780 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
781 EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
782 STRICT_EXPECTED_CALL(get_time(IGNORED_PTR_ARG));
783 STRICT_EXPECTED_CALL(get_difftime(TEST_TIME_T, IGNORED_NUM_ARG)).IgnoreAllArguments().SetReturn(TEST_LATER_TIME);
784 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)).IgnoreAllArguments();
785
786 // act
787 result = SASToken_Validate(handle);
788
789 // assert
790 ASSERT_IS_FALSE(result);
791 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
792 }
793
794 TEST_FUNCTION(SASToken_validate_invalid_expiry_1_fail)
795 {
796 // arrange
797 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sig=TESTSIG&sr=TESTSR&se=10A";
798 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
799 STRING_HANDLE handle = TEST_STRING_HANDLE;
800 bool result;
801 umock_c_reset_all_calls();
802
803 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
804 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
805 EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
806 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)).IgnoreAllArguments();
807
808 // act
809 result = SASToken_Validate(handle);
810
811 // assert
812 ASSERT_IS_FALSE(result);
813 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
814 }
815
816 TEST_FUNCTION(SASToken_validate_invalid_expiry_2_fail)
817 {
818 // arrange
819 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sig=TESTSIG&sr=TESTSR&se=-10";
820 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
821 STRING_HANDLE handle = TEST_STRING_HANDLE;
822 bool result;
823 umock_c_reset_all_calls();
824
825 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
826 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
827 EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
828 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)).IgnoreAllArguments();
829
830 // act
831 result = SASToken_Validate(handle);
832
833 // assert
834 ASSERT_IS_FALSE(result);
835 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
836 }
837
838 TEST_FUNCTION(SASToken_validate_invalid_expiry_3_fail)
839 {
840 // arrange
841 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sig=TESTSIG&sr=TESTSR&se=0";
842 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
843 STRING_HANDLE handle = TEST_STRING_HANDLE;
844 bool result;
845 umock_c_reset_all_calls();
846
847 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
848 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
849 EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
850 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)).IgnoreAllArguments();
851
852 // act
853 result = SASToken_Validate(handle);
854
855 // assert
856 ASSERT_IS_FALSE(result);
857 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
858 }
859
860 TEST_FUNCTION(SASToken_validate_invalid_expiry_4_fail)
861 {
862 // arrange
863 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sig=TESTSIG&sr=TESTSR&se=A0";
864 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
865 STRING_HANDLE handle = TEST_STRING_HANDLE;
866 bool result;
867 umock_c_reset_all_calls();
868
869 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
870 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
871 EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
872 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)).IgnoreAllArguments();
873
874 // act
875 result = SASToken_Validate(handle);
876
877 // assert
878 ASSERT_IS_FALSE(result);
879 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
880 }
881
882 TEST_FUNCTION(SASToken_validate_invalid_expiry_5_fail)
883 {
884 // arrange
885 const char* TEST_INVALID_SE = "SharedAccessSignature=SharedAccessSignature sig=TESTSIG&sr=TESTSR&se=1A0";
886 size_t TEST_INVALID_SE_LENGTH = strlen(TEST_INVALID_SE);
887 STRING_HANDLE handle = TEST_STRING_HANDLE;
888 bool result;
889 umock_c_reset_all_calls();
890
891 STRICT_EXPECTED_CALL(STRING_c_str(handle)).SetReturn(TEST_INVALID_SE);
892 STRICT_EXPECTED_CALL(STRING_length(handle)).SetReturn(TEST_INVALID_SE_LENGTH);
893 EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
894 EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)).IgnoreAllArguments();
895
896 // act
897 result = SASToken_Validate(handle);
898
899 // assert
900 ASSERT_IS_FALSE(result);
901 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
902 }
903
904 /*Tests_SRS_SASTOKEN_06_001: [If key is NULL then SASToken_Create shall return NULL.]*/
905 TEST_FUNCTION(SASToken_Create_null_key_fails)
906 {
907 // arrange
908 STRING_HANDLE handle;
909
910 // act
911 handle = SASToken_Create(TEST_NULL_STRING_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
912
913 // assert
914 ASSERT_IS_NULL(handle);
915 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
916 }
917
918 /*Tests_SRS_SASTOKEN_06_003: [If scope is NULL then SASToken_Create shall return NULL.]*/
919 TEST_FUNCTION(SASToken_Create_null_scope_fails)
920 {
921 // arrange
922 STRING_HANDLE handle;
923
924 // act
925 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_NULL_STRING_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
926
927 // assert
928 ASSERT_IS_NULL(handle);
929 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
930 }
931
932 /*Tests_SRS_SASTOKEN_06_007: [keyName is optional and can be set to NULL.]*/
933 TEST_FUNCTION(SASToken_Create_null_keyName_succeeds)
934 {
935 // arrange
936 STRING_HANDLE handle;
937
938 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
939 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
940 STRICT_EXPECTED_CALL(STRING_c_str(NULL)).SetReturn(NULL);
941
942 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
943 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
944
945 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
946 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
947 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
948
949 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
950 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
951 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
952
953 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
954 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
955 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
956 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
957
958 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
959 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(TEST_BASE64SIGNATURE_HANDLE);
960 STRICT_EXPECTED_CALL(URL_Encode(TEST_BASE64SIGNATURE_HANDLE)).SetReturn(TEST_URLENCODEDSIGNATURE_HANDLE);
961 STRICT_EXPECTED_CALL(STRING_copy(TEST_RESULT_HANDLE, "SharedAccessSignature sr="));
962 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG));
963 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&sig="));
964 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(TEST_RESULT_HANDLE, TEST_URLENCODEDSIGNATURE_HANDLE));
965 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&se="));
966 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
967
968 STRICT_EXPECTED_CALL(STRING_delete(TEST_BASE64SIGNATURE_HANDLE));
969 STRICT_EXPECTED_CALL(STRING_delete(TEST_URLENCODEDSIGNATURE_HANDLE));
970 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
971 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
972 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
973
974
975 // act
976 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_NULL_STRING_HANDLE, TEST_EXPIRY);
977
978 // assert
979 ASSERT_IS_NOT_NULL(handle);
980 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
981 }
982
983 /*Tests_SRS_SASTOKEN_06_030: [If there is an error in the decoding then SASToken_Create shall return NULL.]*/
984 TEST_FUNCTION(SASToken_Create_decoded_key_fails)
985 {
986 // arrange
987 STRING_HANDLE handle;
988
989 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
990 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
991 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
992 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_NULL_BUFFER_HANDLE);
993
994 // act
995 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
996
997 // assert
998 ASSERT_IS_NULL(handle);
999 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1000 }
1001
1002 /*Tests_SRS_SASTOKEN_06_029: [The key parameter is decoded from base64.]*/
1003 /*Tests_SRS_SASTOKEN_06_026: [If the conversion to string form fails for any reason then SASToken_Create shall return NULL.]*/
1004 TEST_FUNCTION(SASToken_Create_uint64_tToString_fails)
1005 {
1006 // arrange
1007 STRING_HANDLE handle;
1008
1009 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1010 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1011 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1012 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1013
1014 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME)).SetReturn(-1);
1015
1016 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1017
1018 // act
1019 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1020
1021 // assert
1022 ASSERT_IS_NULL(handle);
1023 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1024 }
1025
1026 /*Tests_SRS_SASTOKEN_06_024: [The uint64_t value ((uint64_t) (difftime(get_time(NULL),0) + 3600)) is converted to a string form.]*/
1027 TEST_FUNCTION(SASToken_Create_buffer_new_fails)
1028 {
1029 // arrange
1030 STRING_HANDLE handle;
1031
1032 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1033 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1034 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1035 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1036
1037 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1038 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(NULL);
1039
1040 STRICT_EXPECTED_CALL(STRING_delete(NULL));
1041 STRICT_EXPECTED_CALL(BUFFER_delete(NULL));
1042 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1043
1044 // act
1045 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1046
1047 // assert
1048 ASSERT_IS_NULL(handle);
1049 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1050 }
1051
1052 TEST_FUNCTION(SASToken_Create_first_string_new_fails)
1053 {
1054 // arrange
1055 STRING_HANDLE handle;
1056
1057 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1058 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1059 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1060 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1061
1062 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1063 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1064 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(NULL);
1065
1066 STRICT_EXPECTED_CALL(STRING_delete(NULL));
1067 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1068 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1069
1070 // act
1071 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1072
1073 // assert
1074 ASSERT_IS_NULL(handle);
1075 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1076 }
1077
1078 TEST_FUNCTION(SASToken_Create_second_string_new_fails)
1079 {
1080 // arrange
1081 STRING_HANDLE handle;
1082
1083 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1084 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1085 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1086 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1087
1088 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1089 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1090 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1091 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(NULL);
1092
1093 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1094 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1095 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1096
1097 // act
1098 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1099
1100 // assert
1101 ASSERT_IS_NULL(handle);
1102 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1103 }
1104
1105 TEST_FUNCTION(SASToken_Create_build_to_be_hashed_part1_fails)
1106 {
1107 // arrange
1108 STRING_HANDLE handle;
1109
1110 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1111 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1112 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1113 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1114
1115 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1116 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1117 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1118 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1119
1120 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG)).SetReturn(1);
1121
1122 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1123 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1124 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1125 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1126
1127 // act
1128 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1129
1130 // assert
1131 ASSERT_IS_NULL(handle);
1132 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1133 }
1134
1135 /*Tests_SRS_SASTOKEN_06_009: [The scope is the basis for creating a STRING_HANDLE.]*/
1136 TEST_FUNCTION(SASToken_Create_build_to_be_hashed_part2_fails)
1137 {
1138 // arrange
1139 STRING_HANDLE handle;
1140
1141 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1142 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1143 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1144 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1145
1146 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1147 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1148 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1149 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1150
1151 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1152 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n")).SetReturn(1);
1153
1154 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1155 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1156 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1157 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1158
1159 // act
1160 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1161
1162 // assert
1163 ASSERT_IS_NULL(handle);
1164 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1165 }
1166
1167 /*Tests_SRS_SASTOKEN_06_010: [A "\n" is appended to that string.]*/
1168 TEST_FUNCTION(SASToken_Create_build_to_be_hashed_part3_fails)
1169 {
1170 // arrange
1171 STRING_HANDLE handle;
1172
1173 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1174 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1175 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1176 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1177
1178 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1179 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1180 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1181 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1182
1183 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1184 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1185 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME)).SetReturn(1);
1186
1187 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1188 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1189 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1190 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1191
1192 // act
1193 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1194
1195 // assert
1196 ASSERT_IS_NULL(handle);
1197 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1198 }
1199
1200 /*Tests_SRS_SASTOKEN_06_011: [tokenExpirationTime is appended to that string.]*/
1201 /*Tests_SRS_SASTOKEN_06_013: [If an error is returned from the HMAC256 function then NULL is returned from SASToken_Create.]*/
1202 TEST_FUNCTION(SASToken_Create_HMAC256_fails)
1203 {
1204 // arrange
1205 STRING_HANDLE handle;
1206
1207 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1208 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1209 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1210 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1211
1212 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1213 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1214 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1215 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1216
1217 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1218 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1219 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1220
1221 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1222 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1223 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1224 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1225
1226 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).SetReturn(HMACSHA256_ERROR);
1227
1228 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1229 STRICT_EXPECTED_CALL(STRING_delete(NULL));
1230 STRICT_EXPECTED_CALL(STRING_delete(NULL));
1231 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1232 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1233 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1234
1235 // act
1236 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1237
1238 // assert
1239 ASSERT_IS_NULL(handle);
1240 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1241 }
1242
1243
1244 /*Tests_SRS_SASTOKEN_06_012: [An HMAC256 hash is calculated using the decodedKey, over toBeHashed.]*/
1245 /*Tests_SRS_SASTOKEN_06_014: [If there are any errors from the following operations then NULL shall be returned.]*/
1246 TEST_FUNCTION(SASToken_Create_HMAC256_passes_signature_encode_fails)
1247 {
1248 // arrange
1249 STRING_HANDLE handle;
1250
1251 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1252 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1253 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1254 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1255
1256 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1257 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1258 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1259 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1260
1261 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1262 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1263 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1264
1265 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1266 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1267 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1268 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1269
1270 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
1271 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(NULL);
1272
1273 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1274 STRICT_EXPECTED_CALL(STRING_delete(NULL));
1275 STRICT_EXPECTED_CALL(STRING_delete(NULL));
1276 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1277 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1278 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1279
1280 // act
1281 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1282
1283 // assert
1284 ASSERT_IS_NULL(handle);
1285 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1286 }
1287
1288 /*Tests_SRS_SASTOKEN_06_014: [If there are any errors from the following operations then NULL shall be returned.]*/
1289 /*Tests_SRS_SASTOKEN_06_015: [The hash is base 64 encoded.]*/
1290 TEST_FUNCTION(SASToken_Create_building_token_signature_url_encoding_fails)
1291 {
1292 // arrange
1293 STRING_HANDLE handle;
1294
1295 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1296 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1297 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1298 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1299
1300 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1301 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1302 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1303 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1304
1305 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1306 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1307 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1308
1309 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1310 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1311 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1312 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1313
1314 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
1315 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(TEST_BASE64SIGNATURE_HANDLE);
1316 STRICT_EXPECTED_CALL(URL_Encode(TEST_BASE64SIGNATURE_HANDLE)).SetReturn(NULL);
1317
1318 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1319 STRICT_EXPECTED_CALL(STRING_delete(TEST_BASE64SIGNATURE_HANDLE));
1320 STRICT_EXPECTED_CALL(STRING_delete(NULL));
1321 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1322 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1323 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1324
1325 // act
1326 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1327
1328 // assert
1329 ASSERT_IS_NULL(handle);
1330 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1331 }
1332
1333 /*Tests_SRS_SASTOKEN_06_014: [If there are any errors from the following operations then NULL shall be returned.]*/
1334 /*Tests_SRS_SASTOKEN_06_028: [base64Signature shall be url encoded.]*/
1335 TEST_FUNCTION(SASToken_Create_building_token_copy_scope_identifier_fails)
1336 {
1337 // arrange
1338 STRING_HANDLE handle;
1339
1340 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1341 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1342 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1343 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1344
1345 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1346 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1347 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1348 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1349
1350 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1351 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1352 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1353
1354 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1355 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1356 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1357 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1358
1359 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
1360 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(TEST_BASE64SIGNATURE_HANDLE);
1361 STRICT_EXPECTED_CALL(URL_Encode(TEST_BASE64SIGNATURE_HANDLE)).SetReturn(TEST_URLENCODEDSIGNATURE_HANDLE);
1362 STRICT_EXPECTED_CALL(STRING_copy(TEST_RESULT_HANDLE, "SharedAccessSignature sr=")).SetReturn(1);
1363
1364 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1365 STRICT_EXPECTED_CALL(STRING_delete(TEST_BASE64SIGNATURE_HANDLE));
1366 STRICT_EXPECTED_CALL(STRING_delete(TEST_URLENCODEDSIGNATURE_HANDLE));
1367 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1368 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1369 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1370
1371 // act
1372 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1373
1374 // assert
1375 ASSERT_IS_NULL(handle);
1376 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1377 }
1378
1379 /*Tests_SRS_SASTOKEN_06_016: [The string "SharedAccessSignature sr=" is the first part of the result of SASToken_Create.]*/
1380 /*Tests_SRS_SASTOKEN_06_014: [If there are any errors from the following operations then NULL shall be returned.]*/
1381 TEST_FUNCTION(SASToken_Create_building_token_concat_scope_fails)
1382 {
1383 // arrange
1384 STRING_HANDLE handle;
1385
1386 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1387 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1388 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1389 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1390
1391 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1392 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1393 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1394 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1395
1396 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1397 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1398 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1399
1400 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1401 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1402 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1403 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1404
1405 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
1406 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(TEST_BASE64SIGNATURE_HANDLE);
1407 STRICT_EXPECTED_CALL(URL_Encode(TEST_BASE64SIGNATURE_HANDLE)).SetReturn(TEST_URLENCODEDSIGNATURE_HANDLE);
1408 STRICT_EXPECTED_CALL(STRING_copy(TEST_RESULT_HANDLE, "SharedAccessSignature sr="));
1409 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG)).SetReturn(1);
1410
1411 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1412 STRICT_EXPECTED_CALL(STRING_delete(TEST_BASE64SIGNATURE_HANDLE));
1413 STRICT_EXPECTED_CALL(STRING_delete(TEST_URLENCODEDSIGNATURE_HANDLE));
1414 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1415 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1416 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1417
1418 // act
1419 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1420
1421 // assert
1422 ASSERT_IS_NULL(handle);
1423 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1424 }
1425
1426 /*Tests_SRS_SASTOKEN_06_014: [If there are any errors from the following operations then NULL shall be returned.]*/
1427 /*Tests_SRS_SASTOKEN_06_017: [The scope parameter is appended to result.]*/
1428 TEST_FUNCTION(SASToken_Create_building_token_concat_signature_identifier_fails)
1429 {
1430 // arrange
1431 STRING_HANDLE handle;
1432
1433 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1434 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1435 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1436 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1437
1438 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1439 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1440 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1441 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1442
1443 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1444 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1445 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1446
1447 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1448 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1449 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1450 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1451
1452 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
1453 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(TEST_BASE64SIGNATURE_HANDLE);
1454 STRICT_EXPECTED_CALL(URL_Encode(TEST_BASE64SIGNATURE_HANDLE)).SetReturn(TEST_URLENCODEDSIGNATURE_HANDLE);
1455 STRICT_EXPECTED_CALL(STRING_copy(TEST_RESULT_HANDLE, "SharedAccessSignature sr="));
1456 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG));
1457 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&sig=")).SetReturn(1);
1458
1459 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1460 STRICT_EXPECTED_CALL(STRING_delete(TEST_BASE64SIGNATURE_HANDLE));
1461 STRICT_EXPECTED_CALL(STRING_delete(TEST_URLENCODEDSIGNATURE_HANDLE));
1462 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1463 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1464 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1465
1466 // act
1467 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1468
1469 // assert
1470 ASSERT_IS_NULL(handle);
1471 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1472 }
1473
1474 /*Tests_SRS_SASTOKEN_06_014: [If there are any errors from the following operations then NULL shall be returned.]*/
1475 /*Tests_SRS_SASTOKEN_06_018: [The string "&sig=" is appended to result.]*/
1476 TEST_FUNCTION(SASToken_Create_building_token_concat_signature_fails)
1477 {
1478 // arrange
1479 STRING_HANDLE handle;
1480
1481 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1482 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1483 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1484 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1485
1486 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1487 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1488 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1489 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1490
1491 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1492 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1493 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1494
1495 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1496 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1497 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1498 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1499
1500 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
1501 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(TEST_BASE64SIGNATURE_HANDLE);
1502 STRICT_EXPECTED_CALL(URL_Encode(TEST_BASE64SIGNATURE_HANDLE)).SetReturn(TEST_URLENCODEDSIGNATURE_HANDLE);
1503 STRICT_EXPECTED_CALL(STRING_copy(TEST_RESULT_HANDLE, "SharedAccessSignature sr="));
1504 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG));
1505 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&sig="));
1506 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(TEST_RESULT_HANDLE, TEST_URLENCODEDSIGNATURE_HANDLE)).SetReturn(1);
1507
1508 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1509 STRICT_EXPECTED_CALL(STRING_delete(TEST_BASE64SIGNATURE_HANDLE));
1510 STRICT_EXPECTED_CALL(STRING_delete(TEST_URLENCODEDSIGNATURE_HANDLE));
1511 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1512 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1513 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1514
1515 // act
1516 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1517
1518 // assert
1519 ASSERT_IS_NULL(handle);
1520 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1521 }
1522
1523 /*Tests_SRS_SASTOKEN_06_014: [If there are any errors from the following operations then NULL shall be returned.]*/
1524 /*Tests_SRS_SASTOKEN_06_019: [The string urlEncodedSignature shall be appended to result.]*/
1525 TEST_FUNCTION(SASToken_Create_building_token_concat_token_expiration_time_identifier_fails)
1526 {
1527 // arrange
1528 STRING_HANDLE handle;
1529
1530 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1531 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1532 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1533 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1534
1535 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1536 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1537 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1538 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1539
1540 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1541 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1542 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1543
1544 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1545 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1546 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1547 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1548
1549 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
1550 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(TEST_BASE64SIGNATURE_HANDLE);
1551 STRICT_EXPECTED_CALL(URL_Encode(TEST_BASE64SIGNATURE_HANDLE)).SetReturn(TEST_URLENCODEDSIGNATURE_HANDLE);
1552 STRICT_EXPECTED_CALL(STRING_copy(TEST_RESULT_HANDLE, "SharedAccessSignature sr="));
1553 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG));
1554 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&sig="));
1555 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(TEST_RESULT_HANDLE, TEST_URLENCODEDSIGNATURE_HANDLE));
1556 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&se=")).SetReturn(1);
1557
1558 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1559 STRICT_EXPECTED_CALL(STRING_delete(TEST_BASE64SIGNATURE_HANDLE));
1560 STRICT_EXPECTED_CALL(STRING_delete(TEST_URLENCODEDSIGNATURE_HANDLE));
1561 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1562 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1563 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1564
1565 // act
1566 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1567
1568 // assert
1569 ASSERT_IS_NULL(handle);
1570 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1571 }
1572
1573 /*Tests_SRS_SASTOKEN_06_014: [If there are any errors from the following operations then NULL shall be returned.]*/
1574 /*Tests_SRS_SASTOKEN_06_020: [The string "&se=" shall be appended to result.]*/
1575 TEST_FUNCTION(SASToken_Create_building_token_concat_token_expiration_time_fails)
1576 {
1577 // arrange
1578 STRING_HANDLE handle;
1579
1580 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1581 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1582 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1583 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1584
1585 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1586 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1587 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1588 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1589
1590 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1591 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1592 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1593
1594 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1595 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1596 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1597 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1598
1599 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
1600 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(TEST_BASE64SIGNATURE_HANDLE);
1601 STRICT_EXPECTED_CALL(URL_Encode(TEST_BASE64SIGNATURE_HANDLE)).SetReturn(TEST_URLENCODEDSIGNATURE_HANDLE);
1602 STRICT_EXPECTED_CALL(STRING_copy(TEST_RESULT_HANDLE, "SharedAccessSignature sr="));
1603 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG));
1604 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&sig="));
1605 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(TEST_RESULT_HANDLE, TEST_URLENCODEDSIGNATURE_HANDLE));
1606 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&se="));
1607 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, TEST_TOKEN_EXPIRATION_TIME)).SetReturn(1);
1608
1609 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1610 STRICT_EXPECTED_CALL(STRING_delete(TEST_BASE64SIGNATURE_HANDLE));
1611 STRICT_EXPECTED_CALL(STRING_delete(TEST_URLENCODEDSIGNATURE_HANDLE));
1612 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1613 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1614 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1615
1616 // act
1617 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1618
1619 // assert
1620 ASSERT_IS_NULL(handle);
1621 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1622 }
1623
1624 /*Tests_SRS_SASTOKEN_06_014: [If there are any errors from the following operations then NULL shall be returned.]*/
1625 /*Tests_SRS_SASTOKEN_06_021: [tokenExpirationTime is appended to result.]*/
1626 TEST_FUNCTION(SASToken_Create_building_token_concat_keyname_identifier_fails)
1627 {
1628 // arrange
1629 STRING_HANDLE handle;
1630
1631 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1632 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1633 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1634 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1635
1636 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1637 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1638 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1639 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1640
1641 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1642 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1643 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1644
1645 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1646 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1647 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1648 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1649
1650 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
1651 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(TEST_BASE64SIGNATURE_HANDLE);
1652 STRICT_EXPECTED_CALL(URL_Encode(TEST_BASE64SIGNATURE_HANDLE)).SetReturn(TEST_URLENCODEDSIGNATURE_HANDLE);
1653 STRICT_EXPECTED_CALL(STRING_copy(TEST_RESULT_HANDLE, "SharedAccessSignature sr="));
1654 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG));
1655 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&sig="));
1656 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(TEST_RESULT_HANDLE, TEST_URLENCODEDSIGNATURE_HANDLE));
1657 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&se="));
1658 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1659 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&skn=")).SetReturn(1);
1660
1661 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1662 STRICT_EXPECTED_CALL(STRING_delete(TEST_BASE64SIGNATURE_HANDLE));
1663 STRICT_EXPECTED_CALL(STRING_delete(TEST_URLENCODEDSIGNATURE_HANDLE));
1664 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1665 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1666 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1667
1668 // act
1669 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1670
1671 // assert
1672 ASSERT_IS_NULL(handle);
1673 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1674 }
1675
1676 /*Tests_SRS_SASTOKEN_06_014: [If there are any errors from the following operations then NULL shall be returned.]*/
1677 /*Tests_SRS_SASTOKEN_06_022: [If keyName is non-NULL, the string "&skn=" is appended to result.]*/
1678 TEST_FUNCTION(SASToken_Create_building_token_concat_keyname_fails)
1679 {
1680 // arrange
1681 STRING_HANDLE handle;
1682
1683 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1684 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1685 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1686 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1687
1688 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1689 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1690 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1691 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1692
1693 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1694 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1695 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1696
1697 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1698 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1699 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1700 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1701
1702 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
1703 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(TEST_BASE64SIGNATURE_HANDLE);
1704 STRICT_EXPECTED_CALL(URL_Encode(TEST_BASE64SIGNATURE_HANDLE)).SetReturn(TEST_URLENCODEDSIGNATURE_HANDLE);
1705 STRICT_EXPECTED_CALL(STRING_copy(TEST_RESULT_HANDLE, "SharedAccessSignature sr="));
1706 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG));
1707 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&sig="));
1708 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(TEST_RESULT_HANDLE, TEST_URLENCODEDSIGNATURE_HANDLE));
1709 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&se="));
1710 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1711 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&skn="));
1712 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG)).SetReturn(1);
1713
1714 STRICT_EXPECTED_CALL(STRING_delete(TEST_RESULT_HANDLE));
1715 STRICT_EXPECTED_CALL(STRING_delete(TEST_BASE64SIGNATURE_HANDLE));
1716 STRICT_EXPECTED_CALL(STRING_delete(TEST_URLENCODEDSIGNATURE_HANDLE));
1717 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1718 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1719 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1720
1721 // act
1722 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1723
1724 // assert
1725 ASSERT_IS_NULL(handle);
1726 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1727 }
1728
1729 /*Tests_SRS_SASTOKEN_06_023: [The argument keyName is appended to result.]*/
1730 TEST_FUNCTION(SASToken_Create_succeeds)
1731 {
1732 // arrange
1733 STRING_HANDLE handle;
1734
1735 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEY_HANDLE)).SetReturn(&TEST_CHAR_ARRAY[0]);
1736 STRICT_EXPECTED_CALL(STRING_c_str(TEST_SCOPE_HANDLE)).SetReturn(TEST_STRING_VALUE);
1737 STRICT_EXPECTED_CALL(STRING_c_str(TEST_KEYNAME_HANDLE)).SetReturn(TEST_STRING_VALUE);
1738
1739 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1740 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1741
1742 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1743 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1744 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1745
1746 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1747 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1748 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1749
1750 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1751 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1752 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1753 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1754
1755 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
1756 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(TEST_BASE64SIGNATURE_HANDLE);
1757 STRICT_EXPECTED_CALL(URL_Encode(TEST_BASE64SIGNATURE_HANDLE)).SetReturn(TEST_URLENCODEDSIGNATURE_HANDLE);
1758 STRICT_EXPECTED_CALL(STRING_copy(TEST_RESULT_HANDLE, "SharedAccessSignature sr="));
1759 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG));
1760 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&sig="));
1761 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(TEST_RESULT_HANDLE, TEST_URLENCODEDSIGNATURE_HANDLE));
1762 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&se="));
1763 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1764 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&skn="));
1765 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG));
1766
1767 STRICT_EXPECTED_CALL(STRING_delete(TEST_BASE64SIGNATURE_HANDLE));
1768 STRICT_EXPECTED_CALL(STRING_delete(TEST_URLENCODEDSIGNATURE_HANDLE));
1769 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1770 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1771 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1772
1773 // act
1774 handle = SASToken_Create(TEST_KEY_HANDLE, TEST_SCOPE_HANDLE, TEST_KEYNAME_HANDLE, TEST_EXPIRY);
1775
1776 // assert
1777 ASSERT_IS_NOT_NULL(handle);
1778 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1779 }
1780
1781 TEST_FUNCTION(SASToken_CreateString_succeeds)
1782 {
1783 // arrange
1784 STRING_HANDLE handle;
1785
1786 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1787 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME), TEST_EXPIRY)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME, sizeof(TEST_TOKEN_EXPIRATION_TIME));
1788
1789 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1790 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1791 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1792
1793 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1794 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1795 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1796
1797 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1798 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1799 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1800 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1801
1802 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
1803 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(TEST_BASE64SIGNATURE_HANDLE);
1804 STRICT_EXPECTED_CALL(URL_Encode(TEST_BASE64SIGNATURE_HANDLE)).SetReturn(TEST_URLENCODEDSIGNATURE_HANDLE);
1805 STRICT_EXPECTED_CALL(STRING_copy(TEST_RESULT_HANDLE, "SharedAccessSignature sr="));
1806 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG));
1807 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&sig="));
1808 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(TEST_RESULT_HANDLE, TEST_URLENCODEDSIGNATURE_HANDLE));
1809 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&se="));
1810 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, TEST_TOKEN_EXPIRATION_TIME));
1811 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&skn="));
1812 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG));
1813
1814 STRICT_EXPECTED_CALL(STRING_delete(TEST_BASE64SIGNATURE_HANDLE));
1815 STRICT_EXPECTED_CALL(STRING_delete(TEST_URLENCODEDSIGNATURE_HANDLE));
1816 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1817 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1818 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1819
1820 // act
1821 handle = SASToken_CreateString(TEST_CHAR_ARRAY, TEST_STRING_VALUE, TEST_STRING_VALUE, TEST_EXPIRY);
1822
1823 // assert
1824 ASSERT_IS_NOT_NULL(handle);
1825 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1826 }
1827
1828 // Testing for Y2K38.
1829 TEST_FUNCTION(SASToken_CreateString_large_int_succeeds)
1830 {
1831 // arrange
1832 STRING_HANDLE handle;
1833
1834 STRICT_EXPECTED_CALL(Azure_Base64_Decode(&TEST_CHAR_ARRAY[0])).SetReturn(TEST_DECODEDKEY_HANDLE);
1835 STRICT_EXPECTED_CALL(uint64_tToString(IGNORED_PTR_ARG, sizeof(TEST_TOKEN_EXPIRATION_TIME_LARGE), TEST_EXPIRY_LARGE)).IgnoreArgument(1).CopyOutArgumentBuffer(1, TEST_TOKEN_EXPIRATION_TIME_LARGE, sizeof(TEST_TOKEN_EXPIRATION_TIME_LARGE));
1836
1837 STRICT_EXPECTED_CALL(BUFFER_new()).SetReturn(TEST_HASH_HANDLE);
1838 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_TOBEHASHED_HANDLE);
1839 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(TEST_RESULT_HANDLE);
1840
1841 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, IGNORED_PTR_ARG));
1842 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, "\n"));
1843 STRICT_EXPECTED_CALL(STRING_concat(TEST_TOBEHASHED_HANDLE, TEST_TOKEN_EXPIRATION_TIME_LARGE));
1844
1845 STRICT_EXPECTED_CALL(STRING_length(TEST_TOBEHASHED_HANDLE)).SetReturn(TEST_LENGTH_TOBEHASHED);
1846 STRICT_EXPECTED_CALL(STRING_c_str(TEST_TOBEHASHED_HANDLE));
1847 STRICT_EXPECTED_CALL(BUFFER_length(TEST_DECODEDKEY_HANDLE)).SetReturn(TEST_LENGTH_DECODEDKEY);
1848 STRICT_EXPECTED_CALL(BUFFER_u_char(TEST_DECODEDKEY_HANDLE));
1849
1850 STRICT_EXPECTED_CALL(HMACSHA256_ComputeHash(IGNORED_PTR_ARG, TEST_LENGTH_DECODEDKEY, IGNORED_PTR_ARG, TEST_LENGTH_TOBEHASHED, TEST_HASH_HANDLE)).IgnoreArgument(1).IgnoreArgument(3);
1851 STRICT_EXPECTED_CALL(Azure_Base64_Encode(TEST_HASH_HANDLE)).SetReturn(TEST_BASE64SIGNATURE_HANDLE);
1852 STRICT_EXPECTED_CALL(URL_Encode(TEST_BASE64SIGNATURE_HANDLE)).SetReturn(TEST_URLENCODEDSIGNATURE_HANDLE);
1853 STRICT_EXPECTED_CALL(STRING_copy(TEST_RESULT_HANDLE, "SharedAccessSignature sr="));
1854 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG));
1855 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&sig="));
1856 STRICT_EXPECTED_CALL(STRING_concat_with_STRING(TEST_RESULT_HANDLE, TEST_URLENCODEDSIGNATURE_HANDLE));
1857 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&se="));
1858 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, TEST_TOKEN_EXPIRATION_TIME_LARGE));
1859 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, "&skn="));
1860 STRICT_EXPECTED_CALL(STRING_concat(TEST_RESULT_HANDLE, IGNORED_PTR_ARG));
1861
1862 STRICT_EXPECTED_CALL(STRING_delete(TEST_BASE64SIGNATURE_HANDLE));
1863 STRICT_EXPECTED_CALL(STRING_delete(TEST_URLENCODEDSIGNATURE_HANDLE));
1864 STRICT_EXPECTED_CALL(STRING_delete(TEST_TOBEHASHED_HANDLE));
1865 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_HASH_HANDLE));
1866 STRICT_EXPECTED_CALL(BUFFER_delete(TEST_DECODEDKEY_HANDLE));
1867
1868 // act
1869 handle = SASToken_CreateString(TEST_CHAR_ARRAY, TEST_STRING_VALUE, TEST_STRING_VALUE, TEST_EXPIRY_LARGE);
1870
1871 // assert
1872 ASSERT_IS_NOT_NULL(handle);
1873 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1874 }
1875
1876 END_TEST_SUITE(sastoken_unittests)