Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/tests/httpapiexsas_ut/httpapiexsas_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 #include <cstddef>
7 #include <ctime>
8 #include <cstdint>
9 #else
10 #include <stdlib.h>
11 #include <stddef.h>
12 #include <time.h>
13 #include <stdint.h>
14 #endif
15
16 static void* my_gballoc_malloc(size_t size)
17 {
18 return malloc(size);
19 }
20
21 static void my_gballoc_free(void* ptr)
22 {
23 free(ptr);
24 }
25
26 #include "azure_macro_utils/macro_utils.h"
27 #include "testrunnerswitcher.h"
28 #include "umock_c/umock_c.h"
29 #include "umock_c/umocktypes_charptr.h"
30 #include "umock_c/umock_c_negative_tests.h"
31 #include "umock_c/umocktypes_stdint.h"
32
33 #define ENABLE_MOCKS
34 #include "azure_c_shared_utility/gballoc.h"
35 #include "azure_c_shared_utility/agenttime.h"
36 #include "azure_c_shared_utility/strings.h"
37 #include "azure_c_shared_utility/buffer_.h"
38 #include "azure_c_shared_utility/sastoken.h"
39 #include "azure_c_shared_utility/httpheaders.h"
40 #include "azure_c_shared_utility/httpapiex.h"
41 #include "azure_c_shared_utility/crt_abstractions.h"
42
43 #undef ENABLE_MOCKS
44
45 #include "azure_c_shared_utility/httpapiexsas.h"
46
47 TEST_DEFINE_ENUM_TYPE(HTTPAPIEX_RESULT, HTTPAPIEX_RESULT_VALUES);
48 IMPLEMENT_UMOCK_C_ENUM_TYPE(HTTPAPIEX_RESULT, HTTPAPIEX_RESULT_VALUES);
49
50 IMPLEMENT_UMOCK_C_ENUM_TYPE(HTTP_HEADERS_RESULT, HTTP_HEADERS_RESULT_VALUES);
51
52 #define TEST_STRING_HANDLE (STRING_HANDLE)0x46
53 #define TEST_NULL_STRING_HANDLE (STRING_HANDLE)0x00
54 #define TEST_KEYNAME_HANDLE (STRING_HANDLE)0x48
55 #define TEST_KEY_HANDLE (STRING_HANDLE)0x49
56 #define TEST_URIRESOURCE_HANDLE (STRING_HANDLE)0x50
57 #define TEST_CLONED_KEYNAME_HANDLE (STRING_HANDLE)0x51
58 #define TEST_CLONED_URIRESOURCE_HANDLE (STRING_HANDLE)0x52
59 #define TEST_CLONED_KEY_HANDLE (STRING_HANDLE)0x53
60 #define TEST_HTTPAPIEX_HANDLE (HTTPAPIEX_HANDLE)0x54
61 #define TEST_HTTPAPI_REQUEST_TYPE (HTTPAPI_REQUEST_TYPE)0x55
62 #define TEST_REQUEST_HTTP_HEADERS_HANDLE (HTTP_HEADERS_HANDLE)0x56
63 #define TEST_REQUEST_CONTENT (BUFFER_HANDLE)0x57
64 #define TEST_RESPONSE_HTTP_HEADERS_HANDLE (HTTP_HEADERS_HANDLE)0x58
65 #define TEST_RESPONSE_CONTENT (BUFFER_HANDLE)0x59
66 #define TEST_CONST_CHAR_STAR_NULL (const char*)NULL
67 #define TEST_SASTOKEN_HANDLE (STRING_HANDLE)0x60
68 #define TEST_EXPIRY ((uint64_t)7200)
69 #define TEST_TIME_T ((time_t)-1)
70
71 static const char* TEST_KEY = "key";
72 static const char* TEST_SAS = "signature";
73 static const char* TEST_SAS_KEY = "sas=signature";
74 static const char* TEST_URI_RESOURCE = "test_uri";
75 static const char* TEST_KEY_NAME = "key_name";
76
77 static const char TEST_CHAR_ARRAY[10] = "ABCD";
78
79 static TEST_MUTEX_HANDLE g_testByTest;
80
81 static int my_mallocAndStrcpy_s(char** destination, const char* source)
82 {
83 size_t len = strlen(source);
84 *destination = (char*)my_gballoc_malloc(len+1);
85 (void)strcpy(*destination, source);
86 return 0;
87 }
88
89 static STRING_HANDLE my_STRING_construct(const char* psz)
90 {
91 char* temp = (char*)my_gballoc_malloc(strlen(psz) + 1);
92 ASSERT_IS_NOT_NULL(temp);
93 (void)memcpy(temp, psz, strlen(psz) + 1);
94 return (STRING_HANDLE)temp;
95 }
96
97 static void my_STRING_delete(STRING_HANDLE handle)
98 {
99 my_gballoc_free(handle);
100 }
101
102 static STRING_HANDLE my_SASToken_CreateString(const char* key, const char* scope, const char* keyName, uint64_t expiry)
103 {
104 (void)key, (void)scope, (void)keyName, (void)expiry;
105 return (STRING_HANDLE)my_gballoc_malloc(1);
106 }
107
108 static void setupSASString_Create_happy_path(bool allocateKeyName)
109 {
110 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
111 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
112 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
113 if (allocateKeyName)
114 {
115 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
116 }
117 }
118
119 static void setupSAS_Create_happy_path_provide_key(bool useSasKey, bool allocateKeyName)
120 {
121 // HTTPAPIEX_SAS_Create
122 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)).SetReturn(useSasKey ? TEST_SAS_KEY : TEST_KEY);
123 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)).SetReturn(TEST_URI_RESOURCE);
124 if (allocateKeyName)
125 {
126 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)).SetReturn(TEST_KEY_NAME);
127 }
128 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
129 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
130 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
131 if (allocateKeyName)
132 {
133 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
134 }
135 }
136
137 static void setupSAS_Create_happy_path(bool allocateKeyName)
138 {
139 setupSAS_Create_happy_path_provide_key(false, allocateKeyName);
140 }
141
142 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
143
144 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
145 {
146 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
147 }
148
149 int umocktypes_copy_time_t(time_t* destination, const time_t* source)
150 {
151 *destination = *source;
152 return 0;
153 }
154
155 void umocktypes_free_time_t(time_t* value)
156 {
157 (void)value;
158 }
159
160 char* umocktypes_stringify_time_t(const time_t* value)
161 {
162 char temp_str[32];
163 char* result;
164 int length = snprintf(temp_str, sizeof(temp_str), "%d", (int)(*value));
165 if (length <= 0)
166 {
167 result = NULL;
168 }
169 else
170 {
171 result = (char*)malloc(length + 1);
172 (void)memcpy(result, temp_str, length + 1);
173 }
174 return result;
175 }
176
177 int umocktypes_are_equal_time_t(time_t* left, time_t* right)
178 {
179 int result;
180
181 if (*left == *right)
182 {
183 result = 1;
184 }
185 else
186 {
187 result = 0;
188 }
189
190 return result;
191 }
192
193 IMPLEMENT_UMOCK_C_ENUM_TYPE(HTTPAPI_REQUEST_TYPE, HTTPAPI_REQUEST_TYPE_VALUES);
194
195 BEGIN_TEST_SUITE(httpapiexsas_unittests)
196
197 TEST_SUITE_INITIALIZE(TestClassInitialize)
198 {
199 int result;
200
201 g_testByTest = TEST_MUTEX_CREATE();
202 ASSERT_IS_NOT_NULL(g_testByTest);
203
204 umock_c_init(on_umock_c_error);
205
206 result = umocktypes_stdint_register_types();
207 ASSERT_ARE_EQUAL(int, 0, result, "umocktypes_stdint_register_types");
208
209 result = umocktypes_charptr_register_types();
210 ASSERT_ARE_EQUAL(int, 0, result);
211
212 REGISTER_TYPE(HTTPAPIEX_RESULT, HTTPAPIEX_RESULT);
213 REGISTER_TYPE(HTTP_HEADERS_RESULT, HTTP_HEADERS_RESULT);
214 REGISTER_UMOCK_ALIAS_TYPE(STRING_HANDLE, void*);
215 REGISTER_UMOCK_ALIAS_TYPE(HTTP_HEADERS_HANDLE, void*);
216 REGISTER_TYPE(time_t, time_t);
217 REGISTER_UMOCK_ALIAS_TYPE(HTTPAPIEX_HANDLE, void*);
218 REGISTER_UMOCK_ALIAS_TYPE(BUFFER_HANDLE, void*);
219 REGISTER_TYPE(HTTPAPI_REQUEST_TYPE, HTTPAPI_REQUEST_TYPE);
220
221 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
222 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
223 REGISTER_GLOBAL_MOCK_HOOK(SASToken_CreateString, my_SASToken_CreateString);
224 REGISTER_GLOBAL_MOCK_HOOK(mallocAndStrcpy_s, my_mallocAndStrcpy_s);
225
226 REGISTER_GLOBAL_MOCK_RETURN(STRING_c_str, TEST_CONST_CHAR_STAR_NULL);
227 REGISTER_GLOBAL_MOCK_RETURN(STRING_length, 0);
228 REGISTER_GLOBAL_MOCK_HOOK(STRING_construct, my_STRING_construct);
229 REGISTER_GLOBAL_MOCK_HOOK(STRING_delete, my_STRING_delete);
230
231 REGISTER_GLOBAL_MOCK_RETURN(HTTPAPIEX_ExecuteRequest, HTTPAPIEX_OK);
232 REGISTER_GLOBAL_MOCK_RETURN(HTTPHeaders_FindHeaderValue, TEST_CONST_CHAR_STAR_NULL);
233 REGISTER_GLOBAL_MOCK_RETURN(HTTPHeaders_ReplaceHeaderNameValuePair, HTTP_HEADERS_ERROR);
234 REGISTER_GLOBAL_MOCK_RETURN(get_time, TEST_TIME_T);
235 }
236
237 TEST_SUITE_CLEANUP(TestClassCleanup)
238 {
239 umock_c_deinit();
240
241 TEST_MUTEX_DESTROY(g_testByTest);
242 }
243
244 TEST_FUNCTION_INITIALIZE(TestMethodInitialize)
245 {
246 if (TEST_MUTEX_ACQUIRE(g_testByTest))
247 {
248 ASSERT_FAIL("our mutex is ABANDONED. Failure in test framework");
249 }
250 }
251
252 TEST_FUNCTION_CLEANUP(TestMethodCleanup)
253 {
254 TEST_MUTEX_RELEASE(g_testByTest);
255
256 umock_c_reset_all_calls();
257 }
258
259 TEST_FUNCTION(HTTPAPIEX_SAS_is_zero_the_epoch)
260 {
261 time_t epoch_candidate = 0;
262 struct tm broken_down_time;
263 broken_down_time = *gmtime(&epoch_candidate);
264 ASSERT_ARE_EQUAL(int, broken_down_time.tm_hour, 0);
265 ASSERT_ARE_EQUAL(int, broken_down_time.tm_min, 0);
266 ASSERT_ARE_EQUAL(int, broken_down_time.tm_sec, 0);
267 ASSERT_ARE_EQUAL(int, broken_down_time.tm_year, 70);
268 ASSERT_ARE_EQUAL(int, broken_down_time.tm_mon, 0);
269 ASSERT_ARE_EQUAL(int, broken_down_time.tm_mday, 1);
270 }
271
272 /*Tests_SRS_HTTPAPIEXSAS_01_001: [ HTTPAPIEX_SAS_Create shall create a new instance of HTTPAPIEX_SAS and return a non-NULL handle to it. ]*/
273 TEST_FUNCTION(HTTPAPIEX_SAS_Create_Succeeds)
274 {
275 // arrange
276 HTTPAPIEX_SAS_HANDLE handle;
277
278 setupSAS_Create_happy_path(true);
279
280 // act
281 handle = HTTPAPIEX_SAS_Create(TEST_KEY_HANDLE, TEST_URIRESOURCE_HANDLE, TEST_KEYNAME_HANDLE);
282
283 // assert
284 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
285 ASSERT_IS_NOT_NULL(handle);
286
287 // Cleanup
288 HTTPAPIEX_SAS_Destroy(handle);
289 }
290
291 /*Tests_SRS_HTTPAPIEXSAS_06_001: [If the parameter key is NULL then HTTPAPIEX_SAS_Create shall return NULL.]*/
292 TEST_FUNCTION(HTTPAPIEX_SAS_Create_null_key_fails)
293 {
294 // arrange
295 HTTPAPIEX_SAS_HANDLE handle;
296
297 // act
298 handle = HTTPAPIEX_SAS_Create(NULL, TEST_STRING_HANDLE, TEST_STRING_HANDLE);
299
300 // assert
301 ASSERT_IS_NULL(handle);
302 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
303 }
304
305 /*Tests_SRS_HTTPAPIEXSAS_06_002: [If the parameter uriResource is NULL then HTTPAPIEX_SAS_Create shall return NULL.]*/
306 TEST_FUNCTION(HTTPAPIEX_SAS_Create_null_uriResource_fails)
307 {
308 // arrange
309 HTTPAPIEX_SAS_HANDLE handle;
310
311 // act
312 handle = HTTPAPIEX_SAS_Create(TEST_STRING_HANDLE, NULL, TEST_STRING_HANDLE);
313
314 // assert
315 ASSERT_IS_NULL(handle);
316 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
317 }
318
319 /*Tests_SRS_HTTPAPIEXSAS_06_003: [The parameter keyName for HTTPAPIEX_SAS_Create is optional and can be NULL.]*/
320 TEST_FUNCTION(HTTPAPIEX_SAS_Create_null_keyName_succeeds)
321 {
322 // arrange
323 HTTPAPIEX_SAS_HANDLE handle;
324
325 setupSAS_Create_happy_path(true);
326
327 // act
328 handle = HTTPAPIEX_SAS_Create(TEST_KEY_HANDLE, TEST_URIRESOURCE_HANDLE, TEST_KEYNAME_HANDLE);
329
330 // assert
331 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
332 ASSERT_IS_NOT_NULL(handle);
333
334 // Cleanup
335 HTTPAPIEX_SAS_Destroy(handle);
336 }
337
338 /*Tests_SRS_HTTPAPIEXSAS_01_001: [ HTTPAPIEX_SAS_Create shall create a new instance of HTTPAPIEX_SAS and return a non-NULL handle to it. ]*/
339 TEST_FUNCTION(HTTPAPIEX_SAS_Create_From_String_Succeeds)
340 {
341 // arrange
342 HTTPAPIEX_SAS_HANDLE handle;
343
344 setupSASString_Create_happy_path(true);
345
346 // act
347 handle = HTTPAPIEX_SAS_Create_From_String(TEST_KEY, TEST_URI_RESOURCE, TEST_KEY_NAME);
348
349 // assert
350 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
351 ASSERT_IS_NOT_NULL(handle);
352
353 // Cleanup
354 HTTPAPIEX_SAS_Destroy(handle);
355 }
356
357 /* Tests_SRS_HTTPAPIEXSAS_07_001: [ If the parameter key or uriResource is NULL then HTTPAPIEX_SAS_Create_From_String shall return NULL. ] */
358 TEST_FUNCTION(HTTPAPIEX_SAS_Create_From_String_null_key_fails)
359 {
360 // arrange
361 HTTPAPIEX_SAS_HANDLE handle;
362
363 // act
364 handle = HTTPAPIEX_SAS_Create_From_String(NULL, TEST_URI_RESOURCE, TEST_KEY_NAME);
365
366 // assert
367 ASSERT_IS_NULL(handle);
368 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
369 }
370
371 /* Tests_SRS_HTTPAPIEXSAS_07_001: [ If the parameter key or uriResource is NULL then HTTPAPIEX_SAS_Create_From_String shall return NULL. ] */
372 TEST_FUNCTION(HTTPAPIEX_SAS_Create_From_String_null_uriResource_fails)
373 {
374 // arrange
375 HTTPAPIEX_SAS_HANDLE handle;
376
377 // act
378 handle = HTTPAPIEX_SAS_Create_From_String(TEST_KEY, NULL, TEST_KEY_NAME);
379
380 // assert
381 ASSERT_IS_NULL(handle);
382 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
383 }
384
385 /*Tests_SRS_HTTPAPIEXSAS_06_003: [The parameter keyName for HTTPAPIEX_SAS_Create is optional and can be NULL.]*/
386 TEST_FUNCTION(HTTPAPIEX_SAS_Create_From_String_null_keyName_succeeds)
387 {
388 // arrange
389 HTTPAPIEX_SAS_HANDLE handle;
390
391 setupSASString_Create_happy_path(false);
392
393 // act
394 handle = HTTPAPIEX_SAS_Create_From_String(TEST_KEY, TEST_URI_RESOURCE, NULL);
395
396 // assert
397 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
398 ASSERT_IS_NOT_NULL(handle);
399
400 // Cleanup
401 HTTPAPIEX_SAS_Destroy(handle);
402 }
403
404 /*Tests_SRS_HTTPAPIEXSAS_06_004: [If there are any other errors in the instantiation of this handle then HTTPAPIEX_SAS_Create shall return NULL.]*/
405 TEST_FUNCTION(HTTPAPIEX_SAS_Create_malloc_state_fails)
406 {
407 // arrange
408 HTTPAPIEX_SAS_HANDLE handle;
409
410 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)).SetReturn(TEST_KEY);
411 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)).SetReturn(TEST_URI_RESOURCE);
412 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)).SetReturn(TEST_KEY_NAME);
413 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG)).SetReturn(NULL);
414
415 // act
416 handle = HTTPAPIEX_SAS_Create(TEST_KEY_HANDLE, TEST_URIRESOURCE_HANDLE, TEST_KEYNAME_HANDLE);
417
418 // assert
419 ASSERT_IS_NULL(handle);
420 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
421 }
422
423 /*Tests_SRS_HTTPAPIEXSAS_06_004: [If there are any other errors in the instantiation of this handle then HTTPAPIEX_SAS_Create shall return NULL.]*/
424
425 TEST_FUNCTION(HTTPAPIEX_SAS_Create_first_string_copy_fails)
426 {
427 // arrange
428 HTTPAPIEX_SAS_HANDLE handle;
429
430 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
431 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG)).SetReturn(__LINE__);
432 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
433
434 // act
435 handle = HTTPAPIEX_SAS_Create_From_String(TEST_KEY, TEST_URI_RESOURCE, TEST_KEY_NAME);
436
437 // assert
438 ASSERT_IS_NULL(handle);
439 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
440 }
441
442 /*Tests_SRS_HTTPAPIEXSAS_06_004: [If there are any other errors in the instantiation of this handle then HTTPAPIEX_SAS_Create shall return NULL.]*/
443 TEST_FUNCTION(HTTPAPIEX_SAS_Create_second_string_copy_fails)
444 {
445 // arrange
446 HTTPAPIEX_SAS_HANDLE handle;
447
448 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
449 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
450 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG)).SetReturn(__LINE__);
451 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
452 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
453
454 // act
455 handle = HTTPAPIEX_SAS_Create_From_String(TEST_KEY, TEST_URI_RESOURCE, TEST_KEY_NAME);
456
457 // assert
458 ASSERT_IS_NULL(handle);
459 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
460 }
461
462 /*Tests_SRS_HTTPAPIEXSAS_06_004: [If there are any other errors in the instantiation of this handle then HTTPAPIEX_SAS_Create shall return NULL.]*/
463 TEST_FUNCTION(HTTPAPIEX_SAS_Create_third_string_copy_fails)
464 {
465 // arrange
466 HTTPAPIEX_SAS_HANDLE handle;
467
468 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
469 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
470 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
471 STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG)).SetReturn(__LINE__);
472 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
473 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
474 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
475
476 // act
477 handle = HTTPAPIEX_SAS_Create_From_String(TEST_KEY, TEST_URI_RESOURCE, TEST_KEY_NAME);
478
479 // assert
480 ASSERT_IS_NULL(handle);
481 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
482 }
483
484 /*Tests_SRS_HTTPAPIEXSAS_06_006: [HTTAPIEX_SAS_Destroy shall deallocate any structures denoted by the parameter handle.]*/
485 TEST_FUNCTION(HTTPAPIEX_SAS_Destroy_frees_underlying_strings)
486 {
487 // arrange
488 HTTPAPIEX_SAS_HANDLE handle;
489
490 setupSAS_Create_happy_path(true);
491 handle = HTTPAPIEX_SAS_Create(TEST_KEY_HANDLE, TEST_URIRESOURCE_HANDLE, TEST_KEYNAME_HANDLE);
492 umock_c_reset_all_calls();
493
494 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
495 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
496 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
497 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
498
499 // act
500 HTTPAPIEX_SAS_Destroy(handle);
501
502 // assert
503 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
504 }
505
506 /*Tests_SRS_HTTPAPIEXSAS_06_005: [If the parameter handle is NULL then HTTAPIEX_SAS_Destroy shall do nothing and return.]*/
507 TEST_FUNCTION(HTTPAPIEX_SAS_destroy_with_null_succeeds)
508 {
509 // arrange
510 // act
511 HTTPAPIEX_SAS_Destroy(NULL);
512
513 // assert
514 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
515 }
516
517 /*Tests_SRS_HTTPAPIEXSAS_06_007: [If the parameter sasHandle is NULL then HTTPAPIEX_SAS_ExecuteRequest shall simply invoke HTTPAPIEX_ExecuteRequest with the remaining parameters (following sasHandle) as its arguments and shall return immediately with the result of that call as the result of HTTPAPIEX_SAS_ExecuteRequest.]*/
518 TEST_FUNCTION(HTTPAPIEX_SAS_invoke_executerequest_with_null_sas_handle_succeeds)
519 {
520 HTTPAPIEX_RESULT result = HTTPAPIEX_ERROR;
521 unsigned int statusCode;
522
523 STRICT_EXPECTED_CALL(HTTPAPIEX_ExecuteRequest(TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT)).SetReturn(HTTPAPIEX_OK);
524 // act
525 result = HTTPAPIEX_SAS_ExecuteRequest(NULL, TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT);
526
527 // assert
528 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, result, HTTPAPIEX_OK);
529 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
530 }
531
532 /*Tests_SRS_HTTPAPIEXSAS_06_008: [if the parameter requestHttpHeadersHandle is NULL then fallthrough.]*/
533 TEST_FUNCTION(HTTPAPIEX_SAS_invoke_executerequest_with_null_request_http_headers_handle_succeeds)
534 {
535
536 HTTPAPIEX_RESULT result;
537 unsigned int statusCode;
538 HTTPAPIEX_SAS_HANDLE sasHandle;
539
540 // arrange
541 setupSAS_Create_happy_path(true);
542 sasHandle = HTTPAPIEX_SAS_Create(TEST_KEY_HANDLE, TEST_URIRESOURCE_HANDLE, TEST_KEYNAME_HANDLE);
543 umock_c_reset_all_calls();
544
545 STRICT_EXPECTED_CALL(HTTPAPIEX_ExecuteRequest(TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, NULL, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT)).SetReturn(HTTPAPIEX_OK);
546
547 // act
548 result = HTTPAPIEX_SAS_ExecuteRequest(sasHandle, TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, NULL, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT);
549
550 // assert
551 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, result, HTTPAPIEX_OK);
552 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
553
554 // Cleanup
555 HTTPAPIEX_SAS_Destroy(sasHandle);
556 }
557
558 /*Tests_SRS_HTTPAPIEXSAS_06_009: [HTTPHeaders_FindHeaderValue shall be invoked with the requestHttpHeadersHandle as its first argument and the string "Authorization" as its second argument.]*/
559 /*Tests_SRS_HTTPAPIEXSAS_06_010: [If the return result of the invocation of HTTPHeaders_FindHeaderValue is NULL then fallthrough.]*/
560 TEST_FUNCTION(HTTPAPIEX_SAS_invoke_executerequest_findheadervalues_returns_null_succeeds)
561 {
562
563 HTTPAPIEX_RESULT result;
564 unsigned int statusCode;
565 HTTPAPIEX_SAS_HANDLE sasHandle;
566
567 // arrange
568 setupSAS_Create_happy_path(true);
569 sasHandle = HTTPAPIEX_SAS_Create(TEST_KEY_HANDLE, TEST_URIRESOURCE_HANDLE, TEST_KEYNAME_HANDLE);
570 umock_c_reset_all_calls();
571
572 STRICT_EXPECTED_CALL(HTTPHeaders_FindHeaderValue(TEST_REQUEST_HTTP_HEADERS_HANDLE, "Authorization")).SetReturn(TEST_CONST_CHAR_STAR_NULL);
573 STRICT_EXPECTED_CALL(HTTPAPIEX_ExecuteRequest(TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT)).SetReturn(HTTPAPIEX_OK);
574
575 // act
576 result = HTTPAPIEX_SAS_ExecuteRequest(sasHandle, TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT);
577
578 // assert
579 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, result, HTTPAPIEX_OK);
580 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
581
582 // Cleanup
583 HTTPAPIEX_SAS_Destroy(sasHandle);
584 }
585
586 /*Tests_SRS_HTTPAPIEXSAS_06_018: [A value of type time_t that shall be known as currentTime is obtained from calling get_time.]*/
587 /*Tests_SRS_HTTPAPIEXSAS_06_019: [If the value of currentTime is (time_t)-1 is then fallthrough.]*/
588 TEST_FUNCTION(HTTPAPIEX_SAS_invoke_executerequest_get_time_fails)
589 {
590
591 HTTPAPIEX_RESULT result;
592 unsigned int statusCode;
593 HTTPAPIEX_SAS_HANDLE sasHandle;
594
595 // arrange
596 setupSAS_Create_happy_path(true);
597 sasHandle = HTTPAPIEX_SAS_Create(TEST_KEY_HANDLE, TEST_URIRESOURCE_HANDLE, TEST_KEYNAME_HANDLE);
598 umock_c_reset_all_calls();
599
600 STRICT_EXPECTED_CALL(HTTPHeaders_FindHeaderValue(TEST_REQUEST_HTTP_HEADERS_HANDLE, "Authorization")).SetReturn(TEST_CHAR_ARRAY);
601 STRICT_EXPECTED_CALL(get_time(NULL)).SetReturn((time_t)-1);
602 STRICT_EXPECTED_CALL(HTTPAPIEX_ExecuteRequest(TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT)).SetReturn(HTTPAPIEX_OK);
603
604 // act
605 result = HTTPAPIEX_SAS_ExecuteRequest(sasHandle, TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT);
606
607 // assert
608 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, result, HTTPAPIEX_OK);
609 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
610
611 // Cleanup
612 HTTPAPIEX_SAS_Destroy(sasHandle);
613 }
614
615 /*Tests_SRS_HTTPAPIEXSAS_06_017: [If state->key is prefixed with "sas=", SharedAccessSignature will be used rather than created. STRING_construct will be invoked.]*/
616 TEST_FUNCTION(HTTPAPIEX_SAS_invoke_executerequest_sas_is_provided_succeeds)
617 {
618
619 HTTPAPIEX_RESULT result;
620 unsigned int statusCode;
621 HTTPAPIEX_SAS_HANDLE sasHandle;
622
623 // arrange
624 setupSAS_Create_happy_path_provide_key(true, true);
625 sasHandle = HTTPAPIEX_SAS_Create(TEST_KEY_HANDLE, TEST_URIRESOURCE_HANDLE, TEST_KEYNAME_HANDLE);
626 umock_c_reset_all_calls();
627
628 STRICT_EXPECTED_CALL(HTTPHeaders_FindHeaderValue(TEST_REQUEST_HTTP_HEADERS_HANDLE, "Authorization")).SetReturn(TEST_CHAR_ARRAY);
629 STRICT_EXPECTED_CALL(get_time(NULL)).SetReturn(3600);
630 STRICT_EXPECTED_CALL(STRING_construct(TEST_SAS));
631 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)).SetReturn(TEST_CHAR_ARRAY);
632 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(TEST_REQUEST_HTTP_HEADERS_HANDLE, "Authorization", IGNORED_PTR_ARG)).SetReturn(HTTP_HEADERS_ERROR);
633 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG));
634 STRICT_EXPECTED_CALL(HTTPAPIEX_ExecuteRequest(TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT)).SetReturn(HTTPAPIEX_OK);
635
636 // act
637 result = HTTPAPIEX_SAS_ExecuteRequest(sasHandle, TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT);
638
639 // assert
640 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, result, HTTPAPIEX_OK);
641 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
642
643 // Cleanup
644 HTTPAPIEX_SAS_Destroy(sasHandle);
645 }
646
647 /*Tests_SRS_HTTPAPIEXSAS_06_011: [SASToken_Create shall be invoked.]*/
648 /*Tests_SRS_HTTPAPIEXSAS_06_012: [If the return result of SASToken_Create is NULL then fallthrough.]*/
649 TEST_FUNCTION(HTTPAPIEX_SAS_invoke_executerequest_sastoken_create_returns_null_succeeds)
650 {
651
652 HTTPAPIEX_RESULT result;
653 unsigned int statusCode;
654 HTTPAPIEX_SAS_HANDLE sasHandle;
655
656 // arrange
657 setupSAS_Create_happy_path(true);
658 sasHandle = HTTPAPIEX_SAS_Create(TEST_KEY_HANDLE, TEST_URIRESOURCE_HANDLE, TEST_KEYNAME_HANDLE);
659 umock_c_reset_all_calls();
660
661 STRICT_EXPECTED_CALL(HTTPHeaders_FindHeaderValue(TEST_REQUEST_HTTP_HEADERS_HANDLE, "Authorization")).SetReturn(TEST_CHAR_ARRAY);
662 STRICT_EXPECTED_CALL(get_time(NULL)).SetReturn(3600);
663 STRICT_EXPECTED_CALL(get_difftime(3600, 0)).SetReturn(3600);
664 STRICT_EXPECTED_CALL(SASToken_CreateString(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, TEST_EXPIRY)).SetReturn(NULL);
665 STRICT_EXPECTED_CALL(HTTPAPIEX_ExecuteRequest(TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT)).SetReturn(HTTPAPIEX_OK);
666
667 // act
668 result = HTTPAPIEX_SAS_ExecuteRequest(sasHandle, TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT);
669
670 // assert
671 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, result, HTTPAPIEX_OK);
672 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
673
674 // Cleanup
675 HTTPAPIEX_SAS_Destroy(sasHandle);
676 }
677
678 /*Tests_SRS_HTTPAPIEXSAS_06_013: [HTTPHeaders_ReplaceHeaderNameValuePair shall be invoked with "Authorization" as its second argument and STRING_c_str (newSASToken) as its third argument.]*/
679 /*Tests_SRS_HTTPAPIEXSAS_06_014: [If the result of the invocation of HTTPHeaders_ReplaceHeaderNameValuePair is NOT HTTP_HEADERS_OK then fallthrough.]*/
680 /*Tests_SRS_HTTPAPIEXSAS_06_015: [STRING_delete(newSASToken) will be invoked.]*/
681 TEST_FUNCTION(HTTPAPIEX_SAS_invoke_executerequest_replace_header_name_value_pair_fails_succeeds)
682 {
683
684 HTTPAPIEX_RESULT result;
685 unsigned int statusCode;
686 HTTPAPIEX_SAS_HANDLE sasHandle;
687
688 // arrange
689 setupSAS_Create_happy_path(true);
690 sasHandle = HTTPAPIEX_SAS_Create(TEST_KEY_HANDLE, TEST_URIRESOURCE_HANDLE, TEST_KEYNAME_HANDLE);
691 umock_c_reset_all_calls();
692
693 STRICT_EXPECTED_CALL(HTTPHeaders_FindHeaderValue(TEST_REQUEST_HTTP_HEADERS_HANDLE, "Authorization")).SetReturn(TEST_CHAR_ARRAY);
694 STRICT_EXPECTED_CALL(get_time(NULL)).SetReturn(3600);
695 STRICT_EXPECTED_CALL(get_difftime(3600, 0)).SetReturn(3600);
696 STRICT_EXPECTED_CALL(SASToken_CreateString(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, TEST_EXPIRY));
697 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)).SetReturn(TEST_CHAR_ARRAY);
698 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(TEST_REQUEST_HTTP_HEADERS_HANDLE, "Authorization", IGNORED_PTR_ARG)).SetReturn(HTTP_HEADERS_ERROR);
699 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG));
700 STRICT_EXPECTED_CALL(HTTPAPIEX_ExecuteRequest(TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT)).SetReturn(HTTPAPIEX_OK);
701
702 // act
703 result = HTTPAPIEX_SAS_ExecuteRequest(sasHandle, TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT);
704
705 // assert
706 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, result, HTTPAPIEX_OK);
707 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
708
709 // Cleanup
710 HTTPAPIEX_SAS_Destroy(sasHandle);
711 }
712
713 /*Tests_SRS_HTTPAPIEXSAS_06_016: [HTTPAPIEX_ExecuteRequest with the remaining parameters (following sasHandle) as its arguments will be invoked and the result of that call is the result of HTTPAPIEX_SAS_ExecuteRequest.]*/
714 TEST_FUNCTION(HTTPAPIEX_SAS_invoke_executerequest_replace_header_name_value_pair_succeeds_succeeds)
715 {
716
717 HTTPAPIEX_RESULT result;
718 unsigned int statusCode;
719 HTTPAPIEX_SAS_HANDLE sasHandle;
720
721 // arrange
722 setupSAS_Create_happy_path(true);
723 sasHandle = HTTPAPIEX_SAS_Create(TEST_KEY_HANDLE, TEST_URIRESOURCE_HANDLE, TEST_KEYNAME_HANDLE);
724 umock_c_reset_all_calls();
725
726 STRICT_EXPECTED_CALL(HTTPHeaders_FindHeaderValue(TEST_REQUEST_HTTP_HEADERS_HANDLE, "Authorization")).SetReturn(TEST_CHAR_ARRAY);
727 STRICT_EXPECTED_CALL(get_time(NULL)).SetReturn((time_t)3600);
728 STRICT_EXPECTED_CALL(get_difftime(3600, 0)).SetReturn(3600);
729 STRICT_EXPECTED_CALL(SASToken_CreateString(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, TEST_EXPIRY));
730 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)).SetReturn(TEST_CHAR_ARRAY);
731 STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(TEST_REQUEST_HTTP_HEADERS_HANDLE, "Authorization", TEST_CHAR_ARRAY)).SetReturn(HTTP_HEADERS_OK);
732 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG));
733 STRICT_EXPECTED_CALL(HTTPAPIEX_ExecuteRequest(TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT));
734
735 // act
736 result = HTTPAPIEX_SAS_ExecuteRequest(sasHandle, TEST_HTTPAPIEX_HANDLE, TEST_HTTPAPI_REQUEST_TYPE, TEST_CHAR_ARRAY, TEST_REQUEST_HTTP_HEADERS_HANDLE, TEST_REQUEST_CONTENT, &statusCode, TEST_RESPONSE_HTTP_HEADERS_HANDLE, TEST_RESPONSE_CONTENT);
737
738 // assert
739 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
740 ASSERT_ARE_EQUAL(HTTPAPIEX_RESULT, result, HTTPAPIEX_OK);
741
742 // Cleanup
743 HTTPAPIEX_SAS_Destroy(sasHandle);
744 }
745
746 END_TEST_SUITE(httpapiexsas_unittests)